def __init__(
self,
rho0,
p0,
wavenumber_factor=4.0,
pertubation_amplitude=1e-3,
gamma=5.0/3.0,
ncells=100):
self.rho0 = rho0
self.p0 = p0
self.pertubation_amplitude = pertubation_amplitude
self.gamma = gamma
self.ncells = ncells
self.dimensions_of_mesh = (ncells, ncells, 1)
self.sound_speed = (self.gamma * self.p0 / self.rho0).sqrt()
self.jeans_wavenumber = (
4 * numpy.pi * constants.G * self.rho0).sqrt() / self.sound_speed
self.wavenumber = wavenumber_factor * self.jeans_wavenumber
self.length_scale = (
0.5 * (
numpy.pi * self.gamma * self.p0 / (
constants.G * self.rho0**2
)
).sqrt()
)
self.unit_converter = \
generic_unit_converter.ConvertBetweenGenericAndSiUnits(
self.length_scale,
1 | units.s,
1 | units.g
)
def test16(self):
print "Testing add_interface_parameter"
class TestModule(BaseTestModule):
pass
o = TestModule()
parameters_handler = HandleParameters(o)
parameters_handler.add_vector_parameter(
"mesh_length",
"length of the model in the x, y and z directions",
("length_x", "length_y", "length_z")
)
for i,par_name in enumerate(["length_x", "length_y", "length_z"]):
parameters_handler.add_interface_parameter(
par_name,
"a test parameter",
default_value = i*10.0 | generic_unit_system.length,
)
x = parameters_handler.get_attribute(None, None)
self.assertTrue("mesh_length" in str(x))
self.assertTrue("[0.0, 10.0, 20.0] length" in str(x))
converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(2.0 | units.m, 4.0 | units.kg, 6.0 | units.s)
y = parameters.ParametersWithUnitsConverted(
x,
converter.as_converter_from_si_to_generic()
)
self.assertTrue("mesh_length" in str(y))
self.assertTrue("[0.0, 20.0, 40.0] m" in str(y))
def slowtest4(self):
print "Generate a model for a disk galaxy (10k disk, no bulge, 20k halo) - SI units"
halo_number_of_particles = 20000
converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
constants.G, 1.0e12 | units.MSun, 50.0 | units.kpc)
particles = new_galactics_model(halo_number_of_particles,
disk_number_of_particles=10000,
generate_bulge_flag=False,
do_scale=True,
unit_system_converter=converter)
self.assertEquals(len(particles), 30000)
self.assertAlmostRelativeEquals(particles.total_mass(),
1.0e12 | units.MSun, 10)
self.assertAlmostRelativeEquals(
particles.kinetic_energy(),
converter.to_si(0.25 | nbody_system.energy), 10)
disk = particles[:10000]
self.assertAlmostRelativeEquals(disk.total_mass(),
2.156e10 | units.MSun, 3)
self.assertAlmostRelativeEquals(
disk.position.lengths_squared().amax().sqrt().in_(units.kpc),
15.584 | units.kpc, 3)
self.assertAlmostRelativeEquals(
disk.position.std(axis=0).in_(units.kpc),
[3.5934, 3.6768, 0.17078] | units.kpc, 3)
write_set_to_file(
particles,
os.path.join(get_path_to_results(), 'disk_galactICs.amuse'),
'amuse')
def make_galaxies():
# File 'disk_galactICs.amuse' contains 30k particles, (10k disk, no bulge, 20k halo)
if os.path.exists('disk_galactICs.amuse'):
galaxy1 = read_set_from_file('disk_galactICs.amuse', 'amuse')
else:
halo_number_of_particles = 20000
converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
constants.G, 1.0e12 | units.MSun, 50.0 | units.kpc)
galaxy1 = new_galactics_model(halo_number_of_particles,
disk_number_of_particles=10000,
generate_bulge_flag=False,
do_scale=True,
unit_system_converter=converter)
write_set_to_file(galaxy1, 'disk_galactICs.amuse', 'amuse')
galaxy2 = Particles(len(galaxy1))
galaxy2.mass = galaxy1.mass
galaxy2.position = galaxy1.position
galaxy2.velocity = galaxy1.velocity
galaxy1.rotate(0.0, numpy.pi / 4, 0.0)
galaxy2.rotate(numpy.pi / 6, 0.0, 0.0)
galaxy1.position += [100.0, 0, 0] | units.kpc
galaxy2.position -= [100.0, 0, 0] | units.kpc
galaxy1.velocity += [0.0, 50.0, 0] | units.km / units.s
galaxy2.velocity -= [0.0, 50.0, 0] | units.km / units.s
return galaxy1, galaxy2
def test11(self):
print(
"Testing ParametersWithUnitsConverted on vector parameters, using add_vector_parameter"
)
class TestModule(BaseTestModule):
x = 123.0 | generic_unit_system.length
y = 456.0 | generic_unit_system.length
z = 789.0 | generic_unit_system.length
def get_length_x(self):
return self.x
def set_length_x(self, value):
self.x = value
def get_length_y(self):
return self.y
def set_length_y(self, value):
self.y = value
def get_length_z(self):
return self.z
def set_length_z(self, value):
self.z = value
o = TestModule()
parameters_handler = HandleParameters(o)
parameters_handler.add_vector_parameter(
"mesh_length", "length of the model in the x, y and z directions",
("length_x", "length_y", "length_z"))
for par_name in ["length_x", "length_y", "length_z"]:
parameters_handler.add_method_parameter(
"get_" + par_name,
"set_" + par_name,
par_name,
"a test parameter",
default_value=10.0 | generic_unit_system.length,
)
x = parameters_handler.get_attribute(None, None)
self.assertTrue("mesh_length" in str(x))
self.assertTrue("[123.0, 456.0, 789.0] length" in str(x))
converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
2.0 | units.m, 4.0 | units.kg, 6.0 | units.s)
y = parameters.ParametersWithUnitsConverted(
x, converter.as_converter_from_si_to_generic())
self.assertTrue("mesh_length" in str(y))
self.assertTrue("[246.0, 912.0, 1578.0] m" in str(y))
def test10(self):
print("Testing ParametersWithUnitsConverted on vector parameters")
definitions = []
for par_name in ["length_x", "length_y", "length_z"]:
definitions.append(
parameters.ModuleMethodParameterDefinition(
"get_" + par_name, "set_" + par_name, par_name,
"a test parameter", 10.0 | generic_unit_system.length))
definitions.append(
parameters.VectorParameterDefinition(
"mesh_length",
"length of the model in the x, y and z directions",
("length_x", "length_y", "length_z"),
[10, 10, 10] | generic_unit_system.length))
class TestModule(BaseTestModule):
x = 123.0 | generic_unit_system.length
y = 456.0 | generic_unit_system.length
z = 789.0 | generic_unit_system.length
def get_length_x(self):
return self.x
def set_length_x(self, value):
self.x = value
def get_length_y(self):
return self.y
def set_length_y(self, value):
self.y = value
def get_length_z(self):
return self.z
def set_length_z(self, value):
self.z = value
o = TestModule()
x = parameters.Parameters(definitions, o)
self.assertTrue("mesh_length" in str(x))
self.assertTrue("[123.0, 456.0, 789.0] length" in str(x))
converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
2.0 | units.m, 4.0 | units.kg, 6.0 | units.s)
y = parameters.ParametersWithUnitsConverted(
x, converter.as_converter_from_si_to_generic())
self.assertTrue("mesh_length" in str(y))
self.assertTrue("[246.0, 912.0, 1578.0] m" in str(y))
def load_string(self, string):
x = Dyn2Xml()
xml_string = x.convert_starlab_string_to_xml_string(string)
xml2particles = Xml2Particles()
xml2particles.dynamics_mass_units = self.dynamics_mass_units
xml2particles.dynamics_time_units = self.dynamics_time_units
xml2particles.dynamics_length_units = self.dynamics_length_units
xml2particles.parse_xml(xml_string)
unit_converter = None
if not self.nbody_to_si_converter is None:
unit_converter = self.nbody_to_si_converter
elif self.must_scale:
if not self._is_valid_scaling_factor(xml2particles.mass_scale):
unit_converter = None
elif not self._is_valid_scaling_factor(xml2particles.time_scale):
unit_converter = nbody_system.nbody_to_si(
(1.0 / xml2particles.mass_scale) | units.MSun,
(1.0 / xml2particles.size_scale) | units.RSun,
)
else:
unit_converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
(1.0 / xml2particles.mass_scale) | units.MSun,
(1.0 / xml2particles.size_scale) | units.RSun,
(1.0 / xml2particles.time_scale) | units.Myr,
)
if unit_converter is None:
result = xml2particles.system
else:
result = datamodel.ParticlesWithUnitsConverted(
xml2particles.system,
unit_converter.as_converter_from_si_to_generic()
)
if self.return_children:
if self.return_converter:
return result[0].children(), unit_converter
else:
return result[0].children()
else:
if self.return_converter:
return result[0], unit_converter
else:
return result[0]
def ism_cube(targetN=10000,
L=10 | units.parsec,
density=(1.14 | units.amu / units.cm**3),
u=50 | (units.kms)**2,
nf=32,
power=-3.,
seed=None,
base_grid=None,
eketh_ratio=1.):
total_mass = density * (2 * L)**3
internalE = total_mass * u
convert = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
total_mass, L, internalE)
return constant_density_div_free_power_law_v_ism_cube(
convert=convert,
targetN=targetN,
nf=nf,
power=power,
seed=seed,
base_grid=base_grid,
eketh_ratio=eketh_ratio)
def new_star_cluster(
stellar_mass=False,
initial_mass_function="salpeter",
upper_mass_limit=125. | units.MSun,
lower_mass_limit=0.1 | units.MSun,
number_of_stars=1024,
effective_radius=3.0 | units.parsec,
star_distribution="plummer",
star_distribution_w0=7.0,
star_distribution_fd=2.0,
star_metallicity=0.01,
# initial_binary_fraction=0,
**kwargs):
"""
Create stars.
When using an IMF, either the stellar mass is fixed (within
stochastic error) or the number of stars is fixed. When using
equal-mass stars, both are fixed.
"""
imf_name = initial_mass_function.lower()
if imf_name == "salpeter":
from amuse.ic.salpeter import new_salpeter_mass_distribution
initial_mass_function = new_salpeter_mass_distribution
elif imf_name == "kroupa":
from amuse.ic.brokenimf import new_kroupa_mass_distribution
initial_mass_function = new_kroupa_mass_distribution
elif imf_name == "flat":
from amuse.ic.flatimf import new_flat_mass_distribution
initial_mass_function = new_flat_mass_distribution
elif imf_name == "fixed":
from amuse.ic.flatimf import new_flat_mass_distribution
def new_fixed_mass_distribution(number_of_particles, *list_arguments,
**keyword_arguments):
return new_flat_mass_distribution(
number_of_particles,
mass_min=stellar_mass / number_of_stars,
mass_max=stellar_mass / number_of_stars,
)
initial_mass_function = new_fixed_mass_distribution
if stellar_mass:
# Add stars to cluster, until mass limit reached (inclusive!)
mass = initial_mass_function(
0,
mass_min=lower_mass_limit,
mass_max=upper_mass_limit,
)
while mass.sum() < stellar_mass:
mass.append(
initial_mass_function(
1,
mass_min=lower_mass_limit,
mass_max=upper_mass_limit,
)[0])
total_mass = mass.sum()
number_of_stars = len(mass)
else:
# Give stars their mass
mass = initial_mass_function(
number_of_stars,
mass_min=lower_mass_limit,
mass_max=upper_mass_limit,
)
total_mass = mass.sum()
converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
total_mass,
1. | units.kms,
effective_radius,
)
# Give stars a position and velocity, based on the distribution model.
if star_distribution == "plummer":
stars = new_plummer_sphere(
number_of_stars,
convert_nbody=converter,
)
elif star_distribution == "king":
stars = new_king_model(
number_of_stars,
star_distribution_w0,
convert_nbody=converter,
)
elif star_distribution == "fractal":
stars = new_fractal_cluster_model(
number_of_stars,
fractal_dimension=star_distribution_fd,
convert_nbody=converter,
)
else:
return -1, "No stellar distribution"
# set the stellar mass.
stars.mass = mass
# set other stellar parameters.
stars.metallicity = star_metallicity
# Virialize the star cluster if > 1 star
if len(stars) > 1:
stars.move_to_center()
stars.scale_to_standard(
convert_nbody=converter,
# virial_ratio=virial_ratio,
# smoothing_length_squared= ...,
)
# Record the cluster's initial parameters to the particle distribution
stars.collection_attributes.initial_mass_function = imf_name
stars.collection_attributes.upper_mass_limit = upper_mass_limit
stars.collection_attributes.lower_mass_limit = lower_mass_limit
stars.collection_attributes.number_of_stars = number_of_stars
stars.collection_attributes.effective_radius = effective_radius
stars.collection_attributes.star_distribution = star_distribution
stars.collection_attributes.star_distribution_w0 = star_distribution_w0
stars.collection_attributes.star_distribution_fd = star_distribution_fd
stars.collection_attributes.star_metallicity = star_metallicity
# Derived/legacy values
stars.collection_attributes.converter_mass = \
converter.to_si(1 | nbody_system.mass)
stars.collection_attributes.converter_length =\
converter.to_si(1 | nbody_system.length)
stars.collection_attributes.converter_speed =\
converter.to_si(1 | nbody_system.speed)
return stars
if __name__ == "__main__":
number_of_grid_points = 40
halfway = int((number_of_grid_points - 1) / 2)
t_end = 1.0 | units.Myr
n_steps = 100
dt = t_end / n_steps
length_unit = 10.0 | units.parsec
mass_unit = (1.14
| units.amu / units.cm**3) * length_unit**3 # ~ total mass
speed_unit = 1.0 | units.kms
converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
length_unit, mass_unit, speed_unit)
hydro_code = Athena(unit_converter=converter,
number_of_workers=2) #,redirection='none')
hydro_code.initialize_code()
hydro_code.parameters.gamma = 1.001
hydro_code.parameters.courant_number = 0.3
hydro_code.parameters.mesh_size = (number_of_grid_points,
number_of_grid_points,
number_of_grid_points)
hydro_code.parameters.length_x = 1 | length
hydro_code.parameters.length_y = 1 | length
hydro_code.parameters.length_z = 1 | length
hydro_code.parameters.x_boundary_conditions = ("periodic", "periodic")
hydro_code.parameters.y_boundary_conditions = ("periodic", "periodic")
hydro_code.parameters.z_boundary_conditions = ("periodic", "periodic")
rho = 1.14 * 1 | units.amu / units.cm**3
u = (5.e11 | units.erg / units.g).in_(units.cm**2 / units.s**2) # =5000K
tend = 1. | units.Myr
dt = 10000 | units.yr
print(u**0.5).in_(units.kms)
print((L / u**0.5) / dt)
particles = box(N, L, rho, u)
UnitLength = L
UnitMass = particles.mass.sum()
UnitVelocity = units.kms
convert = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
UnitLength, UnitMass, UnitVelocity)
sph = Gadget2(convert, mode='periodic_nogravity') #,redirection='none')
sph.parameters.periodic_box_size = L
sph.gas_particles.add_particles(particles)
i = 0
t = 0. | units.Myr
while t < (tend - dt / 2):
t = t + dt
i = i + 1
sph.evolve_model(t)
print t.in_(units.Myr), sph.model_time.in_(units.Myr)
rho = make_map(sph, L)
f = pyplot.figure(figsize=(8, 8))
