def test7(self): """ Test setting the x and y limits in various ways""" if not HAS_MATPLOTLIB: return self.skip() pyplot.clf() set_printing_strategy('default') x = numpy.linspace(0, 100, 100) y = numpy.linspace(0, 200, 100) | units.RSun line = aplot.plot(x, y) aplot.xlim(-10, 80) self.assertEquals(-10, pyplot.xlim()[0]) self.assertEquals(80, pyplot.xlim()[1]) print pyplot.xlim() aplot.xlim(xmax=90) print pyplot.xlim() self.assertEquals(-10, pyplot.xlim()[0]) self.assertEquals(90, pyplot.xlim()[1]) aplot.ylim([-12, 110]|units.RSun) self.assertEquals(-12, pyplot.ylim()[0]) self.assertEquals(110, pyplot.ylim()[1]) aplot.ylim(ymin=1e6|units.km) self.assertAlmostEquals(1.43781452, pyplot.ylim()[0]) self.assertEquals(110, pyplot.ylim()[1])
def test7(self): """ Test setting the x and y limits in various ways""" if not HAS_MATPLOTLIB: return self.skip() pyplot.clf() set_printing_strategy('default') x = numpy.linspace(0, 100, 100) y = numpy.linspace(0, 200, 100) | units.RSun line = aplot.plot(x, y) aplot.xlim(-10, 80) self.assertEquals(-10, pyplot.xlim()[0]) self.assertEquals(80, pyplot.xlim()[1]) print pyplot.xlim() aplot.xlim(xmax=90) print pyplot.xlim() self.assertEquals(-10, pyplot.xlim()[0]) self.assertEquals(90, pyplot.xlim()[1]) aplot.ylim([-12, 110] | units.RSun) self.assertEquals(-12, pyplot.ylim()[0]) self.assertEquals(110, pyplot.ylim()[1]) aplot.ylim(ymin=1e6 | units.km) self.assertAlmostEquals(1.43781452, pyplot.ylim()[0]) self.assertEquals(110, pyplot.ylim()[1])
def test9(self): print("Testing custom printing strategy") mass = 2.0 | 0.5 * units.MSun acc = (0.0098 | nbody_system.length) * (1 | units.Myr** -2).as_quantity_in(units.s**-2) position = [0.1, 0.2, 0.3] | nbody_system.length power = 10 | units.W temperature = 5000 | units.K pi = 3.14 | units.none converter = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.kpc) set_printing_strategy("custom", nbody_converter=converter, preferred_units=[ units.amu, units.AU, units.minute, units.milli(units.K), units.erg ], precision=3, prefix="(> ", separator=" <|> ", suffix=" <)") self.assertEqual(str(mass), "(> 1.20e+57 <|> amu <)") self.assertEqual(str(acc), "(> 7.31e-18 <|> AU * min**-2 <)") self.assertEqual(str(position), "(> [2.06e+07, 4.13e+07, 6.19e+07] <|> AU <)") self.assertEqual(str(power), "(> 6.00e+09 <|> erg / min <)") self.assertEqual(str(constants.G), "(> 1.19e-67 <|> AU**3 * amu**-1 * min**-2 <)") self.assertEqual(str(constants.kB), "(> 1.38e-19 <|> erg * mK**-1 <)") self.assertEqual(str(temperature), "(> 5.00e+06 <|> mK <)") self.assertEqual(str(pi), "(> 3.14 <|> none <)") set_printing_strategy("default")
def print_results(orbit): set_printing_strategy("custom", preferred_units = [units.MSun, units.RSun, units.Myr], precision = 7) if orbit.A == 1.0: print "This is a circular, corotating orbit, so the eggleton formula is correct." else: print "Warning: This is not a circular, corotating orbit, so the eggleton formula is not correct." print "Roche radius for: M =", orbit.mass_1, "m =", orbit.mass_2, "a =", orbit.semimajor_axis, "e =", orbit.eccentricity print print "Eggleton Roche radius =", orbit.eggleton_roche_radius() print "Sepinsky Roche radius =", orbit.sepinsky_roche_radius()
def test7(self): print "Testing astro printing strategy with units printed" mass = 2.0 | 0.5 * units.MSun acc = (0.0097 | nbody_system.length) * (1 | units.Myr**-2).as_quantity_in(units.s**-2) position = [0.1, 0.2, 0.3] | nbody_system.length energy = 1e8 | units.erg temperature = 5000 | units.K pi = 3.14 | units.none converter = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.kpc) set_printing_strategy("astro") self.assertEqual(str(mass), "1.0 MSun") self.assertEqual(str(acc), "0.0097 length * Myr**-2") self.assertEqual(str(converter.to_si(acc)), "9.7 parsec * Myr**-2") self.assertEqual(str(converter.to_si(position)), "[100.0, 200.0, 300.0] parsec") self.assertEqual(str(energy), "10.0 J") self.assertEqual(str(constants.G)[:8], "0.004499450561351174 parsec**3 * MSun**-1 * Myr**-2"[:8]) self.assertEqual(str(constants.G)[-30:], "parsec**3 * MSun**-1 * Myr**-2") self.assertEqual(str(temperature), "5000 K") self.assertEqual(str(pi), "3.14 none") set_printing_strategy("astro", nbody_converter = converter) self.assertEqual(str(acc), "9.7 parsec * Myr**-2") set_printing_strategy("astro", ignore_converter_exceptions = False) self.assertRaises(AmuseException, str, acc, expected_message = "Unable to convert length * s**-2 to SI units. No nbody_converter given") set_printing_strategy("default")
def test3(self): """ Test a plot with preferred units """ if not HAS_MATPLOTLIB: return self.skip() pyplot.clf() x = numpy.linspace(0, 100, 100) | units.yr y = numpy.linspace(0, 200, 100) | units.RSun set_printing_strategy('custom', preferred_units=[units.Myr, units.AU]) aplot.plot(x, y) self.assertEquals("[Myr]", self.xaxis().get_label_text()) self.assertEquals("[AU]", self.yaxis().get_label_text()) self.assertEquals((0., 0.0001), pyplot.xlim())
def test3(self): """ Test a plot with preferred units """ if not HAS_MATPLOTLIB: return self.skip() pyplot.clf() x = numpy.linspace(0, 100, 100) | units.yr y = numpy.linspace(0, 200, 100) | units.RSun set_printing_strategy('custom', preferred_units=[units.Myr, units.AU]) aplot.plot(x, y) self.assertEquals("[Myr]", self.xaxis().get_label_text()) self.assertEquals("[AU]", self.yaxis().get_label_text()) self.assertEquals((0., 0.0001), pyplot.xlim())
def test3(self): print("Testing no units printing strategy with N-body quantities") mass = 1.0 | nbody_system.mass acc = 9.8 | nbody_system.acceleration position = [1, 2, 3] | nbody_system.length self.assertEqual(str(mass), "1.0 mass") self.assertEqual(str(acc), "9.8 length / (time**2)") self.assertEqual(str(position), "[1, 2, 3] length") set_printing_strategy("no_unit") self.assertEqual(str(mass), "1.0") self.assertEqual(str(acc), "9.8") self.assertEqual(str(position), "[1, 2, 3]") set_printing_strategy("default")
def test4(self): print "Testing formal printing strategy" mass = 1.0 | units.kg acc = 9.8 | units.m / units.s**2 position = [1, 2.0, 3] | nbody_system.length mass_in_g = mass.as_quantity_in(units.g) * 1.0 pi = 3.14 | units.none set_printing_strategy("formal") self.assertEqual(str(mass), "<quantity 1.0 | kg>") self.assertEqual(str(acc), "<quantity 9.8 | m / (s**2)>") self.assertEqual(str(position), "<quantity [1.0, 2.0, 3.0] | length>") self.assertEqual(str(mass_in_g), "<quantity 1000.0 | 0.001 * kg>")#<quantity 1000.0 | g>") self.assertEqual(str(pi), "<quantity 3.14 | none>") set_printing_strategy("default")
def test3(self): print "Testing no units printing strategy with N-body quantities" mass = 1.0 | nbody_system.mass acc = 9.8 | nbody_system.acceleration position = [1, 2, 3] | nbody_system.length self.assertEqual(str(mass), "1.0 mass") self.assertEqual(str(acc), "9.8 length / (time**2)") self.assertEqual(str(position), "[1, 2, 3] length") set_printing_strategy("no_unit") self.assertEqual(str(mass), "1.0") self.assertEqual(str(acc), "9.8") self.assertEqual(str(position), "[1, 2, 3]") set_printing_strategy("default")
def test4(self): """ Test text in a plot """ if not HAS_MATPLOTLIB: return self.skip() pyplot.clf() set_printing_strategy('default') x = numpy.linspace(0, 100, 100) | units.yr y = numpy.linspace(0, 200, 100) | units.RSun aplot.plot(x, y) text = aplot.text(50 | units.yr, 0.5 | units.AU, "test text") self.assertEquals(50., text.get_position()[0]) self.assertAlmostEquals(107.546995464, text.get_position()[1])
def test6(self): """ Test setting the x limits on a plot """ if not HAS_MATPLOTLIB: return self.skip() pyplot.clf() set_printing_strategy('default') x = numpy.linspace(0, 100, 100) | units.yr y = numpy.linspace(0, 200, 100) | units.RSun line = aplot.plot(x, y) aplot.xlim(0|units.yr, 2e9|units.s) self.assertAlmostEquals(0, pyplot.xlim()[0]) self.assertAlmostEquals(63.37752924, pyplot.xlim()[1])
def test4(self): """ Test text in a plot """ if not HAS_MATPLOTLIB: return self.skip() pyplot.clf() set_printing_strategy('default') x = numpy.linspace(0, 100, 100) | units.yr y = numpy.linspace(0, 200, 100) | units.RSun aplot.plot(x, y) text = aplot.text(50|units.yr, 0.5|units.AU, "test text") self.assertEquals(50., text.get_position()[0]) self.assertAlmostEquals(107.546995464, text.get_position()[1])
def test6(self): """ Test setting the x limits on a plot """ if not HAS_MATPLOTLIB: return self.skip() pyplot.clf() set_printing_strategy('default') x = numpy.linspace(0, 100, 100) | units.yr y = numpy.linspace(0, 200, 100) | units.RSun line = aplot.plot(x, y) aplot.xlim(0 | units.yr, 2e9 | units.s) self.assertAlmostEquals(0, pyplot.xlim()[0]) self.assertAlmostEquals(63.37752924, pyplot.xlim()[1])
def test5(self): """ Test errorbar plot """ if not HAS_MATPLOTLIB: return self.skip() pyplot.clf() set_printing_strategy('default') x = numpy.linspace(0, 100, 100) | units.yr y = numpy.linspace(0, 200, 100) | units.RSun yerr = [2e5]*len(y) | units.km line = aplot.errorbar(x, y, yerr=yerr, capsize = 10) points, caps, bars = line bottoms, tops = caps error_height = tops.get_ydata()[0] - bottoms.get_ydata()[0] self.assertAlmostEquals(0.575125808, error_height)
def test5(self): """ Test errorbar plot """ if not HAS_MATPLOTLIB: return self.skip() pyplot.clf() set_printing_strategy('default') x = numpy.linspace(0, 100, 100) | units.yr y = numpy.linspace(0, 200, 100) | units.RSun yerr = [2e5] * len(y) | units.km line = aplot.errorbar(x, y, yerr=yerr, capsize=10) points, caps, bars = line bottoms, tops = caps error_height = tops.get_ydata()[0] - bottoms.get_ydata()[0] self.assertAlmostEqual(0.575125808, error_height)
def test10(self): print "Testing custom printing strategy with precision keyword" mass = 2.0 | 0.5 * units.MSun acc = 0.23456 | 0.54321 * units.m * units.s**-2 velocity = [-0.12345]*3 | units.km / units.s position = [0.1234567890123456789, 0.2, 3.0] | units.AU positions = [position.number]*2 | position.unit multi_dimensional = [positions.number]*2 | positions.unit pi = 3.1415926535 | units.none set_printing_strategy("custom", precision = 3) self.assertEqual(str(mass), "2.00 0.5 * MSun") self.assertEqual(str(acc), "0.235 0.54321 * m * s**-2") self.assertEqual(str(velocity), "[-0.123, -0.123, -0.123] km / s") tmp = "[0.123, 0.200, 3.00]" self.assertEqual(str(position), tmp + " AU") self.assertEqual(str(positions), "["+tmp+", "+tmp+"] AU") self.assertEqual(str(multi_dimensional), "[["+tmp+", "+tmp+ "], ["+tmp+", "+tmp+"]] AU") self.assertEqual(str(pi), "3.14 none") set_printing_strategy("default")
def test8(self): print("Testing SI printing strategy") mass = 2.0 | 0.5 * units.MSun acc = 0.0098 | nbody_system.length / units.Myr**2 position = [0.1, 0.2, 0.3] | nbody_system.length energy = 1e8 | units.erg temperature = 5000 | units.milli(units.K) pi = 3.14 | units.none converter = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.kpc) set_printing_strategy("SI", nbody_converter=converter) self.assertEqual(str(mass), "1.98892e+30 kg") self.assertEqual(str(acc), "3.03659755643e-10 m * s**-2") self.assertEqual( str(position), "[3.08567758128e+18, 6.17135516256e+18, 9.25703274384e+18] m") self.assertEqual(str(energy), "10.0 kg * m**2 * s**-2") self.assertEqual(str(constants.G), "6.67428e-11 m**3 * kg**-1 * s**-2") self.assertEqual(str(temperature), "5.0 K") self.assertEqual(str(pi), "3.14 none") set_printing_strategy("SI", nbody_converter=converter, print_units=False) self.assertEqual(str(mass), "1.98892e+30") self.assertEqual(str(acc), "3.03659755643e-10") self.assertEqual( str(position), "[3.08567758128e+18, 6.17135516256e+18, 9.25703274384e+18]") self.assertEqual(str(energy), "10.0") self.assertEqual(str(constants.G), "6.67428e-11") self.assertEqual(str(temperature), "5.0") self.assertEqual(str(pi), "3.14") set_printing_strategy("default")
def test6(self): print("Testing astro printing strategy without units printed") mass = 2.0 | 0.5 * units.MSun acc = (0.0098 | nbody_system.length) * (1 | units.Myr** -2).as_quantity_in(units.s**-2) position = [0.1, 0.2, 0.3] | nbody_system.length energy = 1e8 | units.erg temperature = 5000 | units.K pi = 3.14 | units.none converter = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.kpc) set_printing_strategy("astro", print_units=False) self.assertEqual(str(mass), "1.0") self.assertRaises( AmuseException, str, acc, expected_message= "Unable to convert length * s**-2 to SI units. No nbody_converter given" ) self.assertEqual(str(converter.to_si(acc)), "9.8") self.assertEqual(str(converter.to_si(position)), "[100.0, 200.0, 300.0]") self.assertEqual(str(energy), "10.0") self.assertEqual(str(constants.G)[:8], "0.00449945056135"[:8]) self.assertEqual(str(temperature), "5000") self.assertEqual(str(pi), "3.14") set_printing_strategy("astro", nbody_converter=converter, print_units=False) self.assertEqual(str(acc), "9.8") set_printing_strategy("default")
def test5(self): print("Testing nbody printing strategy") mass = 1.0 | nbody_system.mass acc = 9.8 | nbody_system.length / units.s**2 position = [1, 2, 3] | units.m pi = 3.14 | units.none converter = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.m) set_printing_strategy("nbody") self.assertEqual(str(mass), "1.0") self.assertRaises( AmuseException, str, acc, expected_message= "Unable to convert length / (s**2) to N-body units. No nbody_converter given" ) self.assertEqual(str(converter.to_nbody(acc * constants.G.number)), "9.8") if sys.hexversion > 0x03000000: self.assertEqual(str(converter.to_nbody(position)), "[1.0, 2.0, 3.0]") else: self.assertEqual(str(converter.to_nbody(position)), "[1, 2, 3]") self.assertEqual(str(pi), "3.14") set_printing_strategy("nbody", nbody_converter=converter) self.assertEqual(str(mass), "1.0") self.assertEqual(str(acc * constants.G.number), "9.8") if sys.hexversion > 0x03000000: self.assertEqual(str(position), "[1.0, 2.0, 3.0]") else: self.assertEqual(str(position), "[1, 2, 3]") set_printing_strategy("default")
def test8(self): print "Testing SI printing strategy" mass = 2.0 | 0.5 * units.MSun acc = 0.0098 | nbody_system.length / units.Myr**2 position = [0.1, 0.2, 0.3] | nbody_system.length energy = 1e8 | units.erg temperature = 5000 | units.milli(units.K) pi = 3.14 | units.none converter = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.kpc) set_printing_strategy("SI", nbody_converter = converter) self.assertEqual(str(mass), "1.98892e+30 kg") self.assertEqual(str(acc), "3.03659755643e-10 m * s**-2") self.assertEqual(str(position), "[3.08567758128e+18, 6.17135516256e+18, 9.25703274384e+18] m") self.assertEqual(str(energy), "10.0 kg * m**2 * s**-2") self.assertEqual(str(constants.G), "6.67428e-11 m**3 * kg**-1 * s**-2") self.assertEqual(str(temperature), "5.0 K") self.assertEqual(str(pi), "3.14 none") set_printing_strategy("SI", nbody_converter = converter, print_units = False) self.assertEqual(str(mass), "1.98892e+30") self.assertEqual(str(acc), "3.03659755643e-10") self.assertEqual(str(position), "[3.08567758128e+18, 6.17135516256e+18, 9.25703274384e+18]") self.assertEqual(str(energy), "10.0") self.assertEqual(str(constants.G), "6.67428e-11") self.assertEqual(str(temperature), "5.0") self.assertEqual(str(pi), "3.14") set_printing_strategy("default")
def test5(self): print "Testing nbody printing strategy" mass = 1.0 | nbody_system.mass acc = 9.8 | nbody_system.length / units.s**2 position = [1, 2, 3] | units.m pi = 3.14 | units.none converter = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.m) set_printing_strategy("nbody") self.assertEqual(str(mass), "1.0") self.assertRaises(AmuseException, str, acc, expected_message = "Unable to convert length / (s**2) to N-body units. No nbody_converter given") self.assertEqual(str(converter.to_nbody(acc * constants.G.number)), "9.8") if sys.hexversion > 0x03000000: self.assertEqual(str(converter.to_nbody(position)), "[1.0, 2.0, 3.0]") else: self.assertEqual(str(converter.to_nbody(position)), "[1, 2, 3]") self.assertEqual(str(pi), "3.14") set_printing_strategy("nbody", nbody_converter = converter) self.assertEqual(str(mass), "1.0") self.assertEqual(str(acc * constants.G.number), "9.8") if sys.hexversion > 0x03000000: self.assertEqual(str(position), "[1.0, 2.0, 3.0]") else: self.assertEqual(str(position), "[1, 2, 3]") set_printing_strategy("default")
def test2(self): print "Testing no units printing strategy with SI quantities" mass = 1.0 | units.kg acc = 9.8 | units.m / units.s**2 position = [1, 2.0, 3] | units.m mass_in_g = mass.as_quantity_in(units.g) pi = 3.14 | units.none self.assertEqual(str(mass), "1.0 kg") self.assertEqual(str(acc), "9.8 m / (s**2)") self.assertEqual(str(position), "[1.0, 2.0, 3.0] m") self.assertEqual(str(mass_in_g), "1000.0 g") self.assertEqual(str(pi), "3.14 none") set_printing_strategy("no_unit") self.assertEqual(get_current_printing_strategy(), console.NoUnitsPrintingStrategy) self.assertEqual(str(mass), "1.0") self.assertEqual(str(acc), "9.8") self.assertEqual(str(position), "[1.0, 2.0, 3.0]") self.assertEqual(str(mass_in_g), "1000.0") self.assertEqual(str(pi), "3.14") set_printing_strategy("default")
def test9(self): print "Testing custom printing strategy" mass = 2.0 | 0.5 * units.MSun acc = (0.0098 | nbody_system.length) * (1 | units.Myr**-2).as_quantity_in(units.s**-2) position = [0.1, 0.2, 0.3] | nbody_system.length power = 10 | units.W temperature = 5000 | units.K pi = 3.14 | units.none converter = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.kpc) set_printing_strategy("custom", nbody_converter = converter, preferred_units = [units.amu, units.AU, units.minute, units.milli(units.K), units.erg], precision = 3, prefix = "(> ", separator = " <|> ", suffix = " <)") self.assertEqual(str(mass), "(> 1.20e+57 <|> amu <)") self.assertEqual(str(acc), "(> 7.31e-18 <|> AU * min**-2 <)") self.assertEqual(str(position), "(> [2.06e+07, 4.13e+07, 6.19e+07] <|> AU <)") self.assertEqual(str(power), "(> 6.00e+09 <|> erg / min <)") self.assertEqual(str(constants.G), "(> 1.19e-67 <|> AU**3 * amu**-1 * min**-2 <)") self.assertEqual(str(constants.kB), "(> 1.38e-19 <|> erg * mK**-1 <)") self.assertEqual(str(temperature), "(> 5.00e+06 <|> mK <)") self.assertEqual(str(pi), "(> 3.14 <|> none <)") set_printing_strategy("default")
def test6(self): print "Testing astro printing strategy without units printed" mass = 2.0 | 0.5 * units.MSun acc = (0.0098 | nbody_system.length) * (1 | units.Myr**-2).as_quantity_in(units.s**-2) position = [0.1, 0.2, 0.3] | nbody_system.length energy = 1e8 | units.erg temperature = 5000 | units.K pi = 3.14 | units.none converter = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.kpc) set_printing_strategy("astro", print_units = False) self.assertEqual(str(mass), "1.0") self.assertRaises(AmuseException, str, acc, expected_message = "Unable to convert length * s**-2 to SI units. No nbody_converter given") self.assertEqual(str(converter.to_si(acc)), "9.8") self.assertEqual(str(converter.to_si(position)), "[100.0, 200.0, 300.0]") self.assertEqual(str(energy), "10.0") self.assertEqual(str(constants.G)[:8], "0.00449945056135"[:8]) self.assertEqual(str(temperature), "5000") self.assertEqual(str(pi), "3.14") set_printing_strategy("astro", nbody_converter = converter, print_units = False) self.assertEqual(str(acc), "9.8") set_printing_strategy("default")
result.add_option("--aout", unit=units.AU, dest="aout", type="float", default = 100|units.AU, help="orbital separation [%default]") result.add_option("--ein", dest="ein", type="float", default = 0.2, help="orbital eccentricity [%default]") result.add_option("--eout", dest="eout", type="float", default = 0.6, help="orbital eccentricity [%default]") result.add_option("-t", unit=units.Myr, dest="t_end", type="float", default = 0.55 | units.Myr, help="end time of the simulation [%default]") result.add_option("-s", dest="scheme", type="int", default = 3, help="integration scheme [%default]") result.add_option("--dtse", dest="dtse_fac", type="float", default = 0.1, help="stellar mass-loss time step fraction [%default]") return result if __name__ in ('__main__', '__plot__'): set_printing_strategy("custom", preferred_units = [units.MSun, units.AU, units.Myr], precision = 12, prefix = "", separator = " [", suffix = "]") o, arguments = new_option_parser().parse_args() main(**o.__dict__)
def main(): "Run make_a_star_cluster" set_printing_strategy( "custom", preferred_units=[units.MSun, units.parsec, units.yr, units.kms], precision=5, ) clustertemplate = "TESTCluster_%08i" args = new_argument_parser() cluster_model_number = args.cluster_model_number star_distribution = args.star_distribution # gas_distribution = args.gas_distribution king_parameter_w0 = args.king_parameter_w0 fractal_parameter_fd = args.fractal_parameter_fd initial_mass_function = args.initial_mass_function number_of_stars = args.number_of_stars if args.cluster_mass != 0: cluster_mass = args.cluster_mass | units.MSun else: cluster_mass = False upper_mass_limit = args.upper_mass_limit | units.MSun effective_radius = args.effective_radius | units.parsec metallicity = args.metallicity # virial_ratio = args.virial_ratio filetype = args.filetype # not implemented yet # initial_binary_fraction = args.initial_binary_fraction np.random.seed(cluster_model_number) if not (number_of_stars or cluster_mass): print("no number of stars or cluster mass given, exiting") exit() stars = make_a_star_cluster( stellar_mass=cluster_mass, initial_mass_function=initial_mass_function, upper_mass_limit=upper_mass_limit, number_of_stars=number_of_stars, effective_radius=effective_radius, star_distribution=star_distribution, star_distribution_w0=king_parameter_w0, star_distribution_fd=fractal_parameter_fd, star_metallicity=metallicity, ) print(stars.mass.sum()) print(len(stars)) if args.clustername != "auto": clustername = args.clustername else: cluster_file_exists = True N = -1 while cluster_file_exists: N += 1 clustername = (clustertemplate % N + "." + filetype) cluster_file_exists = os.path.isfile(clustername) write_set_to_file(stars, clustername, filetype)
result.add_option("--aout", unit=units.AU, dest="aout", type="float", default = 100|units.AU, help="orbital separation [%default]") result.add_option("--ein", dest="ein", type="float", default = 0.2, help="orbital eccentricity [%default]") result.add_option("--eout", dest="eout", type="float", default = 0.6, help="orbital eccentricity [%default]") result.add_option("-t", unit=units.Myr, dest="t_end", type="float", default = 0.55 | units.Myr, help="end time of the simulation [%default]") result.add_option("-s", dest="scheme", type="int", default = 3, help="integration scheme [%default]") result.add_option("--dtse", dest="dtse_fac", type="float", default = 0.1, help="stellar mass-loss time step fraction [%default]") return result if __name__ in ('__main__', '__plot__'): set_printing_strategy("custom", preferred_units = [units.MSun, units.AU, units.Myr], precision = 12, prefix = "", separator = " [", suffix = "]") o, arguments = new_option_parser().parse_args() main(**o.__dict__)
def test1(self): print "Testing get/set of printing strategy" self.assertEqual(get_current_printing_strategy(), console.DefaultPrintingStrategy) set_printing_strategy("no_unit") self.assertEqual(get_current_printing_strategy(), console.NoUnitsPrintingStrategy) set_printing_strategy("default") self.assertEqual(get_current_printing_strategy(), console.DefaultPrintingStrategy) set_printing_strategy("no_units") self.assertEqual(get_current_printing_strategy(), console.NoUnitsPrintingStrategy) set_printing_strategy("with_units") self.assertEqual(get_current_printing_strategy(), console.DefaultPrintingStrategy) set_printing_strategy("formal") self.assertEqual(get_current_printing_strategy(), console.FormalPrintingStrategy) set_printing_strategy("nbody") self.assertEqual(get_current_printing_strategy(), console.NBodyPrintingStrategy) set_printing_strategy(console.NoUnitsPrintingStrategy) self.assertEqual(get_current_printing_strategy(), console.NoUnitsPrintingStrategy) set_printing_strategy(console.DefaultPrintingStrategy) self.assertEqual(get_current_printing_strategy(), console.DefaultPrintingStrategy)
def tearDown(self): set_printing_strategy('default')
numpy.maximum(numpy.zeros_like(log_v), numpy.log((rho / (10 * min_rho))))).reshape(shape) rgba = numpy.concatenate((red, green, blue, alpha), axis=2) pyplot.figure(figsize=(image_size[0] / 100.0, image_size[1] / 100.0), dpi=100) im = pyplot.figimage(rgba, origin='lower') pyplot.savefig(figname, transparent=True, dpi=100) print "\nHydroplot was saved to: ", figname pyplot.close() def stop(self): print "Stopping the code. End of pipeline :-)" self.code.stop() if __name__ == "__main__": from amuse.support.console import set_printing_strategy set_printing_strategy( "custom", preferred_units=[units.MSun, units.kpc, units.Myr, units.kms], precision=4, prefix="", separator=" [", suffix="]") merger = ClusterMerger() merger.evolve()
def test1(self): print("Testing get/set of printing strategy") self.assertEqual(get_current_printing_strategy(), console.DefaultPrintingStrategy) set_printing_strategy("no_unit") self.assertEqual(get_current_printing_strategy(), console.NoUnitsPrintingStrategy) set_printing_strategy("default") self.assertEqual(get_current_printing_strategy(), console.DefaultPrintingStrategy) set_printing_strategy("no_units") self.assertEqual(get_current_printing_strategy(), console.NoUnitsPrintingStrategy) set_printing_strategy("with_units") self.assertEqual(get_current_printing_strategy(), console.DefaultPrintingStrategy) set_printing_strategy("formal") self.assertEqual(get_current_printing_strategy(), console.FormalPrintingStrategy) set_printing_strategy("nbody") self.assertEqual(get_current_printing_strategy(), console.NBodyPrintingStrategy) set_printing_strategy(console.NoUnitsPrintingStrategy) self.assertEqual(get_current_printing_strategy(), console.NoUnitsPrintingStrategy) set_printing_strategy(console.DefaultPrintingStrategy) self.assertEqual(get_current_printing_strategy(), console.DefaultPrintingStrategy)
log_v)).reshape(shape) blue = numpy.minimum(numpy.ones_like(rho.number), numpy.maximum(numpy.zeros_like(rho.number), log_E)).reshape(shape) alpha = numpy.minimum( numpy.ones_like(log_v), numpy.maximum(numpy.zeros_like(log_v), numpy.log( (rho / (10 * min_rho))))).reshape(shape) rgba = numpy.concatenate((red, green, blue, alpha), axis=2) pyplot.figure(figsize=(image_size[0] / 100.0, image_size[1] / 100.0), dpi=100) im = pyplot.figimage(rgba, origin='lower') # pyplot.savefig(figname, transparent=True, dpi = 100) # print "\nHydroplot was saved to: ", figname pyplot.show() pyplot.close() if __name__ == "__main__": set_printing_strategy("custom", preferred_units=[ units.MSun, units.Mpc, units.Myr, units.kms, units.erg ]) print "hello, world" # subcluster = SubCluster("Sub Cluster A") merger = World()
def setUp(self): set_printing_strategy("custom", preferred_units=[ units.MSun, units.parsec, units.Myr, units.kms, units.kms**2, units.m / units.s**2 ])
plot_channels = Channels() plot_channels.add_channel(stellar.particles.new_channel_to(stars)) plot_channels.add_channel(gravity.particles.new_channel_to(stars)) time = 0 | units.Myr while time <= end_time: bridge.evolve_model(time) plot_channels.copy() plot_results(stars, time) time += plot_timestep def parse_arguments(): parser = OptionParser() parser.add_option("-N", dest="number_of_stars", type="int", default=100, help="The number of stars in the cluster [%default].") parser.add_option("-s", dest="size", type="float", unit=units.parsec, default=10, help="The total size of the cluster [%default %unit].") parser.add_option("-t", dest="end_time", type="float", unit=units.Gyr, default=0.1, help="The end time of the simulation [%default %unit].") options, args = parser.parse_args() return options.__dict__ if __name__ == "__main__": options = parse_arguments() set_printing_strategy("custom", preferred_units = [units.MSun, units.parsec, units.Myr], precision=3) gravity_and_stellar_evolution(**options)
star = stev.particles.add_particle(Particle(mass=2 | units.MSun)) while star.radius < radius: star.evolve_one_step() print("evolved to:", star.age, "->", star.radius) star1 = star.copy() # High mass loss rates can only be calculated for small time steps star.time_step = 1. | units.yr star.mass_change = mdot print(star.mass_change) star.evolve_one_step() print_report(star1, star, mdot) if __name__ == "__main__": set_printing_strategy( "custom", preferred_units=[ units.RSun, units.MSun, units.Myr, units.MSun/units.yr, units.RSun/units.yr, ] ) evolve_star_and_apply_mass_loss( 39. | units.RSun, -1e-3 | units.MSun/units.yr)
print "rad" sph.gas_particles.u = evolve_internal_energy( sph.gas_particles.u, dt, sph.gas_particles.rho / global_mu, sph.gas_particles.du_dt) print(global_mu / constants.kB * sph.gas_particles.u.amin()).in_( units.K), print(global_mu / constants.kB * sph.gas_particles.u.amax()).in_( units.K) print "sph2" sph.evolve_model(t + dt) t += dt if __name__ == '__main__': set_printing_strategy("cgs") plot_cooling_function(gerritsen_cooling_function, "gerritsen_cooling_function.png") plot_cooling_function(my_cooling_function, "gerritsen_cooling_function_fudged.png") plot_cooling_vs_heating_n(0.1 | units.cm**-3, gerritsen_cooling_function, gerritsen_heating_function, "gerritsen_cooling_vs_heating_n-1.png") print "Equilibrium temperature:", print 10.0**log_equilibrium_temperature( 0.1 | units.cm**-3, gerritsen_cooling_function, gerritsen_heating_function) | units.K plot_cooling_vs_heating_P(1.0e3 | units.K * units.cm**-3, my_cooling_function, gerritsen_heating_function,
def tearDown(self): set_printing_strategy('default')
def setUp(self): set_printing_strategy("custom", preferred_units = [units.MSun, units.parsec, units.Myr, units.kms, units.kms**2, units.m/units.s**2])
star = stev.particles.add_particle(Particle(mass=2 | units.MSun)) while star.radius < radius: star.evolve_one_step() print("evolved to:", star.age, "->", star.radius) star1 = star.copy() # High mass loss rates can only be calculated for small time steps star.time_step = 1. | units.yr star.mass_change = mdot print(star.mass_change) star.evolve_one_step() print_report(star1, star, mdot) if __name__ == "__main__": set_printing_strategy("custom", preferred_units=[ units.RSun, units.MSun, units.Myr, units.MSun / units.yr, units.RSun / units.yr, ]) evolve_star_and_apply_mass_loss(39. | units.RSun, -1e-3 | units.MSun / units.yr)
parser = OptionParser() parser.add_option("-N", dest="number_of_stars", type="int", default=100, help="The number of stars in the cluster [%default].") parser.add_option("-s", dest="size", type="float", unit=units.parsec, default=10, help="The total size of the cluster [%default %unit].") parser.add_option("-t", dest="end_time", type="float", unit=units.Gyr, default=0.1, help="The end time of the simulation [%default %unit].") options, args = parser.parse_args() return options.__dict__ if __name__ == "__main__": options = parse_arguments() set_printing_strategy( "custom", preferred_units=[units.MSun, units.parsec, units.Myr], precision=3) gravity_and_stellar_evolution(**options)
parser.add_option("-t", dest="dt", unit=units.Myr, type="float", default = 0.1|units.Myr, help="Time resolution of the simulation [%default]") parser.add_option("-T", dest="t_end", unit=units.Myr, type="float", default = 10|units.Myr, help="End time of the simulation [%default]") parser.add_option("-f", dest="filename", type="string", default = "CA_Exam_TLRH_hybrid.amuse", help="The file in which to save the data [%default]") options, arguments = parser.parse_args() return options.__dict__ if __name__ == "__main__": set_printing_strategy("custom", preferred_units = [units.MSun, units.parsec, units.Myr, units.kms]) options = parse_options() # Hybrid # hybrid_self_gravitating_cluster(**options) # All stars above_cut, thus, direct # options["Mcut"] = 0. | units.MSun # options["filename"] = "CA_Exam_TLRH_direct.amuse" # hybrid_self_gravitating_cluster(**options) # All stars below_cut, thus, tree # options["Mcut"] = options["Mstar"] # options["filename"] = "CA_Exam_TLRH_tree.amuse" # hybrid_self_gravitating_cluster(**options) # Hybrid
def main(): "Make a star cluster" set_printing_strategy( "custom", preferred_units=[units.MSun, units.parsec, units.yr, units.kms], precision=5, ) clustertemplate = "TESTCluster_%08i" args = new_argument_parser() sinks = args.sinks cluster_model_number = args.cluster_model_number star_distribution = args.star_distribution # gas_distribution = args.gas_distribution king_parameter_w0 = args.king_parameter_w0 fractal_parameter_fd = args.fractal_parameter_fd initial_mass_function = args.initial_mass_function.lower() number_of_stars = args.number_of_stars if args.cluster_mass != 0: cluster_mass = args.cluster_mass | units.MSun else: cluster_mass = False upper_mass_limit = args.upper_mass_limit | units.MSun lower_mass_limit = args.lower_mass_limit | units.MSun effective_radius = args.effective_radius | units.parsec metallicity = args.metallicity # virial_ratio = args.virial_ratio filetype = args.filetype # not implemented yet # initial_binary_fraction = args.initial_binary_fraction np.random.seed(cluster_model_number) if not (number_of_stars or cluster_mass or sinks): print( "no number of stars, cluster mass or origin sinks given, exiting" ) exit() if sinks is not None: sinks = read_set_from_file(sinks, "amuse") stars = Particles() for sink in sinks: try: velocity_dispersion = sink.u.sqrt() except AttributeError: velocity_dispersion = args.velocity_dispersion | units.kms new_stars = new_stars_from_sink( sink, upper_mass_limit=upper_mass_limit, lower_mass_limit=lower_mass_limit, default_radius=effective_radius, velocity_dispersion=velocity_dispersion, initial_mass_function=initial_mass_function, # logger=logger, ) stars.add_particles( new_stars ) else: stars = new_star_cluster( stellar_mass=cluster_mass, initial_mass_function=initial_mass_function, upper_mass_limit=upper_mass_limit, lower_mass_limit=lower_mass_limit, number_of_stars=number_of_stars, effective_radius=effective_radius, star_distribution=star_distribution, star_distribution_w0=king_parameter_w0, star_distribution_fd=fractal_parameter_fd, star_metallicity=metallicity, ) print( "%i stars generated (%s)" % (len(stars), stars.total_mass().in_(units.MSun)) ) if args.clustername != "auto": clustertemplate = args.clustername + "%s" stars_file_exists = True sinks_file_exists = True N = -1 while (stars_file_exists or sinks_file_exists): N += 1 starsfilename = ( clustertemplate % N + "-stars." + filetype ) stars_file_exists = os.path.isfile(starsfilename) sinksfilename = ( clustertemplate % N + "-sinks." + filetype ) sinks_file_exists = os.path.isfile(sinksfilename) write_set_to_file(stars, starsfilename, filetype) if sinks is not None: write_set_to_file(sinks, sinksfilename, filetype)