big long run follow up

I reran the 2nd stage of the run with 20k particles and a heavy particle 20 times larger than the background particles. The only thing that changed here was the initial particle that was chosen. The results look qualitatively different, the energy diagram is monatonic this time, although there is still a feature at around 200 ATUs. The movie was more or less unilluminating (there did not seem to be a gap cleared out this time, or at least less so... but it is harder to see the heavy particle b/c it's farther in and the contrast is bad. Sorry.).



Here it the evolution of the heavy particles specific energy.


I also looked at a few stills form the previous run to see if I could find evidence for hte gaps we thought we could see in the movie. I was mostly just spot checking, but it's kindof hard to see when the red guy is not moving around. Here are a few example stills:






Energy distributions for the background particles forthcoming. But I am wondering if this is happening partly because the backgorund was still winding, not virialized yet (became clearer to me in looking through these stills). Maybe I'll run the background 2x as long before releasing the heavy guy, and see if there are qualitative differences.

Initial Conditions 1: Cold

I have finished some preliminary investigations into the sensitivity to the initial conditions. Below is a plot with 4 different runs of 1001, with different initial phase space configurations. The green and blue are simlar to runs you've seen before, the red has a more complicated velocity structure with an inflection point, and the yellow is still expanding rather than initially contracting. In all cases the initial positions are equally spaced out.



Here is the final configuration of these systems, after 4oo ATUs (arbitrary time units).


The final states look pretty similar, although the density profile is only sortof reflecting the r^-2 ness. The path these systems took to the final are quite different (although the phase space diagrams for all 4 are roughly the same at ~10 ATUs). Below are plots for 10, 20, and 40 ATUs:

10 ATU:

20 ATU:
40 ATU:

Also interesting are the specific energy distributions of the particles, and their evolution. Below I have histograms of the particle energies at times (0,10,20,40,400) ATUs:

0 ATU:


10 ATU:

20 ATUs:

40 ATUs:

and 400 ATUs:


There is probably some obvious explanation, but can either of you explain why the initial energy distributions are so identical, given the differences in the initial conditions??

More Dynamical Friction

I know Scott said we should put this dynamical friction question to rest, but I had this big long run in the can, so I decided to look at it once I finished running it. Strange things are afoot at the circle-k. This run has 20k particles in it, and the heavy guy gets introduced by replacing one of the light guys (possibly slightly before the object has entirely virialized, but not much before). The heavy particle is 20 times heavier than the light particles. Here is the video:




And here is the specific energy plot:


Which shows no dynamical friction going on at all even though the mass ratio is even more extreme than the previous examples, This looks totally different than the last two studies with only 1000 in the background. I thought this was an odd result, so I thought I'd put it in. By the way, I can't quite tell, but the video suggests that there might be a little void behind the heavy particle... I'll try to find it in the stills.

Energy Plots

I made plots of the position and the specific energy as a function of time for the two runs with mass ratio 10:1. It looks like in fact, the heavy particle in both systems is losing energy. The first plot shows the particle released outside the virialized system, and the second plots shows the run where the heavy particle replaced one of the existing particles.

Here is the one released outside:


Here is the one released inside:


Note: the axes are different.

Dynamical Friction 3

A few frustrating scripting errors later, I have made another dynamical friction experiment. In this case, I take one of the background particles and increase its mass by 10, but leave it's position and velocity data alone. It is losing energy a little bit, at least by eye...





I've repeated this for different choices of initial particle. The ones that start out very near the edges of the distribution do not visibly decay at all.

Sorry this preliminary work is so non-quantitative... I'm working on the specific energy plots, but (if what you mean by specific energy is (kinetic+potential)/mass) I think I have to get the code to spit out the potential energy of the particles.... since the center of the blob isn't constrained to live at zero. Until I figure that out, maybe I'll make a plot of the x maxima (the amplitude of the decaying oscillations) versus time.

Dynamical friction 2

I tried a heavy particle that was 10x bigger than the little guys, and found that it essentially never falls in, at least not in 400 (arbitrary time units =ATU), which is a few 10's of crossing times. I think in order to try 100x bigger, I am going to have to run more background particles. One problem with the first experiment (I realized after I ran it) was that the heavy particle was EQUAL in mass to all the little guys combined, which I don't think is all that physically interesting. Anyhow, here is the movie. I warn you it's boring.



I think in order to study this, I'll start making a plot of x vs t for the heavy particle, that ought to give a more quantitative notion of how fast/if the thing is sinking to the center.

Anyhow, on to a few of Scott's questions. I'll put them in Blue.
It appears that you can handle a lot more particles with Walter's code. Is this mainly because it's in C++ rather than Python?

I really don't think so. If it had been C versus Py, maybe this would be a factor, but my impression is that C++ is comparable in speed if one is taking full advantage of the object oriented programming (which W certainly is). If you are interested in Python versus C, you should talk to Doug, who has looked into this in some detail. He was telling me that sometimes interpreted languages have better optimizations than compiled languages so the comparison can be complex. In this case, I think the main difference is that my original code was computing ALL the crossing times, sorting the whole list, and pushing all the particles at every crossing. In Walter's code, in contrast, each particle has it's own time variable, and only the particles near the shell crossing are pushed at all, so they all exist at different times until a dump, at which point they are synchronized. Also, he obviously only computes new crossing times for the relevant shells, and his sorting strategy is quite sophisticated (read very fast) compared to mine.

Incidentally, I did rewrite my code to maintain a sorted list of crossing times, and only recompute the ones near the crossing (and put them back into the sorted list). It had a few problems I was sorting out, but playing with W's code turned out to be much more fun, so I suspended that effort for the time being. I do think I will go back and sort it out eventually, because my algorithm is independent enough that (even if it is superslow) it will be useful for cross-checking any results that we find surprising.
In practice how many particles can you handle?

Quite a large number it would seem. When W was demonstrating the code, he was running 10k particles for 100 ATUs, and that was taking maybe 2 minutes or maybe 5, I can't really remember. Here is a plot:




More question answering soon. And a third dynamical friction test.

Dynamical Friction 1

I made a first attempt to simulate one heavy particle falling into a "halo" of light particles. The procedure was the following: Using Walter's original initial conditions (which are similar but not identical to Binney's), I simulated forward well past the time when the object has virialized. I then dumped out the particle positions and velocities. From this file, I create a new initial condition file, adding one single particle some distance outside the edge of the virialized object. I then run the simulation forward again, for the same amount of time (i.e. long enough to hope that system can come to an equilibrium configuration). My inexperience shows here, I think I picked too high of a heavy particle mass... it was 1000 times more massive. The upshot is that the heavy particle more or less destroys the halo immediately, and it doesn't really re-form by the time the simulation ends.

I saw a great talk by A. MacFadyen, and it had a lot of really pretty movies. I was inspired to try it myself, it turned out to be fairly easy with Python. My movies are less pretty than his, so far. Here is a movie of the heavy particle falling in. The frames are in time intervals of 1 for 300 (in arbitrary time units). One interesting thing is that there is a little knot of the small particles that seems to be long lived, and orbits around the large guy for roughly the whole time.



Also, it's useful to look at the stills, so here are a few, at times (0,1,2,5) and then longterm at times (50,100,200,300). One thing I noticed is that the infalling particle seems to re-introduce some order into the phase space of the little guys that was definitely not there in the initially virialized object.


Also, Scott sent me a list of questions over e-mail. I'll start answering them as I get the answers. I'll send note about this post now, though.

Half 'n' Half

I've done as Walter suggested, and put all the light particles on the left and the heavier ones on the right. The mass ratio is 2:1 and there are 2x as many light particles. I've normed the histograms so that the distributions can be compared. I think there is some minimal evidence for slight mass segregation, but it is the lighter particles that are farther out, not the heavier ones. The heavier ones are more centrally concentrated at the end. Below is the evolution, times (0,10, 20, 30) and (50,100,200,300) in arbitrary units.





I do not well understand the auxiliary blob that develops in the heavy population. At first I thought it was the central blog that moved, but the central blob has a small velocity in the previous snapshot, so that is probably wrong. I am interested to try one very massive particle on the outskirts falling in, I will probably do that next.

(No) Mass Segregation

Some students of Walter saw mass segregation when they put in two species. The odd part was that they saw the small particles sink to the center, and the large particles get spewn out. I don't really see a way to put in two species without introducing small scale power, but I repeated the experiment with Walter's code. 1001 particles, m and 10m masses. Below is a plot (times 0,10,20,90 in arbitrary units). The windup is well lost by the end, the thing is virialized, but there's no mass segregation. Or if there is a smaaaaall hint of one, it is the smaller particles on the outside. Because of the local density fluctuations, it looks like each little guy has basically stapled itself to a large guy, i.e. each heavy-light pair collapsed together instantly, and then behaved as one particle. I will play around and see if I do m and 1.05m whether things behave qualitatively differently. Click on the picture to see it bigger/better.

------------------------

Okay, I just repeated the experiment with m, and 1.1 m. In this plot the times are at (0,20,30,90) in arbitrary units. We do not get the composite particle behavior any longer, but it looks to me like the particles basically remain interleaved. At the final output, there is some "segregation" that can be seen in the stair-stepping of the density profile, but no evidence of inside/ouside mass segregation as far as I can see. I can't be sure, but this might be again because the initial condition does not have a smooth mass density profile, it's lumpy. Here's the plot (click it).