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))