Python EVtwin.stop方法代码示例

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
 def test6(self):
     print "Test for obtaining the stellar structure model"
     stars = Particles(2)
     stars.mass = [1.0, 10.0] | units.MSun
     instance = EVtwin()
     instance.initialize_code()
     instance.commit_parameters()
     instance.particles.add_particles(stars)
     instance.commit_particles()
     self.assertEquals(instance.particles.get_number_of_zones(), [199, 199])
     self.assertEquals(len(instance.particles[0].get_radius_profile()), 199)
     self.assertRaises(AmuseException, instance.particles.get_radius_profile,
         expected_message = "Querying radius profiles of more than one particle at a time is not supported.")
     self.assertEquals(len(instance.particles[1].get_density_profile()), 199)
     self.assertIsOfOrder(instance.particles[0].get_radius_profile()[-1],          1.0 | units.RSun)
     self.assertIsOfOrder(instance.particles[0].get_temperature_profile()[0],  1.0e7 | units.K)
     self.assertIsOfOrder(instance.particles[0].get_temperature_profile()[-1],  5.0e3 | units.K)
     radius1 = instance.particles[0].get_radius_profile()
     radius2 = radius1[:-1]
     radius2.prepend(0|units.m)
     delta_radius_cubed = (radius1**3 - radius2**3)
     total_mass = (4./3. * pi * instance.particles[0].get_density_profile() * delta_radius_cubed).sum()
     self.assertAlmostRelativeEqual(total_mass, stars[0].mass, places = 1)
     self.assertAlmostEquals(instance.particles[0].get_mu_profile()[:100], [0.62]*100 | units.amu, places=1)
     instance.stop()

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
    def slowtest8(self):
        print "Test for obtaining the stellar composition structure - evolved star"
        stars = Particles(1)
        stars.mass = 1.0 | units.MSun
        instance = EVtwin()
        instance.initialize_code()
        instance.commit_parameters()
        instance.particles.add_particles(stars)
        instance.commit_particles()
        instance.evolve_model(11.7 | units.Gyr)
        self.assertTrue(instance.particles[0].age >= 11.7 | units.Gyr)
        print instance.particles[0].stellar_type
#~        self.assertTrue(str(instance.particles[0].stellar_type) == "First Giant Branch")
        number_of_zones   = instance.particles.get_number_of_zones()[0]
        number_of_species = instance.particles.get_number_of_species()[0]
        composition       = instance.particles[0].get_chemical_abundance_profiles()
        species_names     = instance.particles[0].get_names_of_species()
        self.assertEquals(number_of_zones,    199)
        self.assertEquals(number_of_species,    9)
        self.assertEquals(len(species_names),  number_of_species)
        self.assertEquals(len(composition),    number_of_species)
        self.assertEquals(len(composition[0]), number_of_zones)
        self.assertEquals(species_names, ['h1', 'he4', 'c12', 'n14', 'o16', 'ne20', 'mg24', 'si28', 'fe56'])
        self.assertAlmostRelativeEquals(composition[0, -1],        0.7 | units.none, 1)
        self.assertAlmostRelativeEquals(composition[1, -1],        0.3 - instance.parameters.metallicity, 1)
        self.assertAlmostRelativeEquals(composition[2:,-1].sum(),  instance.parameters.metallicity, 1)
        self.assertAlmostEquals(composition.sum(axis=0), [1.0]*number_of_zones | units.none)
        self.assertAlmostEquals(composition[0, 0],        0.00 | units.none)
        self.assertAlmostEquals(composition[1, 0],        1.00 - instance.parameters.metallicity, 3)
        self.assertAlmostEquals(composition[2:,0].sum(),  instance.parameters.metallicity, 3)
        instance.stop()

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
 def xtest19(self):
     print "Testing EVtwin central_temperature and central_density"
     instance = EVtwin()
     stars = instance.particles.add_particles(Particles(mass=[0.1, 1, 10]|units.MSun))
     self.assertIsOfOrder(stars.central_temperature, [4e6, 13e6, 31e6] | units.K)
     self.assertIsOfOrder(stars.central_density, [400, 77, 9] | units.g * units.cm**-3)
     instance.stop()

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
    def xtest13(self):
        print "Test evolve_model optional arguments: end_time and keep_synchronous"
        stars = Particles(3)
        stars.mass = [1.0, 2.0, 3.0] | units.MSun
        instance = EVtwin()
        instance.particles.add_particles(stars)

        self.assertAlmostEqual(instance.particles.age, [0.0, 0.0, 0.0] | units.yr)
        self.assertAlmostEqual(instance.particles.time_step, [70465.105509, 6063.68785133, 1876.53255132] | units.yr, 3)

        print "evolve_model without arguments: use shared timestep = 0.99*min(particles.time_step)"
        instance.evolve_model()
        self.assertAlmostEqual(instance.particles.age, 0.99*([1876.53255132,1876.53255132,1876.53255132] | units.yr), 3)
        self.assertAlmostEqual(instance.particles.time_step, [70465.105509,6063.68785133,1876.53255132] | units.yr, 3)
        self.assertAlmostEqual(instance.model_time, 0.99*1876.53255132 | units.yr, 3)

        print "evolve_model with end_time: take timesteps, until end_time is reached exactly"
        instance.evolve_model(15000 | units.yr)
        self.assertAlmostEqual(instance.particles.age, [15000.0, 15000.0, 15000.0] | units.yr, 3)
        self.assertAlmostEqual(instance.particles.time_step, [ 84558.1266108,7276.4254216,2251.83906159] | units.yr, 3)
        self.assertAlmostEqual(instance.model_time, 15000.0 | units.yr, 3)

        print "evolve_model with keep_synchronous: use non-shared timestep, particle ages will typically diverge"
        instance.evolve_model(keep_synchronous = False)
        self.assertAlmostEqual(instance.particles.age, (15000 | units.yr) + ([ 84558.1266108,7276.4254216,2251.83906159] | units.yr), 3)
        self.assertAlmostRelativeEquals(instance.particles.time_step, [101469.751933,8731.71050591,2702.2068739] | units.yr, 1)
        self.assertAlmostEqual(instance.model_time, 15000.0 | units.yr, 3) # Unchanged!
        instance.stop()

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
    def xtest9(self):
        print "Test for changing the stellar structure model (not yet implemented)"
        star = Particles(1)
        star.mass = 1.0 | units.MSun
        instance = EVtwin()
        instance.initialize_code()
        instance.commit_parameters()
        instance.particles.add_particles(star)
        instance.commit_particles()
        instance.evolve_model()

        density_profile = instance.particles[0].get_density_profile()

        self.assertRaises(AmuseException, instance.particles[0].set_density_profile, density_profile[2:],
            expected_message = "The length of the supplied vector (197) does not match the number of "
            "mesh zones of the star (199).")

        mass_factor = 1.1
        instance.particles[0].set_density_profile(mass_factor*density_profile)
        self.assertAlmostRelativeEqual(instance.particles[0].get_density_profile(), density_profile*mass_factor, places=10)
        instance.particles.mass *= mass_factor
        instance.evolve_model()

        outer_radius = instance.particles[0].get_radius_profile()
        inner_radius = outer_radius[:-1]
        inner_radius.prepend(0|units.m)
        delta_radius_cubed = (outer_radius**3 - inner_radius**3)
        integrated_mass = (4./3.*pi*delta_radius_cubed*instance.particles[0].get_density_profile()).sum()
        self.assertAlmostRelativeEqual(integrated_mass, star.mass*mass_factor, places = 3)
        instance.stop()
        del instance

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
    def test11(self):
        print "Test for importing new stellar models"
        instance = EVtwin()
#~        instance.parameters.import_model_entropy_force = 1.0
#~        instance.parameters.import_model_entropy_accuracy = 1.0e-1
        instance.parameters.verbosity = True
        instance.particles.add_particles(Particles(mass = [0.8] | units.MSun))
        instance.evolve_model()

        instance.new_particle_from_model(instance.particles[0].get_internal_structure())
        # The above line is equivalent with:
        #copy = Particles(1)
        #copy.internal_structure = instance.particles[0].get_internal_structure()
        #instance.particles.add_particles(copy)

        number_of_zones = instance.particles[0].get_number_of_zones()
        self.assertEqual(len(instance.particles), 2)
        self.assertEqual(instance.particles[1].get_number_of_zones(), number_of_zones)
        self.assertIsOfOrder(instance.particles[1].get_radius_profile()[-1],          1.0 | units.RSun)
        self.assertIsOfOrder(instance.particles[1].get_temperature_profile()[0],  1.0e7 | units.K)
        self.assertIsOfOrder(instance.particles[1].get_pressure_profile()[0],      1.0e17 | units.barye)

        instance.evolve_model(keep_synchronous = False)
        self.assertAlmostRelativeEqual(
            instance.particles[0].temperature, instance.particles[1].temperature, 2)
        self.assertAlmostRelativeEqual(
            instance.particles[0].luminosity, instance.particles[1].luminosity, 2)
        instance.stop()

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
    def slowtest11(self):
        print "Test for importing new stellar models, also check long-term evolution"
        instance = EVtwin()
        instance.parameters.verbosity = True
        instance.particles.add_particles(Particles(mass = [0.8] | units.MSun))
        instance.evolve_model()

        copy = Particles(1)
        copy.internal_structure = instance.particles[0].get_internal_structure()
        instance.particles.add_particles(copy)

        number_of_zones = instance.particles[0].get_number_of_zones()
        self.assertEqual(len(instance.particles), 2)
        self.assertEqual(instance.particles[1].get_number_of_zones(), number_of_zones)
        self.assertIsOfOrder(instance.particles[1].get_radius_profile()[-1],          1.0 | units.RSun)
        self.assertIsOfOrder(instance.particles[1].get_temperature_profile()[0],  1.0e7 | units.K)
        self.assertIsOfOrder(instance.particles[1].get_pressure_profile()[0],      1.0e17 | units.barye)

        t1, l1 = simulate_evolution_tracks(instance.particles[0], end_time=26.5|units.Gyr)
        t2, l2 = simulate_evolution_tracks(instance.particles[1], end_time=26.5|units.Gyr)
        instance.stop()

        i1 = t1.argmax() # Maximum temperature ~ turnoff main sequence
        i2 = t2.argmax()
        self.assertAlmostRelativeEqual(t1[i1], t2[i2], 2)
        self.assertAlmostRelativeEqual(l1[i1], l2[i2], 2)

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
 def slowtest7(self):
     print "Test handle_collision"
     position_offset = [100.0, 200.0, 300.0] | units.RSun
     velocity_offset = [10000.0, 20000.0, 30000.0] | units.km / units.s
     colliders = self.new_colliders()
     colliders.position += position_offset
     colliders.velocity += velocity_offset
     
     class GravityCodeStub(object):
         def __init__(self, particles):
             self.particles = particles
     gravity = GravityCodeStub(colliders)
     
     stellar = EVtwin()
     stellar.particles.add_particles(colliders)
     
     collision = StellarEncounterInHydrodynamics(
         #28000, # Bit too slow, even for a slowtest... 
         2800, 
         new_plotting_hydrodynamics_code(Gadget2, 0.2|units.hour, 
             plot_function = pynbody_column_density_plot if HAS_PYNBODY else None,
             plot_function_arguments = dict(width=20|units.RSun, vmin=29, vmax=35) if HAS_PYNBODY else dict(width=20|units.RSun)), 
         hydrodynamics_arguments = dict(redirection="file", redirect_file="hydro_collision_slowtest7_gadget_out.log"),
         hydrodynamics_parameters = dict(time_limit_cpu=1|units.day, gas_epsilon=0.01|units.RSun),
         verbose=True,
         debug=False
     )
     result = collision.handle_collision(colliders[0], colliders[1], gravity_code=gravity, stellar_evolution_code=stellar)
     stellar.stop()
     print result
     self.assertTrue(isinstance(result, Particles))
     self.assertEqual(len(result), 2)
     self.assertTrue((result.mass < [5.0, 2.0] | units.MSun).all())
     self.assertAlmostRelativeEqual(result.center_of_mass(), position_offset, 2)
     self.assertAlmostRelativeEqual(result.center_of_mass_velocity(), velocity_offset, 2)

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
 def test6(self):
     print "Test handle_collision"
     position_offset = [100.0, 200.0, 300.0] | units.RSun
     velocity_offset = [10000.0, 20000.0, 30000.0] | units.km / units.s
     colliders = self.new_colliders()
     colliders.position *= 1.5 # Grazing collision
     colliders.position += position_offset
     colliders.velocity += velocity_offset
     
     class GravityCodeStub(object):
         def __init__(self, particles):
             self.particles = particles
     gravity = GravityCodeStub(colliders)
     
     stellar = EVtwin()
     stellar.particles.add_particles(colliders)
     
     collision = StellarEncounterInHydrodynamics(280,  # For speed
         Gadget2,
         relax_sph_models=False,  # For speed
         verbose=True)
     collision.extra_steps_when_encounter_is_over = 0 # For speed, no extra steps...
     collision.dynamical_timescales_per_step = 1.3 # ... but then we need to evolve a bit longer in the first step
     result = collision.handle_collision(colliders[0], colliders[1], gravity_code=gravity, stellar_evolution_code=stellar)
     stellar.stop()
     print result
     self.assertTrue(isinstance(result, Particles))
     self.assertEqual(len(result), 2)
     self.assertAlmostEqual(result.mass, [5.0, 2.0] | units.MSun, 1)
     self.assertAlmostRelativeEqual(result.center_of_mass(), position_offset, 2)
     self.assertAlmostRelativeEqual(result.center_of_mass_velocity(), velocity_offset, 2)

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
 def test5(self):
     print "Test group_bound_particles"
     colliders = self.new_colliders()
     colliders.position = [[0.0, 0.0, 0.0], [1.1, 0.0, 0.0]] | units.RSun
     colliders.velocity = [[0.0, 0.0, 0.0], [10000, 0.0, 0.0]] | units.km / units.s
     stellar = EVtwin()
     stellar.particles.add_particles(colliders)
     
     collision = StellarEncounterInHydrodynamics(7000, None, relax_sph_models=False, verbose=True, 
         star_to_sph_arguments=dict(base_grid_options=dict(type="sobol")))
     collision.dynamical_timescale = zero
     gas_particles = collision.convert_stars(colliders, stellar)
     stellar.stop()
     
     collision.hop = collision.new_hop(gas_particles)
     collision.start_kepler(7 | units.MSun, 10 | units.RSun)
     self.assertTrue(collision.encounter_is_over(gas_particles))
     collision.hop.stop()
     collision.kepler.stop()
     
     groups = collision.groups_after_encounter
     self.assertEqual(len(groups), 2)
     self.assertTrue(4500 < len(groups[0]) < 5000)
     self.assertTrue(1800 < len(groups[1]) < 2000)
     self.assertEqual(len(gas_particles - groups[0] - groups[1]), 346)
     self.assertAlmostEqual(groups[0].center_of_mass()[0], 0 | units.RSun, 1)
     self.assertAlmostEqual(groups[1].center_of_mass()[0], 1.1 | units.RSun, 0)
     self.assertIsOfOrder(groups[1].center_of_mass_velocity()[0], 10000 | units.km / units.s)

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
    def test5(self):
        print "Testing adding and removing particles from stellar evolution code..."

        particles = Particles(3)
        particles.mass = 0.3 | units.MSun

        instance = EVtwin()#redirection="none")
        instance.initialize_code()
        instance.parameters.verbosity = True
        instance.commit_parameters()
        stars = instance.particles
        self.assertEquals(len(stars), 0) # before creation
        stars.add_particles(particles[:-1])
        instance.commit_particles()
        instance.evolve_model(1.0 | units.Myr)
        self.assertEquals(len(stars), 2) # before remove
        self.assertAlmostEqual(stars.age, 1.0 | units.Myr)

        stars.remove_particle(particles[0])
        self.assertEquals(len(stars), 1)
        self.assertEquals(instance.get_number_of_particles(), 1)
        instance.evolve_model(2.0 | units.Myr)
        self.assertAlmostEqual(stars[0].age, 2.0 | units.Myr)

        stars.add_particles(particles[::2])
        self.assertEquals(len(stars), 3) # it's back...
        self.assertAlmostEqual(stars[0].age, 2.0 | units.Myr)
        self.assertAlmostEqual(stars[1].age, 0.0 | units.Myr)
        self.assertAlmostEqual(stars[2].age, 0.0 | units.Myr) # ... and rejuvenated.

        instance.evolve_model(3.0 | units.Myr) # The young stars keep their age offset from the old star
        self.assertAlmostEqual(stars.age, [3.0, 1.0, 1.0] | units.Myr)
        instance.evolve_model(4.0 | units.Myr)
        self.assertAlmostEqual(stars.age, [4.0, 2.0, 2.0] | units.Myr)
        instance.stop()

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
    def xtest18(self):
        print "Testing EVtwin calculate_core_mass"
        instance = EVtwin()#redirection="none")
        star = instance.particles.add_particle(Particle(mass=1|units.MSun))
        instance.evolve_model(0.4|units.Gyr) # VERY short, for test speed up
        central_hydrogen_abundance = star.get_chemical_abundance_profiles()[0][0]
        self.assertTrue(central_hydrogen_abundance < 0.68) # some hydrogen is burned
        self.assertTrue(central_hydrogen_abundance > 0.67) # ... but not that much yet
        self.assertEqual(star.calculate_core_mass(core_H_abundance_limit=0.67), 0 | units.MSun)
        self.assertAlmostEqual(star.calculate_core_mass(core_H_abundance_limit=0.71), 1 | units.MSun, 1)

        # For test speed up, we use a weird core_H_abundance_limit to define the "hydrogen exhausted core"
        limit = 0.68
        expected_core_mass = 0.0123182798542 | units.MSun
        self.assertAlmostEqual(star.calculate_core_mass(core_H_abundance_limit=limit), expected_core_mass, 3)

        species_names = star.get_names_of_species()
        self.assertEquals(species_names, ['h1', 'he4', 'c12', 'n14', 'o16', 'ne20', 'mg24', 'si28', 'fe56'])
        h1_core_mass = star.calculate_core_mass(species=["h1"], core_H_abundance_limit=limit)
        he4_core_mass = star.calculate_core_mass(species=["he4"], core_H_abundance_limit=limit)
        c12_core_mass = star.calculate_core_mass(species=["c12"], core_H_abundance_limit=limit)
        n14_core_mass = star.calculate_core_mass(species=["n14"], core_H_abundance_limit=limit)
        o16_core_mass = star.calculate_core_mass(species=["o16"], core_H_abundance_limit=limit)
        ne20_core_mass = star.calculate_core_mass(species=["ne20"], core_H_abundance_limit=limit)
        mg24_core_mass = star.calculate_core_mass(species=["mg24"], core_H_abundance_limit=limit)
        si28_core_mass = star.calculate_core_mass(species=["si28"], core_H_abundance_limit=limit)
        fe56_core_mass = star.calculate_core_mass(species=["fe56"], core_H_abundance_limit=limit)
        metal_core_mass = star.calculate_core_mass(species=["c12", "n14", "o16", "ne20", "mg24", "si28", "fe56"], core_H_abundance_limit=limit)
        instance.stop()
        self.assertAlmostRelativeEqual(h1_core_mass, expected_core_mass*0.68, 2)
        self.assertAlmostRelativeEqual(he4_core_mass, expected_core_mass*0.30, 2)
        self.assertAlmostRelativeEqual(metal_core_mass, expected_core_mass*0.02, 1)
        self.assertAlmostRelativeEqual(expected_core_mass, he4_core_mass + metal_core_mass + h1_core_mass, 7)
        self.assertAlmostRelativeEqual(metal_core_mass, c12_core_mass + n14_core_mass +
            o16_core_mass + ne20_core_mass + mg24_core_mass + si28_core_mass + fe56_core_mass, 7)

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
def convert_star_to_hydro_model(M, t_end):
    stellar_evolution = EVtwin()
    star = stellar_evolution.particles.add_particle(Particle(mass=M))
    stellar_evolution.evolve_model(t_end)
    Ngas = 10000
    sph_particles = convert_stellar_model_to_SPH(star, Ngas).gas_particles
    stellar_evolution.stop()
    return sph_particles

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
 def test1(self):
     print "Testing assigned default parameter values..."
     instance = EVtwin()
     instance.initialize_code()
     instance.parameters.set_defaults()
     self.assertEquals(10, instance.parameters.maximum_number_of_stars)
     instance.parameters.maximum_number_of_stars = 12
     self.assertEquals(12, instance.parameters.maximum_number_of_stars)
     instance.stop()

# 需要导入模块: from amuse.community.evtwin.interface import EVtwin [as 别名]
# 或者: from amuse.community.evtwin.interface.EVtwin import stop [as 别名]
 def test9(self):
     print "Test for saving and loading the stellar structure model"
     filenames = ["test1.dump", "test2.dump"]
     filenames = [os.path.join(get_path_to_results(), name) for name in filenames]
     instance = EVtwin(redirection="none")
     instance.parameters.verbosity = True
     instance.particles.add_particles(Particles(mass=[0.5, 0.8] | units.MSun))
     instance.evolve_model()
     instance.particles.write_star_to_file(filenames)
     copies = Particles(2)
     copies.filename = filenames
     instance.particles.add_particles(copies)
     instance.evolve_model()
     print instance.particles
     self.assertAlmostRelativeEquals(instance.particles.temperature, [3644, 4783, 3644, 4783] | units.K, 3)
     instance.stop()