jmpep

Members
  • Content count

    54
  • Joined

  • Last visited

Community Reputation

375 Neutral

About jmpep

  • Rank
    Member
  1. EDIT: Wow, this came out too long. The key of my wall of text is: Yes, you can work without a PhD, the people having them will assist you, and you need problem-solving skills above all, as already said. ---   It is definitely possible to work on scientific computing without a PhD.   I work in a company that develops CFD software and I have not a PhD Well, I'm currently doing the graphics engine so the fact that the software is a CFD doesn't matter much to me now, but I have had to develop things in the simulation engine in the past. And the process is pretty much:   * The people who actually understanding what is going on and what they want done tell you which new feature they want. You gather as much info from them as you can. * You go to the simulation engine code and start engineering the solution: choosing what is the most efficient way to gather the data you need, what is the most maintainable organization of the new code, etc. * If you need any formula to compute something you ask for it (or try to come up with it yourself, just for fun ) * You program the new feature, and test that it, at least, looks correct. * You call someone who actually understands what should happen with new feature and ask them if they agree that it works fine or not. * Either you have to change something, or you can move on to the next task   So, in principle, the people knowing the physics don't need to know much about programming and the people who develop don't really need to know much about the physics. Of course, the interaction between these two people lead to both of them learning much from each other, so it is pretty enriching. This is actually what I like the most about my work, I never stop learning.   About what skills to have... several: problem-solving skills are a must. You'll need to know pretty much about how computers work also, because you'll need to be very performance-aware when you do things (scientific applications = huge amounts of data which usually need pretty complex processing). Some knowledge of numerical analysis is also valuable but not always required (limitations of floating point, time integration schemes - https://www.udacity.com/course/cs222 -, etc).   The thing is, the "scientific area" as you call it is pretty much huge (there is a lot of 'science' out there) so apart from the common skills I listed many others might be needed for the particular field you want to work in. For example if you are going to work developing a weather prediction application that works in a distributed cluster you might need to know about networking (sockets, OpenMPI, ZeroMQ...). But if you are working in another application entirely developed to run on a CUDA cluster... well, CUDA will likely be a requisite   In general, be prepared to learn whatever you need to for your work, and don't be afraid to ask what you don't know (nobody is expected to know everything!).
  2. Resharper for C++!

    Reminds me of Tomato Visual Assist. I'll keep and eye on it... thanks for the news!
  3. Deep water simulation

    Thanks for answering, Lightness1024! I had lost hope :)   Tessendorf's method actually results in seamlessly tileable textures, so that's not really a problem. Not sure about whether it is periodic in time or not. I mean, it must be, since the waves comes from the IFFT of the spectra, but the period might be too long, I don't know.   About the bandwidth, the texture is big, but you only read a small, coherent part from it each frame, so I though that wouldn't be such an issue? Except upon uploading it, of course.   But yeah, between the memory amount and the periodicity problem you pointed out I guess there's enough reason not to go there and try :)
  4. Deep water simulation

    Hi all!   I am currently engaged with learning more about deep water simulations. I have just began to scratch the surface but there is one thing I have been wondering for a while: why most modern methods compute the inverse fft in realtime instead of precomputing one (or several) animated textures and use them as vertex displacement textures? Is it actually more efficient to compute the IFFT in realtime than simply fetching from the textures?   I can think of a pretty good reason which is that a texture for a 256x256 grid with a periodicity of 30 seconds, at 30 fps that would be: 3 * 30 * 30 * 256 * 256 bytes  =  177 megabytes. I don't know what the usual memory budget for a thing like this is so I don't know if that might be too much. Is this the reason for computing the IFFT in realtime or am I missing something?   Thanks in advance!   Javier
  5. Polygon Triangulation

    Just my two cents: If you are allowed to introduce new vertices (which you usually are), for convex polygons it is usually better to add a vertex in the center and join it to the other vertices, instead of just using one of the vertices of the polygon. This way you avoid slivers and have better triangles in general.   EDIT: The article is awesome, by the way ;)
  6.   Awesome! I specially like the lighting... the candle lighting the nose looks just perfect :)
  7.   Which is equally cumbersome to get, since you have to divide first by the sin of half the angle you got... I seriously recommend having a little mobile app to convert from quaternions to euler or something... for example: https://play.google.com/store/apps/details?id=quaternion.angel     Unless you brain can only work with unit-length vectors, you don't need to divide by anything.     That's pretty much my case, but I see your point :P My mistake.
  8.   Which is equally cumbersome to get, since you have to divide first by the sin of half the angle you got... I seriously recommend having a little mobile app to convert from quaternions to euler or something... for example: https://play.google.com/store/apps/details?id=quaternion.angel
  9. Quaternion Basics

    About SLERP, this article is usually worth looking: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/   By the way, the thing about SLERP is not that it interpolates through the shortest path, but the fact that it ensures constant angular velocity.   In fact using the formula of your explanation alone you are NOT ensuring that you take the shortest path. For SLERP to ensure the minimal path the interpolation must be done between quaternions in the same hyperhemisphere.  In order to do that, you need to test whether the dot product of both quaternions is negative and then, if so, negate one of them. And you can do that whether you use SLERP or NLERP.
  10. Rotate a quaternion

    Samoth got me thinking that I am one of those who uses quaternions without actually knowing how it works.   About that, I found this presentation from Jim Van Verth that is simply awesome:   http://www.essentialmath.com/GDC2013/GDC13_quaternions_final.pdf   And then these videos that seem pretty interesting but far more in depth:   https://www.youtube.com/watch?v=uRKZnFAR7yw&list=PLIljB45xT85Bfc-S4WHvTIM7E-ir3nAOf   Disclaimer: I haven't fully watched them, so I don't know how good they are. I just saw enough to deem they were worth sharing.
  11. You are pretty much simulating a gas already (surprise!) but with the density of water and in the vacuum, so it ultimately behaves like water.   Actually very dense gases are not that different from liquids: https://www.youtube.com/watch?v=DzLX96VWTkc   EDIT: Well, the "in the vacuum" part is pretty bad explained. In the end if we have a gas we are not in the vacuum, sorry about that. What I meant here is that we only have one phase (just our simulated fluid, without air surrounding it). What really matters here is that for dense gases the action of gravity is stronger than the repulsion forces of pressure until the particles are quite close together.
  12. This is an article I like about the topic of Singletons: http://www.ibm.com/developerworks/webservices/library/co-single/index.html   I like it because it doesn't just say "Why Singletons Are Evil". It explains it and it also explains when it is OK to use them.   Also, I would add to what Satharis said that one reason to have multiple instances of something that have come to me in the past more often than not is multi-threading. If you build your application relying on singletons and then you need to multithread... well, you are in for a world of pain. If you just use mutex in the singleton you end up with a parallel program that is not so parallel (most threads are always waiting for some other which is accessing a singleton). You could just create singletons that can actually return one instance per thread but then you are constraining yourself to having a fixed amount of threads and manually manage them... 
  13. If you use OpenGL+FreeType, you can have a look at: https://code.google.com/p/freetype-gl/. If not, well, you still get to see an implementation of what Hodgman was saying :)
  14.   Actually it does in Windows 7's calculator. Windows calculator uses arbitrary precision numbers or it just performs symbolic optimization.   Regardless, I hadn't thought about floating point issues when doing the cubic root of a number in C++,so I am glad you pointed out that converting roots to powers is not a good idea when it comes to negative numbers, as a rule
  15. The wikipedia page about vanishing points illustrates part what Olof Hedman just said: http://en.wikipedia.org/wiki/Vanishing_point