Python SSE.stop方法代码示例

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
 def test11(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 = SSE()
     instance.commit_parameters()
     instance.particles.add_particles(stars)
     
     self.assertEqual(instance.particles.age, [0.0, 0.0, 0.0] | units.yr)
     self.assertAlmostEqual(instance.particles.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
     self.assertAlmostEqual(instance.particles.radius, [0.8882494502, 1.610210385, 1.979134445] | units.RSun)
     
     print "evolve_model without arguments: use shared timestep = min(particles.time_step)"
     instance.evolve_model()
     self.assertAlmostEqual(instance.particles.age, [18.8768, 18.8768, 18.8768] | units.Myr, 3)
     self.assertAlmostEqual(instance.particles.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
     self.assertAlmostEqual(instance.model_time, 18.8768 | units.Myr, 3)
     
     print "evolve_model with end_time: take timesteps, until end_time is reached exactly"
     instance.evolve_model(100 | units.Myr)
     self.assertAlmostEqual(instance.particles.age, [100.0, 100.0, 100.0] | units.Myr, 3)
     self.assertAlmostEqual(instance.particles.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
     self.assertAlmostEqual(instance.model_time, 100.0 | units.Myr, 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, (100 | units.Myr) + ([550.1565, 58.2081, 18.8768] | units.Myr), 3)
     self.assertAlmostEqual(instance.particles.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
     self.assertAlmostEqual(instance.model_time, 100.0 | units.Myr, 3) # Unchanged!
     instance.stop()

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
    def test13(self):
        print "Testing SSE states"
        stars = Particles(1)
        stars.mass = 1.0 | units.MSun
        
        print "First do everything manually:",
        instance = SSE()
        self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED')
        instance.initialize_code()
        self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
        instance.commit_parameters()
        self.assertEquals(instance.get_name_of_current_state(), 'RUN')
        instance.cleanup_code()
        self.assertEquals(instance.get_name_of_current_state(), 'END')
        instance.stop()
        print "ok"

        print "initialize_code(), commit_parameters(), " \
            "and cleanup_code() should be called automatically:",
        instance = SSE()
        self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED')
        instance.parameters.reimers_mass_loss_coefficient = 0.5
        self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
        instance.particles.add_particles(stars)
        self.assertEquals(instance.get_name_of_current_state(), 'RUN')
        instance.stop()
        self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
        print "ok"

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
    def test6(self):
        print "Test whether a set of stars evolves synchronously..."
#       Create an array of stars with a range in stellar mass
        masses = [.5, 1., 2., 5., 10., 30.] | units.MSun
        number_of_stars = len(masses)
        stars = Particles(number_of_stars)
        stars.mass = masses

#       Initialize stellar evolution code
        instance = SSE()
        instance.commit_parameters() 
        instance.particles.add_particles(stars)
        instance.commit_particles()
        
        from_code_to_model = instance.particles.new_channel_to(stars)
        from_code_to_model.copy()
        
        instance.evolve_model(end_time = 125 | units.Myr)
        from_code_to_model.copy()
                
        end_types = (
            "deeply or fully convective low mass MS star",
            "Main Sequence star",
            "Main Sequence star",
            "Carbon/Oxygen White Dwarf",
            "Neutron Star",
            "Black Hole",
        )
        for i in range(number_of_stars):
            self.assertAlmostEquals(stars[i].age, 125.0 | units.Myr)
            self.assertTrue(stars[i].mass <= masses[i])
            self.assertEquals(str(stars[i].stellar_type), end_types[i])
        instance.stop()

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
    def test16(self):
        print "test evolution of 1000 star sampled over flattish IMF"
        
        number_of_stars=1000
        
        class notsorandom(object):
            def random(self,N):
                return numpy.array(range(N))/(N-1.)
            def random_sample(self,N):
                return numpy.array(range(N))/(N-1.)

        masses = new_salpeter_mass_distribution(
            number_of_stars, 
            mass_min = 0.1 | units.MSun,
            mass_max = 100.0 | units.MSun, 
            alpha = -1.01,random=notsorandom()
        )
 
        stars=Particles(mass=masses)

        instance=SSE()
        instance.particles.add_particles(stars)
        
        i=0
        for p in instance.particles:
          print i,p.mass,
          p.evolve_for(13.2 | units.Gyr)
          print p.mass
          i+=1
        instance.stop()

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
 def test17(self):
     print "evolve_one_step and evolve_for after particle removal and addition"
     particles = Particles(10)
     particles.mass = range(1, 11) | units.MSun
     instance = SSE()
     instance.particles.add_particles(particles)
     self.assertAlmostEqual(instance.particles.age, 0.0 | units.yr)
     time_steps = numpy.linspace(0.1, 1.0, num=10) | units.Myr
     for i in range(10):
         instance.particles[i].evolve_for(time_steps[i])
     self.assertAlmostEqual(instance.particles.age, time_steps)
     
     instance.particles.remove_particles(particles[[1, 4, 8]])
     revived = instance.particles.add_particle(particles[4])
     revived.evolve_for(numpy.pi | units.Myr)
     for star in instance.particles:
         star.evolve_for(star.age)
     self.assertAlmostEqual(instance.particles.age[:-1], 2*time_steps[[0, 2,3, 5,6,7, 9]])
     self.assertAlmostEqual(instance.particles.age[-1], 2*numpy.pi | units.Myr)
     
     instance.particles.remove_particles(particles[[2, 5, 6]])
     instance.particles.add_particles(particles[[8, 1]])
     self.assertEqual(len(instance.particles), 7)
     expected_ages = instance.particles.age + instance.particles.time_step
     for star in instance.particles:
         star.evolve_one_step()
     self.assertAlmostEqual(instance.particles.age, expected_ages)
     instance.stop()

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
 def test5(self):
     sse = SSE()
     sse.commit_parameters() 
     stars = Particles(1)
     
     star = stars[0]
     star.mass = 35 | units.MSun
     star.radius = 0.0 | units.RSun
     
     stars.synchronize_to(sse.particles)
     
     channel = sse.particles.new_channel_to(stars)
     channel.copy_attributes(sse.particles.get_attribute_names_defined_in_store())   
     
     previous_type = star.stellar_type
     results = []
     
     dt = 1 | units.Myr
     t = 0 | units.Myr
     while t < 30 | units.Myr:
         t += dt
         sse.evolve_model(t)
             
     self.assertTrue(sse.particles[0].mass.value_in(units.MSun) < 10.6)
      
     sse.stop()

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
 def test19(self):
     print "SSE core_mass and CO_core_mass (high mass star)"
     instance = SSE()
     star = instance.particles.add_particle(Particle(mass = 30 | units.MSun))
     instance.evolve_model(5.8 | units.Myr)
     print star.mass, star.core_mass, star.CO_core_mass, star.stellar_type
     self.assertEqual(str(star.stellar_type), "Main Sequence star")
     self.assertIsOfOrder(star.mass, 30 | units.MSun)
     self.assertEqual(star.core_mass, 0 | units.MSun)
     self.assertEqual(star.CO_core_mass, 0 | units.MSun)
     instance.evolve_model(6.0 | units.Myr)
     print star.mass, star.core_mass, star.CO_core_mass, star.stellar_type
     self.assertEqual(str(star.stellar_type), "Core Helium Burning")
     self.assertIsOfOrder(star.mass, 30 | units.MSun)
     self.assertIsOfOrder(star.core_mass, 10 | units.MSun)
     self.assertEqual(star.CO_core_mass, 0 | units.MSun)
     instance.evolve_model(6.5 | units.Myr)
     print star.mass, star.core_mass, star.CO_core_mass, star.stellar_type
     self.assertEqual(str(star.stellar_type), "Main Sequence Naked Helium star")
     self.assertIsOfOrder(star.mass, 10 | units.MSun)
     self.assertEqual(star.core_mass, star.mass)
     self.assertEqual(star.CO_core_mass, 0 | units.MSun)
     instance.evolve_model(6.65 | units.Myr)
     print star.mass, star.core_mass, star.CO_core_mass, star.stellar_type
     self.assertEqual(str(star.stellar_type), "Hertzsprung Gap Naked Helium star")
     self.assertIsOfOrder(star.mass, 10 | units.MSun)
     self.assertEqual(star.core_mass, star.mass)
     self.assertAlmostEqual(star.CO_core_mass, 7.12 | units.MSun, 2)
     instance.evolve_model(7.0 | units.Myr)
     print star.mass, star.core_mass, star.CO_core_mass, star.stellar_type
     self.assertEqual(str(star.stellar_type), "Black Hole")
     self.assertIsOfOrder(star.mass, 10 | units.MSun)
     self.assertEqual(star.core_mass, star.mass)
     self.assertEqual(star.CO_core_mass, star.mass)
     instance.stop()

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
 def test18(self):
     print "SSE validation"
     sse_src_path = os.path.join(os.path.dirname(sys.modules[SSE.__module__].__file__), 'src')
     if not os.path.exists(os.path.join(sse_src_path, "evolve.in")):
         self.skip("Not in a source release")
     instance = SSE()
     instance.particles.add_particle(Particle(mass = 1.416 | units.MSun))
     instance.particles[0].evolve_for(7000.0 | units.Myr)
     evolved_star = instance.particles.copy()[0]
     evolved_star.temperature = instance.particles[0].temperature
     instance.stop()
    
     testpath = get_path_to_results()
     shutil.copy(os.path.join(sse_src_path, "evolve.in"), os.path.join(testpath, "evolve.in"))
     
     call([os.path.join(sse_src_path, "sse")], cwd=testpath)
     
     with open(os.path.join(testpath, "evolve.dat"), "r") as sse_output:
         lines = sse_output.readlines()
         sse_final_result = lines[-2].split()
     
     self.assertAlmostEqual(evolved_star.age, float(sse_final_result[0]) | units.Myr, 3)
     self.assertAlmostEqual(evolved_star.stellar_type, float(sse_final_result[1]) | units.stellar_type, 3)
     self.assertAlmostEqual(evolved_star.initial_mass, float(sse_final_result[2]) | units.MSun, 3)
     self.assertAlmostEqual(evolved_star.mass, float(sse_final_result[3]) | units.MSun, 3)
     self.assertAlmostEqual(evolved_star.luminosity, 10**float(sse_final_result[4]) | units.LSun, 3)
     self.assertAlmostEqual(evolved_star.radius, 10**float(sse_final_result[5]) | units.RSun, 3)
     self.assertAlmostRelativeEqual(evolved_star.temperature, 10**float(sse_final_result[6]) | units.K, 2)
     self.assertAlmostEqual(evolved_star.core_mass, float(sse_final_result[7]) | units.MSun, 3)
     self.assertAlmostEqual(evolved_star.convective_envelope_mass, float(sse_final_result[8]) | units.MSun, 3)
     self.assertAlmostEqual(evolved_star.epoch, float(sse_final_result[9]) | units.Myr, 3)
     self.assertAlmostEqual(evolved_star.spin, float(sse_final_result[10]) | units.yr**-1, 3)

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
def plottillagb():
    sun = datamodel.Particle(
        mass=1 | units.MSun,
        radius=1 | units.RSun
    )

    sse = SSE()
    sse.particles.add_particle(sun)

    channel_from_se_to_memory = sse.particles.new_channel_to(sun.as_set())
    channel_from_se_to_memory.copy()

    masses = [] | units.MSun

    timerange = numpy.arange(11500, 13500, 10) | units.Myr
    for time in timerange:
        sse.evolve_model(time)
        channel_from_se_to_memory.copy()
        masses.append(sun.mass)
        print(time.as_quantity_in(units.Myr),
              sun.mass.as_quantity_in(units.MSun))

    sse.stop()

    figure = pyplot.figure(figsize=(6, 6))

    subplot = figure.add_subplot(1, 1, 1)
    subplot.plot(timerange.value_in(units.Gyr),
                 masses.value_in(units.MSun), '.')
    subplot.set_xlabel('t (Gyr)')
    subplot.set_ylabel('mass (MSun)')

    pyplot.show()

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
def simulate_evolution_tracks():
    stellar_evolution = SSE()

    star = datamodel.Particle()
    star.mass = stellar_mass

    star = stellar_evolution.particles.add_particle(star)

    luminosity_at_time = [] | units.LSun
    temperature_at_time = [] | units.K

    print("Evolving a star with mass:", stellar_mass)
    is_evolving = True
    while is_evolving and star.age < end_time:
        luminosity_at_time.append(star.luminosity)
        temperature_at_time.append(star.temperature)
        previous_age = star.age
        # if we do not specify an end_time in the evolve_model function
        # a stellar evolution code will evolve to the next
        # 'natural' timestep, this will ensure all interesting physics
        # is seen in the hr diagram
        stellar_evolution.evolve_model()
        is_evolving = (star.age != previous_age)

    stellar_evolution.stop()

    return temperature_at_time, luminosity_at_time

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
 def test12(self):
     print "Testing adding and removing particles from stellar evolution code..."
     
     particles = Particles(3)
     particles.mass = 1.0 | units.MSun
     
     instance = SSE()
     instance.initialize_code()
     instance.commit_parameters()
     self.assertEquals(len(instance.particles), 0) # before creation
     instance.particles.add_particles(particles[:-1])
     instance.commit_particles()
     instance.evolve_model(1.0 | units.Myr)
     self.assertEquals(len(instance.particles), 2) # before remove
     self.assertAlmostEqual(instance.particles.age, 1.0 | units.Myr)
     
     instance.particles.remove_particle(particles[0])
     self.assertEquals(len(instance.particles), 1)
     instance.evolve_model(2.0 | units.Myr)
     self.assertAlmostEqual(instance.particles[0].age, 2.0 | units.Myr)
     
     instance.particles.add_particles(particles[::2])
     self.assertEquals(len(instance.particles), 3) # it's back...
     self.assertAlmostEqual(instance.particles[0].age, 2.0 | units.Myr)
     self.assertAlmostEqual(instance.particles[1].age, 0.0 | units.Myr)
     self.assertAlmostEqual(instance.particles[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(instance.particles.age, [3.0, 1.0, 1.0] | units.Myr)
     instance.evolve_model(4.0 | units.Myr)
     self.assertAlmostEqual(instance.particles.age, [4.0, 2.0, 2.0] | units.Myr)
     instance.stop()

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
 def test23(self):
     instance = SSE()
     p=Particles(mass = [1.0, 10.0] | units.MSun, temperature=[10,10] | units.K)
     stars = instance.particles.add_particles(p)
     channel=stars.new_channel_to(p)
     channel.copy_attributes(["mass","temperature"])
     self.assertEqual(stars.temperature, p.temperature)
     instance.stop()

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
 def test21(self):
     instance = SSE()
     stars = instance.particles.add_particles(Particles(mass = 30 | units.MSun))
     mass_loss_wind = stars[0].mass_loss_wind
     self.assertAlmostRelativeEquals(mass_loss_wind, 1.703e-07 | units.MSun / units.yr, 3)
     instance.evolve_model(1 | units.Myr)
     dm = (1 | units.Myr)* mass_loss_wind
     self.assertAlmostRelativeEquals(stars[0].mass, (30 | units.MSun) - dm  ,  3)
     self.assertAlmostRelativeEquals(stars[0].mass_loss_wind, 2.053e-07 | units.MSun / units.yr, 3)
 
     instance.stop()

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
 def test9(self):
     print "Test: large number of particles"
     stellar_evolution = SSE(max_message_length=500)
     stellar_evolution.commit_parameters()
     number_of_particles = 10000
     print "Has been tested with up to a million particles!"
     print "Now using ", number_of_particles, "particles only, for speed."
     stars = Particles(number_of_particles)
     stars.mass = 1.0 | units.MSun
     stellar_evolution.particles.add_particles(stars)
     self.assertEqual(len(stellar_evolution.particles), number_of_particles)
     stellar_evolution.stop()

# 需要导入模块: from amuse.community.sse.interface import SSE [as 别名]
# 或者: from amuse.community.sse.interface.SSE import stop [as 别名]
 def test22(self):
     instance = SSE()
     stars = instance.particles.add_particles(Particles(mass = [1.0, 10.0] | units.MSun))
     gyration_radius = stars.gyration_radius
     self.assertTrue(numpy.all(0.0 < gyration_radius))
     self.assertTrue(numpy.all(gyration_radius < 1.0))
     instance.evolve_model(12.4 | units.Gyr)
     self.assertTrue(stars[0].gyration_radius < gyration_radius[0])
     self.assertTrue(stars[1].gyration_radius > gyration_radius[1])
     instance.evolve_model(14 | units.Gyr)
     self.assertTrue(numpy.all(stars.gyration_radius > gyration_radius))
     instance.stop()