def save(ICobj, filename=None):
if filename is None:
filename = ICobj.settings.filenames.IC_file_name
save_dict = {}
if hasattr(ICobj, '__version__'):
save_dict['version'] = ICobj.__version__
# --------------------------------------------------
# GET SETTINGS/save a copy
# --------------------------------------------------
save_dict['settings'] = ICobj.settings
settings_name = os.path.splitext(filename)[0] + '_settings.p'
ICobj.settings.save(settings_name)
# --------------------------------------------------
# Prepare rho, if available
# --------------------------------------------------
if hasattr(ICobj, 'rho'):
rho = ICobj.rho
# Generate a dictionary containing rho_binned, z_bins, r_bins
rho_dict = {\
'rho': rho.rho_binned,\
'z': rho.z_bins,\
'r': rho.r_bins}
# Update save dictionary
save_dict['rho'] = rho_dict
# --------------------------------------------------
# Prepare sigma, if available
# --------------------------------------------------
if hasattr(ICobj, 'sigma'):
sigma = ICobj.sigma
# Update save dictionary
save_dict['sigma'] = sigma.input_dict
save_dict['CDF'] = sigma._CDF
# --------------------------------------------------
# Prepare pos if possible
# --------------------------------------------------
if hasattr(ICobj, 'pos'):
save_dict['pos'] = ICobj.pos
# --------------------------------------------------
# Prepare param/dict if possible
# --------------------------------------------------
if hasattr(ICobj, 'snapshot_param'):
save_dict['snapshot_param'] = ICobj.snapshot_param
param_name = ICobj.settings.filenames.paramName
isaac.configsave(ICobj.snapshot_param, param_name)
print 'param file saved to {0}'.format(param_name)
if hasattr(ICobj, 'snapshot_director'):
save_dict['snapshot_director'] = ICobj.snapshot_director
director_name = ICobj.settings.filenames.directorName
isaac.configsave(ICobj.snapshot_director, director_name)
print 'director file saved to {0}'.format(director_name)
# --------------------------------------------------
# SAVE
# --------------------------------------------------
# Save snapshot if possible
if hasattr(ICobj, 'snapshot'):
fmt = pynbody.tipsy.TipsySnap
fname = ICobj.settings.filenames.snapshotName
save_dict['snapshotName'] = fname
# Sometimes, saving the snapshot once raises an error. Saving again
# can fix this for some reason
try:
ICobj.snapshot.write(fmt=fmt, filename=fname)
except ValueError:
ICobj.snapshot.write(fmt=fmt, filename=fname)
# Save the save dictionary
pickle.dump(save_dict, open(filename, 'wb'), protocol=2)
print 'Initial conditions saved to {0}'.format(filename)
def make_continue_sub(simdir='.', paramname='snapshot.param', \
newparam='continue.param', t=None, t_extra=None, oldsub='subber.sh', \
newsub='cont_subber.sh'):
"""
Makes a submission script for continuing a simulation from a previous output.
Also makes a .param file for the continued simulation. The simulation
will be continued in the same directory, with snapshot numbering scheme
for outputs being the same.
Parameters for the original simulation cannot be altered (except the number
of steps you want to continue the simulation by). PBS runtime parameters
also cannot be changed (number of nodes, walltime, etc...)
Any checkpoints will be deleted.
Requires a submission script be present for the original simulation
NOTE: if nSteps, nSteps_extra are not set, the total number of steps
to simulate is not changed.
**ARGUMENTS**
simdir : str
The simulation directory
paramname : str
Filename of the .param file for the simulation
newparam : str
filename for the .param file for the continued simulation
t : float or SimArray
Total simulation time to run.
If no units are specified, it is in simulation units
t_extra : float or SimArray
Extra simulation time to run
If no units are specified, it is in simulation units
OVERIDES t!!!
oldsub : str
Filename for the original submission script
newsub : str
Filename for the new submission script
**RETURNS**
sub_path : str
Full path to the PBS submission script
"""
# Lazy man's way of dealing with files in another directory
cwd = os.getcwd()
os.chdir(simdir)
# Load param file
param = isaac.configparser(paramname, 'param')
fprefix = param['achOutName']
# Find all the outputs. They should be of the format fprefix.000000
search_exp = '^' + fprefix + '.(?:(?<!\d)\d{6}(?!\d))$'
flist = []
for fname in glob.glob(fprefix + '*'):
if re.search(search_exp, fname) is not None:
flist.append(fname)
# Find the number of the last output (the last 6 chars should be an int)
flist.sort()
iStartStep = int(flist[-1][-6:])
param['iStartStep'] = iStartStep
param['achInFile'] = flist[-1]
dDelta = param['dDelta']
# Set the number of steps to run
if t_extra is not None:
# Convert to simulation units if needed
if pynbody.units.has_units(t_extra):
t_unit = isaac.units_from_param(param)['t_unit']
t_extra.convert_units(t_unit)
# Assign output
param['nSteps'] = iStartStep + int(round(t_extra / dDelta))
elif t is not None:
# Convert to simulation units if needed
if pynbody.units.has_units(t):
t_unit = isaac.units_from_param(param)['t_unit']
t.convert_units(t_unit)
# Assign output
param['nSteps'] = int(round(t / dDelta))
# Save new param file
isaac.configsave(param, newparam, ftype='param')
# Delete old checkpoints
for checkpoint in glob.glob(fprefix + '.chk*'):
print 'removing ' + checkpoint
os.system('rm -rf ' + checkpoint)
if os.path.exists('lastcheckpoint'):
print 'removing lastcheckpoint'
os.remove('lastcheckpoint')
# Create a submission script for the simulation continuation
oldsubfile = open(oldsub, 'r')
newsubfile = open(newsub, 'w')
for line in oldsubfile:
newsubfile.write(line.replace(paramname, newparam))
oldsubfile.close()
newsubfile.close()
# Make the submission script executable
os.chmod(newsub, 0777)
sub_path = os.path.abspath(newsub)
# Change back to original working directory
os.chdir(cwd)
return sub_path
def v_xy(f, param, changbin=None, nr=50, min_per_bin=100):
"""
Attempts to calculate the circular velocities for particles in a thin
(not flat) keplerian disk. Requires ChaNGa
**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.
**RETURNS**
vel : SimArray
An N by 3 SimArray of gas particle velocities.
"""
if changbin is None:
# Try to find the ChaNGa binary full path
changbin = os.popen('which ChaNGa').read().strip()
# Load stuff from the snapshot
x = f.g['x']
y = f.g['y']
z = f.g['z']
r = f.g['rxy']
vel0 = f.g['vel'].copy()
# Remove units from all quantities
r = isaac.strip_units(r)
x = isaac.strip_units(x)
y = isaac.strip_units(y)
z = isaac.strip_units(z)
# 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
if 'dDumpFrameTime' in p_temp: p_temp.pop('dDumpFrameTime')
if 'dDumpFrameStep' in p_temp: p_temp.pop('dDumpFrameStep')
# --------------------------------------------
# Estimate velocity from gravity only
# --------------------------------------------
# Note, accelerations due to gravity are calculated twice to be extra careful
# This is so that any velocity dependent effects are properly accounted for
# (although, ideally, there should be none)
# The second calculation uses the updated velocities from the first
for iGrav in range(2):
# Save files
f.write(filename=f_name, fmt=pynbody.tipsy.TipsySnap)
isaac.configsave(p_temp, p_name, ftype='param')
# Run ChaNGa, only calculating gravity
command = 'charmrun ++local ' + changbin + ' -gas -n 0 ' + p_name
p = subprocess.Popen(command.split(), stdout=subprocess.PIPE)
while p.poll() is None:
time.sleep(0.1)
# Load accelerations
acc_name = f_prefix + '.000000.acc2'
a = isaac.load_acc(acc_name)
# Clean-up
for fname in glob.glob(f_prefix + '*'):
os.remove(fname)
# If a is not a vector, calculate radial acceleration. Otherwise, assume
# a is the radial acceleration
a_r = a[:, 0] * x / r + a[:, 1] * y / r
# Make sure the units are correct then remove them
a_r = isaac.match_units(a_r, a)[0]
a_r = isaac.strip_units(a_r)
# Calculate cos(theta) where theta is angle above x-y plane
cos = r / np.sqrt(r**2 + z**2)
ar2 = a_r * 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)
# 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_calc = m_spline(r) * cos + b_spline(r)
v_calc = np.sqrt(abs(ar2_calc) / r)
vel = f.g['vel'].copy()
v_calc = isaac.match_units(v_calc, vel)[0]
vel[:, 0] = -v_calc * y / r
vel[:, 1] = v_calc * x / r
# Assign to f
f.g['vel'] = vel
# --------------------------------------------
# Estimate pressure/gas dynamics accelerations
# --------------------------------------------
a_grav = a
ar2_calc_grav = ar2_calc
# Save files
f.write(filename=f_name, fmt=pynbody.tipsy.TipsySnap)
isaac.configsave(p_temp, p_name, ftype='param')
# Run ChaNGa, including SPH
command = 'charmrun ++local ' + changbin + ' +gas -n 0 ' + p_name
p = subprocess.Popen(command.split(), stdout=subprocess.PIPE)
while p.poll() is None:
time.sleep(0.1)
# Load accelerations
acc_name = f_prefix + '.000000.acc2'
a_total = isaac.load_acc(acc_name)
# 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_grav
ar_gas = a_gas[:, 0] * x / r + a_gas[:, 1] * y / r
ar_gas = isaac.strip_units(ar_gas)
ar2_gas = ar_gas * r**2
logr_bins, ratio, err = isaac.binned_mean(np.log(r), ar2_gas/ar2_calc_grav, nbins=nr,\
weighted_bins=True)
r_bins = np.exp(logr_bins)
ratio_spline = isaac.extrap1d(r_bins, ratio)
ar2_calc = ar2_calc_grav * (1 + ratio_spline(r))
a_calc = ar2_calc / r**2
v = np.sqrt(r * abs(a_calc))
v = isaac.match_units(v, vel0.units)[0]
vel = vel0.copy()
vel[:, 0] = -v * y / r
vel[:, 1] = v * x / r
# more cleanup
f.g['vel'] = vel0
return vel
# Start saving log file
logFile = open(logFileName, 'w')
logFile.write('Generated from settings file: {0}\n'.format(
os.path.abspath(settings_file)))
m_amu = float((m * 0.992733 / pynbody.units.m_p).in_units('1'))
# Save director file
if paramName is not None:
try:
import isaac
defPar = os.path.join(ICgenDir, 'default.param')
pars = isaac.configparser(defPar, ftype='param')
pars['achInFile'] = snapshotName
pars['achOutName'] = os.path.splitext(snapshotName)[0]
# Convert molecular mass from mass of proton to amu
pars['dMeanMolWeight'] = m_amu
isaac.configsave(pars, paramName, ftype='param')
print 'ChaNGa parameter file saved to {0}'.format(paramName)
logFile.write(
'ChaNGa parameter file saved to {0}\n'.format(paramName))
except:
print 'Could not save .param file. Check that the module isaac\
was properly imported'
#Continue writing to log file
logFile.write('Tipsy snapshot saved to {0}\n'.format(snapshotName))
logFile.write('Surface density profile saved to {0}\n\
rho(z,r) saved to {1}\n\
random positions saved to {2}\n'.format(sigmaFileName, rhoFileName,
posFileName))
logFile.write('Mstar = {0} {1}\n\
Mean molecular mass: {2} amu\n'.format(mStar, mStar.units, m_amu))
def v_xy(snapshot, param, changbin=None):
"""
Attempts to calculate the circular velocities for particles in a thin
(not flat) keplerian disk. Requires ChaNGa
ARGUMENTS:
snapshot: a tipsy snapshot for a gaseous disk
param: a dictionary containing params for changa.
(see isaac.configparser)
changbin: (OPTIONAL) If set, should be the full path to the ChaNGa
executable. If None, an attempt to find ChaNGa is made
"""
if changbin is None:
# Try to find the ChaNGa binary full path
changbin = os.popen('which ChaNGa').read().strip()
# --------------------------------------------
# Initialize
# --------------------------------------------
# Load things from snapshot
x = snapshot.g['x']
y = snapshot.g['y']
z = snapshot.g['z']
r = snapshot.g['rxy']
v_initial = snapshot.g['vel'].copy()
# 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
if 'dDumpFrameTime' in p_temp: p_temp.pop('dDumpFrameTime')
if 'dDumpFrameStep' in p_temp: p_temp.pop('dDumpFrameStep')
# --------------------------------------------
# Estimate velocity from gravity only
# --------------------------------------------
# Save files
snapshot.write(filename=f_name, fmt=pynbody.tipsy.TipsySnap)
isaac.configsave(p_temp, p_name, ftype='param')
# Run ChaNGa, only calculating gravity
command = 'charmrun ++local ' + changbin + ' -gas -n 0 ' + p_name
p = subprocess.Popen(command.split(), stdout=subprocess.PIPE)
while p.poll() is None:
time.sleep(0.1)
# Load accelerations
acc_name = f_prefix + '.000000.acc2'
a = isaac.load_acc(acc_name)
# Calculate radial acceleration
a_r = a[:, 0] * x / r + a[:, 1] * y / r
# circular velocity
v = np.sqrt(abs(r * a_r))
# Assign
snapshot.g['vel'][:, 0] = -v * y / r
snapshot.g['vel'][:, 1] = v * x / r
# --------------------------------------------
# Estimate velocity from gravity & sph (assuming bDoGas=1 in param)
# --------------------------------------------
# Write file
snapshot.write(filename=f_name, fmt=pynbody.tipsy.TipsySnap)
# Run ChaNGa, only calculating gravity
changbin = os.popen('which ChaNGa').read().strip()
#command = 'charmrun ++local ' + changbin + ' +gas -n 0 ' + p_name
command = 'charmrun ++local ' + changbin + ' -n 0 ' + p_name
p = subprocess.Popen(command.split(), stdout=subprocess.PIPE)
while p.poll() is None:
time.sleep(0.1)
# Load accelerations
acc_name = f_prefix + '.000000.acc2'
a = isaac.load_acc(acc_name)
# Calculate radial acceleration
a_r = a[:, 0] * x / r + a[:, 1] * y / r
# circular velocity
v = np.sqrt(abs(r * a_r))
logv = np.log(v)
logr = np.log(r)
logr_bins, logv_mean, err = isaac.binned_mean(logr, logv, 50, \
weighted_bins=True)
logv_spline = isaac.extrap1d(logr_bins, logv_mean)
v_calc = np.exp(logv_spline(logr))
v_calc = isaac.match_units(v_calc, v_initial.units)[0]
v_out = v_initial * 0.0
v_out[:, 0] = -v_calc * y / r
v_out[:, 1] = v_calc * x / r
# Clean-up
for fname in glob.glob(f_prefix + '*'):
os.remove(fname)
# Re-assign velocity to snapshot
snapshot.g['vel'] = v_initial
return v_out
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 = 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
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
#snapshot.star['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 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 = isaac.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 * isaac.strip_units(secMass)
param['bDoSinks'] = 1
return snapshotBinary, param, director
def find_clumps(f,
n_smooth=32,
param=None,
arg_string=None,
seed=None,
verbose=True):
"""
Uses skid (https://github.com/N-BodyShop/skid) to find clumps in a gaseous
protoplanetary disk.
The linking length used is equal to the gravitational softening length of
the gas particles.
The density cut-off comes from the criterion that there are n_smooth particles
within the Hill sphere of a particle. This is formulated mathematically as:
rho_min = 3*n_smooth*Mstar/R^3
where R is the distance from the star. The trick used here is to multiply
all particle masses by R^3 before running skid so the density cut-off is:
rho_min = 3*n_smooth*Mstar
**ARGUMENTS**
*f* : TipsySnap, or str
A tipsy snapshot loaded/created by pynbody -OR- a filename pointing to a
snapshot.
*n_smooth* : int (optional)
Number of particles used in SPH calculations. Should be the same as used
in the simulation. Default = 32
*param* : str (optional)
filename for a .param file for the simulation
*arg_string* : str (optional)
Additional arguments to be passed to skid. Cannot use -tau, -d, -m, -s, -o
*seed* : int
An integer used to seed the random filename generation for temporary
files. Necessary for multiprocessing and should be unique for each
thread.
*verbose* : bool
Verbosity flag. Default is True
**RETURNS**
*clumps* : array, int-like
Array containing the group number each particle belongs to, with star
particles coming after gas particles. A zero means the particle belongs
to no groups
"""
# Parse areguments
if isinstance(f, str):
f = pynbody.load(f, paramfile=param)
if seed is not None:
np.random.seed(seed)
# Estimate the linking length as the gravitational softening length
tau = f.g['eps'][0]
# Calculate minimum density
rho_min = 3 * n_smooth * f.s['mass'][0]
# Center on star. This is done because R used in hill-sphere calculations
# is relative to the star
star_pos = f.s['pos'].copy()
f['pos'] -= star_pos
# Scale mass by R^3
R = isaac.strip_units(f['rxy'])
m0 = f['mass'].copy()
f['mass'] *= (R + tau)**3
# Save temporary snapshot
f_prefix = str(np.random.randint(np.iinfo(int).max))
f_name = f_prefix + '.std'
# Save temporary .param file
if param is not None:
param_name = f_prefix + '.param'
param_dict = isaac.configparser(param, 'param')
isaac.configsave(param_dict, param_name)
f.write(filename=f_name, fmt=pynbody.tipsy.TipsySnap)
f['pos'] += star_pos
f['mass'] = m0
command = 'totipnat < {} | skid -tau {:.2e} -d {:.2e} -m {:d} -s {:d} -o {}'\
.format(f_name, tau, rho_min, n_smooth, n_smooth, f_prefix)
p = subprocess.Popen(command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if verbose:
for line in iter(p.stdout.readline, ''):
print line,
p.wait()
# Load clumps
clumps = isaac.loadhalos(f_prefix + '.grp')
# Cleanup
for name in glob.glob(f_prefix + '*'):
os.remove(name)
return clumps
def save(ICobj, filename=None):
if filename is None:
filename = ICobj.settings.filenames.IC_file_name
save_dict = {}
# --------------------------------------------------
# GET SETTINGS
# --------------------------------------------------
save_dict['settings'] = ICobj.settings
# --------------------------------------------------
# Prepare rho, if available
# --------------------------------------------------
if hasattr(ICobj, 'rho'):
rho = ICobj.rho
# Generate a dictionary containing rho_binned, z_bins, r_bins
rho_dict = {\
'rho': rho.rho_binned,\
'z': rho.z_bins,\
'r': rho.r_bins}
# Update save dictionary
save_dict['rho'] = rho_dict
# --------------------------------------------------
# Prepare sigma, if available
# --------------------------------------------------
if hasattr(ICobj, 'sigma'):
sigma = ICobj.sigma
# Update save dictionary
save_dict['sigma'] = sigma.input_dict
# --------------------------------------------------
# Prepare pos if possible
# --------------------------------------------------
if hasattr(ICobj, 'pos'):
save_dict['pos'] = ICobj.pos
# --------------------------------------------------
# Prepare param if possible
# --------------------------------------------------
if hasattr(ICobj, 'snapshot_param'):
save_dict['snapshot_param'] = ICobj.snapshot_param
param_name = ICobj.settings.filenames.paramName
isaac.configsave(ICobj.snapshot_param, param_name)
print 'param file saved to {}'.format(param_name)
# --------------------------------------------------
# SAVE
# --------------------------------------------------
# Save snapshot if possible
if hasattr(ICobj, 'snapshot'):
fmt = pynbody.tipsy.TipsySnap
fname = ICobj.settings.filenames.snapshotName
save_dict['snapshotName'] = fname
ICobj.snapshot.write(fmt=fmt, filename=fname)
# Save the save dictionary
pickle.dump(save_dict, open(filename, 'wb'))
print 'Initial conditions saved to {}'.format(filename)
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
