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)
