def calc_rungdist(param_name, dDelta): """ Calls ChaNGa to calculate the rung distribution """ changa_args = '+n 1 -dt {}'.format(dDelta) command = ICgen_utils.changa_command(param_name, changa_args=changa_args, preset='isaac') p = ICgen_utils.changa_run(command, verbose=False) return read_rungdist(p)
def __getstate__(self): """ This is required to make the object pickle-able """ # Define a dictionary containing everything needed. # Ignore self.parent state = self.__dict__.copy() state.pop('_parent', None) # Now handle the possibly large arrays (too large to pickle) for key,val in state.iteritems(): if isinstance(val, np.ndarray): state[key] = ICgen_utils.listify(val, 1001) return state
def __getstate__(self): """ This is required to make the object pickle-able """ # Define a dictionary containing everything needed. # Ignore self.parent state = self.__dict__.copy() state.pop('_parent', None) # Now handle the possibly large arrays (too large to pickle) for key, val in state.iteritems(): if isinstance(val, np.ndarray): state[key] = ICgen_utils.listify(val, 1001) return state
def snapshot_gen(ICobj): """ Generates a tipsy snapshot from the initial conditions object ICobj. Returns snapshot, param snapshot: tipsy snapshot param: dictionary containing info for a .param file """ print 'Generating snapshot...' # Constants G = SimArray(1.0,'G') # ------------------------------------ # Load in things from ICobj # ------------------------------------ print 'Accessing data from ICs' settings = ICobj.settings # filenames snapshotName = settings.filenames.snapshotName paramName = settings.filenames.paramName # particle positions r = ICobj.pos.r xyz = ICobj.pos.xyz # Number of particles nParticles = ICobj.pos.nParticles # molecular mass m = settings.physical.m # star mass m_star = settings.physical.M.copy() # disk mass m_disk = ICobj.sigma.m_disk.copy() m_disk = match_units(m_disk, m_star)[0] # mass of the gas particles m_particles = m_disk / float(nParticles) # re-scale the particles (allows making of lo-mass disk) m_particles *= settings.snapshot.mScale # ------------------------------------------------- # Assign output # ------------------------------------------------- print 'Assigning data to snapshot' # Get units all set up m_unit = m_star.units pos_unit = r.units if xyz.units != r.units: xyz.convert_units(pos_unit) # time units are sqrt(L^3/GM) t_unit = np.sqrt((pos_unit**3)*np.power((G*m_unit), -1)).units # velocity units are L/t v_unit = (pos_unit/t_unit).ratio('km s**-1') # Make it a unit v_unit = pynbody.units.Unit('{0} km s**-1'.format(v_unit)) # Other settings metals = settings.snapshot.metals star_metals = metals # ------------------------------------------------- # Initialize snapshot # ------------------------------------------------- # Note that empty pos, vel, and mass arrays are created in the snapshot snapshot = pynbody.new(star=1,gas=nParticles) snapshot['vel'].units = v_unit snapshot['eps'] = 0.01*SimArray(np.ones(nParticles+1, dtype=np.float32), pos_unit) snapshot['metals'] = SimArray(np.zeros(nParticles+1, dtype=np.float32)) snapshot['rho'] = SimArray(np.zeros(nParticles+1, dtype=np.float32)) snapshot.gas['pos'] = xyz snapshot.gas['temp'] = ICobj.T(r) snapshot.gas['mass'] = m_particles snapshot.gas['metals'] = metals snapshot.star['pos'] = SimArray([[ 0., 0., 0.]],pos_unit) snapshot.star['vel'] = SimArray([[ 0., 0., 0.]], v_unit) snapshot.star['mass'] = m_star snapshot.star['metals'] = SimArray(star_metals) # Estimate the star's softening length as the closest particle distance snapshot.star['eps'] = r.min() # Make param file param = make_param(snapshot, snapshotName) param['dMeanMolWeight'] = m eos = (settings.physical.eos).lower() if eos == 'adiabatic': param['bGasAdiabatic'] = 1 param['bGasIsothermal'] = 0 param['dConstGamma'] gc.collect() # ------------------------------------------------- # CALCULATE VELOCITY USING calc_velocity.py. This also estimates the # gravitational softening length eps # ------------------------------------------------- print 'Calculating circular velocity' preset = settings.changa_run.preset max_particles = global_settings['misc']['max_particles'] calc_velocity.v_xy(snapshot, param, changa_preset=preset, max_particles=max_particles) gc.collect() # ------------------------------------------------- # Estimate time step for changa to use # ------------------------------------------------- # Save param file configsave(param, paramName, 'param') # Save snapshot snapshot.write(filename=snapshotName, fmt=pynbody.tipsy.TipsySnap) # est dDelta dDelta = ICgen_utils.est_time_step(paramName, preset) param['dDelta'] = dDelta # ------------------------------------------------- # Create director file # ------------------------------------------------- # largest radius to plot r_director = float(0.9 * r.max()) # Maximum surface density sigma_min = float(ICobj.sigma(r_director)) # surface density at largest radius sigma_max = float(ICobj.sigma.input_dict['sigma'].max()) # Create director dict director = make_director(sigma_min, sigma_max, r_director, filename=param['achOutName']) ## Save .director file #configsave(director, directorName, 'director') # ------------------------------------------------- # Wrap up # ------------------------------------------------- print 'Wrapping up' # Now set the star particle's tform to a negative number. This allows # UW ChaNGa treat it as a sink particle. snapshot.star['tform'] = -1.0 # Update params r_sink = strip_units(r.min()) param['dSinkBoundOrbitRadius'] = r_sink param['dSinkRadius'] = r_sink param['dSinkMassMin'] = 0.9 * strip_units(m_star) param['bDoSinks'] = 1 return snapshot, param, director
def v_xy(f, param, changbin=None, nr=50, min_per_bin=100, changa_preset=None, \ max_particles=None, est_eps=True): """ Attempts to calculate the circular velocities for particles in a thin (not flat) keplerian disk. Also estimates gravitational softening (eps) for the gas particles Requires ChaNGa Note that this will change the velocities IN f **ARGUMENTS** f : tipsy snapshot For a gaseous disk param : dict a dictionary containing params for changa. (see isaac.configparser) changbin : str (OPTIONAL) If set, should be the full path to the ChaNGa executable. If None, an attempt to find ChaNGa is made nr : int (optional) number of radial bins to use when averaging over accelerations min_per_bin : int (optional) The minimum number of particles to be in each bin. If there are too few particles in a bin, it is merged with an adjacent bin. Thus, actual number of radial bins may be less than nr. changa_preset : str Which ChaNGa execution preset to use (ie 'mpi', 'local', ...). See ICgen_utils.changa_command max_particles : int or None Specifies the maximum number of particles to use for calculating accelerations and velocities. Setting a smaller number can speed up computation and save on memory but can yield noisier results. If None, max is unlimited. est_eps : bool Estimate eps (gravitational softening length). Default is True. If False, it is assumed eps has already been estimated **RETURNS** Nothing. Velocities are updated within f as is eps """ # If the snapshot has too many particles, randomly select gas particles # To use for calculating velocity and make a view of the snapshot n_gas = len(f) - 1 subview = (n_gas > max_particles) and (max_particles is not None) if subview: max_particles = int(max_particles) mask = np.zeros(n_gas + 1, dtype=bool) mask[-1] = True # Use the star particle always # randomly select particles to use m = np.random.rand(n_gas) ind = m.argsort()[0:max_particles] mask[ind] = True # Make a subview and create a reference to the complete snapshot complete_snapshot = f f = complete_snapshot[mask] # Scale gas mass m_scale = float(n_gas)/float(max_particles) f.g['mass'] *= m_scale if not est_eps: f.g['eps'] *= m_scale**(1.0/3) # Load stuff from the snapshot r = f.g['rxy'].astype(np.float32) cosine = (f.g['x']/r).in_units('1').astype(np.float32) sine = (f.g['y']/r).in_units('1').astype(np.float32) z = f.g['z'] vel = f.g['vel'] a = None # arbitrary initialization # Temporary filenames for running ChaNGa f_prefix = str(np.random.randint(0, 2**32)) f_name = f_prefix + '.std' p_name = f_prefix + '.param' # Update parameters p_temp = param.copy() p_temp['achInFile'] = f_name p_temp['achOutName'] = f_prefix p_temp['dDelta'] = 1e-10 if 'dDumpFrameTime' in p_temp: p_temp.pop('dDumpFrameTime') if 'dDumpFrameStep' in p_temp: p_temp.pop('dDumpFrameStep') # -------------------------------------------- # Estimate velocity from gravity only # -------------------------------------------- for iGrav in range(2): # Save files f.write(filename=f_name, fmt = pynbody.tipsy.TipsySnap) isaac.configsave(p_temp, p_name, ftype='param') if iGrav == 0: # Run ChaNGa calculating all forces (for initial run) command = ICgen_utils.changa_command(p_name, changa_preset, changbin, '+gas +n 0') else: # Run ChaNGa, only calculating gravity (on second run) command = ICgen_utils.changa_command(p_name, changa_preset, changbin, '-gas +n 0') print command p = ICgen_utils.changa_run(command) p.wait() if (iGrav == 0) and est_eps: # Estimate the gravitational softening length on the first iteration smoothlength_file = f_prefix + '.000000.smoothlength' eps = ICgen_utils.est_eps(smoothlength_file) f.g['eps'] = eps # Load accelerations acc_name = f_prefix + '.000000.acc2' del a gc.collect() a = isaac.load_acc(acc_name, low_mem=True) gc.collect() # Clean-up for fname in glob.glob(f_prefix + '*'): os.remove(fname) # Calculate cos(theta) where theta is angle above x-y plane cos = (r/np.sqrt(r**2 + z**2)).in_units('1').astype(np.float32) # Calculate radial acceleration times r^2 ar2 = (a[:,0]*cosine + a[:,1]*sine)*r**2 # Bin the data r_edges = np.linspace(r.min(), (1+np.spacing(2))*r.max(), nr + 1) ind, r_edges = isaac.digitize_threshold(r, min_per_bin, r_edges) ind -= 1 nr = len(r_edges) - 1 r_bins, ar2_mean, err = isaac.binned_mean(r, ar2, binedges=r_edges, \ weighted_bins=True) gc.collect() # Fit lines to ar2 vs cos for each radial bin m = np.zeros(nr) b = np.zeros(nr) for i in range(nr): mask = (ind == i) p = np.polyfit(cos[mask], ar2[mask], 1) m[i] = p[0] b[i] = p[1] # Interpolate the line fits m_spline = isaac.extrap1d(r_bins, m) b_spline = isaac.extrap1d(r_bins, b) # Calculate circular velocity ar2 = SimArray(m_spline(r)*cos + b_spline(r), ar2.units) gc.collect() v_calc = (np.sqrt(abs(ar2)/r)).in_units(vel.units) gc.collect() vel[:,0] = -v_calc*sine vel[:,1] = v_calc*cosine del v_calc gc.collect() # -------------------------------------------- # Estimate pressure/gas dynamics accelerations # -------------------------------------------- # Save files f.write(filename=f_name, fmt = pynbody.tipsy.TipsySnap) isaac.configsave(p_temp, p_name, ftype='param') # Run ChaNGa, including SPH command = ICgen_utils.changa_command(p_name, changa_preset, changbin, '+gas -n 0') p = ICgen_utils.changa_run(command) p.wait() # Load accelerations acc_name = f_prefix + '.000000.acc2' a_total = isaac.load_acc(acc_name, low_mem=True) gc.collect() # Clean-up for fname in glob.glob(f_prefix + '*'): os.remove(fname) # Estimate the accelerations due to pressure gradients/gas dynamics a_gas = a_total - a del a_total, a gc.collect() ar2_gas = (a_gas[:,0]*cosine + a_gas[:,1]*sine)*r**2 del a_gas gc.collect() logr_bins, ratio, err = isaac.binned_mean(np.log(r), ar2_gas/ar2, nbins=nr,\ weighted_bins=True) r_bins = np.exp(logr_bins) del ar2_gas gc.collect() ratio_spline = isaac.extrap1d(r_bins, ratio) # If not all the particles were used for calculating velocity, # Make sure to use them now if subview: # Re-scale mass back to normal f.g['mass'] /= m_scale # Scale eps appropriately f.g['eps'] /= m_scale**(1.0/3) complete_snapshot.g['eps'] = f.g['eps'][[0]] # Rename complete snapshot f = complete_snapshot # Calculate stuff for all particles r = f.g['rxy'] z = f.g['z'] cos = (r/np.sqrt(r**2 + z**2)).in_units('1').astype(np.float32) ar2 = SimArray(m_spline(r)*cos + b_spline(r), ar2.units) cosine = (f.g['x']/r).in_units('1').astype(np.float32) sine = (f.g['y']/r).in_units('1').astype(np.float32) vel = f.g['vel'] ar2_calc = ar2*(1 + ratio_spline(r)) del ar2 gc.collect() # Calculate velocity v = (np.sqrt(abs(ar2_calc)/r)).in_units(f.g['vel'].units) del ar2_calc gc.collect() vel[:,0] = -v*sine vel[:,1] = v*cosine return
def snapshot_gen(ICobj): """ Generates a tipsy snapshot from the initial conditions object ICobj. Returns snapshot, param snapshot: tipsy snapshot param: dictionary containing info for a .param file Note: Code has been edited (dflemin3) such that now it returns a snapshot for a circumbinary disk where initial conditions generated assuming star at origin of mass M. After gas initialized, replaced star at origin with binary system who's center of mass lies at the origin and who's mass m1 +m2 = M """ print "Generating snapshot..." # Constants G = SimArray(1.0, "G") # ------------------------------------ # Load in things from ICobj # ------------------------------------ print "Accessing data from ICs" settings = ICobj.settings # snapshot file name snapshotName = settings.filenames.snapshotName paramName = settings.filenames.paramName # Load user supplied snapshot (assumed to be in cwd) path = "/astro/store/scratch/tmp/dflemin3/nbodyshare/9au-Q1.05-129K/" snapshot = pynbody.load(path + snapshotName) # particle positions r = snapshot.gas["r"] xyz = snapshot.gas["pos"] # Number of particles nParticles = len(snapshot.gas) # molecular mass m = settings.physical.m # Pull star mass from user-supplied snapshot ICobj.settings.physical.M = snapshot.star["mass"] # Total stellar mass in solar masses m_star = ICobj.settings.physical.M # disk mass m_disk = np.sum(snapshot.gas["mass"]) m_disk = match_units(m_disk, m_star)[0] # mass of the gas particles m_particles = m_disk / float(nParticles) # re-scale the particles (allows making of low-mass disk) m_particles *= settings.snapshot.mScale # ------------------------------------------------- # Assign output # ------------------------------------------------- print "Assigning data to snapshot" # Get units all set up m_unit = m_star.units pos_unit = r.units if xyz.units != r.units: xyz.convert_units(pos_unit) # time units are sqrt(L^3/GM) t_unit = np.sqrt((pos_unit ** 3) * np.power((G * m_unit), -1)).units # velocity units are L/t v_unit = (pos_unit / t_unit).ratio("km s**-1") # Make it a unit, save value for future conversion v_unit_vel = v_unit # Ensure v_unit_vel is the same as what I assume it is. assert np.fabs(AddBinary.VEL_UNIT - v_unit_vel) < AddBinary.SMALL, "VEL_UNIT not equal to ChaNGa unit! Why??" v_unit = pynbody.units.Unit("{0} km s**-1".format(v_unit)) # Other settings metals = settings.snapshot.metals star_metals = metals # Estimate the star's softening length as the closest particle distance eps = r.min() # Make param file param = make_param(snapshot, snapshotName) param["dMeanMolWeight"] = m gc.collect() # CALCULATE VELOCITY USING calc_velocity.py. This also estimates the # gravitational softening length eps preset = settings.changa_run.preset # ------------------------------------------------- # Estimate time step for changa to use # ------------------------------------------------- # Save param file configsave(param, paramName, "param") # Save snapshot snapshot.write(filename=snapshotName, fmt=pynbody.tipsy.TipsySnap) # est dDelta dDelta = ICgen_utils.est_time_step(paramName, preset) param["dDelta"] = dDelta # ------------------------------------------------- # Create director file # ------------------------------------------------- # largest radius to plot r_director = float(0.9 * r.max()) # Maximum surface density sigma_min = float(ICobj.sigma(r_director)) # surface density at largest radius sigma_max = float(ICobj.sigma.input_dict["sigma"].max()) # Create director dict director = make_director(sigma_min, sigma_max, r_director, filename=param["achOutName"]) ## Save .director file # configsave(director, directorName, 'director') """ Now that the gas disk is initializes around the primary (M=m1), add in the second star as specified by the user. """ # Now that velocities and everything are all initialized for gas particles, create new snapshot to return in which # single star particle is replaced by 2, same units as above snapshotBinary = pynbody.new(star=2, gas=nParticles) snapshotBinary["eps"] = 0.01 * SimArray(np.ones(nParticles + 2, dtype=np.float32), pos_unit) snapshotBinary["metals"] = SimArray(np.zeros(nParticles + 2, dtype=np.float32)) snapshotBinary["vel"].units = v_unit snapshotBinary["pos"].units = pos_unit snapshotBinary["mass"].units = snapshot["mass"].units snapshotBinary["rho"] = SimArray(np.zeros(nParticles + 2, dtype=np.float32)) # Assign gas particles with calculated/given values from above snapshotBinary.gas["pos"] = snapshot.gas["pos"] snapshotBinary.gas["vel"] = snapshot.gas["vel"] snapshotBinary.gas["temp"] = snapshot.gas["temp"] snapshotBinary.gas["rho"] = snapshot.gas["rho"] snapshotBinary.gas["eps"] = snapshot.gas["eps"] snapshotBinary.gas["mass"] = snapshot.gas["mass"] snapshotBinary.gas["metals"] = snapshot.gas["metals"] # Load Binary system obj to initialize system binsys = ICobj.settings.physical.binsys m_disk = strip_units(np.sum(snapshotBinary.gas["mass"])) binsys.m1 = strip_units(m_star) binsys.m1 = binsys.m1 + m_disk # Recompute cartesian coords considering primary as m1+m_disk binsys.computeCartesian() x1, x2, v1, v2 = binsys.generateICs() # Assign position, velocity assuming CCW orbit snapshotBinary.star[0]["pos"] = SimArray(x1, pos_unit) snapshotBinary.star[0]["vel"] = SimArray(v1, v_unit) snapshotBinary.star[1]["pos"] = SimArray(x2, pos_unit) snapshotBinary.star[1]["vel"] = SimArray(v2, v_unit) """ We have the binary positions about their center of mass, (0,0,0), so shift the position, velocity of the gas disk to be around the primary. """ snapshotBinary.gas["pos"] += snapshotBinary.star[0]["pos"] snapshotBinary.gas["vel"] += snapshotBinary.star[0]["vel"] # Set stellar masses: Create simArray for mass, convert units to simulation mass units snapshotBinary.star[0]["mass"] = SimArray(binsys.m1 - m_disk, m_unit) snapshotBinary.star[1]["mass"] = SimArray(binsys.m2, m_unit) snapshotBinary.star["metals"] = SimArray(star_metals) print "Wrapping up" # Now set the star particle's tform to a negative number. This allows # UW ChaNGa treat it as a sink particle. snapshotBinary.star["tform"] = -1.0 # Set sink radius, stellar smoothing length as fraction of distance # from primary to inner edge of the disk r_sink = eps snapshotBinary.star[0]["eps"] = SimArray(r_sink / 2.0, pos_unit) snapshotBinary.star[1]["eps"] = SimArray(r_sink / 2.0, pos_unit) param["dSinkBoundOrbitRadius"] = r_sink param["dSinkRadius"] = r_sink param["dSinkMassMin"] = 0.9 * binsys.m2 param["bDoSinks"] = 1 return snapshotBinary, param, director
def snapshot_gen(ICobj): """ Generates a tipsy snapshot from the initial conditions object ICobj. Returns snapshot, param snapshot: tipsy snapshot param: dictionary containing info for a .param file Note: Code has been edited (dflemin3) such that now it returns a snapshot for a circumbinary disk where initial conditions generated assuming star at origin of mass M. After gas initialized, replaced star at origin with binary system who's center of mass lies at the origin and who's mass m1 +m2 = M """ print 'Generating snapshot...' # Constants G = SimArray(1.0,'G') # ------------------------------------ # Load in things from ICobj # ------------------------------------ print 'Accessing data from ICs' settings = ICobj.settings # snapshot file name snapshotName = settings.filenames.snapshotName paramName = settings.filenames.paramName # particle positions r = ICobj.pos.r xyz = ICobj.pos.xyz # Number of particles nParticles = ICobj.pos.nParticles # molecular mass m = settings.physical.m # star mass m_star = settings.physical.M.copy() # disk mass m_disk = ICobj.sigma.m_disk.copy() m_disk = isaac.match_units(m_disk, m_star)[0] # mass of the gas particles m_particles = m_disk / float(nParticles) # re-scale the particles (allows making of low-mass disk) m_particles *= settings.snapshot.mScale # ------------------------------------------------- # Assign output # ------------------------------------------------- print 'Assigning data to snapshot' # Get units all set up m_unit = m_star.units pos_unit = r.units if xyz.units != r.units: xyz.convert_units(pos_unit) # time units are sqrt(L^3/GM) t_unit = np.sqrt((pos_unit**3)*np.power((G*m_unit), -1)).units # velocity units are L/t v_unit = (pos_unit/t_unit).ratio('km s**-1') # Make it a unit, save value for future conversion v_unit_vel = v_unit #Ensure v_unit_vel is the same as what I assume it is. assert(np.fabs(AddBinary.VEL_UNIT-v_unit_vel)<AddBinary.SMALL),"VEL_UNIT not equal to ChaNGa unit! Why??" v_unit = pynbody.units.Unit('{0} km s**-1'.format(v_unit)) # Other settings metals = settings.snapshot.metals star_metals = metals # Generate snapshot # Note that empty pos, vel, and mass arrays are created in the snapshot snapshot = pynbody.new(star=1,gas=nParticles) snapshot['vel'].units = v_unit snapshot['eps'] = 0.01*SimArray(np.ones(nParticles+1, dtype=np.float32), pos_unit) snapshot['metals'] = SimArray(np.zeros(nParticles+1, dtype=np.float32)) snapshot['rho'] = SimArray(np.zeros(nParticles+1, dtype=np.float32)) snapshot.gas['pos'] = xyz snapshot.gas['temp'] = ICobj.T(r) snapshot.gas['mass'] = m_particles snapshot.gas['metals'] = metals snapshot.star['pos'] = SimArray([[ 0., 0., 0.]],pos_unit) snapshot.star['vel'] = SimArray([[ 0., 0., 0.]], v_unit) snapshot.star['mass'] = m_star snapshot.star['metals'] = SimArray(star_metals) # Estimate the star's softening length as the closest particle distance eps = r.min() # Make param file param = isaac.make_param(snapshot, snapshotName) param['dMeanMolWeight'] = m gc.collect() # CALCULATE VELOCITY USING calc_velocity.py. This also estimates the # gravitational softening length eps print 'Calculating circular velocity' preset = settings.changa_run.preset max_particles = global_settings['misc']['max_particles'] calc_velocity.v_xy(snapshot, param, changa_preset=preset, max_particles=max_particles) gc.collect() # ------------------------------------------------- # Estimate time step for changa to use # ------------------------------------------------- # Save param file isaac.configsave(param, paramName, 'param') # Save snapshot snapshot.write(filename=snapshotName, fmt=pynbody.tipsy.TipsySnap) # est dDelta dDelta = ICgen_utils.est_time_step(paramName, preset) param['dDelta'] = dDelta # ------------------------------------------------- # Create director file # ------------------------------------------------- # largest radius to plot r_director = float(0.9 * r.max()) # Maximum surface density sigma_min = float(ICobj.sigma(r_director)) # surface density at largest radius sigma_max = float(ICobj.sigma.input_dict['sigma'].max()) # Create director dict director = isaac.make_director(sigma_min, sigma_max, r_director, filename=param['achOutName']) ## Save .director file #isaac.configsave(director, directorName, 'director') """ Now that the gas disk is initializes around the primary (M=m1), add in the second star as specified by the user. """ #Now that velocities and everything are all initialized for gas particles, create new snapshot to return in which #single star particle is replaced by 2, same units as above snapshotBinary = pynbody.new(star=2,gas=nParticles) snapshotBinary['eps'] = 0.01*SimArray(np.ones(nParticles+2, dtype=np.float32), pos_unit) snapshotBinary['metals'] = SimArray(np.zeros(nParticles+2, dtype=np.float32)) snapshotBinary['vel'].units = v_unit snapshotBinary['pos'].units = pos_unit snapshotBinary['mass'].units = snapshot['mass'].units snapshotBinary['rho'] = SimArray(np.zeros(nParticles+2, dtype=np.float32)) #Assign gas particles with calculated/given values from above snapshotBinary.gas['pos'] = snapshot.gas['pos'] snapshotBinary.gas['vel'] = snapshot.gas['vel'] snapshotBinary.gas['temp'] = snapshot.gas['temp'] snapshotBinary.gas['rho'] = snapshot.gas['rho'] snapshotBinary.gas['eps'] = snapshot.gas['eps'] snapshotBinary.gas['mass'] = snapshot.gas['mass'] snapshotBinary.gas['metals'] = snapshot.gas['metals'] #Load Binary system obj to initialize system binsys = ICobj.settings.physical.binsys m_disk = isaac.strip_units(np.sum(snapshotBinary.gas['mass'])) binsys.m1 = binsys.m1 + m_disk #Recompute cartesian coords considering primary as m1+m_disk binsys.computeCartesian() x1,x2,v1,v2 = binsys.generateICs() #Assign position, velocity assuming CCW orbit snapshotBinary.star[0]['pos'] = SimArray(x1,pos_unit) snapshotBinary.star[0]['vel'] = SimArray(v1,v_unit) snapshotBinary.star[1]['pos'] = SimArray(x2,pos_unit) snapshotBinary.star[1]['vel'] = SimArray(v2,v_unit) """ We have the binary positions about their center of mass, (0,0,0), so shift the position, velocity of the gas disk to be around the primary. """ snapshotBinary.gas['pos'] += snapshotBinary.star[0]['pos'] snapshotBinary.gas['vel'] += snapshotBinary.star[0]['vel'] #Set stellar masses: Create simArray for mass, convert units to simulation mass units snapshotBinary.star[0]['mass'] = SimArray(binsys.m1-m_disk,m_unit) snapshotBinary.star[1]['mass'] = SimArray(binsys.m2,m_unit) snapshotBinary.star['metals'] = SimArray(star_metals) #Now that everything has masses and positions, adjust positions so the #system center of mass corresponds to the origin """ com = binaryUtils.computeCOM(snapshotBinary.stars,snapshotBinary.gas) print com snapshotBinary.stars['pos'] -= com snapshotBinary.gas['pos'] -= com """ print 'Wrapping up' # Now set the star particle's tform to a negative number. This allows # UW ChaNGa treat it as a sink particle. snapshotBinary.star['tform'] = -1.0 #Set sink radius, stellar smoothing length as fraction of distance #from primary to inner edge of the disk r_sink = eps snapshotBinary.star[0]['eps'] = SimArray(r_sink/2.0,pos_unit) snapshotBinary.star[1]['eps'] = SimArray(r_sink/2.0,pos_unit) param['dSinkBoundOrbitRadius'] = r_sink param['dSinkRadius'] = r_sink param['dSinkMassMin'] = 0.9 * binsys.m2 param['bDoSinks'] = 1 return snapshotBinary, param, director
def v_xy(f, param, changbin=None, nr=50, min_per_bin=100, changa_preset=None, \ max_particles=None, est_eps=True): """ Attempts to calculate the circular velocities for particles in a thin (not flat) keplerian disk. Also estimates gravitational softening (eps) for the gas particles Requires ChaNGa Note that this will change the velocities IN f **ARGUMENTS** f : tipsy snapshot For a gaseous disk param : dict a dictionary containing params for changa. (see isaac.configparser) changbin : str (OPTIONAL) If set, should be the full path to the ChaNGa executable. If None, an attempt to find ChaNGa is made nr : int (optional) number of radial bins to use when averaging over accelerations min_per_bin : int (optional) The minimum number of particles to be in each bin. If there are too few particles in a bin, it is merged with an adjacent bin. Thus, actual number of radial bins may be less than nr. changa_preset : str Which ChaNGa execution preset to use (ie 'mpi', 'local', ...). See ICgen_utils.changa_command max_particles : int or None Specifies the maximum number of particles to use for calculating accelerations and velocities. Setting a smaller number can speed up computation and save on memory but can yield noisier results. If None, max is unlimited. est_eps : bool Estimate eps (gravitational softening length). Default is True. If False, it is assumed eps has already been estimated **RETURNS** Nothing. Velocities are updated within f as is eps """ # If the snapshot has too many particles, randomly select gas particles # To use for calculating velocity and make a view of the snapshot n_gas = len(f) - 1 subview = (n_gas > max_particles) and (max_particles is not None) if subview: max_particles = int(max_particles) mask = np.zeros(n_gas + 1, dtype=bool) mask[-1] = True # Use the star particle always # randomly select particles to use m = np.random.rand(n_gas) ind = m.argsort()[0:max_particles] mask[ind] = True # Make a subview and create a reference to the complete snapshot complete_snapshot = f f = complete_snapshot[mask] # Scale gas mass m_scale = float(n_gas) / float(max_particles) f.g['mass'] *= m_scale if not est_eps: f.g['eps'] *= m_scale**(1.0 / 3) # Load stuff from the snapshot r = f.g['rxy'].astype(np.float32) cosine = (f.g['x'] / r).in_units('1').astype(np.float32) sine = (f.g['y'] / r).in_units('1').astype(np.float32) z = f.g['z'] vel = f.g['vel'] a = None # arbitrary initialization # Temporary filenames for running ChaNGa f_prefix = str(np.random.randint(0, 2**32)) f_name = f_prefix + '.std' p_name = f_prefix + '.param' # Update parameters p_temp = param.copy() p_temp['achInFile'] = f_name p_temp['achOutName'] = f_prefix p_temp['dDelta'] = 1e-10 if 'dDumpFrameTime' in p_temp: p_temp.pop('dDumpFrameTime') if 'dDumpFrameStep' in p_temp: p_temp.pop('dDumpFrameStep') # -------------------------------------------- # Estimate velocity from gravity only # -------------------------------------------- for iGrav in range(2): # Save files f.write(filename=f_name, fmt=pynbody.tipsy.TipsySnap) isaac.configsave(p_temp, p_name, ftype='param') if iGrav == 0: # Run ChaNGa calculating all forces (for initial run) command = ICgen_utils.changa_command(p_name, changa_preset, changbin, '+gas +n 0') else: # Run ChaNGa, only calculating gravity (on second run) command = ICgen_utils.changa_command(p_name, changa_preset, changbin, '-gas +n 0') print command p = ICgen_utils.changa_run(command) p.wait() if (iGrav == 0) and est_eps: # Estimate the gravitational softening length on the first iteration smoothlength_file = f_prefix + '.000000.smoothlength' eps = ICgen_utils.est_eps(smoothlength_file) f.g['eps'] = eps # Load accelerations acc_name = f_prefix + '.000000.acc2' del a gc.collect() a = isaac.load_acc(acc_name, low_mem=True) gc.collect() # Clean-up for fname in glob.glob(f_prefix + '*'): os.remove(fname) # Calculate cos(theta) where theta is angle above x-y plane cos = (r / np.sqrt(r**2 + z**2)).in_units('1').astype(np.float32) # Calculate radial acceleration times r^2 ar2 = (a[:, 0] * cosine + a[:, 1] * sine) * r**2 # Bin the data r_edges = np.linspace(r.min(), (1 + np.spacing(2)) * r.max(), nr + 1) ind, r_edges = isaac.digitize_threshold(r, min_per_bin, r_edges) ind -= 1 nr = len(r_edges) - 1 r_bins, ar2_mean, err = isaac.binned_mean(r, ar2, binedges=r_edges, \ weighted_bins=True) gc.collect() # Fit lines to ar2 vs cos for each radial bin m = np.zeros(nr) b = np.zeros(nr) for i in range(nr): mask = (ind == i) p = np.polyfit(cos[mask], ar2[mask], 1) m[i] = p[0] b[i] = p[1] # Interpolate the line fits m_spline = isaac.extrap1d(r_bins, m) b_spline = isaac.extrap1d(r_bins, b) # Calculate circular velocity ar2 = SimArray(m_spline(r) * cos + b_spline(r), ar2.units) gc.collect() v_calc = (np.sqrt(abs(ar2) / r)).in_units(vel.units) gc.collect() vel[:, 0] = -v_calc * sine vel[:, 1] = v_calc * cosine del v_calc gc.collect() # -------------------------------------------- # Estimate pressure/gas dynamics accelerations # -------------------------------------------- # Save files f.write(filename=f_name, fmt=pynbody.tipsy.TipsySnap) isaac.configsave(p_temp, p_name, ftype='param') # Run ChaNGa, including SPH command = ICgen_utils.changa_command(p_name, changa_preset, changbin, '+gas -n 0') p = ICgen_utils.changa_run(command) p.wait() # Load accelerations acc_name = f_prefix + '.000000.acc2' a_total = isaac.load_acc(acc_name, low_mem=True) gc.collect() # Clean-up for fname in glob.glob(f_prefix + '*'): os.remove(fname) # Estimate the accelerations due to pressure gradients/gas dynamics a_gas = a_total - a del a_total, a gc.collect() ar2_gas = (a_gas[:, 0] * cosine + a_gas[:, 1] * sine) * r**2 del a_gas gc.collect() logr_bins, ratio, err = isaac.binned_mean(np.log(r), ar2_gas/ar2, nbins=nr,\ weighted_bins=True) r_bins = np.exp(logr_bins) del ar2_gas gc.collect() ratio_spline = isaac.extrap1d(r_bins, ratio) # If not all the particles were used for calculating velocity, # Make sure to use them now if subview: # Re-scale mass back to normal f.g['mass'] /= m_scale # Scale eps appropriately f.g['eps'] /= m_scale**(1.0 / 3) complete_snapshot.g['eps'] = f.g['eps'][[0]] # Rename complete snapshot f = complete_snapshot # Calculate stuff for all particles r = f.g['rxy'] z = f.g['z'] cos = (r / np.sqrt(r**2 + z**2)).in_units('1').astype(np.float32) ar2 = SimArray(m_spline(r) * cos + b_spline(r), ar2.units) cosine = (f.g['x'] / r).in_units('1').astype(np.float32) sine = (f.g['y'] / r).in_units('1').astype(np.float32) vel = f.g['vel'] ar2_calc = ar2 * (1 + ratio_spline(r)) del ar2 gc.collect() # Calculate velocity v = (np.sqrt(abs(ar2_calc) / r)).in_units(f.g['vel'].units) del ar2_calc gc.collect() vel[:, 0] = -v * sine vel[:, 1] = v * cosine return
def snapshot_gen(ICobj): """ Generates a tipsy snapshot from the initial conditions object ICobj. Returns snapshot, param snapshot: tipsy snapshot param: dictionary containing info for a .param file Note: Code has been edited (dflemin3) such that now it returns a snapshot for a circumbinary disk where initial conditions generated assuming star at origin of mass M. After gas initialized, replaced star at origin with binary system who's center of mass lies at the origin and who's mass m1 +m2 = M """ print 'Generating snapshot...' # Constants G = SimArray(1.0,'G') # ------------------------------------ # Load in things from ICobj # ------------------------------------ print 'Accessing data from ICs' settings = ICobj.settings # snapshot file name snapshotName = settings.filenames.snapshotName paramName = settings.filenames.paramName # particle positions r = ICobj.pos.r xyz = ICobj.pos.xyz # Number of particles nParticles = ICobj.pos.nParticles # molecular mass m = settings.physical.m # star mass m_star = settings.physical.M.copy() # disk mass m_disk = ICobj.sigma.m_disk.copy() m_disk = match_units(m_disk, m_star)[0] # mass of the gas particles m_particles = m_disk / float(nParticles) # re-scale the particles (allows making of low-mass disk) m_particles *= settings.snapshot.mScale # ------------------------------------------------- # Assign output # ------------------------------------------------- print 'Assigning data to snapshot' # Get units all set up m_unit = m_star.units pos_unit = r.units if xyz.units != r.units: xyz.convert_units(pos_unit) # time units are sqrt(L^3/GM) t_unit = np.sqrt((pos_unit**3)*np.power((G*m_unit), -1)).units # velocity units are L/t v_unit = (pos_unit/t_unit).ratio('km s**-1') # Make it a unit, save value for future conversion v_unit_vel = v_unit #Ensure v_unit_vel is the same as what I assume it is. assert(np.fabs(AddBinary.VEL_UNIT-v_unit_vel)<AddBinary.SMALL),"VEL_UNIT not equal to ChaNGa unit! Why??" v_unit = pynbody.units.Unit('{0} km s**-1'.format(v_unit)) # Other settings metals = settings.snapshot.metals star_metals = metals # Generate snapshot # Note that empty pos, vel, and mass arrays are created in the snapshot snapshot = pynbody.new(star=1,gas=nParticles) snapshot['vel'].units = v_unit snapshot['eps'] = 0.01*SimArray(np.ones(nParticles+1, dtype=np.float32), pos_unit) snapshot['metals'] = SimArray(np.zeros(nParticles+1, dtype=np.float32)) snapshot['rho'] = SimArray(np.zeros(nParticles+1, dtype=np.float32)) snapshot.gas['pos'] = xyz snapshot.gas['temp'] = ICobj.T(r) snapshot.gas['mass'] = m_particles snapshot.gas['metals'] = metals snapshot.star['pos'] = SimArray([[ 0., 0., 0.]],pos_unit) snapshot.star['vel'] = SimArray([[ 0., 0., 0.]], v_unit) snapshot.star['mass'] = m_star snapshot.star['metals'] = SimArray(star_metals) # Estimate the star's softening length as the closest particle distance #snapshot.star['eps'] = r.min() # Make param file param = make_param(snapshot, snapshotName) param['dMeanMolWeight'] = m gc.collect() # CALCULATE VELOCITY USING calc_velocity.py. This also estimates the # gravitational softening length eps print 'Calculating circular velocity' preset = settings.changa_run.preset max_particles = global_settings['misc']['max_particles'] calc_velocity.v_xy(snapshot, param, changa_preset=preset, max_particles=max_particles) gc.collect() # ------------------------------------------------- # Estimate time step for changa to use # ------------------------------------------------- # Save param file configsave(param, paramName, 'param') # Save snapshot snapshot.write(filename=snapshotName, fmt=pynbody.tipsy.TipsySnap) # est dDelta dDelta = ICgen_utils.est_time_step(paramName, preset) param['dDelta'] = dDelta # ------------------------------------------------- # Create director file # ------------------------------------------------- # largest radius to plot r_director = float(0.9 * r.max()) # Maximum surface density sigma_min = float(ICobj.sigma(r_director)) # surface density at largest radius sigma_max = float(ICobj.sigma.input_dict['sigma'].max()) # Create director dict director = make_director(sigma_min, sigma_max, r_director, filename=param['achOutName']) ## Save .director file #configsave(director, directorName, 'director') #Now that velocities and everything are all initialized for gas particles, create new snapshot to return in which #single star particle is replaced by 2, same units as above snapshotBinary = pynbody.new(star=2,gas=nParticles) snapshotBinary['eps'] = 0.01*SimArray(np.ones(nParticles+2, dtype=np.float32), pos_unit) snapshotBinary['metals'] = SimArray(np.zeros(nParticles+2, dtype=np.float32)) snapshotBinary['vel'].units = v_unit snapshotBinary['pos'].units = pos_unit snapshotBinary['mass'].units = snapshot['mass'].units snapshotBinary['rho'] = SimArray(np.zeros(nParticles+2, dtype=np.float32)) #Assign gas particles with calculated/given values from above snapshotBinary.gas['pos'] = snapshot.gas['pos'] snapshotBinary.gas['vel'] = snapshot.gas['vel'] snapshotBinary.gas['temp'] = snapshot.gas['temp'] snapshotBinary.gas['rho'] = snapshot.gas['rho'] snapshotBinary.gas['eps'] = snapshot.gas['eps'] snapshotBinary.gas['mass'] = snapshot.gas['mass'] snapshotBinary.gas['metals'] = snapshot.gas['metals'] #Load Binary system obj to initialize system binsys = ICobj.settings.physical.binsys x1,x2,v1,v2 = binsys.generateICs() #Put velocity in sim units #!!! Note: v_unit_vel will always be 29.785598165 km/s when m_unit = Msol and r_unit = 1 AU in kpc!!! #conv = v_unit_vel #km/s in sim units #v1 /= conv #v2 /= conv #Assign position, velocity assuming CCW orbit snapshotBinary.star[0]['pos'] = SimArray(x1,pos_unit) snapshotBinary.star[0]['vel'] = SimArray(v1,v_unit) snapshotBinary.star[1]['pos'] = SimArray(x2,pos_unit) snapshotBinary.star[1]['vel'] = SimArray(v2,v_unit) #Set stellar masses #Set Mass units #Create simArray for mass, convert units to simulation mass units priMass = SimArray(binsys.m1,m_unit) secMass = SimArray(binsys.m2,m_unit) snapshotBinary.star[0]['mass'] = priMass snapshotBinary.star[1]['mass'] = secMass snapshotBinary.star['metals'] = SimArray(star_metals) #Estimate stars' softening length as fraction of distance to COM d = np.sqrt(AddBinary.dotProduct(x1-x2,x1-x2)) snapshotBinary.star[0]['eps'] = SimArray(math.fabs(d)/4.0,pos_unit) snapshotBinary.star[1]['eps'] = SimArray(math.fabs(d)/4.0,pos_unit) print 'Wrapping up' # Now set the star particle's tform to a negative number. This allows # UW ChaNGa treat it as a sink particle. snapshotBinary.star['tform'] = -1.0 #Set Sink Radius to be mass-weighted average of Roche lobes of two stars r1 = AddBinary.calcRocheLobe(binsys.m1/binsys.m2,binsys.a) r2 = AddBinary.calcRocheLobe(binsys.m2/binsys.m1,binsys.a) p = strip_units(binsys.m1/(binsys.m1 + binsys.m2)) r_sink = (r1*p) + (r2*(1.0-p)) param['dSinkBoundOrbitRadius'] = r_sink param['dSinkRadius'] = r_sink param['dSinkMassMin'] = 0.9 * strip_units(secMass) param['bDoSinks'] = 1 return snapshotBinary, param, director
def snapshot_gen(ICobj): """ Generates a tipsy snapshot from the initial conditions object ICobj. Returns snapshot, param snapshot: tipsy snapshot param: dictionary containing info for a .param file Note: Code has been edited (dflemin3) such that now it returns a snapshot for a circumbinary disk where initial conditions generated assuming star at origin of mass M. After gas initialized, replaced star at origin with binary system who's center of mass lies at the origin and who's mass m1 +m2 = M """ print 'Generating snapshot...' # Constants G = SimArray(1.0, 'G') # ------------------------------------ # Load in things from ICobj # ------------------------------------ print 'Accessing data from ICs' settings = ICobj.settings # snapshot file name snapshotName = settings.filenames.snapshotName paramName = settings.filenames.paramName #Load user supplied snapshot (assumed to be in cwd) path = "/astro/store/scratch/tmp/dflemin3/nbodyshare/9au-Q1.05-129K/" snapshot = pynbody.load(path + snapshotName) # particle positions r = snapshot.gas['r'] xyz = snapshot.gas['pos'] # Number of particles nParticles = len(snapshot.gas) # molecular mass m = settings.physical.m #Pull star mass from user-supplied snapshot ICobj.settings.physical.M = snapshot.star[ 'mass'] #Total stellar mass in solar masses m_star = ICobj.settings.physical.M # disk mass m_disk = np.sum(snapshot.gas['mass']) m_disk = isaac.match_units(m_disk, m_star)[0] # mass of the gas particles m_particles = m_disk / float(nParticles) # re-scale the particles (allows making of low-mass disk) m_particles *= settings.snapshot.mScale # ------------------------------------------------- # Assign output # ------------------------------------------------- print 'Assigning data to snapshot' # Get units all set up m_unit = m_star.units pos_unit = r.units if xyz.units != r.units: xyz.convert_units(pos_unit) # time units are sqrt(L^3/GM) t_unit = np.sqrt((pos_unit**3) * np.power((G * m_unit), -1)).units # velocity units are L/t v_unit = (pos_unit / t_unit).ratio('km s**-1') # Make it a unit, save value for future conversion v_unit_vel = v_unit #Ensure v_unit_vel is the same as what I assume it is. assert (np.fabs(AddBinary.VEL_UNIT - v_unit_vel) < AddBinary.SMALL), "VEL_UNIT not equal to ChaNGa unit! Why??" v_unit = pynbody.units.Unit('{0} km s**-1'.format(v_unit)) # Other settings metals = settings.snapshot.metals star_metals = metals # Estimate the star's softening length as the closest particle distance eps = r.min() # Make param file param = isaac.make_param(snapshot, snapshotName) param['dMeanMolWeight'] = m gc.collect() # CALCULATE VELOCITY USING calc_velocity.py. This also estimates the # gravitational softening length eps preset = settings.changa_run.preset # ------------------------------------------------- # Estimate time step for changa to use # ------------------------------------------------- # Save param file isaac.configsave(param, paramName, 'param') # Save snapshot snapshot.write(filename=snapshotName, fmt=pynbody.tipsy.TipsySnap) # est dDelta dDelta = ICgen_utils.est_time_step(paramName, preset) param['dDelta'] = dDelta # ------------------------------------------------- # Create director file # ------------------------------------------------- # largest radius to plot r_director = float(0.9 * r.max()) # Maximum surface density sigma_min = float(ICobj.sigma(r_director)) # surface density at largest radius sigma_max = float(ICobj.sigma.input_dict['sigma'].max()) # Create director dict director = isaac.make_director(sigma_min, sigma_max, r_director, filename=param['achOutName']) ## Save .director file #isaac.configsave(director, directorName, 'director') """ Now that the gas disk is initializes around the primary (M=m1), add in the second star as specified by the user. """ #Now that velocities and everything are all initialized for gas particles, create new snapshot to return in which #single star particle is replaced by 2, same units as above snapshotBinary = pynbody.new(star=2, gas=nParticles) snapshotBinary['eps'] = 0.01 * SimArray( np.ones(nParticles + 2, dtype=np.float32), pos_unit) snapshotBinary['metals'] = SimArray( np.zeros(nParticles + 2, dtype=np.float32)) snapshotBinary['vel'].units = v_unit snapshotBinary['pos'].units = pos_unit snapshotBinary['mass'].units = snapshot['mass'].units snapshotBinary['rho'] = SimArray(np.zeros(nParticles + 2, dtype=np.float32)) #Assign gas particles with calculated/given values from above snapshotBinary.gas['pos'] = snapshot.gas['pos'] snapshotBinary.gas['vel'] = snapshot.gas['vel'] snapshotBinary.gas['temp'] = snapshot.gas['temp'] snapshotBinary.gas['rho'] = snapshot.gas['rho'] snapshotBinary.gas['eps'] = snapshot.gas['eps'] snapshotBinary.gas['mass'] = snapshot.gas['mass'] snapshotBinary.gas['metals'] = snapshot.gas['metals'] #Load Binary system obj to initialize system binsys = ICobj.settings.physical.binsys m_disk = isaac.strip_units(np.sum(snapshotBinary.gas['mass'])) binsys.m1 = isaac.strip_units(m_star) binsys.m1 = binsys.m1 + m_disk #Recompute cartesian coords considering primary as m1+m_disk binsys.computeCartesian() x1, x2, v1, v2 = binsys.generateICs() #Assign position, velocity assuming CCW orbit snapshotBinary.star[0]['pos'] = SimArray(x1, pos_unit) snapshotBinary.star[0]['vel'] = SimArray(v1, v_unit) snapshotBinary.star[1]['pos'] = SimArray(x2, pos_unit) snapshotBinary.star[1]['vel'] = SimArray(v2, v_unit) """ We have the binary positions about their center of mass, (0,0,0), so shift the position, velocity of the gas disk to be around the primary. """ snapshotBinary.gas['pos'] += snapshotBinary.star[0]['pos'] snapshotBinary.gas['vel'] += snapshotBinary.star[0]['vel'] #Set stellar masses: Create simArray for mass, convert units to simulation mass units snapshotBinary.star[0]['mass'] = SimArray(binsys.m1 - m_disk, m_unit) snapshotBinary.star[1]['mass'] = SimArray(binsys.m2, m_unit) snapshotBinary.star['metals'] = SimArray(star_metals) print 'Wrapping up' # Now set the star particle's tform to a negative number. This allows # UW ChaNGa treat it as a sink particle. snapshotBinary.star['tform'] = -1.0 #Set sink radius, stellar smoothing length as fraction of distance #from primary to inner edge of the disk r_sink = eps snapshotBinary.star[0]['eps'] = SimArray(r_sink / 2.0, pos_unit) snapshotBinary.star[1]['eps'] = SimArray(r_sink / 2.0, pos_unit) param['dSinkBoundOrbitRadius'] = r_sink param['dSinkRadius'] = r_sink param['dSinkMassMin'] = 0.9 * binsys.m2 param['bDoSinks'] = 1 return snapshotBinary, param, director
def snapshot_gen(ICobj): """ Generates a tipsy snapshot from the initial conditions object ICobj. Returns snapshot, param snapshot: tipsy snapshot param: dictionary containing info for a .param file """ print 'Generating snapshot...' # Constants G = SimArray(1.0, 'G') # ------------------------------------ # Load in things from ICobj # ------------------------------------ print 'Accessing data from ICs' settings = ICobj.settings # filenames snapshotName = settings.filenames.snapshotName paramName = settings.filenames.paramName # particle positions r = ICobj.pos.r xyz = ICobj.pos.xyz # Number of particles nParticles = ICobj.pos.nParticles # molecular mass m = settings.physical.m # star mass m_star = settings.physical.M.copy() # disk mass m_disk = ICobj.sigma.m_disk.copy() m_disk = isaac.match_units(m_disk, m_star)[0] # mass of the gas particles m_particles = m_disk / float(nParticles) # re-scale the particles (allows making of lo-mass disk) m_particles *= settings.snapshot.mScale # ------------------------------------------------- # Assign output # ------------------------------------------------- print 'Assigning data to snapshot' # Get units all set up m_unit = m_star.units pos_unit = r.units if xyz.units != r.units: xyz.convert_units(pos_unit) # time units are sqrt(L^3/GM) t_unit = np.sqrt((pos_unit**3) * np.power((G * m_unit), -1)).units # velocity units are L/t v_unit = (pos_unit / t_unit).ratio('km s**-1') # Make it a unit v_unit = pynbody.units.Unit('{0} km s**-1'.format(v_unit)) # Other settings metals = settings.snapshot.metals star_metals = metals # ------------------------------------------------- # Initialize snapshot # ------------------------------------------------- # Note that empty pos, vel, and mass arrays are created in the snapshot snapshot = pynbody.new(star=1, gas=nParticles) snapshot['vel'].units = v_unit snapshot['eps'] = 0.01 * SimArray( np.ones(nParticles + 1, dtype=np.float32), pos_unit) snapshot['metals'] = SimArray(np.zeros(nParticles + 1, dtype=np.float32)) snapshot['rho'] = SimArray(np.zeros(nParticles + 1, dtype=np.float32)) snapshot.gas['pos'] = xyz snapshot.gas['temp'] = ICobj.T(r) snapshot.gas['mass'] = m_particles snapshot.gas['metals'] = metals snapshot.star['pos'] = SimArray([[0., 0., 0.]], pos_unit) snapshot.star['vel'] = SimArray([[0., 0., 0.]], v_unit) snapshot.star['mass'] = m_star snapshot.star['metals'] = SimArray(star_metals) # Estimate the star's softening length as the closest particle distance snapshot.star['eps'] = r.min() # Make param file param = isaac.make_param(snapshot, snapshotName) param['dMeanMolWeight'] = m eos = (settings.physical.eos).lower() if eos == 'adiabatic': param['bGasAdiabatic'] = 1 param['bGasIsothermal'] = 0 param['dConstGamma'] gc.collect() # ------------------------------------------------- # CALCULATE VELOCITY USING calc_velocity.py. This also estimates the # gravitational softening length eps # ------------------------------------------------- print 'Calculating circular velocity' preset = settings.changa_run.preset max_particles = global_settings['misc']['max_particles'] calc_velocity.v_xy(snapshot, param, changa_preset=preset, max_particles=max_particles) gc.collect() # ------------------------------------------------- # Estimate time step for changa to use # ------------------------------------------------- # Save param file isaac.configsave(param, paramName, 'param') # Save snapshot snapshot.write(filename=snapshotName, fmt=pynbody.tipsy.TipsySnap) # est dDelta dDelta = ICgen_utils.est_time_step(paramName, preset) param['dDelta'] = dDelta # ------------------------------------------------- # Create director file # ------------------------------------------------- # largest radius to plot r_director = float(0.9 * r.max()) # Maximum surface density sigma_min = float(ICobj.sigma(r_director)) # surface density at largest radius sigma_max = float(ICobj.sigma.input_dict['sigma'].max()) # Create director dict director = isaac.make_director(sigma_min, sigma_max, r_director, filename=param['achOutName']) ## Save .director file #isaac.configsave(director, directorName, 'director') # ------------------------------------------------- # Wrap up # ------------------------------------------------- print 'Wrapping up' # Now set the star particle's tform to a negative number. This allows # UW ChaNGa treat it as a sink particle. snapshot.star['tform'] = -1.0 # Update params r_sink = isaac.strip_units(r.min()) param['dSinkBoundOrbitRadius'] = r_sink param['dSinkRadius'] = r_sink param['dSinkMassMin'] = 0.9 * isaac.strip_units(m_star) param['bDoSinks'] = 1 return snapshot, param, director