repo
stringlengths 2
99
| file
stringlengths 13
225
| code
stringlengths 0
18.3M
| file_length
int64 0
18.3M
| avg_line_length
float64 0
1.36M
| max_line_length
int64 0
4.26M
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
amuse
|
amuse-main/src/amuse/io/store_v1.py
|
try:
import h5py
except ImportError as ex:
import warnings
warnings.warn("could not load h5py, hdf5 files not supported", ImportWarning)
h5py = None
import numpy
import pickle
import os.path
import sys
from amuse.units import si
from amuse.units import units
from amuse.units import core
from amuse.units.quantities import is_quantity
from amuse.support import exceptions
from amuse.datamodel import Particles
from amuse.datamodel import LinkedArray
from amuse.datamodel import AttributeStorage
import logging
logger = logging.getLogger(__name__)
def pickle_to_string(value):
return numpy.void(pickle.dumps(value, protocol=0))
def unpickle_from_string(value):
return pickle.loads(value, encoding='bytes')
class HDF5Attribute(object):
def __init__(self, name):
self.name = name
def get_values(self, indices):
pass
def set_values(self, indices, valus):
pass
def get_length(self):
return 0
def get_shape(self):
return 0
def increase_to_length(self, newlength):
pass
def copy(self):
pass
@classmethod
def new_attribute(cls, name, shape, input, group):
if is_quantity(input):
if not hasattr(shape, '__iter__'):
shape = shape,
dataset = group.create_dataset(name, shape=shape, dtype=input.number.dtype)
dataset.attrs["units"] = input.unit.to_simple_form().reference_string().encode("ascii")
return HDF5VectorQuantityAttribute(name, dataset, input.unit)
elif hasattr(input, 'as_set'):
subgroup = group.create_group(name)
group.create_dataset('keys', shape=shape, dtype=input.key.dtype)
group.create_dataset('masked', shape=shape, dtype=numpy.bool)
return HDF5LinkedAttribute(name, subgroup)
else:
dtype = numpy.asanyarray(input).dtype
if dtype.kind == 'U':
new_dtype = numpy.dtype('S' + dtype.itemsize * 4)
dataset = group.create_dataset(name, shape=shape, dtype=dtype)
dataset.attrs["units"] = "UNICODE".encode('ascii')
return HDF5UnicodeAttribute(name, dataset)
else:
if not hasattr(shape, '__iter__'):
shape = shape,
dtype = numpy.asanyarray(input).dtype
dataset = group.create_dataset(name, shape=shape, dtype=dtype)
dataset.attrs["units"] = "none".encode("ascii")
return HDF5UnitlessAttribute(name, dataset)
@classmethod
def load_attribute(cls, name, dataset, loader):
units_string = dataset.attrs["units"] if isinstance(dataset.attrs["units"], str) else dataset.attrs["units"].decode("ascii")
if units_string == "none":
return HDF5UnitlessAttribute(name, dataset)
elif units_string == "object":
return HDF5LinkedAttribute(name, dataset, loader)
elif units_string == "UNICODE":
return HDF5UnicodeAttribute(name, dataset)
else:
unit = eval(units_string, core.__dict__)
return HDF5VectorQuantityAttribute(name, dataset, unit)
def get_value(self, index):
pass
def remove_indices(self, indices):
pass
class HDF5VectorQuantityAttribute(HDF5Attribute):
def __init__(self, name, dataset, unit):
HDF5Attribute.__init__(self, name)
self.dataset = dataset
self.unit = unit
def get_values(self, indices):
if indices is None:
return self.unit.new_quantity(self.dataset[:])
elif len(self.get_shape()) > 1:
return self.unit.new_quantity(self.dataset[:][indices])
else:
return self.unit.new_quantity(self.dataset[:][indices])
def set_values(self, indices, values):
try:
self.dataset[indices] = values.value_in(self.unit)
except AttributeError:
if not is_quantity(values):
raise ValueError("Tried to put a non quantity value in a quantity")
else:
raise
def get_shape(self):
return self.dataset.shape
def increase_to_length(self, newlength):
oldlength = len(self.dataset)
delta = newlength - len(self.dataset)
if delta == 0:
return
newshape = list(self.dataset.shape)
newshape[0] = newlength
values = numpy.empty(shape=self.dataset.shape, dtype=self.dataset.dtype)
values[:] = self.dataset[:]
parent = self.dataset.parent
del parent[self.name]
self.dataset = parent.create_dataset(self.name, shape=newshape, dtype=values.dtype)
self.dataset[:oldlength] = values[:]
def get_length(self):
return len(self.dataset)
def copy(self):
#result = type(self)(self.name, self.get_shape(), self.quantity.unit)
#result.set_values(None, self.get_values(None))
#return result
raise NotImplementedError("Copy of an attribute in a hdf5 file is not implemented")
def get_value(self, index):
return self.unit.new_quantity(self.dataset[index])
def remove_indices(self, indices):
oldlength = len(self.dataset)
values = numpy.empty(shape=self.dataset.shape, dtype=self.dataset.dtype)
values[:] = self.dataset[:]
values = numpy.delete(values, indices)
parent = self.dataset.parent
del parent[self.name]
self.dataset = parent.create_dataset(self.name, shape=values.shape, dtype=values.dtype)
self.dataset[:] = values[:]
def has_units(self):
return True
class HDF5UnitlessAttribute(HDF5Attribute):
def __init__(self, name, dataset):
HDF5Attribute.__init__(self, name)
self.dataset = dataset
def get_values(self, indices):
if indices is None:
return self.dataset[:]
elif len(self.get_shape()) > 1:
return self.dataset[:][indices]
else:
return self.dataset[:][indices]
def set_values(self, indices, values):
self.dataset[indices] = values
def get_shape(self):
return self.dataset.shape
def increase_to_length(self, newlength):
oldlength = len(self.dataset)
delta = newlength - len(self.dataset)
if delta == 0:
return
newshape = list(self.dataset.shape)
newshape[0] = newlength
values = numpy.empty(shape=self.dataset.shape, dtype=self.dataset.dtype)
values[:] = self.dataset[:]
parent = self.dataset.parent
del parent[self.name]
self.dataset = parent.create_dataset(self.name, shape=newshape, dtype=values.dtype)
self.dataset[:oldlength] = values[:]
def get_length(self):
return len(self.dataset)
def copy(self):
#result = type(self)(self.name, self.get_shape(), self.quantity.unit)
#result.set_values(None, self.get_values(None))
#return result
raise NotImplementedError("Copy of an attribute in hdf5 is not implemented")
def get_value(self, index):
return self.dataset[index]
def remove_indices(self, indices):
oldlength = len(self.dataset)
values = numpy.empty(shape=self.dataset.shape, dtype=self.dataset.dtype)
values[:] = self.dataset[:]
values = numpy.delete(values, indices)
parent = self.dataset.parent
del parent[self.name]
self.dataset = parent.create_dataset(self.name, shape=values.shape, dtype=values.dtype)
self.dataset[:] = values[:]
def has_units(self):
return False
class HDF5LinkedAttribute(HDF5Attribute):
def __init__(self, name, group, loader):
HDF5Attribute.__init__(self, name)
self.group = group
self.keys = group['keys']
self.masked = group['masked']
self.loader = loader
def get_values(self, indices):
reference = self.group.attrs['reference']
referenced_group = self.loader.derefence(reference)
mapping_from_groupid_to_set = self.loader.mapping_from_groupid_to_set
if not referenced_group.id in mapping_from_groupid_to_set:
linked_set = self.loader.load_particles_from_group(referenced_group)
else:
linked_set = mapping_from_groupid_to_set[referenced_group.id]
if indices is None:
indices=slice(None)
keys = self.keys[:][indices]
mask = self.masked[:][indices]
result = LinkedArray(numpy.empty(len(keys), dtype= object))
for index in range(len(keys)):
key = keys[index]
if key >= 0:
result[index] = linked_set._get_particle(key)
return result
def set_values(self, indices, values):
if hasattr(values, 'get_all_keys_in_store'):
keys = values.get_all_keys_in_store()
mask = ~values.get_valid_particles_mask()
self.keys[indices] = keys
self.masked[indices] = mask
else:
if values is None:
self.keys[indices] = 0
self.masked[indices] = True
else:
for index, key in zip(indices, values):
if key is None:
self.keys[indices] = 0
self.masked[indices] = True
else:
self.keys[index] = key
self.masked[indices] = False
def get_length(self):
return len(self.keys)
def increase_to_length(self, newlength):
oldlength = len(self.keys)
delta = newlength - len(self.keys)
if delta == 0:
return
newshape = list(self.keys.shape)
newshape[0] = newlength
values = numpy.empty(shape=self.keys.shape, dtype=self.keys.dtype)
values[:] = self.keys[:]
parent = self.group
del parent['keys']
self.keys = parent.create_dataset('keys', shape=newshape, dtype=values.dtype)
self.keys[:oldlength] = values[:]
values = numpy.empty(shape=self.masked.shape, dtype=self.masked.dtype)
values[:] = self.masked[:]
parent = self.group
del parent['masked']
self.masked = parent.create_dataset('masked', shape=newshape, dtype=values.dtype)
self.masked[:oldlength] = values[:]
def get_shape(self):
return self.keys.shape
def copy(self):
#result = type(self)(self.name, self.get_shape(), self.linked_set)
#result.set_values(None, self.get_values(None))
#return result
raise NotImplementedError("Copy of an attribute in hdf5 is not implemented")
def get_value(self, index):
#key = self.values[index]
#if key is ma.masked:
# return None
#else:
# return self.linked_set._get_particle_unsave(key)
raise NotImplementedError("Copy of an attribute in hdf5 is not implemented")
def remove_indices(self, indices):
if 1:
raise NotImplementedError("Copy of an attribute in hdf5 is not implemented")
oldlength = len(self.dataset)
values = numpy.empty(shape=self.dataset.shape, dtype=self.dataset.dtype)
values[:] = self.dataset[:]
values = numpy.delete(values, indices)
parent = self.dataset.parent
del parent[self.name]
self.dataset = parent.create_dataset(self.name, shape=values.shape, dtype=values.dtype)
self.dataset[:] = values[:]
def has_units(self):
return False
class HDF5AttributeStorage(AttributeStorage):
def __init__(self, keys, hdfgroup, loader):
self.hdfgroup = hdfgroup
self.attributesgroup = self.hdfgroup["attributes"]
self.number_of_particles = self.hdfgroup.attrs["number_of_particles"]
self.particle_keys = keys
self.loader = loader
self.mapping_from_particle_to_index = self.new_index()
def can_extend_attributes(self):
return True
def __len__(self):
return len(self.particle_keys)
def new_index(self):
result = {}
index = 0
for particle_key in self.particle_keys:
result[particle_key] = index
index += 1
return result
def get_indices_of(self, keys):
if keys is None:
return numpy.arange(0,len(self.particle_keys))
mapping_from_particle_to_index = self.mapping_from_particle_to_index
result = numpy.zeros(len(keys),dtype='int32')
index = 0
for index, particle_key in enumerate(keys):
result[index] = mapping_from_particle_to_index[particle_key]
index += 1
return result
def get_defined_attribute_names(self):
return list(self.attributesgroup.keys())
def get_defined_settable_attribute_names(self):
return self.get_defined_attribute_names()
def get_values_in_store(self, indices, attributes):
results = []
for attribute in attributes:
dataset = HDF5Attribute.load_attribute(
attribute,
self.attributesgroup[attribute],
self.loader
)
selected_values = dataset.get_values(indices)
results.append(selected_values)
return results
def has_key_in_store(self, key):
return key in self.mapping_from_particle_to_index
def get_all_keys_in_store(self):
return self.particle_keys
def set_values_in_store(self, indices, attributes, quantities):
for attribute, quantity in zip(attributes, quantities):
if attribute in self.attributesgroup:
dataset = HDF5Attribute.load_attribute(
attribute,
self.attributesgroup[attribute],
self.loader
)
else:
dataset = HDF5Attribute.new_attribute(
attribute,
len(self.particle_keys),
quantity,
self.attributesgroup
)
bools = numpy.zeros(dataset.get_shape(), dtype='bool')
bools[indices] = True
dataset.set_values(bools, quantity)
def get_all_indices_in_store(self):
return numpy.arange(len(self.particle_keys))
class HDF5GridAttributeStorage(AttributeStorage):
def __init__(self, shape, hdfgroup, loader):
self.hdfgroup = hdfgroup
self.attributesgroup = self.hdfgroup["attributes"]
self.shape = shape
self.loader = loader
def storage_shape(self):
return self.shape
def add_particles_to_store(self, keys, attributes = [], quantities = []):
raise exceptions.AmuseException("adding points to the grid is not implemented")
def remove_particles_from_store(self, keys):
raise exceptions.AmuseException("removing points from the grid is not implemented")
def __len__(self):
return numpy.prod(self.shape)
def get_unit_of(self, attribute):
dataset = self.attributesgroup[attribute]
decoded=dataset.attrs["units"] if isinstance(dataset.attrs["units"], str) else dataset.attrs["units"].decode("ascii")
return eval(decoded, core.__dict__)
def get_defined_attribute_names(self):
return list(self.attributesgroup.keys())
def get_values_in_store(self, indices, attributes):
results = []
for attribute in attributes:
dataset = HDF5Attribute.load_attribute(
attribute,
self.attributesgroup[attribute],
self.loader
)
selected_values = dataset.get_values(indices)
results.append(selected_values)
#values_vector = self.attributesgroup[attribute]
#if indices is None:
# selected_values = numpy.ndarray(shape=self.shape, dtype = values_vector.dtype)
# values_vector.read_direct(selected_values)
#else:
# #selection = h5py.selections.PointSelection(values_vector.shape)
# #selection.set(numpy.transpose([indices,]))
# selected_values = values_vector[indices]
#results.append(self.get_unit_of(attribute).new_quantity(selected_values))
return results
def has_key_in_store(self, key):
return False
def get_all_keys_in_store(self):
return None
def set_values_in_store(self, indices, attributes, quantities):
for attribute, quantity in zip(attributes, quantities):
if attribute in self.attributesgroup:
dataset = self.attributesgroup[attribute]
else:
dataset = self.attributesgroup.create_dataset(attribute, shape=self.shape, dtype=quantity.number.dtype)
dataset["unit"] = quantity.unit.to_simple_form().reference_string().encode("ascii")
dataset[indices] = quantity.value_in(self.get_unit_of(attribute))
class StoreHDF(object):
PARTICLES_GROUP_NAME = "particles"
GRIDS_GROUP_NAME = "grids"
UNNAMED_REFERENCES_GROUP_NAME = "referenced"
def __init__(self, filename, append_to_file=True, open_for_writing = True, copy_history = False, overwrite_file=False):
if h5py is None:
raise exceptions.AmuseException("h5py module not available, cannot use hdf5 files")
logger.info("opening {0} with options {1} {2} {3} {4}".format(filename, append_to_file, open_for_writing, copy_history,overwrite_file))
if not append_to_file and open_for_writing:
if os.path.exists(filename):
if overwrite_file:
os.remove(filename)
else:
raise Exception("Opening file for write with overwrite_file is False but file {0} exists".format(filename))
if append_to_file:
if os.access(filename, os.F_OK) and not os.access(filename, os.W_OK):
raise Exception("Opening file for append but file {0} is not writeable".format(filename))
self.hdf5file = h5py.File(filename,'a')
elif open_for_writing:
self.hdf5file = h5py.File(filename,'w')
else:
self.hdf5file = h5py.File(filename,'r')
self.copy_history = copy_history
self.mapping_from_groupid_to_set = {}
def is_correct_version(self):
if self.PARTICLES_GROUP_NAME in self.hdf5file:
return True
if self.GRIDS_GROUP_NAME in self.hdf5file:
return True
if self.UNNAMED_REFERENCES_GROUP_NAME in self.hdf5file:
return True
if 'AMUSE_INF' in self.hdf5file:
return False
return True
def store_sets(self, sets, names, extra_attributes = {}):
mapping_from_setid_to_group = {}
links_to_resolve = []
for x, name in zip(sets, names):
if hasattr(x, 'shape'):
self.store_grid(x, extra_attributes, parent = self.named_group(name))
else:
self.store_particles(x, extra_attributes, self.named_group(name), mapping_from_setid_to_group, links_to_resolve)
while len(links_to_resolve) > 0:
sets_to_store, links_to_resolve = self.resolve_links(
mapping_from_setid_to_group,
links_to_resolve
)
for x in set(sets_to_store):
if hasattr(x, 'shape'):
self.store_grid(x, extra_attributes, parent = self.unnamed_references_group())
else:
self.store_particles(x, {}, self.unnamed_references_group(), mapping_from_setid_to_group, links_to_resolve)
def store(self, container, extra_attributes = {}):
if hasattr(container, 'shape'):
self.store_grid(container, extra_attributes)
else:
mapping_from_setid_to_group = {}
links_to_resolve = []
self.store_particles(container, extra_attributes, None, mapping_from_setid_to_group, links_to_resolve)
while len(links_to_resolve) > 0:
sets_to_store, links_to_resolve = self.resolve_links(
mapping_from_setid_to_group,
links_to_resolve
)
for x in set(sets_to_store):
self.store_particles(x, {}, self.unnamed_references_group(), mapping_from_setid_to_group, links_to_resolve)
def new_group(self, master_group):
index = len(master_group)
name = format(index + 1,"010d")
return master_group.create_group(name)
def store_particles(self, particles, extra_attributes = {}, parent=None, mapping_from_setid_to_group = {}, links = []):
if parent is None:
parent = self.particles_group()
group = self.new_group(parent)
group.attrs["type"] = 'particles'.encode("ascii")
self.mapping_from_groupid_to_set[group.id] = particles._original_set()
group.attrs["number_of_particles"] = len(particles)
group.attrs["class_of_the_particles"] = pickle_to_string(particles._factory_for_new_collection())
keys = particles.get_all_keys_in_store()
dataset = group.create_dataset("keys", data=keys)
self.hdf5file.flush()
self.store_collection_attributes(particles, group, extra_attributes)
self.store_values(particles, group, links)
mapping_from_setid_to_group[id(particles._original_set())] = group
self.hdf5file.flush()
def resolve_links(self, mapping_from_setid_to_group, links):
sets_to_store = []
links_to_resolve = []
for group, linked_set in links:
if id(linked_set) in mapping_from_setid_to_group:
stored_group = mapping_from_setid_to_group[id(linked_set)]
group.attrs['reference'] = stored_group.ref
else:
sets_to_store.append(linked_set)
links_to_resolve.append([group, linked_set])
return sets_to_store, links_to_resolve
def store_grid(self, grid, extra_attributes = {}, parent=None, mapping_from_setid_to_group = {}, links = []):
if parent is None:
parent = self.grids_group()
group = self.new_group(parent)
group.attrs["type"] = 'grid'.encode("ascii")
group.attrs["class_of_the_container"] = pickle_to_string(grid._factory_for_new_collection())
group.create_dataset("shape", data=numpy.asarray(grid.shape))
self.store_collection_attributes(grid, group, extra_attributes)
self.store_values(grid, group)
mapping_from_setid_to_group[id(grid._original_set())] = group
self.hdf5file.flush()
def store_values(self, container, group, links = []):
attributes_group = group.create_group("attributes")
all_values = container.get_values_in_store(None, container.get_attribute_names_defined_in_store())
for attribute, quantity in zip(container.get_attribute_names_defined_in_store(), all_values):
if is_quantity(quantity):
value = quantity.value_in(quantity.unit)
dataset = attributes_group.create_dataset(attribute, data=value)
dataset.attrs["units"] = quantity.unit.to_simple_form().reference_string().encode("ascii")
elif hasattr(quantity, 'as_set'):
quantity = quantity.as_set()
subgroup = attributes_group.create_group(attribute)
keys = quantity.get_all_keys_in_store()
masked = ~quantity.get_valid_particles_mask()
links.append([subgroup, quantity.as_set()._original_set()])
subgroup.create_dataset('keys', data=keys)
subgroup.create_dataset('masked', data=masked)
subgroup.attrs["units"] = "object".encode("ascii")
else:
dtype = numpy.asanyarray(quantity).dtype
if dtype.kind == 'U':
dataset = attributes_group.create_dataset(attribute, data=numpy.char.encode(quantity, 'UTF-32BE'))
dataset.attrs["units"] = "UNICODE".encode("ascii")
else:
dataset = attributes_group.create_dataset(attribute, data=quantity)
dataset.attrs["units"] = "none".encode("ascii")
def store_timestamp(self, container, group):
quantity = container.get_timestamp()
if not quantity is None:
group.attrs["timestamp"] = quantity.value_in(quantity.unit)
group.attrs["timestamp_unit"] = quantity.unit.reference_string().encode("ascii")
def store_collection_attributes(self, container, group, extra_attributes):
collection_attributes = container.collection_attributes.__getstate__()
arguments_and_attributes = {}
arguments_and_attributes.update(collection_attributes)
arguments_and_attributes.update(extra_attributes)
for name, quantity in arguments_and_attributes.items():
if quantity is None:
continue
if is_quantity(quantity):
group.attrs[name] = quantity.value_in(quantity.unit)
group.attrs[name+"_unit"] = quantity.unit.reference_string().encode("ascii")
else:
group.attrs[name] = quantity
group.attrs[name+"_unit"] = "none".encode("ascii")
def load_collection_attributes(self, container, group):
names = group.attrs.keys()
attributenames = [x for x in names if x + '_unit' in group.attrs]
for name in attributenames:
unit_string = group.attrs[name+"_unit"] if isinstance(group.attrs[name+"_unit"],str) else group.attrs[name+"_unit"].decode("ascii")
if unit_string == 'none':
quantity = group.attrs[name]
else:
unit = eval(unit_string, core.__dict__)
quantity = unit.new_quantity(group.attrs[name])
setattr(container.collection_attributes, name, quantity)
def load(self):
if not self.PARTICLES_GROUP_NAME in self.hdf5file:
return self.load_grid(self.grids_group())
else:
if len(self.particles_group()) > 0:
return self.load_particles(self.particles_group())
elif len(self.grids_group()) > 0:
return self.load_grid(self.grids_group())
else:
raise Exception("No particles or grids found in the hdf5 file")
def load_sets(self, names):
result = []
for x in names:
set = self.load_container(self.named_group(x), 'particles')
result.append(set)
return result
def load_particles_from_group(self, group):
class_of_the_particles = unpickle_from_string(group.attrs["class_of_the_particles"])
dataset = group["keys"]
keys = numpy.ndarray(len(dataset), dtype = dataset.dtype)
if len(keys) == 0:
particles = class_of_the_particles()
else:
dataset.read_direct(keys)
particles = class_of_the_particles()
particles._private.attribute_storage = HDF5AttributeStorage(keys, group, self)
self.load_collection_attributes(particles, group)
self.mapping_from_groupid_to_set[group.id] = particles
return particles
def load_grid_from_group(self, group):
class_of_the_container = unpickle_from_string(group.attrs["class_of_the_container"])
shape = tuple(group["shape"])
container = class_of_the_container()
container._private.attribute_storage = HDF5GridAttributeStorage(shape, group, self)
self.load_collection_attributes(container, group)
self.mapping_from_groupid_to_set[group.id] = container
return container
def load_from_group(self, group, default_type = 'particles'):
if 'type' in group.attrs:
container_type = group.attrs['type'] if isinstance(group.attrs['type'], str) else group.attrs['type'].decode('ascii')
else:
container_type = default_type
if container_type == 'particles':
return self.load_particles_from_group(group)
elif container_type == 'grid':
return self.load_grid_from_group(group)
else:
raise Exception('unknown container type in file {0}'.format(container_type))
def load_particles(self, container_group = None):
if container_group is None:
container_group = self.particles_group()
return self.load_container(container_group, 'particles')
def load_grid(self, container_group = None):
if container_group is None:
container_group = self.grids_group()
return self.load_container(container_group, 'grid')
def load_container(self, container_group, default_type):
number_of_saved_containers= len(container_group)
all_containers = [None] * number_of_saved_containers
for group_index in container_group.keys():
group = container_group[group_index]
container = self.load_from_group(group, default_type)
if self.copy_history:
container = container.copy()
all_containers[int(group_index) - 1] = container
previous = None
for x in all_containers:
x._private.previous = previous
previous = x
last = all_containers[-1]
copy_of_last = last.copy()
copy_of_last._private.previous = last
return copy_of_last
def derefence(self, reference):
return self.hdf5file[reference]
def particles_group(self):
return self.named_group(self.PARTICLES_GROUP_NAME)
def unnamed_references_group(self):
return self.named_group(self.UNNAMED_REFERENCES_GROUP_NAME)
def grids_group(self):
return self.named_group(self.GRIDS_GROUP_NAME)
def named_group(self, name):
return self.hdf5file.require_group(name)
def close(self):
if not self.hdf5file is None:
self.hdf5file.flush()
self.hdf5file.close()
self.hdf5file = None
class HDF5UnicodeAttribute(HDF5UnitlessAttribute):
def __init__(self, name, dataset):
HDF5UnitlessAttribute.__init__(self, name, dataset)
def get_values(self, indices):
if indices is None:
encoded = self.dataset[:]
elif len(self.get_shape()) > 1:
encoded = self.dataset[:][indices]
else:
encoded = self.dataset[:][indices]
return numpy.char.decode(encoded, 'UTF-32BE')
def set_values(self, indices, values):
self.dataset[indices] = numpy.char.encode(values, 'UTF-32LE')
def get_value(self, index):
return self.dataset[index].decode('UTF-32BE')
| 32,086
| 36.749412
| 143
|
py
|
amuse
|
amuse-main/src/amuse/io/nemobin.py
|
import array
import numpy
from amuse.io import base
from amuse.units import nbody_system
from amuse.support.core import late, OrderedMultiDictionary
from amuse import datamodel
class NemoItemType(type):
mapping = {}
def __new__(metaclass, name, bases, dict):
if 'datatype' in dict:
if not dict['datatype'] is None:
dict['datatype'] = numpy.dtype(dict['datatype'])
result = type.__new__(metaclass, name, bases, dict)
if 'typecharacter' in dict:
metaclass.mapping[dict['typecharacter']] = result
return result
@classmethod
def new_item(metaclass, typecharacter, tagstring, dimensions, mustswap=False):
return metaclass.mapping[typecharacter](tagstring, dimensions, mustswap=mustswap)
class NemoItem(object, metaclass=NemoItemType):
def __init__(self, tagstring, dimensions=[1], data=None, mustswap=False):
self.tagstring = tagstring
self.dimensions = dimensions
self.mustswap = mustswap
self.data = data
def is_plural(self):
if len(self.dimensions) == 1 and self.dimensions[0] <= 1:
return False
else:
return True
@late
def number_of_values(self):
return numpy.prod(self.dimensions)
def read(self, nemofile):
if self.datatype is None:
pass
else:
self.data = nemofile.read_fixed_array(self.datatype, self.number_of_values)
self.postprocess()
def write(self, nemofile):
if self.datatype is None:
pass
else:
nemofile.write_fixed_array(self.preprocess(), self.datatype)
def postprocess(self):
if self.mustswap:
self.data.byteswap()
def preprocess(self):
return self.data
def isEndOfSet(self):
return False
def isEndOfHistory(self):
return False
def __str__(self):
return 'nemoitem({0},{1})'.format(self.tagstring, self.dimensions)
def __repr__(self):
return '<{0!s} {1},{2}>'.format(type(self), self.tagstring, self.dimensions)
class AnyItem(NemoItem):
"""anything at all"""
typecharacter = "a"
datatype = numpy.byte
class CharItem(NemoItem):
"""printable chars"""
typecharacter = "c"
datatype = "c"
def postprocess(self):
self.data = self.data[:-1].tobytes().decode('latin_1')
def preprocess(self):
result = numpy.array(list(self.data), "c")
result = numpy.append(result, b'\x00')
return result
class ByteItem(NemoItem):
"""unprintable chars"""
typecharacter = "b"
datatype = numpy.byte
def postprocess(self):
self.data = self.data.reshape(self.dimensions)
class ShortItem(NemoItem):
""" short integers """
typecharacter = "s"
datatype = numpy.int16
def postprocess(self):
self.data = self.data.reshape(self.dimensions)
class IntItem(NemoItem):
""" standard integers """
typecharacter = "i"
datatype = numpy.int32
def postprocess(self):
self.data = self.data.reshape(self.dimensions)
class LongItem(NemoItem):
""" long integers """
typecharacter = "l"
datatype = numpy.int64
def postprocess(self):
self.data = self.data.reshape(self.dimensions)
class HalfpItem(NemoItem):
""" half precision floating """
typecharacter = "h"
datatype = numpy.int16
class FloatItem(NemoItem):
""" short floating """
typecharacter = "f"
datatype = numpy.float32
def postprocess(self):
self.data = self.data.reshape(self.dimensions)
class DoubleItem(NemoItem):
""" long floating """
typecharacter = "d"
datatype = numpy.float64
def postprocess(self):
self.data = self.data.reshape(self.dimensions)
class SetItem(NemoItem):
""" begin compound item """
typecharacter = "("
datatype = None
def __init__(self, tagstring, dimensions=[1], data=None, mustswap=False):
if data is None:
data = OrderedMultiDictionary()
NemoItem.__init__(self, tagstring, dimensions, data, mustswap)
def read(self, nemofile):
self.data = OrderedMultiDictionary()
subitem = nemofile.read_item()
while not subitem.isEndOfSet():
self.data[subitem.tagstring] = subitem
subitem = nemofile.read_item()
def write(self, nemofile):
for x in self.data.values():
nemofile.write_item(x)
nemofile.write_item(TesItem(self.tagstring, [1]))
def add_item(self, item):
self.data[item.tagstring] = item
class TesItem(NemoItem):
""" end of compound item """
typecharacter = ")"
datatype = None
def isEndOfSet(self):
return True
def read(self, file):
pass
# Experimental Kludge
class StoryItem(NemoItem):
""" begin of a story item (see starlab) """
typecharacter = "["
typecharacter = "["
datatype = None
def read(self, nemofile):
self.data = OrderedMultiDictionary()
subitem = nemofile.read_item()
while not subitem.isEndOfHistory():
self.data[subitem.tagstring] = subitem
subitem = nemofile.read_item()
def write(self, nemofile):
for x in self.data.values():
nemofile.write_item(x)
nemofile.write_item(YrotsItem(self.tagstring, [1]))
class YrotsItem(NemoItem):
""" end of a story item (see starlab) """
typecharacter = "]"
datatype = None
def isEndOfHistory(self):
return True
class NemoBinaryFile(object):
def __init__(self, file):
self.file = file
SingMagic = ((0o11 << 8) + 0o222)
PlurMagic = ((0o13 << 8) + 0o222)
def _byteswap(self, value, type='H'):
x = array.array('H', [value])
x.byteswap()
return x[0]
@late
def reversed_SingMagic(self):
return self._byteswap(self.SingMagic)
@late
def reversed_PlurMagic(self):
return self._byteswap(self.PlurMagic)
def read_magic_number(self):
nbytes = 2
bytes = self.file.read(nbytes)
if not bytes or len(bytes) < nbytes:
return None
return array.array('h', bytes)[0]
def read_array(self, typetag):
result = array.array(typetag)
# counter = result.itemsize
must_loop = True
while must_loop:
block = self.file.read(result.itemsize)
result.frombytes(block)
must_loop = result[-1] != 0
result.pop()
return result
def read_string(self):
return self.read_array('b').tobytes().decode('latin_1')
def read_fixed_array(self, datatype, count):
bytes = self.file.read(int(datatype.itemsize * count))
return numpy.frombuffer(bytes, dtype=datatype,)
def get_item_header(self):
magic_number = self.read_magic_number()
if magic_number is None:
return (None, None, None, None)
mustswap = False
if magic_number == self.reversed_SingMagic:
magic_number == self.SingMagic
mustswap = True
elif magic_number == self.reversed_PlurMagic:
magic_number == self.PlurMagic
mustswap = True
if not (magic_number == self.SingMagic or magic_number == self.PlurMagic):
raise base.IoException("Item does not have a valid header")
typecharacter = self.read_string()
if not typecharacter == TesItem.typecharacter:
tagstring = self.read_string()
else:
tagstring = ''
if magic_number == self.PlurMagic:
dim = self.read_array('i')
if mustswap:
dim.byteswap()
dim = dim.tolist()
else:
dim = [1]
return (typecharacter, tagstring, dim, mustswap)
def read_item(self):
typecharacter, tagstring, dim, mustswap = self.get_item_header()
if typecharacter is None:
return None
result = NemoItemType.new_item(typecharacter, tagstring, dim, mustswap)
result.read(self)
return result
def read(self):
result = OrderedMultiDictionary()
item = self.read_item()
while item is not None:
result[item.tagstring] = item
item = self.read_item()
return result
def write_magic_number(self, is_plural):
if is_plural:
magic_number = self.PlurMagic
else:
magic_number = self.SingMagic
x = array.array('h', [magic_number])
self.file.write(x.tobytes())
def write_array(self, typetag, data):
x = array.array(typetag, data)
x.append(0)
self.file.write(x.tobytes())
def write_string(self, string):
return self.write_array('b', string.encode('latin_1'))
def write_item_header(self, item):
self.write_magic_number(item.is_plural())
self.write_string(item.typecharacter)
if not item.typecharacter == TesItem.typecharacter:
self.write_string(item.tagstring)
if item.is_plural():
self.write_array('i', item.dimensions)
def write_item(self, item):
self.write_item_header(item)
item.write(self)
def write_fixed_array(self, data, datatype):
temp = numpy.array(data, dtype=datatype)
self.file.write(temp.tobytes())
def write(self, data):
for x in data.values():
self.write_item(x)
class NemoBinaryFileFormatProcessor(base.BinaryFileFormatProcessor):
provided_formats = ['nemobin']
def load_file(self, file):
nemofile = NemoBinaryFile(file)
structure = nemofile.read()
result = None
for snapshot in structure['SnapShot']:
if 'Particles' not in snapshot.data:
continue
parameters = snapshot.data['Parameters'][0].data
nparticles = int(parameters['Nobj'][0].data[0])
time = parameters['Time'][0].data[0]
if result is None:
result = datamodel.Particles(nparticles)
particlesitem = snapshot.data['Particles'][0]
if 'PhaseSpace' in particlesitem.data:
positions_and_velocities = particlesitem.data['PhaseSpace'][0].data
positions = positions_and_velocities[..., 0, :]
velocities = positions_and_velocities[..., 1, :]
else:
positions = particlesitem.data['Position'][0].data
# positions = positions.reshape(positions.shape[:-1])
velocities = particlesitem.data['Velocity'][0].data
# velocities = velocities.reshape(velocities.shape[:-1])
result.position = nbody_system.length.new_quantity(positions)
result.velocity = nbody_system.speed.new_quantity(velocities)
if 'Mass' in particlesitem.data:
mass = particlesitem.data['Mass'][0].data
result.mass = nbody_system.mass.new_quantity(mass)
result.savepoint(time | nbody_system.time)
return result
def store_file(self, file):
nemofile = NemoBinaryFile(file)
item = SetItem('SnapShot')
parameters_item = SetItem('Parameters')
item.add_item(parameters_item)
parameters_item.add_item(IntItem('Nobj', data=len(self.set)))
if self.set.get_timestamp() is None:
parameters_item.add_item(DoubleItem('Time', data=0.0))
else:
parameters_item.add_item(DoubleItem('Time', data=set.get_timestamp().value_in(nbody_system.time)))
particles_item = SetItem('Particles')
item.add_item(particles_item)
particles_item.add_item(
DoubleItem(
'Position',
dimensions=(len(self.set), 3),
data=self.set.position.value_in(nbody_system.length)
)
)
particles_item.add_item(DoubleItem('Velocity', dimensions=(len(self.set), 3), data=self.set.velocity.value_in(nbody_system.speed)))
particles_item.add_item(DoubleItem('Mass', dimensions=(len(self.set), ), data=self.set.mass.value_in(nbody_system.mass)))
nemofile.write({'a': item})
| 12,272
| 28.014184
| 139
|
py
|
amuse
|
amuse-main/src/amuse/io/store_v2.py
|
try:
import h5py
except ImportError as ex:
import warnings
warnings.warn("could not load h5py, hdf5 files not supported", ImportWarning)
h5py = None
import numpy
import pickle
import os.path
import sys
from amuse.units import si
from amuse.units import units
from amuse.units import core
from amuse.units.quantities import is_quantity
from amuse.support import exceptions
from amuse.datamodel import Particles
from amuse.datamodel import Particle
from amuse.datamodel import AttributeStorage
from amuse.datamodel import LinkedArray
from amuse.datamodel import Grid
from amuse.datamodel import GridPoint
from amuse.datamodel import AbstractSet
from amuse.datamodel.base import VectorAttribute
from amuse.io import store_v1
import warnings
import logging
logger = logging.getLogger(__name__)
def pickle_to_string(value):
return numpy.void(pickle.dumps(value, protocol=0))
def unpickle_from_string(value):
return pickle.loads(value, encoding='bytes')
class HDF5Attribute(object):
compression = False
compression_opts = None
def __init__(self, name):
self.name = name
def get_values(self, indices):
pass
def set_values(self, indices, valus):
pass
def get_length(self):
return 0
def get_shape(self):
return 0
def increase_to_length(self, newlength):
pass
def copy(self):
pass
@classmethod
def new_attribute(cls, name, shape, input, group):
if is_quantity(input):
if not hasattr(shape, '__iter__'):
shape = shape,
dtype = numpy.asanyarray(input.number).dtype
dataset = group.create_dataset(
name,
shape=shape,
dtype=dtype,
compression=cls.compression,
compression_opts=cls.compression_opts,
)
dataset.attrs["units"] = input.unit.to_simple_form().reference_string().encode('ascii')
return HDF5VectorQuantityAttribute(name, dataset, input.unit)
elif hasattr(input, 'as_set'):
raise Exception("adding a linked attribute to a set stored in a HDF file is not supported, alternative is to copy the set and save it")
subgroup = group.create_group(name)
group.create_dataset(
'keys',
shape=shape,
dtype=input.key.dtype,
compression=cls.compression,
compression_opts=cls.compression_opts,
)
group.create_dataset(
'masked',
shape=shape,
dtype=numpy.bool,
compression=cls.compression,
compression_opts=cls.compression_opts,
)
return HDF5LinkedAttribute(name, subgroup)
else:
dtype = numpy.asanyarray(input).dtype
if dtype.kind == 'U':
# new_dtype = numpy.dtype('S' + dtype.itemsize * 4)
dataset = group.create_dataset(
name,
shape=shape,
dtype=dtype,
compression=cls.compression,
compression_opts=cls.compression_opts,
)
dataset.attrs["units"] = "UNICODE".encode('ascii')
return HDF5UnicodeAttribute(name, dataset)
else:
if not hasattr(shape, '__iter__'):
shape = shape,
dataset = group.create_dataset(
name,
shape=shape,
dtype=dtype,
compression=cls.compression,
compression_opts=cls.compression_opts,
)
dataset.attrs["units"] = "none".encode('ascii')
return HDF5UnitlessAttribute(name, dataset)
@classmethod
def load_attribute(cls, name, dataset, loader):
units_string = dataset.attrs["units"] if isinstance(dataset.attrs["units"], str) else dataset.attrs["units"].decode("ascii")
if units_string == "none":
return HDF5UnitlessAttribute(name, dataset)
elif units_string == "link":
return HDF5LinkedAttribute(name, dataset, loader)
elif units_string == "UNICODE":
return HDF5UnicodeAttribute(name, dataset)
else:
try:
unit = eval(units_string, core.__dict__)
except:
# These are some strange things found in the
# unit string field of a couple of data files
# I'm unsure if this is a data corruption
# or some problem in printing units...
# same error was found in multiple files
# pointing to a real error
# this code is for existing files
if '*0(' in units_string:
updated = units_string.replace('*0(','* (')
unit = eval(updated, core.__dict__)
elif 'vystem.' in units_string:
updated = units_string.replace('vystem.','system.')
unit = eval(updated, core.__dict__)
else:
print(units_string)
raise
return HDF5VectorQuantityAttribute(name, dataset, unit)
def get_value(self, index):
pass
def remove_indices(self, indices):
pass
class HDF5VectorQuantityAttribute(HDF5Attribute):
compression = False
compression_opts = None
def __init__(self, name, dataset, unit):
HDF5Attribute.__init__(self, name)
self.dataset = dataset
self.unit = unit
def get_values(self, indices):
if indices is None:
return self.unit.new_quantity(self.dataset[:])
elif len(self.get_shape()) > 1:
return self.unit.new_quantity(self.dataset[:][indices])
else:
return self.unit.new_quantity(self.dataset[:][indices])
def set_values(self, indices, values):
try:
self.dataset[indices] = values.value_in(self.unit)
except AttributeError:
if not is_quantity(values):
raise ValueError("Tried to put a non quantity value in a quantity")
else:
raise
def get_shape(self):
return self.dataset.shape
def increase_to_length(self, newlength):
oldlength = len(self.dataset)
delta = newlength - len(self.dataset)
if delta == 0:
return
newshape = list(self.dataset.shape)
newshape[0] = newlength
values = numpy.empty(shape=self.dataset.shape, dtype=self.dataset.dtype)
values[:] = self.dataset[:]
parent = self.dataset.parent
del parent[self.name]
self.dataset = parent.create_dataset(
self.name,
shape=newshape,
dtype=values.dtype,
compression=self.compression,
compression_opts=self.compression_opts,
)
self.dataset[:oldlength] = values[:]
def get_length(self):
return len(self.dataset)
def copy(self):
#result = type(self)(self.name, self.get_shape(), self.quantity.unit)
#result.set_values(None, self.get_values(None))
#return result
raise NotImplementedError("Copy of an attribute in a hdf5 file is not implemented")
def get_value(self, index):
return self.unit.new_quantity(self.dataset[index])
def remove_indices(self, indices):
oldlength = len(self.dataset)
values = numpy.empty(shape=self.dataset.shape, dtype=self.dataset.dtype)
values[:] = self.dataset[:]
values = numpy.delete(values, indices)
parent = self.dataset.parent
del parent[self.name]
self.dataset = parent.create_dataset(
self.name,
shape=values.shape,
dtype=values.dtype,
compression=self.compression,
compression_opts=self.compression_opts,
)
self.dataset[:] = values[:]
def has_units(self):
return True
class HDF5UnitlessAttribute(HDF5Attribute):
compression = False
compression_opts = None
def __init__(self, name, dataset):
HDF5Attribute.__init__(self, name)
self.dataset = dataset
def get_values(self, indices):
if indices is None:
return self.dataset[:]
elif len(self.get_shape()) > 1:
return self.dataset[:][indices]
else:
return self.dataset[:][indices]
def set_values(self, indices, values):
self.dataset[indices] = values
def get_shape(self):
return self.dataset.shape
def increase_to_length(self, newlength):
oldlength = len(self.dataset)
delta = newlength - len(self.dataset)
if delta == 0:
return
newshape = list(self.dataset.shape)
newshape[0] = newlength
values = numpy.empty(shape=self.dataset.shape, dtype=self.dataset.dtype)
values[:] = self.dataset[:]
parent = self.dataset.parent
del parent[self.name]
self.dataset = parent.create_dataset(
self.name,
shape=newshape,
dtype=values.dtype,
compression=self.compression,
compression_opts=self.compression_opts,
)
self.dataset[:oldlength] = values[:]
def get_length(self):
return len(self.dataset)
def copy(self):
#result = type(self)(self.name, self.get_shape(), self.quantity.unit)
#result.set_values(None, self.get_values(None))
#return result
raise NotImplementedError("Copy of an attribute in hdf5 is not implemented")
def get_value(self, index):
return self.dataset[index]
def remove_indices(self, indices):
oldlength = len(self.dataset)
values = numpy.empty(shape=self.dataset.shape, dtype=self.dataset.dtype)
values[:] = self.dataset[:]
values = numpy.delete(values, indices)
parent = self.dataset.parent
del parent[self.name]
self.dataset = parent.create_dataset(
self.name,
shape=values.shape,
dtype=values.dtype,
compression=self.compression,
compression_opts=self.compression_opts,
)
self.dataset[:] = values[:]
def has_units(self):
return False
class HDF5LinkedAttribute(HDF5Attribute):
def __init__(self, name, group, loader):
HDF5Attribute.__init__(self, name)
self.group = group
self.keys_dataset = group['keys']
if 'indices' in group:
self.indices_dataset = group['indices']
else:
self.indices_dataset = None
self.kind_dataset = group['kind']
self.ref_dataset = group['ref']
self.loader = loader
def get_values(self, indices):
if indices is None:
indices=slice(None)
kinds = self.kind_dataset[:][indices]
references = self.ref_dataset[:][indices]
keys = self.keys_dataset[:][indices]
shape = kinds.shape
if self.indices_dataset:
grid_indices = self.indices_dataset[:][indices]
else:
grid_indices = numpy.zeros(shape)
result = LinkedArray(numpy.empty(shape, dtype = object))
if len(shape) == 0:
# we have one unique value, happens with grids
result = self.convert_to_object(kinds, references, keys, grid_indices)
else:
for index in numpy.ndindex(*shape):
if len(index) == 1:
index = index[0]
reference = references[index]
kind = kinds[index]
result[index] = self.convert_to_object(kind,reference, keys[index], grid_indices[index])
return result
def convert_to_object(self, kind, reference, key, grid_index):
if kind == 0:
return None
elif kind == 1:
referenced_group = self.loader.derefence(reference)
mapping_from_groupid_to_set = self.loader.mapping_from_groupid_to_set
if not referenced_group.id in mapping_from_groupid_to_set:
linked_set = self.loader.load_from_group(referenced_group)
else:
linked_set = mapping_from_groupid_to_set[referenced_group.id]
return linked_set._get_particle(key)
elif kind == 2:
referenced_group = self.loader.derefence(reference)
mapping_from_groupid_to_set = self.loader.mapping_from_groupid_to_set
if not referenced_group.id in mapping_from_groupid_to_set:
linked_set = self.loader.load_from_group(referenced_group)
else:
linked_set = mapping_from_groupid_to_set[referenced_group.id]
return linked_set._get_gridpoint(tuple(grid_index))
elif kind == 3:
referenced_group = self.loader.derefence(reference)
mapping_from_groupid_to_set = self.loader.mapping_from_groupid_to_set
if not referenced_group.id in mapping_from_groupid_to_set:
linked_set = self.loader.load_from_group(referenced_group)
else:
linked_set = mapping_from_groupid_to_set[referenced_group.id]
return linked_set
else:
raise Exception("unknown link kind")
def set_values(self, indices, values):
if hasattr(values, 'get_all_keys_in_store'):
keys = values.get_all_keys_in_store()
mask = ~values.get_valid_particles_mask()
self.keys[indices] = keys
self.masked[indices] = mask
else:
if values is None:
self.keys[indices] = 0
self.masked[indices] = True
else:
for index, key in zip(indices, values):
if key is None:
self.keys[indices] = 0
self.masked[indices] = True
else:
self.keys[index] = key
self.masked[indices] = False
def get_length(self):
return len(self.keys)
def increase_to_length(self, newlength):
oldlength = len(self.keys)
delta = newlength - len(self.keys)
if delta == 0:
return
newshape = list(self.keys.shape)
newshape[0] = newlength
values = numpy.empty(shape=self.keys.shape, dtype=self.keys.dtype)
values[:] = self.keys[:]
parent = self.group
del parent['keys']
self.keys = parent.create_dataset(
'keys',
shape=newshape,
dtype=values.dtype,
compression=self.compression,
compression_opts=self.compression_opts,
)
self.keys[:oldlength] = values[:]
values = numpy.empty(shape=self.masked.shape, dtype=self.masked.dtype)
values[:] = self.masked[:]
parent = self.group
del parent['masked']
self.masked = parent.create_dataset(
'masked',
shape=newshape,
dtype=values.dtype,
compression=self.compression,
compression_opts=self.compression_opts,
)
self.masked[:oldlength] = values[:]
def get_shape(self):
return self.keys.shape
def copy(self):
#result = type(self)(self.name, self.get_shape(), self.linked_set)
#result.set_values(None, self.get_values(None))
#return result
raise NotImplementedError("Copy of an attribute in hdf5 is not implemented")
def get_value(self, index):
#key = self.values[index]
#if key is ma.masked:
# return None
#else:
# return self.linked_set._get_particle_unsave(key)
raise NotImplementedError("Copy of an attribute in hdf5 is not implemented")
def remove_indices(self, indices):
if 1:
raise NotImplementedError("Copy of an attribute in hdf5 is not implemented")
oldlength = len(self.dataset)
values = numpy.empty(shape=self.dataset.shape, dtype=self.dataset.dtype)
values[:] = self.dataset[:]
values = numpy.delete(values, indices)
parent = self.dataset.parent
del parent[self.name]
self.dataset = parent.create_dataset(
self.name,
shape=values.shape,
dtype=values.dtype,
compression=self.compression,
compression_opts=self.compression_opts,
)
self.dataset[:] = values[:]
def has_units(self):
return False
class HDF5AttributeStorage(AttributeStorage):
def __init__(self, keys, hdfgroup, loader):
self.hdfgroup = hdfgroup
self.attributesgroup = self.hdfgroup["attributes"]
self.number_of_particles = self.hdfgroup.attrs["number_of_particles"]
self.particle_keys = keys
self.loader = loader
self.mapping_from_particle_to_index = self.new_index()
def can_extend_attributes(self):
return True
def __len__(self):
return len(self.particle_keys)
def new_index(self):
result = {}
index = 0
for particle_key in self.particle_keys:
result[particle_key] = index
index += 1
return result
def get_indices_of(self, keys):
if keys is None:
return numpy.arange(0,len(self.particle_keys))
mapping_from_particle_to_index = self.mapping_from_particle_to_index
result = numpy.zeros(len(keys),dtype='int32')
index = 0
for index, particle_key in enumerate(keys):
result[index] = mapping_from_particle_to_index[particle_key]
index += 1
return result
def get_defined_attribute_names(self):
return list(self.attributesgroup.keys())
def get_defined_settable_attribute_names(self):
return self.get_defined_attribute_names()
def get_values_in_store(self, indices, attributes):
results = []
for attribute in attributes:
dataset = HDF5Attribute.load_attribute(
attribute,
self.attributesgroup[attribute],
self.loader
)
selected_values = dataset.get_values(indices)
results.append(selected_values)
return results
def has_key_in_store(self, key):
return key in self.mapping_from_particle_to_index
def get_all_keys_in_store(self):
return self.particle_keys
def set_values_in_store(self, indices, attributes, quantities):
for attribute, quantity in zip(attributes, quantities):
if attribute in self.attributesgroup:
dataset = HDF5Attribute.load_attribute(
attribute,
self.attributesgroup[attribute],
self.loader
)
else:
dataset = HDF5Attribute.new_attribute(
attribute,
len(self.particle_keys),
quantity,
self.attributesgroup
)
bools = numpy.zeros(dataset.get_shape(), dtype='bool')
bools[indices] = True
dataset.set_values(bools, quantity)
def get_all_indices_in_store(self):
return numpy.arange(len(self.particle_keys))
class HDF5GridAttributeStorage(AttributeStorage):
def __init__(self, shape, hdfgroup, loader):
self.hdfgroup = hdfgroup
self.attributesgroup = self.hdfgroup["attributes"]
self.shape = shape
self.loader = loader
def storage_shape(self):
return self.shape
def add_particles_to_store(self, keys, attributes = [], quantities = []):
raise exceptions.AmuseException("adding points to the grid is not implemented")
def remove_particles_from_store(self, keys):
raise exceptions.AmuseException("removing points from the grid is not implemented")
def __len__(self):
return numpy.prod(self.shape)
def get_unit_of(self, attribute):
dataset = self.attributesgroup[attribute]
decoded = dataset.attrs["units"] if isinstance(dataset.attrs["units"], str) else dataset.attrs["units"].decode("ascii")
return eval(decoded, core.__dict__)
def get_defined_attribute_names(self):
return list(self.attributesgroup.keys())
def get_values_in_store(self, indices, attributes):
results = []
for attribute in attributes:
dataset = HDF5Attribute.load_attribute(
attribute,
self.attributesgroup[attribute],
self.loader
)
selected_values = dataset.get_values(indices)
results.append(selected_values)
return results
def has_key_in_store(self, key):
return False
def get_all_keys_in_store(self):
return Ellipsis
def set_values_in_store(self, indices, attributes, quantities):
for attribute, quantity in zip(attributes, quantities):
if attribute in self.attributesgroup:
dataset = HDF5Attribute.load_attribute(
attribute,
self.attributesgroup[attribute],
self.loader
)
else:
dataset = HDF5Attribute.new_attribute(
attribute,
self.shape,
quantity,
self.attributesgroup
)
bools = numpy.zeros(dataset.get_shape(), dtype='bool')
bools[indices] = True
dataset.set_values(bools, quantity)
class UneresolvedItemInArrayLink(object):
def __init__(self, group, index, dataset_to_resolve, linked_set):
self.group = group
self.index = index
self.dataset_to_resolve = dataset_to_resolve
self.linked_set = linked_set
self.resolved = False
def resolve(self, mapping_from_setid_to_group):
if id(self.linked_set) in mapping_from_setid_to_group:
stored_group = mapping_from_setid_to_group[id(self.linked_set)]
self.dataset_to_resolve[self.index] = stored_group.ref
self.resolved = True
else:
self.resolved = False
def is_resolved(self):
return self.resolved
class UneresolvedAttributeLink(object):
def __init__(self, group, name, linked_set):
self.group = group
self.name = name
self.linked_set = linked_set
self.resolved = False
def resolve(self, mapping_from_setid_to_group):
if id(self.linked_set) in mapping_from_setid_to_group:
stored_group = mapping_from_setid_to_group[id(self.linked_set)]
self.group.attrs[self.name] = stored_group.ref
self.resolved = True
else:
self.resolved = False
def is_resolved(self):
return self.resolved
class StoreHDF(object):
INFO_GROUP_NAME = 'AMUSE_INF'
DATA_GROUP_NAME = 'data'
def __init__(
self,
filename,
append_to_file=True,
open_for_writing=True,
copy_history=False,
overwrite_file=False,
compression=False,
compression_opts=None,
):
self.compression = compression
self.compression_opts = compression_opts
if h5py is None:
raise exceptions.AmuseException(
"h5py module not available, cannot use hdf5 files")
logger.info(
f"opening {filename} with options {append_to_file} "
f"{open_for_writing} {copy_history} {overwrite_file}"
)
if not append_to_file and open_for_writing:
if os.path.exists(filename):
if overwrite_file:
os.remove(filename)
else:
raise FileExistsError("Opening file for write with overwrite_file is False but file {0} exists".format(filename))
if append_to_file:
if os.access(filename, os.F_OK) and not os.access(filename, os.W_OK):
raise Exception("Opening file for append but file {0} is not writeable".format(filename))
self.hdf5file = h5py.File(filename,'a')
elif open_for_writing:
self.hdf5file = h5py.File(filename,'w')
else:
self.hdf5file = h5py.File(filename,'r')
self.copy_history = copy_history
self.mapping_from_groupid_to_set = {}
#warnings.warn("amuse hdf storage version 2.0 is still in development, do not use it for production scripts")
def is_correct_version(self):
if len(self.hdf5file) == 0 or self.INFO_GROUP_NAME in self.hdf5file:
return True
else:
return False
def get_version(self):
return "2.0"
def store_sets(self, sets, names, extra_attributes = {}):
info_group = self.info_group()
info_group.attrs["version"] = self.get_version()
mapping_from_setid_to_group = {}
links_to_resolve = []
for x, name in zip(sets, names):
if hasattr(x, 'shape'):
self.store_grid(x, extra_attributes, parent = self.named_group(name))
else:
self.store_particles(x, extra_attributes, self.named_group(name), mapping_from_setid_to_group, links_to_resolve)
while len(links_to_resolve) > 0:
sets_to_store, links_to_resolve = self.resolve_links(
mapping_from_setid_to_group,
links_to_resolve
)
for group_to_store_under, x in sets_to_store:
if hasattr(x, 'shape'):
self.store_grid(x, {}, group_to_store_under, mapping_from_setid_to_group, links_to_resolve)
else:
self.store_particles(x, {}, group_to_store_under, mapping_from_setid_to_group, links_to_resolve)
def store(self, container, extra_attributes = {}):
info_group = self.info_group()
info_group.attrs["version"] = self.get_version()
mapping_from_setid_to_group = {}
links_to_resolve = []
if hasattr(container, 'keys') and not hasattr(container, 'as_set'):
self.store_sets(
list(container.values()),
list(container.keys()),
extra_attributes
)
if hasattr(container, 'shape'):
self.store_grid(
container,
extra_attributes,
None,
mapping_from_setid_to_group,
links_to_resolve
)
else:
self.store_particles(
container,
extra_attributes,
None,
mapping_from_setid_to_group,
links_to_resolve
)
while len(links_to_resolve) > 0:
sets_to_store, links_to_resolve = self.resolve_links(
mapping_from_setid_to_group,
links_to_resolve
)
for group_to_store_under, x in sets_to_store:
if hasattr(x, 'shape'):
self.store_grid(x, {}, group_to_store_under, mapping_from_setid_to_group, links_to_resolve)
else:
self.store_particles(x, {}, group_to_store_under, mapping_from_setid_to_group, links_to_resolve)
def store_particles(self, particles, extra_attributes = {}, parent=None, mapping_from_setid_to_group = {}, links = []):
if parent is None:
parent = self.data_group()
group = self.new_version(parent)
group.attrs["type"] = 'particles'.encode("ascii")
self.mapping_from_groupid_to_set[group.id] = particles
group.attrs["number_of_particles"] = len(particles)
group.attrs["class_of_the_particles"] = pickle_to_string(particles._factory_for_new_collection())
keys = particles.get_all_keys_in_store()
dataset = group.create_dataset(
"keys",
data=keys,
compression=self.compression,
compression_opts=self.compression_opts,
)
self.hdf5file.flush()
self.store_collection_attributes(particles, group, extra_attributes, links)
self.store_values(particles, group, links)
self.store_selected_derived_attributes(particles,group)
mapping_from_setid_to_group[id(particles)] = group
self.hdf5file.flush()
def store_grid(self, grid, extra_attributes = {}, parent=None, mapping_from_setid_to_group = {}, links = []):
if parent is None:
parent = self.data_group()
group = self.new_version(parent)
group.attrs["type"] = 'grid'.encode("ascii")
group.attrs["class_of_the_container"] = pickle_to_string(grid._factory_for_new_collection())
group.create_dataset(
"shape",
data=numpy.asarray(grid.shape),
compression=self.compression,
compression_opts=self.compression_opts,
)
self.store_selected_derived_attributes(grid, group)
self.store_collection_attributes(grid, group, extra_attributes, links)
self.store_values(grid, group, links)
mapping_from_setid_to_group[id(grid)] = group
self.hdf5file.flush()
def resolve_links(self, mapping_from_setid_to_group, links):
sets_to_store = []
seen_sets_by_id = set([])
links_to_resolve = []
for unresolved_link in links:
unresolved_link.resolve(mapping_from_setid_to_group)
if not unresolved_link.is_resolved():
if not id(unresolved_link.linked_set) in seen_sets_by_id:
sets_to_store.append([unresolved_link.group, unresolved_link.linked_set])
seen_sets_by_id.add(id(unresolved_link.linked_set))
links_to_resolve.append(unresolved_link)
return sets_to_store, links_to_resolve
def store_values(self, container, group, links = []):
attributes_group = group.create_group("attributes")
all_values = container.get_values_in_store(Ellipsis, container.get_attribute_names_defined_in_store())
for attribute, quantity in zip(container.get_attribute_names_defined_in_store(), all_values):
if is_quantity(quantity):
value = quantity.value_in(quantity.unit)
dataset = attributes_group.create_dataset(
attribute,
data=value,
compression=self.compression,
compression_opts=self.compression_opts,
)
dataset.attrs["units"] = quantity.unit.to_simple_form().reference_string().encode("ascii")
elif isinstance(quantity, LinkedArray):
self.store_linked_array(attribute, attributes_group, quantity, group, links)
else:
dtype = numpy.asanyarray(quantity).dtype
if dtype.kind == 'U':
dataset = attributes_group.create_dataset(
attribute,
data=numpy.char.encode(quantity, 'UTF-32BE'),
compression=self.compression,
compression_opts=self.compression_opts,
)
dataset.attrs["units"] = "UNICODE".encode('ascii')
else:
dataset = attributes_group.create_dataset(
attribute,
data=quantity,
compression=self.compression,
compression_opts=self.compression_opts,
)
dataset.attrs["units"] = "none".encode('ascii')
def store_selected_derived_attributes(self, container, group):
saving=dict()
for key in container._derived_attributes.keys():
attr=container._derived_attributes[key]
if key not in container.GLOBAL_DERIVED_ATTRIBUTES and isinstance(attr, VectorAttribute):
saving[key]=attr
if len(saving):
group.attrs["extra_vector_attributes"]=pickle_to_string(saving)
def store_linked_array(self, attribute, attributes_group, quantity, group, links):
subgroup = attributes_group.create_group(attribute)
shape = quantity.shape
kind_array = numpy.zeros(shape, dtype = numpy.int16)
ref_dtype = h5py.special_dtype(ref=h5py.Reference)
ref_array = numpy.empty(shape, dtype = ref_dtype)
ref_dataset = subgroup.create_dataset(
'ref',
data=ref_array,
compression=self.compression,
compression_opts=self.compression_opts,
)
key_array = numpy.zeros(shape, dtype = numpy.uint64)
max_len_grid_indices = 0
for index in numpy.ndindex(*shape):
object = quantity[index]
if isinstance(object, GridPoint):
max_len_grid_indices = max(len(object.index), max_len_grid_indices)
if max_len_grid_indices > 0:
indices_shape = list(shape)
indices_shape.append(max_len_grid_indices)
indices_array = numpy.zeros(indices_shape, dtype = numpy.uint64)
for index in numpy.ndindex(*shape):
object = quantity[index]
if object is None:
kind_array[index] = 0
key_array[index] = 0
elif isinstance(object, Particle):
kind_array[index] = 1
key_array[index] = object.key
links.append(UneresolvedItemInArrayLink(
group,
index,
ref_dataset,
object.get_containing_set()
))
elif isinstance(object, GridPoint):
kind_array[index] = 2
key_array[index] = 0
grid_index = object.index
if len(grid_index) < max_len_grid_indices:
grid_index = list(grid_index)
for _ in range(max_len_grid_indices-len(grid_index)):
grid_index.append(0)
indices_array[index] = grid_index
links.append(UneresolvedItemInArrayLink(
group,
index,
ref_dataset,
object.get_containing_set()
))
elif isinstance(object, AbstractSet):
kind_array[index] = 3
key_array[index] = 0
links.append(UneresolvedItemInArrayLink(
group,
index,
ref_dataset,
object#.copy() #._original_set()
))
else:
raise Exception("unsupported type {0}".format(type(object)))
if max_len_grid_indices > 0:
subgroup.create_dataset(
'indices',
data=indices_array,
compression=self.compression,
compression_opts=self.compression_opts,
)
subgroup.create_dataset(
'keys',
data=key_array,
compression=self.compression,
compression_opts=self.compression_opts,
)
subgroup.create_dataset(
'kind',
data=kind_array,
compression=self.compression,
compression_opts=self.compression_opts,
)
subgroup.attrs["units"] = "link".encode("ascii")
def store_timestamp(self, container, group):
quantity = container.get_timestamp()
if not quantity is None:
group.attrs["timestamp"] = quantity.value_in(quantity.unit)
group.attrs["timestamp_unit"] = quantity.unit.reference_string().encode("ascii")
def store_collection_attributes(self, container, group, extra_attributes, links):
collection_attributes = container.collection_attributes.__getstate__()
arguments_and_attributes = {}
arguments_and_attributes.update(collection_attributes)
arguments_and_attributes.update(extra_attributes)
ref_dtype = h5py.special_dtype(ref=h5py.Reference)
for name, quantity in arguments_and_attributes.items():
if quantity is None:
continue
if is_quantity(quantity):
group.attrs[name] = quantity.value_in(quantity.unit)
group.attrs[name+"_unit"] = quantity.unit.reference_string().encode("ascii")
elif isinstance(quantity, Particle):
#group.attrs[name] = ref_dtype(None)
group.attrs[name+"_key"] = quantity.key
group.attrs[name+"_unit"] = "particle".encode("ascii")
links.append(UneresolvedAttributeLink(
group,
name,
quantity.get_containing_set()
))
elif isinstance(quantity, GridPoint):
#group.attrs[name] = ref_dtype(None)
group.attrs[name+"_index"] = quantity.index
group.attrs[name+"_unit"] = "gridpoint".encode("ascii")
links.append(UneresolvedAttributeLink(
group,
name,
quantity.get_containing_set()
))
elif isinstance(quantity, AbstractSet):
#group.attrs[name] = ref_dtype(None)
group.attrs[name+"_unit"] = "set".encode("ascii")
links.append(UneresolvedAttributeLink(
group,
name,
quantity._original_set()
))
else:
group.attrs[name] = quantity
group.attrs[name+"_unit"] = "none".encode("ascii")
def load_collection_attributes(self, container, group):
names = group.attrs.keys()
attributenames = [x for x in names if x + '_unit' in group.attrs]
for name in attributenames:
unit_string = group.attrs[name+"_unit"] if isinstance(group.attrs[name+"_unit"],str) else group.attrs[name+"_unit"].decode("ascii")
if unit_string == 'none':
quantity = group.attrs[name]
elif unit_string == 'particle':
reference = group.attrs[name]
set = self.get_set_from_reference(reference)
key = group.attrs[name+'_key']
quantity = set._get_particle_unsave(key)
elif unit_string == 'gridpoint':
reference = group.attrs[name]
set = self.get_set_from_reference(reference)
index = group.attrs[name+'_index']
quantity = set._get_gridpoint(tuple(index))
elif unit_string == 'set':
reference = group.attrs[name]
quantity = self.get_set_from_reference(reference)
else:
unit = eval(unit_string, core.__dict__)
quantity = unit.new_quantity(group.attrs[name])
setattr(container.collection_attributes, name, quantity)
def load(self):
if not self.data_group(False) is None and len(self.data_group(False)) > 0:
return self.load_container(self.data_group())
else:
result = {}
for x in self.hdf5file.keys():
if x == 'AMUSE_INF':
continue
result[x] = self.load_container(self.named_group(x))
return result
def load_sets(self, names):
result = []
for x in names:
set = self.load_container(self.named_group(x))
result.append(set)
return result
def load_particles_from_group(self, group):
try:
class_of_the_container = unpickle_from_string(group.attrs["class_of_the_particles"])
except:
class_of_the_container = Particles
dataset = group["keys"]
keys = numpy.ndarray(len(dataset), dtype = dataset.dtype)
if len(keys) == 0:
particles = class_of_the_container(is_working_copy = False)
self.mapping_from_groupid_to_set[group.id] = particles
else:
dataset.read_direct(keys)
particles = class_of_the_container(is_working_copy = False)
particles._private.attribute_storage = HDF5AttributeStorage(keys, group, self)
self.mapping_from_groupid_to_set[group.id] = particles
self.load_collection_attributes(particles, group)
if "extra_vector_attributes" in group.attrs.keys():
self.load_extra_derived_attributes(particles, group)
return particles
def load_grid_from_group(self, group):
try:
class_of_the_container = unpickle_from_string(group.attrs["class_of_the_container"])
except:
class_of_the_container = Grid
shape = tuple(group["shape"])
container = class_of_the_container()
container._private.attribute_storage = HDF5GridAttributeStorage(shape, group, self)
self.mapping_from_groupid_to_set[group.id] = container
self.load_collection_attributes(container, group)
if "extra_vector_attributes" in group.attrs.keys():
self.load_extra_derived_attributes(container, group)
return container
def load_extra_derived_attributes(self, container, group):
attrs=unpickle_from_string(group.attrs["extra_vector_attributes"])
for key, attr in attrs.items():
container._derived_attributes[key]=attr
def load_from_group(self, group):
container_type = group.attrs['type'] if isinstance(group.attrs['type'], str) else group.attrs['type'].decode('ascii')
if container_type == 'particles':
return self.load_particles_from_group(group)
elif container_type == 'grid':
return self.load_grid_from_group(group)
else:
raise Exception('unknown container type in file {0}'.format(container_type))
def load_particles(self, container_group = None):
if container_group is None:
container_group = self.data_group()
return self.load_container(container_group)
def load_grid(self, container_group = None):
if container_group is None:
container_group = self.data_group()
return self.load_container(container_group)
def load_container(self, container_group):
number_of_saved_containers= len(container_group)
all_containers = [None] * number_of_saved_containers
for group_index in container_group.keys():
group = container_group[group_index]
container = self.load_from_group(group)
if self.copy_history:
container = container.copy()
all_containers[int(group_index) - 1] = container
previous = None
for x in all_containers:
x._private.previous = previous
previous = x
last = all_containers[-1]
if self.copy_history:
copy_of_last = last.copy()
copy_of_last._private.previous = last
return copy_of_last
else:
return last
def get_set_from_reference(self, reference):
referenced_group = self.derefence(reference)
mapping_from_groupid_to_set = self.mapping_from_groupid_to_set
if not referenced_group.id in mapping_from_groupid_to_set:
linked_set = self.load_from_group(referenced_group)
else:
linked_set = mapping_from_groupid_to_set[referenced_group.id]
return linked_set
def derefence(self, reference):
return self.hdf5file[reference]
def new_version(self, master_group):
index = len(master_group)
name = format(index + 1,"010d")
return master_group.create_group(name)
def info_group(self, ensure = True):
return self.named_group(self.INFO_GROUP_NAME, ensure)
def data_group(self, ensure = True):
return self.named_group(self.DATA_GROUP_NAME, ensure)
def named_group(self, name, ensure = True):
if self.hdf5file.mode == 'r' or not ensure:
if not name in self.hdf5file:
return None
else:
return self.hdf5file[name]
else:
return self.hdf5file.require_group(name)
def close(self):
if not self.hdf5file is None:
self.hdf5file.flush()
self.hdf5file.close()
self.hdf5file = None
class HDF5UnicodeAttribute(HDF5UnitlessAttribute):
def __init__(self, name, dataset):
HDF5UnitlessAttribute.__init__(self, name, dataset)
def get_values(self, indices):
if indices is None:
encoded = self.dataset[:]
elif len(self.get_shape()) > 1:
encoded = self.dataset[:][indices]
else:
encoded = self.dataset[:][indices]
return numpy.char.decode(encoded, 'UTF-32BE')
def set_values(self, indices, values):
self.dataset[indices] = numpy.char.encode(values, 'UTF-32LE')
def get_value(self, index):
return self.dataset[index].decode('UTF-32BE')
| 46,982
| 35.762911
| 147
|
py
|
amuse
|
amuse-main/src/amuse/io/vtk.py
|
from amuse.support.core import late
from amuse.io import base
from amuse.units import units
from amuse.units import quantities
import numpy
from amuse import datamodel
class VtkStructuredGrid(base.FileFormatProcessor):
"""
Process a text file containing a table of values separated by a predefined character
"""
provided_formats = ['vts']
def __init__(self, filename = None, stream = None, set = None, format = None):
base.FileFormatProcessor.__init__(self, filename, set, format)
self.filename = filename
self.stream = stream
self.set = set
def store(self):
if self.stream is None:
self.stream = open(self.filename, "w")
close_function = self.stream.close
else:
close_function = lambda : None
try:
return self.store_on_stream()
finally:
close_function()
def store_on_stream(self):
self.write_header()
self.write_grid()
self.write_footer()
@late
def quantities(self):
if self.set is None:
return []
else:
return [getattr(self.set, x) for x in self.attribute_names]
@base.format_option
def attribute_names(self):
"list of the names of the attributes to load or store"
if self.set is None:
return ["col({0})".format(x) for x in range(len(self.quantities))]
else:
all_attributes = self.set.get_attribute_names_defined_in_store()
return [ x for x in all_attributes if x not in set(['x','y','z'])]
@base.format_option
def attribute_types(self):
"list of the types of the attributes to store"
quantities = self.quantities
if self.quantities:
return [x.unit.to_simple_form() for x in quantities]
elif self.set is None:
return [units.none for x in self.attribute_names]
@base.format_option
def float_format_string(self):
"format specification string to convert numbers to strings, see format_spec in python documentation"
return ".{0}e".format(self.precision_of_number_output)
@base.format_option
def precision_of_number_output(self):
"The precision is a decimal number indicating how many digits should be displayed after the decimal point"
return 12
@base.format_option
def extent(self):
"The number of points of the grid in the x, y and z direction, array with 6 float xmin, xmax, ymin, ymax, zmin, zmax"
quantities = self.quantities
if self.quantities:
first_quantity = self.quantities[0]
nx,ny,nz = first_quantity.shape[0:3]
return (0,nx,0,ny,0,nz)
elif self.set is None:
nx,ny,nz = self.set.shape
return (0,nx,0,ny,0,nz)
@base.format_option
def minmax(self):
"The extent of the grid, array with 6 float xmin, xmax, ymin, ymax, zmin, zmax"
if not self.set is None:
xmin = self.set.x.min()
xmax = self.set.x.max()
ymin = self.set.y.min()
ymax = self.set.y.max()
zmin = self.set.z.min()
zmax = self.set.z.max()
result = quantities.AdaptingVectorQuantity()
result.append(xmin)
result.append(xmax)
result.append(ymin)
result.append(ymax)
result.append(zmin)
result.append(zmax)
return result.append(zmax)
if 'x' in self.attribute_names and 'y' in self.attribute_names and 'z' in self.attribute_names:
pass
@base.format_option
def points(self):
"The position vector of all grid cells"
if not self.set is None:
return self.set.points()
else:
pass
@base.format_option
def length_unit(self):
if not self.set is None:
return self.set.position.unit
else:
pass
def write_header(self):
self.stream.write('<?xml version="1.0" encoding="utf-8"?>\n')
self.stream.write('<VTKFile type="StructuredGrid" version="0.1" byte_order="LittleEndian">\n')
def write_grid(self):
self.stream.write('<StructuredGrid WholeExtent="')
self.stream.write(" ".join(map(str,self.extent)))
self.stream.write('">')
self.stream.write('<Piece Extent="')
self.stream.write(" ".join(map(str,self.extent)))
self.stream.write('">')
self.stream.write('<CellData>')
for name, quantity, unit in zip(self.attribute_names, self.quantities, self.attribute_types):
self.write_float64_data(quantity.value_in(unit), name = name)
self.stream.write('</CellData>')
self.stream.write('<PointData></PointData>')
self.stream.write('<Points>')
self.write_float64_data(self.points.value_in(self.length_unit))
self.stream.write('</Points>')
self.stream.write('</Piece>')
self.stream.write('</StructuredGrid>')
def write_footer(self):
self.stream.write('</VTKFile>')
def write_float64_data(self, array, name = None):
number_of_components = numpy.prod(array.shape[3:])
if len(array.shape[3:]) == 0:
number_of_components = 1
array = numpy.transpose(array, (2,1,0,)).flatten()
else:
x,y,z = numpy.split(array, 3, axis = array.ndim - 1)
array = numpy.transpose(array, (2,1,0,) + tuple(array.shape[3:])).flatten()
self.stream.write('<DataArray type="Float64" NumberOfComponents="{0}"'.format(number_of_components))
if not name is None:
self.stream.write(' Name="{0}"'.format(name))
self.stream.write('>')
self.stream.write(' '.join(map(self.convert_number_to_string, iter(array.flatten()))))
self.stream.write('</DataArray>\n')
def convert_number_to_string(self, number):
return str(number)
class VtkUnstructuredGrid(base.FileFormatProcessor):
"""
Process a text file containing a table of values separated by a predefined character
"""
provided_formats = ['vtu']
def __init__(self, filename = None, stream = None, set = None, format = None):
base.FileFormatProcessor.__init__(self, filename, set, format)
self.filename = filename
self.stream = stream
self.set = set
def store(self):
if self.stream is None:
self.stream = open(self.filename, "w")
close_function = self.stream.close
else:
close_function = lambda : None
try:
return self.store_on_stream()
finally:
close_function()
def store_on_stream(self):
self.write_header()
self.write_grid()
self.write_footer()
@base.format_option
def is_multiple(self):
"Set to True if storing multiple sets in one vtu file"
if isinstance(self.set, list) or isinstance(self.set, tuple):
return True
else:
return False
@base.format_option
def quantities(self):
"If you don't specify a set to store you can specify a list of quantities"
if self.set is None:
return []
elif self.is_multiple:
return []
else:
return [getattr(self.set, x) for x in self.attribute_names]
@base.format_option
def attribute_names(self):
"list of the names of the attributes to load or store"
if self.set is None:
return ["col({0})".format(x) for x in range(len(self.quantities))]
elif self.is_multiple:
all_attributes = self.set[0].get_attribute_names_defined_in_store()
return [ x for x in all_attributes if x not in set(['x','y','z'])]
else:
all_attributes = self.set.get_attribute_names_defined_in_store()
return [ x for x in all_attributes if x not in set(['x','y','z'])]
@base.format_option
def attribute_types(self):
"list of the types of the attributes to store"
quantities = self.quantities
if self.is_multiple:
return [getattr(self.set[0], x).unit.to_simple_form() for x in self.attribute_names]
elif self.quantities:
return [x.unit.to_simple_form() for x in quantities]
elif self.set is None:
return [units.none for x in self.attribute_names]
@base.format_option
def float_format_string(self):
"format specification string to convert numbers to strings, see format_spec in python documentation"
return ".{0}e".format(self.precision_of_number_output)
@base.format_option
def precision_of_number_output(self):
"The precision is a decimal number indicating how many digits should be displayed after the decimal point"
return 12
@base.format_option
def points(self):
"The position vector of all grid cells"
if not self.set is None:
return self.set.points()
else:
pass
@base.format_option
def cells(self):
"The position vector of all grid cells"
if not self.set is None:
return self.set
else:
raise Exception("options 'cells' not set to an array of grid cells")
@base.format_option
def connectivity(self):
"Indices in the point array that indicate connectivity"
if not self.set is None:
return self.set.connectivity().flatten()
else:
return None
@base.format_option
def cell_types(self):
"VTK cell types (11 for all cells)"
result = numpy.ones(self.cells.shape, dtype=numpy.int32)
result *= 11
return result
@base.format_option
def length_unit(self):
if self.is_multiple:
return self.set[0].position.unit
elif not self.set is None:
return self.set.position.unit
else:
pass
@base.format_option
def number_of_points(self):
"The number of points in the grid"
return numpy.prod(self.points.shape[:-1])
@base.format_option
def offsets(self):
"The index into the connectivity table for the end of each cell"
return ((numpy.arange(self.number_of_cells, dtype=numpy.int32) + 1) * 8)
@base.format_option
def number_of_cells(self):
"The number of grid cells"
return numpy.prod(self.cells.shape)
def cell_types_for_grid(self, grid):
result = numpy.ones(grid.shape, dtype=numpy.int32)
result *= 11
return result
def write_header(self):
self.stream.write('<?xml version="1.0" encoding="utf-8"?>\n')
self.stream.write('<VTKFile type="UnstructuredGrid" version="0.1" byte_order="LittleEndian">\n')
def dimensions(self):
if self.is_multiple:
return self.set[0].dimensions
elif not self.set is None:
return self.set.dimensions
else:
return 3
def write_piece(self, quantities, units, names, points, connectivity, offsets, cell_types, number_of_cells, number_of_points):
self.stream.write('<Piece NumberOfPoints="{0}" NumberOfCells="{1}">\n'.format(number_of_points, number_of_cells))
self.stream.write('<PointData>')
self.stream.write('</PointData>\n')
self.stream.write('<CellData>\n')
for quantitiy, unit, name in zip(quantities, units, names):
self.write_float64_data(quantitiy.value_in(unit), name)
self.stream.write('</CellData>\n')
self.stream.write('<Points>')
self.write_float64_data(points.value_in(self.length_unit), "points")
self.stream.write('</Points>\n')
self.stream.write('<Cells>\n')
self.write_int32_data(connectivity, "connectivity")
self.write_int32_data(offsets, "offsets")
self.write_int32_data(cell_types, "types")
self.stream.write('</Cells>')
self.stream.write('\n</Piece>')
def write_grid(self):
self.stream.write('<UnstructuredGrid>\n')
if self.is_multiple:
for subgrid in self.set:
quantities = subgrid.get_values_in_store(None, self.attribute_names)
points = subgrid.points()
number_of_cells = numpy.prod(subgrid.shape)
offsets = ((numpy.arange(number_of_cells, dtype=numpy.int32) + 1) * 8)
self.write_piece(
quantities,
self.attribute_types,
self.attribute_names,
points,
subgrid.connectivity().flatten(),
offsets,
self.cell_types_for_grid(subgrid),
numpy.prod(subgrid.shape),
numpy.prod(points.shape[:-1])
)
else:
self.write_piece(
self.quantities,
self.attribute_types,
self.attribute_names,
self.points,
self.connectivity,
self.offsets,
self.cell_types,
self.number_of_cells,
self.number_of_points
)
self.stream.write('</UnstructuredGrid>\n')
def write_footer(self):
self.stream.write('</VTKFile>')
def write_float64_data(self, array, name = None):
number_of_components = numpy.prod(array.shape[3:], dtype="int32")
self.stream.write('<DataArray type="Float64" NumberOfComponents="{0}"'.format(number_of_components))
if not name is None:
self.stream.write(' Name="{0}"'.format(name))
self.stream.write('>')
self.stream.write(' '.join(map(self.convert_number_to_string, iter(array.flatten()))))
self.stream.write('</DataArray>\n')
def write_int32_data(self, array, name = None):
number_of_components = numpy.prod(array.shape[3:], dtype="int32")
self.stream.write('<DataArray type="Int32" NumberOfComponents="{0}"'.format(number_of_components))
if not name is None:
self.stream.write(' Name="{0}"'.format(name))
self.stream.write('>')
self.stream.write(' '.join(map(self.convert_number_to_string, iter(array.flatten()))))
self.stream.write('</DataArray>\n')
def convert_number_to_string(self, number):
return str(number)
| 14,998
| 34.458629
| 130
|
py
|
amuse
|
amuse-main/src/amuse/io/gadget.py
|
import struct
import numpy
from collections import namedtuple
from amuse.io import base
from amuse.units import units
from amuse.units import nbody_system
from amuse.support.core import late
from amuse import datamodel
class GadgetFileFormatProcessor(base.FortranFileFormatProcessor):
"""
Process a Gadget binary data file
"""
provided_formats = ['gadget']
GAS = 0
HALO = 1
DISK = 2
BULGE = 3
STARS = 4
BNDRY = 5
@late
def header_format(self):
collate = []
collate.append(self.endianness)
for name, times, formatchar in self.header_struct_format:
for t in range(times):
collate.append(formatchar)
return ''.join(collate)
@base.format_option
def header_struct_format(self):
"""The format of the header structure of the gadget file."""
return (
('Npart', 6, 'I'),
('Massarr', 6, 'd'),
('Time', 1, 'd'),
('Redshift', 1, 'd'),
('FlagSfr', 1, 'i'),
('FlagFeedback', 1, 'i'),
('Nall', 6, 'i'),
('FlagCooling', 1, 'i'),
('NumFiles', 1, 'i'),
('BoxSize', 1, 'd'),
('Omega0', 1, 'd'),
('OmegaLambda', 1, 'd'),
('HubbleParam', 1, 'd'),
('FlagAge', 1, 'd'),
('FlagMetals', 1, 'd'),
('NallHW', 6, 'i'),
('flag_entr_ics', 1, 'i'),
)
@base.format_option
def has_potential_energy(self):
"""Set to true if the file has a potential energy block"""
return False
@base.format_option
def has_acceleration(self):
"""Set to true if the file has a acceleration block"""
return False
@base.format_option
def has_rate_of_entropy_production(self):
"""Set to true if the file has a block with the
rate of change of the entropic function of each gas particle
"""
return False
@base.format_option
def has_timestep(self):
"""Set to true if the file has a block with the
individual timestep for each particle.
"""
return False
@base.format_option
def is_initial_conditions_format(self):
"""Set to true if the file contains
initial conditions. An initial conditions
gadget file contains less data.
"""
return True
@base.format_option
def ids_are_keys(self):
"""Set to True if the file contains
correct keys. Set to False to generate
the keys in amuse and prove an id attribute for
the id's in the gadget file"""
return True
@base.format_option
def equal_mass_array(self):
"""If filled with an array with masses > 0.0
assume equal mass for the corresponding set"""
return ([0.0] * 6) | nbody_system.mass
@base.format_option
def ids_are_long(self):
"""Set to true the ids will be written
as longs in the gadget file"""
return True
@base.format_option
def return_header(self):
"""Set to True to return both the particles and the header from the gadget file"""
return False
@base.format_option
def write_header_from(self):
"""Pass a namedtuple to store non-default values in the header of the gadget file"""
return None
@base.format_option
def convert_gadget_w_to_velocity(self):
"""Set to True to convert the w=sqrt(a)*dx/dt to (comoving) velocity in comoving integrations"""
return False
@late
def header_size(self):
return struct.calcsize(self.header_format)
@late
def struct_class_name(self):
return 'GadgetHeader'
@late
def struct_class(self):
collate = []
for name, times, formatchar in self.header_struct_format:
collate.append(name)
attribute_names = ' '.join(collate)
return namedtuple(self.struct_class_name, attribute_names)
@late
def total_number_of_particles(self):
return sum(self.header_struct.Npart)
@late
def total_number_of_particles_with_variable_masses(self):
result = 0
for x, n in zip(self.header_struct.Massarr, self.header_struct.Npart):
if x == 0.0:
result += n
return result
@late
def number_of_gas_particles(self):
return self.header_struct.Npart[self.GAS]
def collect_values(self, values):
offset = 0
result = []
for name, times, formatchar in self.header_struct_format:
if times > 1:
result.append(values[offset: offset+times])
else:
result.append(values[offset])
offset += times
return result
def load_header(self, file):
header_bytes = self.read_fortran_block(file)
values = struct.unpack(self.header_format, header_bytes[0:self.header_size])
values = self.collect_values(values)
self.header_struct = self.struct_class(*values)
def load_body(self, file):
self.positions = self.read_fortran_block_float_vectors(file)
self.velocities = self.read_fortran_block_float_vectors(file)
id_bytes = self.read_fortran_block(file)
if len(id_bytes) == 4*self.total_number_of_particles:
self.ids = numpy.frombuffer(id_bytes, dtype=self.uint_type)
else:
self.ids = numpy.frombuffer(id_bytes, dtype=self.ulong_type)
if self.total_number_of_particles_with_variable_masses > 0:
self.masses = self.read_fortran_block_floats(file)
else:
self.masses = None
if self.number_of_gas_particles > 0:
self.u = self.read_fortran_block_floats(file)[:self.number_of_gas_particles]
#print self.u, self.number_of_gas_particles, len(self.u)
else:
self.u = None
if self.is_initial_conditions_format:
self.density = None
self.hsml = None
self.pot = None
self.acc = None
self.da_dt = None
self.dt = None
return
if self.number_of_gas_particles > 0:
self.density = self.read_fortran_block_floats(file)
self.hsml = self.read_fortran_block_floats(file)
else:
self.density = None
self.hsml = None
if self.has_potential_energy:
self.pot = self.read_fortran_block_floats(file)
else:
self.pot = None
if self.has_acceleration:
self.acc = self.read_fortran_block_floats(file)
else:
self.acc = None
if self.has_rate_of_entropy_production:
self.da_dt = self.read_fortran_block_floats(file)
else:
self.da_dt = None
if self.has_timestep:
self.dt = self.read_fortran_block_floats(file)
else:
self.dt = None
def new_sets_from_arrays(self):
offset = 0
ids_per_set = []
for x in self.header_struct.Npart:
ids_per_set.append(self.ids[offset:offset+x])
offset += x
if self.ids_are_keys:
sets = [datamodel.Particles(len(x), keys=x) for x in ids_per_set]
else:
sets = [datamodel.Particles(len(x)) for x in ids_per_set]
for set, x in zip(sets, ids_per_set):
if len(set) > 0:
set.id = x
offset = 0
for x in sets:
length = len(x)
if length == 0:
continue
x.position = nbody_system.length.new_quantity(self.positions[offset:offset+length])
x.velocity = nbody_system.speed.new_quantity(self.velocities[offset:offset+length])
if self.convert_gadget_w_to_velocity:
x.velocity *= numpy.sqrt(1.0 + self.header_struct.Redshift)
if not self.pot is None:
x.potential_energy = nbody_system.energy.new_quantity(self.pot[offset:offset+length])
if not self.acc is None:
x.acceleration = nbody_system.acceleration.new_quantity(self.acc[offset:offset+length])
if not self.dt is None:
x.timestep = nbody_system.time.new_quantity(self.dt[offset:offset+length])
offset += length
offset = 0
for x, mass in zip(sets, self.header_struct.Massarr):
length = len(x)
if length == 0:
continue
if mass == 0.0:
x.mass = nbody_system.mass.new_quantity(self.masses[offset:offset+length])
offset += length
else:
x.mass = nbody_system.mass.new_quantity(mass)
if self.number_of_gas_particles > 0:
gas_set = sets[self.GAS]
unit = (nbody_system.length / nbody_system.time) ** 2
gas_set.u = unit.new_quantity(self.u)
unit = nbody_system.mass / nbody_system.length ** 3
if not self.density is None:
gas_set.rho = unit.new_quantity(self.density)
if not self.hsml is None:
gas_set.h_smooth = nbody_system.length.new_quantity(self.hsml)
return sets
def load_file(self, file):
self.load_header(file)
self.load_body(file)
attribute_names = ["gas","halo","disk","bulge","stars","bndry"]
values = self.new_sets_from_arrays()
if self.return_header:
attribute_names += [name for name, times, formatchar in self.header_struct_format]
values += list(self.header_struct)
return namedtuple("GadgetData", attribute_names)(*values)
@late
def sets_to_save(self):
if isinstance(self.set, (tuple, list)):
sets_to_save = self.set
elif hasattr(self.set, 'key'):
sets_to_save = (self.set, )
else:
raise Exception("The Gadget binary file writer can write a particle set or a list of sets but nothing else")
if len(sets_to_save) < 6:
sets_to_save = list(sets_to_save)
sets_to_save.extend([()] * (6 - len(sets_to_save)))
return sets_to_save
def store_file(self, file):
self.store_header(file)
self.store_body(file)
def header_field_value(self, name):
if hasattr(self.write_header_from, name):
return getattr(self.write_header_from, name)
else:
return self.default_header_field_value(name)
def default_header_field_value(self, name):
return self.default_header[name]
def store_header(self, file):
self.default_header = dict(
Massarr = list(self.equal_mass_array.value_in(nbody_system.mass)),
Time = 0.0,
Redshift = 0.0,
FlagSfr = 0,
FlagFeedback = 0,
Nall = [len(x) for x in self.sets_to_save],
FlagCooling = 0,
NumFiles = 1,
BoxSize = 0,
Omega0 = 0,
OmegaLambda = 0,
HubbleParam = 0,
FlagAge = 0.0,
FlagMetals = 0.0,
NallHW = [0]*6,
flag_entr_ics = 0
)
if self.write_header_from is None:
self.header_field_value = self.default_header_field_value
self.header_struct = self.struct_class(
Npart = [len(x) for x in self.sets_to_save],
Massarr = list(self.header_field_value("Massarr")),
Time = self.header_field_value("Time"),
Redshift = self.header_field_value("Redshift"),
FlagSfr = self.header_field_value("FlagSfr"),
FlagFeedback = self.header_field_value("FlagFeedback"),
Nall = list(self.header_field_value("Nall")),
FlagCooling = self.header_field_value("FlagCooling"),
NumFiles = self.header_field_value("NumFiles"),
BoxSize = self.header_field_value("BoxSize"),
Omega0 = self.header_field_value("Omega0"),
OmegaLambda = self.header_field_value("OmegaLambda"),
HubbleParam = self.header_field_value("HubbleParam"),
FlagAge = self.header_field_value("FlagAge"),
FlagMetals = self.header_field_value("FlagMetals"),
NallHW = list(self.header_field_value("NallHW")),
flag_entr_ics = self.header_field_value("flag_entr_ics")
)
bytes = bytearray(256)
parts = list()
for x in list(self.header_struct):
if isinstance(x, list):
parts.extend(x)
else:
parts.append(x)
struct.pack_into(self.header_format, bytes, 0, *parts)
self.write_fortran_block(file, bytes)
def _pack_sets(self, attributename, unit = None):
result = []
for x in self.sets_to_save:
if len(x) > 0:
if unit is None:
result.extend(getattr(x,attributename))
else:
result.extend(getattr(x,attributename).value_in(unit))
return result
def store_body(self, file):
self.positions = self._pack_sets('position', nbody_system.length)
self.velocities = self._pack_sets('velocity', nbody_system.speed)
if self.ids_are_keys:
self.ids = self._pack_sets('key')
else:
self.ids = self._pack_sets('id')
self.masses = []
for equal_mass, x in zip(self.equal_mass_array, self.sets_to_save):
if len(x) > 0 and not equal_mass > (0.0 | nbody_system.mass):
self.masses.extend(x.mass.value_in(nbody_system.mass))
if len(self.masses) == 0:
self.masses = None
number_of_gas_particles = len(self.sets_to_save[self.GAS])
if number_of_gas_particles > 0:
self.u = self.sets_to_save[0].u.value_in(nbody_system.potential)
else:
self.u = None
self.write_fortran_block_float_vectors(file, self.positions)
self.write_fortran_block_float_vectors(file, self.velocities)
if self.ids_are_long:
self.write_fortran_block_ulongs(file, self.ids)
else:
self.write_fortran_block_uints(file, self.ids)
if not self.masses is None:
self.write_fortran_block_floats(file, self.masses)
if not self.u is None:
self.write_fortran_block_floats(file, self.u)
if self.is_initial_conditions_format:
return
if number_of_gas_particles > 0:
self.density = self.sets_to_save[0].rho.value_in(nbody_system.density)
self.hsml = self.sets_to_save[0].h_smooth.value_in(nbody_system.length)
else:
self.density = None
self.hsml = None
if self.has_potential_energy:
self.pot = self._pack_sets('potential_energy', nbody_system.energy)
else:
self.pot = None
if self.has_acceleration:
self.acc = self._pack_sets('acceleration', nbody_system.acceleration)
else:
self.acc = None
if self.has_rate_of_entropy_production:
self.da_dt = None
else:
self.da_dt = None
if self.has_timestep:
self.dt = self._pack_sets('timestep', nbody_system.time)
else:
self.dt = None
if not self.density is None:
self.write_fortran_block_floats(file, self.density)
if not self.hsml is None:
self.write_fortran_block_floats(file, self.hsml)
if not self.pot is None:
self.write_fortran_block_floats(file, self.pot)
if not self.acc is None:
self.write_fortran_block_floats(file, self.acc)
if not self.da_dt is None:
self.write_fortran_block_floats(file, self.da_dt)
if not self.dt is None:
self.write_fortran_block_floats(file, self.dt)
| 16,756
| 33.479424
| 120
|
py
|
amuse
|
amuse-main/src/amuse/io/starlab.py
|
import sys
import xml.dom.minidom
import pdb #use with pdb.set_trace()
import re
from amuse.io import base
from amuse.units import units
from amuse.units import nbody_system
from amuse.units import generic_unit_converter
from amuse import datamodel
starlab_stellar_types_to_amuse_stellar_type = {
"planet":units.stellar_type("Unknown stellar type"),
"proto_star":units.stellar_type("Unknown stellar type"),
"brown_dwarf":units.stellar_type("Unknown stellar type"),
"main_sequence":units.stellar_type("Main Sequence star"),
"hyper_giant":units.stellar_type("Second Asymptotic Giant Branch"),
"hertzsprung_gap":units.stellar_type("Hertzsprung Gap"),
"sub_giant":units.stellar_type("First Giant Branch"),
"horizontal_branch":units.stellar_type("Core Helium Burning"),
"super_giant":units.stellar_type("First Asymptotic Giant Branch"),
"thorne_zytkow":units.stellar_type("Unknown stellar type"),
"carbon_star":units.stellar_type("Unknown stellar type"),
"helium_star":units.stellar_type("Main Sequence Naked Helium star"),
"helium_giant":units.stellar_type("Giant Branch Naked Helium star"),
"helium_dwarf":units.stellar_type("Helium White Dwarf"),
"carbon_dwarf":units.stellar_type("Carbon/Oxygen White Dwarf"),
"oxygen_dwarf":units.stellar_type("Oxygen/Neon White Dwarf"),
"xray_pulsar":units.stellar_type("Neutron Star"),
"radio_pulsar":units.stellar_type("Neutron Star"),
"neutron_star":units.stellar_type("Neutron Star"),
"black_hole":units.stellar_type("Black Hole"),
"Disintegrated":units.stellar_type("Massless Supernova"),
"SPZDCH_star":units.stellar_type("Unknown stellar type"),
"static_star":units.stellar_type("Unknown stellar type"),
"star_cluster":units.stellar_type("Unknown stellar type")
}
class Dyn2Xml(object):
def convert_starlab_string_to_xml_string(self, string):
xml_lines = ['<?xml version="1.0"?>\n<System>']
openpar = 0
closepar = 0
for line in string.splitlines():
line = line.rstrip()
if line.startswith("("):
openpar += 1
line = line.lstrip("(")
newline = "<"+line+">"
elif line.startswith(")"):
closepar +=1
line = line.lstrip(")")
newline = "</"+line+">"
else:
newline = self.convert_storyline(line)
xml_lines.append(newline)
xml_lines.append("</System>")
if closepar!=openpar:
raise base.IoException("\nConversion failure, parenthesis mismatch. Return: no output string written\n")
return '\n'.join(xml_lines)
def convert_to_xml(self,inputfile):
with open(inputfile,'r') as f:
string = f.read()
return self.convert_starlab_string_to_xml_string(string)
def convert_storyline(self, line):
if "===>" in line or line.startswith(" "):
return line
parts = line.split("=",1)
return "<pm "+ parts[0].lstrip()+'= "'+parts[1].lstrip()+'" />'
class Xml2Particles(object):
dynamics_mass_units = nbody_system.mass
dynamics_time_units = nbody_system.time
dynamics_length_units = nbody_system.length
def __init__(self):
self.xmls = ""
self.system = datamodel.Particles()
self.translator = {
#'N':('number', lambda x : int(x) ),
'm':('mass', lambda x : float(x)|self.dynamics_mass_units) ,
't':('time', lambda x : float(x)|self.dynamics_time_units) ,
'r':('position', lambda x : self.convert2vec(x)|self.dynamics_length_units),
'v':('velocity', lambda x : self.convert2vec(x)|self.dynamics_length_units / self.dynamics_time_units),
'a':('acceleration', lambda x : self.convert2vec(x)|self.dynamics_length_units / (self.dynamics_time_units ** 2)),
'pot':('specific_potential', lambda x : float(x)|(self.dynamics_length_units / self.dynamics_time_units) ** 2) ,
'M_env': ('envelope_mass', lambda x: float(x)|units.MSun),
'M_rel': ('relative_mass', lambda x: float(x)|units.MSun),
'M_core': ('core_mass', lambda x: float(x)|units.MSun),
'T_eff' : ('effective_temperature', lambda x: float(x)|units.K),
'T_cur' : ('age', lambda x: float(x)|units.Myr),
'L_eff' : ('effective_luminocity', lambda x: float(x)|units.LSun),
'Type' : ('stellar_type', self.convert_starlab_stellar_type_to_amuse)
}
self.timestamp = None
self.mass_scale = None
self.size_scale = None
self.time_scale = None
def convert_starlab_stellar_type_to_amuse(self, string):
if string in starlab_stellar_types_to_amuse_stellar_type:
return starlab_stellar_types_to_amuse_stellar_type[string]
else:
return units.stellar_type("Unknown stellar type")
def add_particle_with_parameters(self, subnode, parent):
added_particle = self.system.add_particle(datamodel.Particle())
self._recursive_parse_node_into_particles(
subnode,
added_particle,
parent = added_particle
)
if not parent is None:
parent.add_child(added_particle)
def _recursive_parse_node_into_particles(self, xml_node, particle_or_particleset, parent = None):
node_list = xml_node.childNodes
for subnode in node_list:
if subnode.nodeType == subnode.ELEMENT_NODE:
if subnode.tagName == "System": #overslaan
self._recursive_parse_node_into_particles(subnode, particle_or_particleset)
elif subnode.tagName in ["Log", "Dynamics", "Star", "Hydro"]: #overslaan
self._recursive_parse_node_into_particles(subnode, particle_or_particleset)
elif subnode.tagName == "Particle":
self.add_particle_with_parameters(subnode, parent)
elif subnode.tagName == "pm":
key = list(subnode.attributes.keys())[0]
value = subnode.getAttribute(key)
self.copy_starlab_parameter_to_star(key, value, particle_or_particleset)
def copy_starlab_parameter_to_star(self, key, value, particle):
if key == 'mass_scale':
self.mass_scale = float(value)
elif key == 'size_scale':
self.size_scale = float(value)
elif key == 'time_scale':
self.time_scale = float(value)
elif key == 'system_time':
self.timestamp = float(value)|self.dynamics_time_units
elif key in self.translator.keys():
amuse_attribute_name, conversion_function = self.translator[key]
setattr(particle, amuse_attribute_name, conversion_function(value))
def convert2vec(self, attribute):
vector_or_scalar = attribute.split()
if len(vector_or_scalar)>1:
barout = [float(f) for f in vector_or_scalar]
else:
barout = float(vector_or_scalar[0])
return barout
def walk_me(self, SCL):
self.xmls += self.elementstr(SCL,"open") +"\n"
for attrlistitem in SCL.attriblist:
attribute = attrlistitem[0]
modified = attrlistitem[2]
if attribute == "Sister" :
if SCL.nsisters > 0:
for i in range(SCL.nsisters):
self.walk_me(SCL.Sister[i])
elif attribute in ["Log","Dynamics","Star","Hydro"]:
self.walk_me(SCL.__getattribute__(attribute))
elif not attribute in ["nsisters"]:
foostr = str(SCL.__getattribute__(attribute))
if not foostr == "" and modified:
#dont bother if empty
foostr = self.convert2propstr(foostr)
if attribute == "text":
#text is not a <pm />
self.xmls += foostr + "\n"
else:
self.xmls += ' <pm '+attribute+' = "'+ foostr +'" />\n'
self.xmls += self.elementstr(SCL,"close")+"\n"
def elementstr(self,SCL,oc):
"""
write an element node,
If particle is root then it is called System
"""
if oc == "open":
prestr = "<"
elif oc == "close":
prestr = "</"
if SCL.__class__.__name__ == "Particle":
if SCL.isroot:
barstr = prestr+"System>"
else:
barstr = prestr+SCL.__class__.__name__+">"
else:
barstr = prestr+SCL.__class__.__name__.lstrip("_")+">"
return barstr
def convert2propstr(self,foostr):
"""
if foostr is a vector we dont want the brackets and the ,'s
"""
return foostr.replace("[","").replace("]","").replace(","," ")
def makexml(self):
"""
clear and init xmls
"""
self.xmls = '<?xml version="1.0"?>\n'
self.walk_me(self.System)
def dumpxml(self):
"""
Convert System to xml string and dump it on the screen
"""
self.makexml()
print(self.xmls)
def savexml(self, file):
"""
Convert System to xml string and put it in file with name file
"""
f = open(file,'w')
self.makexml()
f.writelines(self.xmls)
f.close()
def loadxml(self,file):
"""
Parse file into dom doc and then create particles accordingly
"""
f = open(file,'r')
doc = xml.dom.minidom.parse(f)
f.close()
#copy the doc to a system object
self._recursive_parse_node_into_particles(doc, self.system)
def parse_xml(self, xmlstring):
"""
Parse xml string into dom doc and then create particles accordingly
"""
doc = xml.dom.minidom.parseString(xmlstring)
self._recursive_parse_node_into_particles(doc, self.system)
if not self.timestamp is None:
self.system.savepoint(self.timestamp)
class ParticlesFromDyn(object):
def __init__(self, dyn_filename=None, convert_nbody=None):
dyn2xml = Dyn2Xml()
xml_string = dyn2xml.convert_to_xml(dyn_filename)
xml2particles = Xml2Particles()
err1 = xml2particles.parse_xml(xml_string)
if convert_nbody is None:
self.convert_nbody = None
self.Particles = xml2particles.system
return
else:
self.convert_nbody = convert_nbody
self.Particles = datamodel.ParticlesWithUnitsConverted(
xml2particles.system,
self.convert_nbody.as_converter_from_si_to_generic()
)
def number_of_particles(self):
return len(self.Particles)
class Particles2Dyn(object):
def convert_to_string(self, particles):
lines = []
prefix = " "
lines.append("(Particle")
lines.append(prefix + "N = " + str(len(particles)))
lines.append("(Log")
lines.append(")Log")
#timestamp = particles.get_timestamp() # Timestamp is only saved if not None
timestamp = particles.get_timestamp() or (0|nbody_system.time) # Timestamp is always saved
if not timestamp is None:
lines.append("(Dynamics")
lines.append(prefix + "system_time = " + str(timestamp.value_in(nbody_system.time)))
lines.append(")Dynamics")
for index, x in enumerate(particles):
lines.append("(Particle")
lines.append(prefix + "i = " + str(index))
lines.append(prefix + "N = " + str(1))
float_format = '{0}'.format
lines.append("(Dynamics")
lines.append(prefix + "m = " + float_format(x.mass.value_in(nbody_system.mass)))
r = x.position.value_in(nbody_system.length)
lines.append(prefix + "r = " + " ".join(map(float_format, r)))
v = x.velocity.value_in(nbody_system.speed)
lines.append(prefix + "v = " + " ".join(map(float_format, v)))
lines.append(")Dynamics")
lines.append(")Particle")
lines.append(")Particle")
return '\n'.join(lines)
class StarlabFileFormatProcessor(base.FullTextFileFormatProcessor):
"""
Process a Starlab binary structured file
"""
provided_formats = ['starlab', 'dyn']
def __init__(self, filename = None, stream = None, set = None, format = None):
base.FileFormatProcessor.__init__(self, filename, set, format)
def _is_valid_scaling_factor(self, factor):
return not factor is None and not factor == -1.0
def load_string(self, string):
x = Dyn2Xml()
xml_string = x.convert_starlab_string_to_xml_string(string)
xml2particles = Xml2Particles()
xml2particles.dynamics_mass_units = self.dynamics_mass_units
xml2particles.dynamics_time_units = self.dynamics_time_units
xml2particles.dynamics_length_units = self.dynamics_length_units
xml2particles.parse_xml(xml_string)
unit_converter = None
if self.nbody_to_si_converter is not None:
unit_converter = self.nbody_to_si_converter
elif self.must_scale:
if not self._is_valid_scaling_factor(xml2particles.mass_scale):
unit_converter = None
elif not self._is_valid_scaling_factor(xml2particles.time_scale):
unit_converter = nbody_system.nbody_to_si(
(1.0 / xml2particles.mass_scale) | units.MSun,
(1.0 / xml2particles.size_scale) | units.RSun,
)
else:
unit_converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
(1.0 / xml2particles.mass_scale) | units.MSun,
(1.0 / xml2particles.size_scale) | units.RSun,
(1.0 / xml2particles.time_scale) | units.Myr,
)
if unit_converter is None:
result = xml2particles.system
else:
result = datamodel.ParticlesWithUnitsConverted(
xml2particles.system,
unit_converter.as_converter_from_si_to_generic()
)
if self.return_children:
if self.return_converter:
return result[0].children(), unit_converter
else:
return result[0].children()
else:
if self.return_converter:
return result[0], unit_converter
else:
return result[0]
def store_string(self):
if not self.nbody_to_si_converter is None:
particles = datamodel.ParticlesWithUnitsConverted(
self.set,
self.nbody_to_si_converter.as_converter_from_generic_to_si()
)
else:
particles = self.set
x = Particles2Dyn()
return x.convert_to_string(particles)
@base.format_option
def return_children(self):
"""If True returns the children of the root node, if False returns the root node (defaults to True)"""
return True
@base.format_option
def nbody_to_si_converter(self):
"""Starlab datafiles store stellar dynamics properties in scaled nbody values,
provide a converter to store si data (defaults to None).
Value None means no converter, or use scaling values provided in the file"""
return None
@base.format_option
def dynamics_mass_units(self):
"""The m field in the dynamics section of a starlab file can be in MSun or in scaled units , defaults to scaled units (nbody_system.mass).
When set to scaled units, AMUSE will convert the units if scaling parameters are also given in the file. See the `must_scale` option
to turn this scaling off"""
return nbody_system.mass
@base.format_option
def dynamics_time_units(self):
"""The time fields in the dynamics section of a starlab file can be in Myr or in scaled units , defaults to scaled units (nbody_system.time).
When set to scaled units, AMUSE will convert the units if scaling parameters are also given in the file. See the `must_scale` option
to turn this scaling off.
"""
return nbody_system.time
@base.format_option
def dynamics_length_units(self):
"""The length fields in the dynamics section of a starlab file can be in parsec or in scaled units , defaults to scaled units (nbody_system.length)
When set to scaled units, AMUSE will convert the units if scaling parameters are also given in the file. See the `must_scale` option
to turn this scaling off.
"""
return nbody_system.length
@base.format_option
def must_scale(self):
"""If True use the scaling values from the file, if False do not scale the stellar dynamics properties.
Only used when no nbody to si converter has been set.
"""
return True
@base.format_option
def return_converter(self):
"""If True also return the converter when reading a set using read_set_from_file
"""
return False
| 17,938
| 38.600442
| 155
|
py
|
amuse
|
amuse-main/src/amuse/io/text.py
|
import numpy
from amuse.support.core import late
from amuse.io import base
from amuse.units import units
from amuse.units import core
from amuse.units.quantities import is_quantity
import re
from amuse import datamodel
class LineBasedFileCursor(object):
def __init__(self, file):
self._line = None
self.file = file
self.read_next_line()
def read_next_line(self):
try:
line = next(self.file)
self._line = line.rstrip('\r\n')
except StopIteration:
self._line = None
def forward(self):
if not self.is_at_end():
self.read_next_line()
def line(self):
return self._line
def is_at_end(self):
return self._line is None
class TableFormattedText(base.FileFormatProcessor):
"""
Process a text file containing a table of values separated by a predefined
character
"""
provided_formats = ['txt']
def __init__(self, filename=None, stream=None, set=None, format=None):
base.FileFormatProcessor.__init__(self, filename, set, format)
self.filename = filename
if not stream is None:
self.stream = stream
self.set = set
def forward(self):
line = self.data_file.readline()
return line.rstrip('\r\n')
def split_into_columns(self, line):
if self.column_separator == ' ':
return line.split()
else:
return line.split(self.column_separator)
def load(self):
if self.stream is None:
self.stream = open(self.filename, "r")
close_function = self.stream.close
else:
close_function = lambda: None
try:
return self.load_from_stream()
finally:
close_function()
def load_from_stream(self):
self.cursor = LineBasedFileCursor(self.stream)
self.read_header()
self.read_rows()
self.read_footer()
return self.set
def store(self):
self.open_stream()
try:
return self.store_on_stream()
finally:
self.close_stream()
def open_stream(self):
if self.stream is None:
self.stream = open(self.filename, "w")
self.close_function = self.stream.close
else:
self.close_function = lambda: None
def close_stream(self):
self.close_function()
def store_on_stream(self):
self.write_header()
self.write_rows()
self.write_footer()
@base.format_option
def attribute_names(self):
"""
List of the names of the attributes to load or store
"""
return self._get_attribute_names()
def _get_attribute_names(self):
if self.set is None:
return ["col({0})".format(x) for x in range(len(self.quantities))]
else:
return sorted(self.set.get_attribute_names_defined_in_store())
@base.format_option
def attribute_types(self):
"""
List of the units of the attributes to store. If not given the
units will be derived from the units stored in the attribute set.
When derived from the set, the units will always be converted to
the base units.
"""
return self._get_attribute_types()
def _get_attribute_types(self):
quantities = self.quantities
if self.quantities:
return [x.unit.to_simple_form() if is_quantity(x) else None for x in quantities]
elif self.set is None:
return [None] * len(self.attribute_names)
@base.format_option
def attribute_dtypes(self):
"""
List of the data types of the attributes. If not given, the
data types will be float64.
"""
return self._get_attribute_dtypes()
def _get_attribute_dtypes(self):
return [None] * len(self.attribute_names)
def _new_converter_from_string_to_dtype(self, dtype):
if dtype is None:
return self.convert_string_to_number
kind = numpy.array([], dtype=dtype).dtype.kind
if kind == 'f':
return self.convert_string_to_number
elif kind == 'S' or kind == 'U':
return lambda string_value: string_value
elif kind == 'b':
return lambda string_value: string_value == 'True' or string_value == 'true'
else:
return self.convert_string_to_long
@base.format_option
def header_prefix_string(self):
"""
Lines starting with this character will be handled as part of the header
"""
return '#'
@base.format_option
def column_separator(self):
"""
Separator between the columns
"""
return ' '
@base.format_option
def footer_prefix_string(self):
"""
Lines starting with this character will be handled as part of the footer
"""
return self.header_prefix_string
@base.format_option
def key_in_column(self):
"""
Column for the key (default is -1, no key stored/loaded).
Keys will be interleaved with the data if set other than 0.
No attribute type or name can be given for the key.
"""
return -1
@base.format_option
def must_store_units_in_header(self):
"""
Store line with parsable units in the header of the text file. This
line can be used to restore the units on reading the file. When this
line is added to the file you do not need to specify the
attribute_types on reading the file
"""
return True
def read_header(self):
while not self.cursor.is_at_end() and self.cursor.line().startswith(self.header_prefix_string):
header_line = self.cursor.line()[len(self.header_prefix_string):]
if not header_line.startswith(self.header_prefix_string):
self.read_header_line(header_line)
self.cursor.forward()
def read_header_line(self, line):
line = line.strip()
if line == 'AMUSE CSV: 1.0':
self.has_amuse_header = True
if self.has_amuse_header:
KEY_IN_COLUMN_HDR = 'KEY IN COLUMN:'
if line.startswith(KEY_IN_COLUMN_HDR):
self.key_in_column = int(line[len(KEY_IN_COLUMN_HDR):].strip())
COLUMN_HDR = 'COL:'
if line.startswith(COLUMN_HDR):
line = line[len(COLUMN_HDR):].strip()
parts = line.split(':')
parts = [x.strip() for x in parts]
index = int(parts[0])
if self.key_in_column >= 0 and index > self.key_in_column:
index -= 1
name = parts[1]
is_on = parts[2] == 'on'
dtype = list(map(float, parts[3:-1]))
unit = self.convert_float_to_unit(dtype)
if self.attribute_names is None:
current = []
else:
current = self.attribute_names[:]
print(index)
while len(current)<=index:
current.append("")
current[index] = name
self.attribute_names = current
if self.attribute_types is None:
current = []
else:
current = self.attribute_types[:]
while len(current)<=index:
current.append(None)
current[index] = unit
self.attribute_types = current
self.attribute_dtypes = self._get_attribute_dtypes()
def read_rows(self):
values = [[] for x in range(len(self.attribute_names))]
number_of_particles = 0
keys = []
self.set = None
string_converters = list(map(self._new_converter_from_string_to_dtype, self.attribute_dtypes))
units_with_dtype = list(map(core.unit_with_specific_dtype, self.attribute_types, self.attribute_dtypes))
while not self.cursor.is_at_end() and not self.cursor.line().startswith(self.footer_prefix_string):
columns = self.split_into_columns(self.cursor.line())
if len(columns)>0:
if self.key_in_column >= 0:
if len(columns) != len(self.attribute_names) + 1:
raise base.IoException(
"Number of values on line '{0}' is {1}, expected {2}".format(self.cursor.line(), len(columns), len(self.attribute_names)))
key = self.convert_string_to_long(columns[self.key_in_column])
keys.append(key)
del columns[self.key_in_column]
if len(columns) != len(self.attribute_names):
raise base.IoException(
"Number of values on line '{0}' is {1}, expected {2}".format(self.cursor.line(), len(columns), len(self.attribute_names)))
for value_string, list_of_values, conv in zip(columns, values, string_converters):
list_of_values.append(conv(value_string))
number_of_particles += 1
self.cursor.forward()
if number_of_particles >= self.maximum_number_of_lines_buffered:
quantities = list(map(
lambda value, unit, dtype: unit.new_quantity(value) if not unit is None else (numpy.asarray(value, dtype=dtype) if not dtype is None else value),
values,
units_with_dtype,
self.attribute_dtypes
))
if self.set is None:
self.set = self.new_set(number_of_particles, keys=keys)
self.set.set_values_in_store(self.set.get_all_indices_in_store(), self.attribute_names, quantities)
else:
tmp_set = self.new_set(number_of_particles, keys=keys)
tmp_set.set_values_in_store(tmp_set.get_all_indices_in_store(), self.attribute_names, quantities)
self.set.add_particles(tmp_set)
number_of_particles = 0
keys = []
values = [[] for x in range(len(self.attribute_names))]
if number_of_particles > 0:
quantities = list(map(
lambda value, unit, dtype: unit.new_quantity(value) if not unit is None else (numpy.asarray(value, dtype=dtype) if not dtype is None else value),
values,
units_with_dtype,
self.attribute_dtypes
))
if self.set is None:
self.set = self.new_set(number_of_particles, keys=keys)
self.set.set_values_in_store(self.set.get_all_indices_in_store(), self.attribute_names, quantities)
else:
tmp_set = self.new_set(number_of_particles, keys=keys)
tmp_set.set_values_in_store(tmp_set.get_all_indices_in_store(), self.attribute_names, quantities)
self.set.add_particles(tmp_set)
elif self.set is None:
self.set = self.new_set(0)
self.cursor.forward()
def read_footer(self):
while not self.cursor.is_at_end() and self.cursor.line().startswith(self.footer_prefix_string):
self.read_footer_line(self.cursor.line()[len(self.footer_prefix_string):])
self.cursor.forward()
def read_footer_line(self, line):
pass
def write_header(self):
for x in self.header_lines():
self.stream.write(self.header_prefix_string)
self.stream.write(x)
self.stream.write('\n')
def write_rows(self):
quantities = self.quantities
units = self.attribute_types
max_row = -1
for x in quantities:
max_row = max(max_row, len(x))
block_size = min(self.maximum_number_of_lines_buffered, max_row)
offset = 0
while offset < max_row:
numbers = map(lambda quantity, unit: quantity[offset:offset+block_size] if unit is None else
quantity[offset:offset+block_size].value_in(unit), quantities, units)
columns = []
for x in numbers:
columns.append(list(map(self.convert_number_to_string, x)))
rows = []
for i in range(len(columns[0])):
row = [x[i] for x in columns]
if self.key_in_column >= 0:
row.insert(self.key_in_column, self.convert_long_to_string(self.keys[i+offset]))
rows.append(row)
lines = [self.column_separator.join(x) for x in rows]
for x in lines:
self.stream.write(x)
self.stream.write('\n')
offset += block_size
def write_row(self, row):
units = self.attribute_types
row = map(lambda quantity, unit: quantity if unit is None else quantity.value_in(unit), row, units)
row = map(self.convert_number_to_string, row)
line = self.column_separator.join(row)
self.stream.write(line)
self.stream.write('\n')
self.stream.flush()
def write_footer(self):
for x in self.footer_lines():
self.stream.write(self.footer_prefix_string)
self.stream.write(x)
self.stream.write('\n')
def header_lines(self):
result = []
if self.has_amuse_header:
result.append('AMUSE CSV: 1.0')
result.append('KEY IN COLUMN: '+str(self.key_in_column))
result.append('HEADERS:')
for i, (x, unit) in enumerate(zip(self.attribute_names, self.attribute_types)):
column = i
if self.key_in_column >= 0:
if i >= self.key_in_column:
column += 1
if unit is None:
unitstring= '1:-1:0:0:0:0:0:0:0'
description = '(-)'
else:
unitstring = '{0:.18g}:{1:.0f}:{2:.18g}:{3:.18g}:{4:.18g}:{5:.18g}:{6:.18g}:{7:.18g}:{8:.18g}'.format(*unit.to_array_of_floats())
description = '(' + unit.describe_array_of_floats() + ')'
result.append('COL:{0}:{1}:{2}:{3}:{4}'.format(column, x, 'on', unitstring, description))
result.append('')
else:
if len(self.attribute_names) > 0:
result.append(self.column_separator.join(self.attribute_names))
result.append(self.column_separator.join(self.units_row))
return result
def footer_lines(self):
return []
def convert_string_to_number(self, string):
return float(string)
def convert_string_to_long(self, string):
return int(string)
def new_set(self, number_of_items, keys=[]):
if len(keys) > 0:
return datamodel.Particles(number_of_items, keys=keys)
else:
return datamodel.Particles(number_of_items)
@late
def units_row(self):
result = []
for x in self.attribute_types:
if x is None:
result.append('-')
else:
result.append(str(x))
return result
@base.format_option
def quantities(self):
"""
List of vector quantities, each vector quantity is one column in the
text file. By default this list will be derived from the particles
set. When this option is given it will override the particle set data.
"""
if self.set is None:
return []
else:
if len(self.set) == 0:
return [[] for x in self.attribute_names]
else:
return [getattr(self.set, x) for x in self.attribute_names]
@late
def keys(self):
if self.set is None:
return []
else:
return self.set.key
def convert_number_to_string(self, number):
if self.is_precise:
return '{:.18e}'.format(number)
else:
return str(number)
def convert_long_to_string(self, number):
return str(number)
@base.format_option
def float_format_string(self):
"""
format specification string to convert numbers to strings, see
format_spec in python documentation
"""
return ".{0}e".format(self.precision_of_number_output)
@base.format_option
def precision_of_number_output(self):
"""
The precision is a decimal number indicating how many digits should be
displayed after the decimal point
"""
return 12
@base.format_option
def maximum_number_of_lines_buffered(self):
"""
The maximum number of lines to convert and write out in one go, larger
values may be a little faster but will use a lot more memory
"""
return 10000
@base.format_option
def is_precise(self):
"""
Output most precise text output for floats (9 digits) and doubles (17
digits)
"""
return False
@base.format_option
def has_amuse_header(self):
"""
If true, store the decription of the attributes and units in the
header, better format than must_store_units_in_header provides
"""
return False
@base.format_option
def comments(self):
"""
Comments to add to the header
"""
return []
def convert_float_to_unit(self, floats):
from amuse.units import core
from amuse.units import units
print(floats, int(floats[1]) == -1, numpy.all(numpy.asarray(floats[2:]) == 0.0), numpy.asarray(floats[2:]) == 0.0)
if int(floats[1]) == -1 and numpy.all(numpy.asarray(floats[2:]) == 0.0):
return None
factor = floats[0]
result = factor
system_index = int(floats[1])
unit_system = None
for x in core.system.ALL.values():
if x.index == system_index:
unit_system = x
break
for x in unit_system.bases:
power = floats[x.index + 2]
if not power == 0.0:
result = result * (x ** power)
return result
@base.format_option
def stream(self):
""""Set the stream to output to"""
return None
class CsvFileText(TableFormattedText):
"""
Process comma separated files
Can process test files with comma separated fields.
"""
provided_formats = ['csv']
def __init__(self, filename=None, stream=None, set=None, format=None):
TableFormattedText.__init__(self, filename, stream, set, format)
if self.set is None:
self.attribute_names = None
self.attribute_types = None
@base.format_option
def column_separator(self):
"separator between the columns"
return ','
def convert_string_to_unit(self, unit_string):
if unit_string == '-':
return None
else:
try:
return eval(unit_string, core.__dict__)
except:
if hasattr(units, unit_string):
return getattr(units, unit_string)
return eval(unit_string, units.__dict__)
def convert_csv_string_to_unit(self, csv_string):
return [self.convert_string_to_unit(sub) for sub in csv_string.split(self.column_separator)]
def read_header_line(self, line):
if self.attribute_names:
if self.attribute_types is None:
self.attribute_types = self.convert_csv_string_to_unit(line)
else:
self.attribute_names = [sub.strip() for sub in line.split(self.column_separator)]
def header_lines(self):
if self.attribute_names is None:
self.attribute_names = self._get_attribute_names()
if self.attribute_types is None:
self.attribute_types = self._get_attribute_types()
result = []
if len(self.comments) > 0:
result.extend([self.header_prefix_string + x for x in self.comments])
result.append(self.column_separator.join(self.attribute_names))
if self.must_store_units_in_header:
result.append(self.column_separator.join(['-' if one_unit is None else one_unit.to_simple_form().reference_string() for one_unit in self.attribute_types]))
result.append(self.column_separator.join(map(str, self.attribute_types)))
return result
class Athena3DText(TableFormattedText):
def read_header_line(self, line):
line = line.lstrip()
if line.startswith('['):
self.read_attribute_names_from_line(line)
def read_attribute_names_from_line(self, line):
column_definition_strings = line.split()
mapping_from_column_index_to_name = {}
definition_re = re.compile(r'\[(\d+)\]=(.+)')
for x in column_definition_strings:
match_object = definition_re.match(x)
if match_object is None:
return
index, name = match_object.groups()
index = int(index) - 1
name = name.replace('-','_')
mapping_from_column_index_to_name[index] = name
self.attribute_names = self.convert_dictionary_to_array(mapping_from_column_index_to_name)
def convert_dictionary_to_array(self, dictionary):
result = [None] * len(dictionary)
for key, value in dictionary.items():
result[key] = value
return result
class AmuseText(TableFormattedText):
"""
Process text files with AMUSE header format
"""
provided_formats = ['amuse-txt']
@base.format_option
def has_amuse_header(self):
"""
If true, store the decription of the attributes and units in the
header, better format than must_store_units_in_header provides (default
True for amuse csv format)
"""
return True
@base.format_option
def is_precise(self):
"""
Output most precise text output for floats (9 digitst) and doubles (17
digits) (True for amuse text)
"""
return True
def convert_number_to_string(self, number):
if self.is_precise:
return '{:.18e}'.format(number)
else:
return str(number)
@base.format_option
def use_fractions(self):
"""
Output floats as fractions, will be more precise
"""
return True
| 22,593
| 33.129909
| 167
|
py
|
amuse
|
amuse-main/src/amuse/io/__init__.py
|
"""
File input and output
AMUSE can read and write to/from several data formats. The main routines
are write_set_to_file and read_set_from_file, explained below.
"""
from amuse.io.base import *
from amuse.io import text
from amuse.io.nemotsf import NemoFileFormatProcessor
from amuse.io.nemobin import NemoBinaryFileFormatProcessor
from amuse.io.starlab import StarlabFileFormatProcessor
from amuse.io.store import HDF5FileFormatProcessor
from amuse.io.gadget import GadgetFileFormatProcessor
from amuse.io.vtk import VtkStructuredGrid
from amuse.io.vtk import VtkUnstructuredGrid
text.TableFormattedText.register()
text.CsvFileText.register()
text.AmuseText.register()
NemoFileFormatProcessor.register()
NemoBinaryFileFormatProcessor.register()
StarlabFileFormatProcessor.register()
HDF5FileFormatProcessor.register()
GadgetFileFormatProcessor.register()
VtkStructuredGrid.register()
VtkUnstructuredGrid.register()
__all__ = ["read_set_from_file", "write_set_to_file", "get_options_for_format"]
| 1,001
| 31.322581
| 79
|
py
|
amuse
|
amuse-main/src/amuse/io/store.py
|
import numpy
import pickle
import os.path
from amuse.io import base
from amuse.units import si
from amuse.units import units
from amuse.units import core
from amuse.units.quantities import is_quantity
from amuse.support import exceptions
from amuse.datamodel import Particles
from amuse.datamodel import AttributeStorage
from amuse.io import store_v1
from amuse.io import store_v2
StoreHDF = store_v1.StoreHDF
class _FileContext(object):
def __init__(self, processor, result):
self.processor = processor
self.result = result
def __enter__(self):
return self.result
def __exit__(self, type, value, traceback):
self.processor.close()
class HDF5FileFormatProcessor(base.FileFormatProcessor):
"""
Process an HDF5 file
"""
provided_formats = ['hdf5', 'amuse']
def __init__(self, filename=None, set=None, format=None):
base.FileFormatProcessor.__init__(self, filename, set, format)
def load(self):
processor, result = self.load_base()
if self.return_context:
return _FileContext(processor, result)
else:
return result
def load_base(self):
processor = store_v2.StoreHDF(
self.filename,
open_for_writing=False,
append_to_file=self.append_to_file or self.allow_writing,
copy_history=self.copy_history,
overwrite_file=self.overwrite_file,
compression=False,
compression_opts=None,
)
if not processor.is_correct_version():
processor.close()
processor = store_v1.StoreHDF(
self.filename,
open_for_writing = False,
append_to_file = self.append_to_file or self.allow_writing,
copy_history = self.copy_history,
overwrite_file = self.overwrite_file )
if len(self.names) > 0:
result = processor.load_sets(self.names)
if self.close_file:
if not self.copy_history:
for part in result:
part._private.previous = None
processor.close()
else:
result = processor.load()
if self.close_file:
if not self.copy_history:
result = result.copy()
result._private.previous = None
processor.close()
return processor, result
def store(self):
if self.version == '1.0':
processor = store_v1.StoreHDF(
self.filename,
append_to_file = self.append_to_file,
open_for_writing = True,
overwrite_file = self.overwrite_file
)
if not processor.is_correct_version():
raise Exception("You are trying to append to a file that was not written in version 1.0 format")
else:
processor = store_v2.StoreHDF(
self.filename,
append_to_file=self.append_to_file,
open_for_writing=True,
overwrite_file=self.overwrite_file,
compression=self.compression,
compression_opts=self.compression_opts
)
if not processor.is_correct_version():
raise Exception("You are trying to append to a file that was written in version 1.0 format")
try:
if len(self.names) > 0:
return processor.store_sets(self.set, self.names, self.extra_attributes)
else:
return processor.store(self.set, self.extra_attributes)
finally:
processor.close()
@base.format_option
def append_to_file(self):
"""If set to True, new data is appended to HDF5 files.
If set to False, the existing file is removed and overwritten.
Only relevant for write set to file. (default: False)"""
return False
@base.format_option
def close_file(self):
"""If set to True, the file is closed after reading, unless you
set copy_history to True no previous savepoints will be returned"""
return True
@base.format_option
def copy_history(self):
"""If set to True, the savepoint history is read from file into memory."""
return True
@base.format_option
def names(self):
"""A list of names to save the data under. If filled this
will load the sets or grids with the given names and
return this as a list. When saving the names will be used to
save each set, a list of sets is needed in the write_set_to_file
function (default: [])"""
return []
@base.format_option
def version(self):
"""AMUSE storage version to use, needs to be >= '2.0' if you want
to store links between particles and grids (default: '2.0')"""
return '2.0'
@base.format_option
def return_context(self):
"""If set to True, will return a context manager instead of
the loaded set(s). This context manager will take care of properly
closing any connected resources. To access the set, use the with
statement.
.. code-block:: python
with load_set_from_file("example.h5", "amuse") as particles:
print particles
Usefull for cases where close_file == False. (default: False)"""
return False
@base.format_option
def allow_writing(self):
"""If set to True, data can be written to the file, equivalent of append_to_file
even if read_set_from_file is used"""
return False
@base.format_option
def overwrite_file(self):
"""If set to True, overwrite file if it exists, otherwise writing an existing
file generates an exception"""
return False
@base.format_option
def compression(self):
"""If set to False, don't use compression, otherwise use specified compression
mode (defaults to False, True means 'gzip')"""
return False
@base.format_option
def compression_opts(self):
"Compression level to use if using compression (0-9, defaults to None)"
return None
| 6,419
| 32.968254
| 112
|
py
|
amuse
|
amuse-main/src/amuse/io/nemotsf.py
|
import re
import numpy
from amuse.io import base
from amuse.units import units
from amuse.units import nbody_system
from amuse import datamodel
TEMPLATE = \
"""set SnapShot
set Parameters
int Nobj {0.number_of_particles:d}
double Time {0.time:e}
tes
set Particles
int CoordSystem {0.coordinate_system_id:d}
double Mass[{0.number_of_particles:d}] {0.mass_paragraph:s}
double PhaseSpace[{0.number_of_particles:d}][{0.number_of_phases:d}][{0.number_of_dimensions:d}] {0.phase_paragraph:s}
tes
tes
"""
class Particles2Tsf(object):
def __init__(self):
self.number_of_particles = 0
self.mass_paragraph = ""
self.phase_paragraph = ""
self.number_of_phases = 2
self.number_of_dimensions = 3
self.coordinate_system_id = 66306
def convert_to_string(self, particles, converter = None):
if not converter is None:
particles=datamodel.ParticlesWithUnitsConverted(
particles,
converter.as_converter_from_generic_to_si()
)
self.time = (particles.get_timestamp() or (0.0|nbody_system.time)).value_in(nbody_system.time)
self.particles = particles
self.number_of_particles = len(particles)
masses = particles.mass.value_in(nbody_system.mass)
velocities = particles.velocity.value_in(nbody_system.speed)
positions = particles.position.value_in(nbody_system.length)
for i, mass in enumerate(masses):
self.mass_paragraph += ' '+str(mass)
if (i % 5) == 0:
self.mass_paragraph += '\n '
for i, phase in enumerate(zip(positions,velocities)):
self.phase_paragraph += ' '.join([str(j) for j in phase[0]]) + ' ' + ' '.join([str(k) for k in phase[1]])
if (i % 1) == 0:
self.phase_paragraph += '\n '
return TEMPLATE.format(self)
class Tsf2Particles(object):
def __init__(self):
self.number_of_particles = 0
self.masses = []
self.phases = []
self.timestamp = None
def return_numbers_in_brackets(self, line):
numbers = []
indices = re.findall('\[[0-9]*\]',line)
for i in indices:
numbers.append((int)(i.strip('[').strip(']')))
return numbers
def return_numbers_from_paragraph(self, lines, start, end):
numlist =[]
for i in range(start, end):
linechunks = lines[i].split(' ')
for j in linechunks:
try:
numlist.append(float(j))
except:
pass
return numlist
def read_to_ram(self, string):
lines = string.splitlines()
timestamp_index = [i for i, oneline in enumerate(lines) if 'double Time' in oneline][0]
self.timestamp = float(lines[timestamp_index].strip().split(' ')[2]) | nbody_system.time
start_masses = [i for i, oneline in enumerate(lines) if 'double Mass' in oneline][0]
start_phasespace = [i for i, oneline in enumerate(lines) if 'double PhaseSpace' in oneline][0]
massline_numbers = self.return_numbers_in_brackets(lines[start_masses])
phaseline_numbers = self.return_numbers_in_brackets(lines[start_phasespace])
no_particles = phaseline_numbers[0]
no_phases = phaseline_numbers[1]
no_dimensions = phaseline_numbers[2]
self.number_of_particles = no_particles
self.masses = self.return_numbers_from_paragraph(lines, start_masses, start_phasespace)
self.phases = numpy.reshape(self.return_numbers_from_paragraph(lines, start_phasespace, len(lines)),
[no_particles,no_phases,no_dimensions])
def convert_to_particles(self, string, converter = None):
self.read_to_ram(string)
result = datamodel.Particles(self.number_of_particles)
result.mass = self.masses|nbody_system.mass
result.position = [i[0] for i in self.phases]|nbody_system.length
result.velocity = [i[1] for i in self.phases]|nbody_system.speed
if not self.timestamp is None:
result.savepoint(self.timestamp)
if not converter is None:
result=datamodel.ParticlesWithUnitsConverted(
result,
converter.as_converter_from_si_to_generic()
)
return result
class NemoFileFormatProcessor(base.FullTextFileFormatProcessor):
"""
Process a NEMO binary structured file
"""
provided_formats = ['nemo', 'tsf']
def __init__(self, filename = None, stream = None, set = None, format = None):
base.FileFormatProcessor.__init__(self, filename, set, format)
def load_string(self, string):
x = Tsf2Particles()
return x.convert_to_particles(string, self.nbody_to_si_converter)
def store_string(self):
x = Particles2Tsf()
return x.convert_to_string(self.set, self.nbody_to_si_converter)
@base.format_option
def nbody_to_si_converter(self):
"NEMO datafiles store nbody data, provide a converter to store si data (None means no converter)"
return None
| 5,389
| 34.933333
| 122
|
py
|
amuse
|
amuse-main/src/amuse/io/horizons.py
|
from datetime import date, timedelta
class LoadStar(object):
def __init__(self, planet):
f = open('../viewer/'+planet+'.txt','r')
M = f.readlines()
f.close()
"""
radiusline = M[4]
radius = float(radiusline.split('=')[1].split('(')[0])
massline = M[5]
Myunit = massline.split('(')[1].split(')')[0].split('^')
Unitbase = float(Myunit[0])
Expo = float(Myunit[1].split('kg')[0])
mass = Unitbase**Expo
"""
days = []
#find '$$SOE' this indicates the start of the R,V, T data
#we do not expect more than one $$OE entry
start_r_v_data_index = [i for i, line in enumerate(M) if '$$SOE' in line][0]
for i, s in enumerate(M):
if 'A.D.' in s and i>start_r_v_data_index:
days.append(i)
r = []
v = []
julian_day = []
for i in days:
julian_day.append((float(M[i].split('=')[0])-1721424.5))
#http://ssd.jpl.nasa.gov/?horizons_doc#time
rs = M[i+1].split(' ')
vs = M[i+2].split(' ')
input_radii = []
input_velocities = []
for j, n in enumerate(rs):
if not n == '':
input_radii.append(float(n))
for j, n in enumerate(vs):
if not n == '':
input_velocities.append(float(n))
r.append([input_radii[0], input_radii[1], input_radii[2]])
v.append([input_velocities[0], input_velocities[1], input_velocities[2]])
self.ordinal = julian_day
self.r = r
self.v = v
#not implemented yet:
self.mass = 0.0
self.radius = 0.0
self.name = planet
self.max = self.ordinal[-1]
del M
def get_vectors_at_date(self, at_date):
if at_date.toordinal()<self.max:
indices = [i for i, j in enumerate(self.ordinal) if j==at_date.toordinal()]
if len(indices)==0:
print("no ordinal index found")
return [0,0,0],[0,0,0]
else:
return self.r[indices[0]], self.v[indices[0]]
else:
print("horizons indexing ERROR")
return self.r[-1],self.v[-1]
class NewStar(LoadStar):
def __init__(self, *kargs):
self.ordinal = []
self.r = []
self.v = []
self.mass = 0.0
self.radius = 0.0
self.name = ""
self.max = 0
| 2,608
| 28.314607
| 87
|
py
|
amuse
|
amuse-main/src/amuse/ic/plummer.py
|
"""
Plummer model generator
This module contains a function used to create Plummer (1911) models, which
follow a spherically symmetric density profile of the form:
rho = c * (1 + r**2)**(-5/2)
"""
import numpy
import numpy.random
from math import pi, sqrt
from amuse.units import nbody_system
from amuse import datamodel
__all__ = ["new_plummer_sphere", "new_plummer_model"]
class MakePlummerModel(object):
def __init__(self, number_of_particles, convert_nbody = None, radius_cutoff = 22.8042468, mass_cutoff = 0.999,
do_scale = False, random_state = None, random = None):
self.number_of_particles = number_of_particles
self.convert_nbody = convert_nbody
self.mass_cutoff = min(mass_cutoff, self.calculate_mass_cuttof_from_radius_cutoff(radius_cutoff))
self.do_scale = do_scale
if not random_state == None:
print("DO NOT USE RANDOM STATE")
self.random_state = None
if random is None:
self.random = numpy.random
else:
self.random = random
def calculate_mass_cuttof_from_radius_cutoff(self, radius_cutoff):
if radius_cutoff > 99999:
return 1.0
scale_factor = 16.0 / (3.0 * pi)
rfrac = radius_cutoff * scale_factor
denominator = pow(1.0 + rfrac ** 2, 1.5)
numerator = rfrac ** 3
return numerator/denominator
def calculate_radius(self, index):
mass_min = (index * self.mass_cutoff) / self.number_of_particles
mass_max = ((index+1) * self.mass_cutoff) / self.number_of_particles
random_mass_fraction = self.random.uniform(mass_min, mass_max)
radius = 1.0 / sqrt( pow (random_mass_fraction, -2.0/3.0) - 1.0)
return radius
def calculate_radius_uniform_distribution(self):
return 1.0 / numpy.sqrt( numpy.power(self.random.uniform(0,self.mass_cutoff,(self.number_of_particles,1)), -2.0/3.0) - 1.0)
def new_positions_spherical_coordinates(self):
pi2 = pi * 2
radius = self.calculate_radius_uniform_distribution()
theta = numpy.arccos(self.random.uniform(-1.0,1.0, (self.number_of_particles,1)))
phi = self.random.uniform(0.0,pi2, (self.number_of_particles,1))
return (radius,theta,phi)
def new_velocities_spherical_coordinates(self, radius):
pi2 = pi * 2
x,y = self.new_xy_for_velocity()
velocity = x * sqrt(2.0) * numpy.power( 1.0 + radius*radius, -0.25)
theta = numpy.arccos(self.random.uniform(-1.0,1.0, (self.number_of_particles,1)))
phi = self.random.uniform(0.0,pi2, (self.number_of_particles,1))
return (velocity,theta,phi)
def coordinates_from_spherical(self, radius, theta, phi):
x = radius * numpy.sin( theta ) * numpy.cos( phi )
y = radius * numpy.sin( theta ) * numpy.sin( phi )
z = radius * numpy.cos( theta )
return (x,y,z)
def new_xy_for_velocity(self):
number_of_selected_items = 0
selected_values_for_x = numpy.zeros(0)
selected_values_for_y = numpy.zeros(0)
while (number_of_selected_items < self.number_of_particles):
x = self.random.uniform(0,1.0, (self.number_of_particles-number_of_selected_items))
y = self.random.uniform(0,0.1, (self.number_of_particles-number_of_selected_items))
g = (x**2) * numpy.power(1.0 - x**2, 3.5)
compare = y <= g
selected_values_for_x = numpy.concatenate((selected_values_for_x, x.compress(compare)))
selected_values_for_y= numpy.concatenate((selected_values_for_x, y.compress(compare)))
number_of_selected_items = len(selected_values_for_x)
return numpy.atleast_2d(selected_values_for_x).transpose(), numpy.atleast_2d(selected_values_for_y).transpose()
def new_model(self):
m = numpy.zeros((self.number_of_particles,1)) + (1.0 / self.number_of_particles)
radius, theta, phi = self.new_positions_spherical_coordinates()
position = numpy.hstack(self.coordinates_from_spherical(radius, theta, phi))
radius, theta, phi = self.new_velocities_spherical_coordinates(radius)
velocity = numpy.hstack(self.coordinates_from_spherical(radius, theta, phi))
position = position / 1.695
velocity = velocity / sqrt(1 / 1.695)
return (m, position, velocity)
@property
def result(self):
masses = numpy.ones(self.number_of_particles) / self.number_of_particles
radius, theta, phi = self.new_positions_spherical_coordinates()
x,y,z = self.coordinates_from_spherical(radius, theta, phi)
radius, theta, phi = self.new_velocities_spherical_coordinates(radius)
vx,vy,vz = self.coordinates_from_spherical(radius, theta, phi)
result = datamodel.Particles(self.number_of_particles)
result.mass = nbody_system.mass.new_quantity(masses)
result.x = nbody_system.length.new_quantity(x.reshape(self.number_of_particles)/1.695)
result.y = nbody_system.length.new_quantity(y.reshape(self.number_of_particles)/1.695)
result.z = nbody_system.length.new_quantity(z.reshape(self.number_of_particles)/1.695)
result.vx = nbody_system.speed.new_quantity(vx.reshape(self.number_of_particles) / sqrt(1/1.695))
result.vy = nbody_system.speed.new_quantity(vy.reshape(self.number_of_particles) / sqrt(1/1.695))
result.vz = nbody_system.speed.new_quantity(vz.reshape(self.number_of_particles) / sqrt(1/1.695))
result.radius = 0 | nbody_system.length
result.move_to_center()
if self.do_scale:
result.scale_to_standard()
if not self.convert_nbody is None:
result = datamodel.ParticlesWithUnitsConverted(result, self.convert_nbody.as_converter_from_si_to_generic())
result = result.copy()
return result
def new_plummer_model(number_of_particles, *list_arguments, **keyword_arguments):
"""
Create a plummer sphere with the given number of particles. Returns
a set of stars with equal mass and positions and velocities distributed
to fit a plummer star distribution model. The model is centered around the
origin. Positions and velocities are optionally scaled such that the kinetic and
potential energies are 0.25 and -0.5 in nbody-units, respectively.
:argument number_of_particles: Number of particles to include in the plummer sphere
:argument convert_nbody: When given will convert the resulting set to SI units
:argument radius_cutoff: Cutoff value for the radius (defaults to 22.8042468)
:argument mass_cutoff: Mass percentage inside radius of 1
:argument do_scale: scale the result to exact nbody units (M=1, K=0.25, U=-0.5)
"""
uc = MakePlummerModel(number_of_particles, *list_arguments, **keyword_arguments)
return uc.result
new_plummer_sphere = new_plummer_model
| 6,918
| 46.390411
| 132
|
py
|
amuse
|
amuse-main/src/amuse/ic/salpeter.py
|
"""
Salpeter (1955) initial mass function (IMF)
This module contains functions used to generate realisations of the
Salpeter IMF.
"""
import numpy
import os
import sys
from amuse.units import nbody_system
from amuse.units import units
__all__ = ["new_salpeter_mass_distribution", "new_salpeter_mass_distribution_nbody"]
class SalpeterIMF(object):
def __init__(self, mass_min = 0.1 | units.MSun, mass_max = 125 | units.MSun, alpha = -2.35,random=numpy.random):
self.mass_min = mass_min
self.mass_max = mass_max
self.alpha = alpha
self.random = random
def mass_mean(self):
alpha1 = self.alpha + 1
alpha2 = self.alpha + 2
l1 = pow(self.mass_min, alpha1)
l2 = pow(self.mass_min, alpha2)
u1 = pow(self.mass_max, alpha1)
u2 = pow(self.mass_max, alpha2)
return ((u2 - l2) * alpha1) / ((u1 - l1) * alpha2)
def mass(self, random_number):
alpha1 = self.alpha + 1
factor = (pow(self.mass_max / self.mass_min, alpha1) - 1.0 )
return self.mass_min * (pow(1.0 + (factor * random_number), 1.0 / alpha1))
def next_mass(self,N=1):
return self.mass(self.random.random_sample(N))
def next_set(self, number_of_stars):
set_of_masses=self.next_mass(number_of_stars).in_(self.mass_min.unit)
total_mass=set_of_masses.sum()
return (total_mass, set_of_masses)
def new_powerlaw_mass_distribution(number_of_particles, *list_arguments, **keyword_arguments):
"""Returns a salpeter mass distribution in SI units.
:argument alpha: the dimensionless exponent of the Salpeter function (defaults to -2.35)
:argument mass_min: the minimum of the mass function (default 0.1 MSun)
:argument mass_max: the maximum of the mass function (default 125 MSun)
"""
uc = SalpeterIMF(*list_arguments, **keyword_arguments)
return uc.next_mass(number_of_particles).as_quantity_in(uc.mass_min.unit)
def new_powerlaw_mass_distribution_nbody(number_of_particles, **keyword_arguments):
"""Returns a salpeter mass distribution in nbody masses.
All masses will be scaled so that the total mass is always 1.0.
:argument alpha: the dimensionless exponent of the Salpeter function (defaults to -2.35)
:argument mass_min: the minimum of the mass function (0.1)
:argument mass_max: the maximum of the mass function (125)
"""
if not 'mass_min' in keyword_arguments:
keyword_arguments['mass_min'] = 0.1 | nbody_system.mass
if not 'mass_max' in keyword_arguments:
keyword_arguments['mass_max'] = 125 | nbody_system.mass
uc = SalpeterIMF(**keyword_arguments)
total_mass, result = uc.next_set(number_of_particles)
result *= (1.0 | total_mass.unit) / total_mass
return result
new_salpeter_mass_distribution = new_powerlaw_mass_distribution
new_salpeter_mass_distribution_nbody = new_powerlaw_mass_distribution_nbody
| 2,981
| 36.746835
| 116
|
py
|
amuse
|
amuse-main/src/amuse/ic/kroupa.py
|
"""
Kroupa (2001) initial mass function (IMF)
This module contains a function used to generate realisations of the Kroupa
(2001) initial mass function (IMF).
"""
from amuse.ic.brokenimf import new_kroupa_mass_distribution
__all__ = ["new_kroupa_mass_distribution"]
| 267
| 28.777778
| 76
|
py
|
amuse
|
amuse-main/src/amuse/ic/solarsystem.py
|
"""
Generate the Solar system at a specified Julian date (default: 2438871.5).
"""
from amuse.ext.solarsystem import new_solar_system_for_mercury, new_solar_system
| 165
| 26.666667
| 80
|
py
|
amuse
|
amuse-main/src/amuse/ic/gasplummer.py
|
"""
Plummer gas model generator
This module contains a function used to create Plummer (1911) models consisting
of (SPH) gas particles.
Plummer models follow a spherically symmetric density profile of the form:
rho = c * (1 + r**2)**(-5/2)
"""
import numpy
from amuse.ext.evrard_test import uniform_unit_sphere
from amuse.units import nbody_system
from amuse.units import units
from amuse import datamodel
__all__ = ["new_plummer_gas_model"]
class MakePlummerGasModel(object):
def __init__(self, targetN, convert_nbody = None, base_grid=None, rscale=1/1.695,
mass_cutoff = 0.999, do_scale = False):
self.targetN = targetN
self.convert_nbody = convert_nbody
self.rscale=rscale
self.mass_frac=mass_cutoff
self.do_scale = do_scale
self.internal_energy = 0.25 / self.rscale
self.base_sphere=uniform_unit_sphere(targetN,base_grid)
def new_model(self):
x,y,z=self.base_sphere.make_xyz()
self.actualN=len(x)
r=numpy.sqrt(x**2+y**2+z**2)*self.mass_frac**(1/3.)
rtarget=self.rscale*(r**2/(1-r**2))**.5
mr=self.mass_frac**(1/3.)
maxr=self.rscale*(mr**2/(1-mr**2))**.5
mass=numpy.ones_like(x)/self.actualN
internal_energy=self.internal_energy/(1+(rtarget/self.rscale)**2)**(1./2)
r=r.clip(1.e-8,maxr)
x=rtarget*x/r
y=rtarget*y/r
z=rtarget*z/r
vx=numpy.zeros_like(x)
vy=numpy.zeros_like(x)
vz=numpy.zeros_like(x)
return (mass,x,y,z,vx,vy,vz,internal_energy)
@property
def result(self):
mass,x,y,z,vx,vy,vz,u = self.new_model()
result = datamodel.Particles(self.actualN)
result.mass = nbody_system.mass.new_quantity(mass)
result.x = nbody_system.length.new_quantity(x)
result.y = nbody_system.length.new_quantity(y)
result.z = nbody_system.length.new_quantity(z)
result.vx = nbody_system.speed.new_quantity(vx)
result.vy = nbody_system.speed.new_quantity(vy)
result.vz = nbody_system.speed.new_quantity(vz)
result.u = (nbody_system.speed**2).new_quantity(u)
result.move_to_center()
if self.do_scale:
potential_energy = result.potential_energy(G = nbody_system.G)
result.position *= potential_energy / (-0.5 | nbody_system.energy)
internal_energy = result.thermal_energy()
result.u *= ((0.25 | nbody_system.energy) / internal_energy)
if not self.convert_nbody is None:
result = datamodel.ParticlesWithUnitsConverted(result, self.convert_nbody.as_converter_from_si_to_generic())
result = result.copy()
return result
def new_plummer_gas_model(number_of_particles, *list_arguments, **keyword_arguments):
"""
Create a plummer gas model with the given number of particles. Returns
a set of SPH particles with equal masses and positions distributed
to fit a plummer distribution model. The model is centered around the
origin. Velocities are set to zero, and internal energies are set to
balance the gravitational forces between the gas particles.
:argument number_of_particles: Number of particles to include in the plummer sphere
:argument convert_nbody: When given will convert the resulting set to SI units
:argument mass_cutoff: Mass percentage inside radius of 1
:argument do_scale: scale the result, similar to true nbody units (M=1, Q=0.25, U=-0.5)
"""
uc = MakePlummerGasModel(number_of_particles, *list_arguments, **keyword_arguments)
return uc.result
| 3,678
| 38.55914
| 120
|
py
|
amuse
|
amuse-main/src/amuse/ic/solar_system_moons.py
|
import numpy
from amuse.units import units, nbody_system, constants
from amuse.datamodel import Particles, Particle
from amuse.community.kepler.interface import Kepler
from amuse.ext.solarsystem import solar_system_in_time
#mass in units of 10^16kg
_lunar_data = [
["Earth", "Moon", 7.34767309e+6, 1.737, 384400., 0.0554, 318.15, 135.27, 5.16, 125.08],
["Mars", "Phobos", 1.08, 11.1, 9376., 0.0151, 150.057, 91.059, 1.075, 207.784],
["Mars", "Deimos", 0.2, 6.3, 23458., 0.0002, 260.729, 325.329, 1.788, 24.525],
["Jupiter", "Io", 8932000., 1821.5, 421800., 0.0041, 84.129, 342.021, 0.036, 43.977],
["Jupiter", "Europa", 4800000., 1560.8, 671100., 0.0094, 88.970, 171.016, 0.466, 219.106],
["Jupiter", "Ganymede", 14819000., 2631.2, 1070400., 0.0013, 192.417, 317.540, 0.177, 63.552],
["Jupiter", "Callisto", 10759000., 2410.3, 1882700., 0.0074, 52.643, 181.408, 0.192, 298.848],
["Jupiter", "Amalthea", 1, 50, 181400., 0.0032, 155.873, 185.194, 0.380, 108.946],
["Jupiter", "Thebe", 1, 50, 221900., 0.0176, 234.269, 135.956, 1.080, 235.694],
["Jupiter", "Adrastea", 1, 50, 129000., 0.0018, 328.047, 135.673, 0.054, 228.378],
["Jupiter", "Metis", 1, 50, 128000., 0.0012, 297.177, 276.047, 0.019, 146.912],
["Jupiter", "Himalia", 1, 50, 11460000., 0.1586, 331.234, 66.874, 28.612, 64.798],
["Jupiter", "Elara", 1, 50, 11740000., 0.2108, 142.001, 330.985, 27.945, 115.511],
["Jupiter", "Pasiphae", 1, 50, 23629000., 0.4062, 169.226, 279.769, 151.413, 314.223],
["Jupiter", "Sinope", 1, 50, 23942000., 0.2552, 354.541, 165.352, 158.189, 309.199],
["Jupiter", "Lysithea", 1, 50, 11717000., 0.1161, 49.670, 330.475, 27.663, 5.326],
["Jupiter", "Carme", 1, 50, 23401000., 0.2546, 26.416, 233.375, 164.994, 114.854],
["Jupiter", "Ananke", 1, 50, 21254000., 0.2332, 95.772, 253.384, 148.693, 15.959],
["Jupiter", "Leda", 1, 50, 11164000., 0.1624, 269.393, 230.352, 27.882, 219.181],
["Jupiter", "Callirrhoe", 1, 50, 24099000., 0.2796, 23.909, 107.962, 147.080, 283.104],
["Jupiter", "Themisto", 1, 50, 7504000., 0.2435, 217.147, 313.051, 42.977, 192.288],
["Jupiter", "Megaclite", 1, 50, 23814000., 0.4156, 288.882, 135.272, 152.781, 280.575],
["Jupiter", "Taygete", 1, 50, 23363000., 0.2523, 231.540, 94.756, 165.253, 305.114],
["Jupiter", "Chaldene", 1, 50, 23181000., 0.2503, 243.878, 267.454, 165.155, 134.240],
["Jupiter", "Harpalyke", 1, 50, 21106000., 0.2296, 134.505, 215.956, 148.759, 29.834],
["Jupiter", "Kalyke", 1, 50, 23565000., 0.2466, 218.934, 255.702, 165.121, 43.864],
["Jupiter", "Iocaste", 1, 50, 21272000., 0.2152, 64.727, 213.675, 149.411, 269.613],
["Jupiter", "Erinome", 1, 50, 23286000., 0.2655, 10.274, 267.136, 164.914, 317.497],
["Jupiter", "Isonoe", 1, 50, 23231000., 0.2471, 116.879, 124.941, 165.250, 130.961],
["Jupiter", "Praxidike", 1, 50, 21148000., 0.2274, 190.862, 117.480, 148.885, 280.956],
["Jupiter", "Autonoe", 1, 50, 24037000., 0.3152, 54.793, 142.035, 152.364, 272.817],
["Jupiter", "Thyone", 1, 50, 21197000., 0.2307, 97.023, 238.786, 148.595, 233.022],
["Jupiter", "Hermippe", 1, 50, 21297000., 0.2095, 300.836, 131.854, 150.740, 330.393],
["Jupiter", "Aitne", 1, 50, 23317000., 0.2627, 99.401, 105.000, 165.048, 8.679],
["Jupiter", "Eurydome", 1, 50, 23146000., 0.2755, 223.631, 287.689, 150.271, 302.470],
["Jupiter", "Euanthe", 1, 50, 21039000., 0.2320, 320.635, 333.101, 148.915, 254.297],
["Jupiter", "Euporie", 1, 50, 19336000., 0.1438, 89.904, 70.243, 145.740, 60.143],
["Jupiter", "Orthosie", 1, 50, 21158000., 0.2807, 216.805, 204.517, 146.004, 221.949],
["Jupiter", "Sponde", 1, 50, 23790000., 0.3112, 61.885, 174.044, 150.997, 116.363],
["Jupiter", "Kale", 1, 50, 23306000., 0.2597, 44.233, 212.853, 164.944, 60.170],
["Jupiter", "Pasithee", 1, 50, 23091000., 0.2682, 231.920, 215.443, 165.117, 327.729],
["Jupiter", "Hegemone", 1, 50, 23575000., 0.3445, 197.144, 236.950, 154.164, 318.902],
["Jupiter", "Mneme", 1, 50, 21033000., 0.2258, 40.542, 256.860, 148.585, 13.467],
["Jupiter", "Aoede", 1, 50, 23974000., 0.4325, 59.739, 197.676, 158.272, 173.392],
["Jupiter", "Thelxinoe", 1, 50, 21160000., 0.2201, 313.183, 268.013, 151.390, 169.962],
["Jupiter", "Arche", 1, 50, 23352000., 0.2495, 171.632, 39.713, 165.015, 339.210],
["Jupiter", "Kallichore", 1, 50, 23276000., 0.2509, 9.836, 55.937, 165.102, 30.339],
["Jupiter", "Helike", 1, 50, 21065000., 0.1498, 299.482, 43.659, 154.842, 89.749],
["Jupiter", "Carpo", 1, 50, 17056000., 0.4317, 90.372, 337.062, 51.624, 50.597],
["Jupiter", "Eukelade", 1, 50, 23323000., 0.2619, 309.685, 204.846, 165.265, 193.558],
["Jupiter", "Cyllene", 1, 50, 23800000., 0.4155, 187.429, 128.345, 150.336, 252.611],
["Jupiter", "Kore", 1, 50, 24482000., 0.3313, 138.071, 33.416, 145.173, 313.355],
["Jupiter", "Herse", 1, 50, 23408000., 0.2541, 330.295, 141.667, 164.964, 295.702],
["Jupiter", "S/2000 J11", 1, 50, 12297000., 0.2320, 173.544, 309.734, 28.631, 294.497],
["Jupiter", "S/2003 J2", 1, 50, 28347000., 0.4100, 165.201, 237.932, 157.291, 344.782],
["Jupiter", "S/2003 J3", 1, 50, 20221000., 0.1969, 66.338, 311.780, 147.547, 231.489],
["Jupiter", "S/2003 J4", 1, 50, 23929000., 0.3624, 197.401, 260.480, 149.589, 179.131],
["Jupiter", "S/2003 J5", 1, 50, 23495000., 0.2476, 90.066, 336.636, 165.248, 176.683],
["Jupiter", "S/2003 J9", 1, 50, 23385000., 0.2632, 292.662, 348.415, 165.047, 44.321],
["Jupiter", "S/2003 J10", 1, 50, 23042000., 0.4299, 170.833, 258.937, 165.073, 151.911],
["Jupiter", "S/2003 J12", 1, 50, 17830000., 0.4904, 13.288, 38.543, 151.003, 65.530],
["Jupiter", "S/2003 J15", 1, 50, 22627000., 0.1899, 18.405, 58.865, 146.492, 236.674],
["Jupiter", "S/2003 J16", 1, 50, 21097000., 0.2281, 57.681, 307.563, 148.683, 16.883],
["Jupiter", "S/2003 J18", 1, 50, 20508000., 0.0895, 130.894, 202.160, 146.077, 158.247],
["Jupiter", "S/2003 J19", 1, 50, 23533000., 0.2552, 176.668, 223.035, 165.116, 27.442],
["Jupiter", "S/2003 J23", 1, 50, 23567000., 0.2746, 255.114, 144.222, 146.424, 41.706],
["Jupiter", "S/2010 J1", 1, 50, 23449000., 0.2491, 189.230, 160.525, 165.100, 282.871],
["Jupiter", "S/2010 J2", 1, 50, 21004000., 0.2267, 18.252, 312.074, 148.673, 5.802],
["Jupiter", "S/2011 J1", 1, 50, 23446000., 0.2534, 31.514, 256.027, 165.318, 250.728],
["Jupiter", "S/2011 J2", 1, 50, 23124000., 0.3493, 270.154, 285.597, 153.597, 24.866],
["Saturn", "Mimas", 3790, 208, 185539., 0.0196, 332.499, 14.848, 1.574, 173.027],
["Saturn", "Enceladus", 10800, 257, 238042., 0.0000, 0.076, 199.686, 0.003, 342.507],
["Saturn", "Tethys", 61800, 538, 294672., 0.0001, 45.202, 243.367, 1.091, 259.842],
["Saturn", "Dione", 110000, 563, 377415., 0.0022, 284.315, 322.232, 0.028, 290.415],
["Saturn", "Rhea", 231000, 765, 527068., 0.0002, 241.619, 179.781, 0.333, 351.042],
["Saturn", "Titan", 13455000, 2575, 1221865., 0.0288, 180.532, 163.310, 0.306, 28.060],
["Saturn", "Hyperion", 560, 180, 1500933., 0.0232, 303.178, 86.342, 0.615, 263.847],
["Saturn", "Iapetus", 181000, 746, 3560854., 0.0293, 271.606, 201.789, 8.298, 81.105],
["Saturn", "Phoebe", 1, 50, 12947918., 0.1634, 342.500, 53.038, 175.243, 241.086],
["Saturn", "Janus", 190, 102, 151450., 0.0098, 16.012, 17.342, 0.165, 154.175],
["Saturn", "Epimetheus", 53, 65, 151450., 0.0161, 88.975, 80.377, 0.353, 192.762],
["Saturn", "Helene", 3, 99, 377444., 0.0000, 33.134, 43.186, 0.213, 163.112],
["Saturn", "Telesto", 1, 50, 294720., 0.0002, 119.135, 260.157, 1.180, 229.182],
["Saturn", "Calypso", 1, 50, 294721., 0.0005, 17.470, 156.660, 1.500, 314.226],
["Saturn", "Atlas", 1, 50, 137774., 0.0011, 210.851, 283.282, 0.003, 236.422],
["Saturn", "Prometheus", 16, 50, 139429., 0.0022, 37.514, 96.886, 0.007, 319.176],
["Saturn", "Pandora", 15, 50, 141810., 0.0042, 66.248, 125.112, 0.050, 147.272],
["Saturn", "Pan", 1, 50, 133585., 0.0000, 103.331, 351.187, 0.000, 52.076],
["Saturn", "Methone", 1, 50, 194402., 0.0000, 134.636, 71.189, 0.013, 313.562],
["Saturn", "Pallene", 1, 50, 212282., 0.0040, 16.074, 356.229, 0.001, 123.180],
["Saturn", "Polydeuces", 1, 50, 377222., 0.0191, 311.847, 89.307, 0.175, 67.936],
["Saturn", "Daphnis", 1, 50, 136504., 0.0000, 266.931, 113.790, 0.003, 132.867],
["Saturn", "Anthe", 1, 50, 196888., 0.0011, 138.902, 190.473, 0.015, 287.852],
["Saturn", "Aegaeon", 1, 50, 167425., 0.0002, 152.905, 322.771, 0.001, 317.202],
["Saturn", "Ymir", 1, 50, 23128000., 0.3338, 21.352, 228.673, 173.497, 192.937],
["Saturn", "Paaliaq", 1, 50, 15204000., 0.3325, 237.522, 321.654, 46.228, 330.022],
["Saturn", "Tarvos", 1, 50, 18243000., 0.5382, 274.104, 265.783, 33.725, 102.504],
["Saturn", "Ijiraq", 1, 50, 11408000., 0.2717, 92.899, 17.328, 47.485, 130.779],
["Saturn", "Suttungr", 1, 50, 19468000., 0.1139, 34.281, 321.133, 175.815, 227.259],
["Saturn", "Kiviuq", 1, 50, 11384000., 0.3325, 90.205, 172.018, 46.764, 353.584],
["Saturn", "Mundilfari", 1, 50, 18653000., 0.2097, 309.694, 92.821, 167.439, 82.856],
["Saturn", "Albiorix", 1, 50, 16393000., 0.4797, 55.932, 32.828, 34.060, 102.512],
["Saturn", "Skathi", 1, 50, 15635000., 0.2718, 203.517, 114.689, 152.633, 286.599],
["Saturn", "Erriapus", 1, 50, 17602000., 0.4722, 282.522, 294.829, 34.481, 150.985],
["Saturn", "Siarnaq", 1, 50, 18182000., 0.2802, 65.929, 201.288, 45.809, 47.826],
["Saturn", "Thrymr", 1, 50, 20418000., 0.4659, 125.404, 30.075, 177.659, 285.762],
["Saturn", "Narvi", 1, 50, 19349000., 0.4296, 169.959, 114.172, 145.731, 174.435],
["Saturn", "Aegir", 1, 50, 20751000., 0.2524, 242.651, 26.017, 166.668, 179.064],
["Saturn", "Bebhionn", 1, 50, 17116000., 0.4682, 358.141, 168.045, 35.101, 199.128],
["Saturn", "Bergelmir", 1, 50, 19336000., 0.1420, 133.400, 306.494, 158.557, 202.164],
["Saturn", "Bestla", 1, 50, 20209000., 0.5145, 81.185, 239.156, 145.136, 288.308],
["Saturn", "Farbauti", 1, 50, 20390000., 0.2414, 342.995, 282.813, 156.520, 135.109],
["Saturn", "Fenrir", 1, 50, 22454000., 0.1347, 120.982, 131.678, 164.963, 226.595],
["Saturn", "Fornjot", 1, 50, 25146000., 0.2077, 324.787, 214.499, 170.372, 259.946],
["Saturn", "Hati", 1, 50, 19868000., 0.3710, 21.286, 163.640, 165.808, 324.380],
["Saturn", "Hyrrokkin", 1, 50, 18440000., 0.3359, 273.076, 291.841, 151.536, 45.402],
["Saturn", "Kari", 1, 50, 22093000., 0.4756, 163.935, 286.021, 156.067, 281.211],
["Saturn", "Loge", 1, 50, 23059000., 0.1862, 32.821, 337.237, 167.689, 343.811],
["Saturn", "Skoll", 1, 50, 17668000., 0.4636, 193.115, 44.965, 161.010, 296.623],
["Saturn", "Surtur", 1, 50, 22941000., 0.4459, 303.662, 136.191, 169.688, 236.537],
["Saturn", "Jarnsaxa", 1, 50, 19354000., 0.2178, 237.422, 198.750, 163.649, 22.519],
["Saturn", "Greip", 1, 50, 18457000., 0.3146, 152.160, 314.541, 174.800, 349.350],
["Saturn", "Tarqeq", 1, 50, 17962000., 0.1675, 34.767, 161.020, 46.291, 83.291],
["Saturn", "S/2004 S7", 1, 50, 21000000., 0.5290, 84.036, 79.762, 165.693, 341.236],
["Saturn", "S/2004 S12", 1, 50, 19886000., 0.3268, 87.128, 1.599, 165.261, 307.942],
["Saturn", "S/2004 S13", 1, 50, 18406000., 0.2591, 346.186, 41.077, 168.798, 205.701],
["Saturn", "S/2004 S17", 1, 50, 19448000., 0.1795, 180.792, 228.545, 168.239, 26.664],
["Saturn", "S/2006 S1", 1, 50, 18780000., 0.1412, 154.950, 96.596, 156.180, 336.641],
["Saturn", "S/2006 S3", 1, 50, 22428000., 0.3792, 188.728, 167.147, 158.631, 206.993],
["Saturn", "S/2007 S2", 1, 50, 16718000., 0.1791, 57.720, 84.066, 174.057, 111.277],
["Saturn", "S/2007 S3", 1, 50, 18938000., 0.1853, 111.854, 292.691, 177.595, 276.824],
["Uranus", "Ariel", 129000, 581.1, 190900., 0.0012, 115.349, 39.481, 0.041, 22.394],
["Uranus", "Umbriel", 122000, 584.7, 266000., 0.0039, 84.709, 12.469, 0.128, 33.485],
["Uranus", "Titania", 342000, 788.9, 436300., 0.0011, 284.400, 24.614, 0.079, 99.771],
["Uranus", "Oberon", 288000, 761.4, 583500., 0.0014, 104.400, 283.088, 0.068, 279.771],
["Uranus", "Miranda", 6600, 240, 129900., 0.0013, 68.312, 311.330, 4.338, 326.438],
["Uranus", "Cordelia", 1, 50, 49800., 0.0003, 136.827, 254.805, 0.085, 38.374],
["Uranus", "Ophelia", 1, 50, 53800., 0.0099, 17.761, 116.259, 0.104, 164.048],
["Uranus", "Bianca", 1, 50, 59200., 0.0009, 8.293, 138.486, 0.193, 93.220],
["Uranus", "Cressida", 1, 50, 61800., 0.0004, 44.236, 233.795, 0.006, 99.403],
["Uranus", "Desdemona", 1, 50, 62700., 0.0001, 183.285, 184.627, 0.113, 306.089],
["Uranus", "Juliet", 1, 50, 64400., 0.0007, 223.819, 244.696, 0.065, 200.155],
["Uranus", "Portia", 1, 50, 66100., 0.0001, 222.433, 218.312, 0.059, 260.067],
["Uranus", "Rosalind", 1, 50, 69900., 0.0001, 140.477, 136.181, 0.279, 12.847],
["Uranus", "Belinda", 1, 50, 75300., 0.0001, 42.406, 357.224, 0.031, 279.337],
["Uranus", "Puck", 1, 50, 86000., 0.0001, 177.094, 245.796, 0.319, 268.734],
["Uranus", "Perdita", 1, 50, 76417., 0.0116, 253.925, 192.405, 0.470, 309.376],
["Uranus", "Mab", 1, 50, 97736., 0.0025, 249.565, 273.769, 0.134, 350.737],
["Uranus", "Cupid", 1, 50, 74392., 0.0013, 247.608, 163.830, 0.099, 182.793],
["Uranus", "Caliban", 1, 50, 7231100., 0.1812, 354.339, 7.271, 141.529, 171.189],
["Uranus", "Sycorax", 1, 50, 12179400., 0.5219, 20.103, 266.583, 159.420, 263.034],
["Uranus", "Prospero", 1, 50, 16276800., 0.4445, 174.152, 233.586, 151.830, 319.003],
["Uranus", "Setebos", 1, 50, 17420400., 0.5908, 359.953, 179.449, 158.235, 250.235],
["Uranus", "Stephano", 1, 50, 8007400., 0.2248, 14.956, 270.163, 143.819, 191.411],
["Uranus", "Trinculo", 1, 50, 8505200., 0.2194, 158.688, 180.374, 166.971, 193.755],
["Uranus", "Francisco", 1, 50, 4282900., 0.1324, 140.644, 3.202, 147.250, 100.738],
["Uranus", "Margaret", 1, 50, 14146700., 0.6772, 90.017, 322.187, 57.367, 7.067],
["Uranus", "Ferdinand", 1, 50, 20430000., 0.3993, 156.298, 26.163, 169.793, 217.350],
["Neptune", "Triton", 2140000, 1353, 354759., 0.0000, 66.142, 352.257, 156.865, 177.608],
["Neptune", "Nereid", 3000, 170, 5513818., 0.7507, 281.117, 216.692, 7.090, 335.570],
["Neptune", "Naiad", 20, 48, 48227., 0.0003, 2.045, 30.035, 4.691, 42.279],
["Neptune", "Thalassa", 40, 54, 50074., 0.0002, 237.065, 262.923, 0.135, 145.980],
["Neptune", "Despina", 200, 90, 52526., 0.0002, 176.857, 230.812, 0.068, 77.060],
["Neptune", "Galatea", 400, 102, 61953., 0.0001, 343.011, 65.999, 0.034, 37.247],
["Neptune", "Larissa", 500, 108, 73548., 0.0014, 249.891, 166.246, 0.205, 308.127],
["Neptune", "Proteus", 5000, 220, 117646., 0.0005, 67.968, 250.938, 0.075, 315.131],
["Neptune", "S/2004 N1", 1, 10, 105284., 0.0000, 0.000, 302.652, 0.000, 0.000],
["Neptune", "Halimede", 20, 30, 16681000., 0.2909, 162.119, 105.258, 112.898, 217.288],
["Neptune", "Psamathe", 2, 20, 46705000., 0.4617, 144.158, 190.027, 137.679, 298.074],
["Neptune", "Sao", 10, 20, 22619000., 0.2827, 65.047, 168.139, 49.907, 60.354],
["Neptune", "Laomedeia", 10, 20, 23613000., 0.4339, 140.107, 285.863, 34.049, 59.124],
["Neptune", "Neso", 20, 30, 50258000., 0.4243, 86.441, 260.648, 131.265, 49.151]
]
def new_kepler():
converter = nbody_system.nbody_to_si(1|units.MSun,1|units.AU)
kepler = Kepler(converter)
kepler.initialize_code()
return kepler
def get_position(mass_sun, mass_planet, ecc, semi, mean_anomaly, incl, argument, longitude, delta_t=0.|units.day):
"""
cartesian position and velocity from orbital elements,
where the orbit is evolved from given mean_anomaly
by time delta_t
argument -- argument of perihelion
longitude -- longitude of ascending node
"""
kepler = new_kepler()
kepler.initialize_from_elements(mass=(mass_sun+mass_planet),
semi=semi,
ecc=ecc,
mean_anomaly=mean_anomaly)
kepler.transform_to_time(time=delta_t)
r = kepler.get_separation_vector()
v = kepler.get_velocity_vector()
kepler.stop()
a1 = ([numpy.cos(longitude), -numpy.sin(longitude), 0.0], [numpy.sin(longitude), numpy.cos(longitude), 0.0], [0.0, 0.0, 1.0])
a2 = ([1.0, 0.0, 0.0], [0.0, numpy.cos(incl), -numpy.sin(incl)], [0.0, numpy.sin(incl), numpy.cos(incl)])
a3 = ([numpy.cos(argument), -numpy.sin(argument), 0.0], [numpy.sin(argument), numpy.cos(argument), 0.0], [0.0, 0.0, 1.0])
A = numpy.dot(numpy.dot(a1,a2),a3)
print(A, r)
# old version from P2.7
# r_vec = numpy.dot(A,numpy.reshape(r,3,1))
# v_vec = numpy.dot(A,numpy.reshape(v,3,1))
r_vec = numpy.dot(A,numpy.reshape(r,3,'F'))
v_vec = numpy.dot(A,numpy.reshape(v,3,'F'))
# for relative vectors
r[0] = r_vec[0]
r[1] = r_vec[1]
r[2] = r_vec[2]
v[0] = v_vec[0]
v[1] = v_vec[1]
v[2] = v_vec[2]
return r,v
def get_moons_for_planet(planet, delta_JD=0.|units.day):
"""
The Earth's moon
as for JD = 2457099.500000000 = A.D. 2015-Mar-18 00:00:00.0000 (CT)
https://ssd.jpl.nasa.gov/?sat_elem
"""
data = numpy.array([tuple(entry) for entry in _lunar_data],
dtype=[('planet_name','S10'), ('name','S10'),
('mass','<f8'), ('radius','<f8'), ('semimajor_axis','<f8'),
('eccentricity','<f8'), ('argument_of_peri','<f8'),
('mean_anomaly','<f8'), ('inclination','<f8'), ('longitude_oan','<f8')])
moon_data = data[data['planet_name']==planet.name.encode('UTF-8')]
print("Planet=", planet.name, "moon=", moon_data["name"])
moons = Particles()
if len(moon_data["name"]):
print(len(moon_data["name"]))
for moon in moon_data:
#print moon
r, v = get_position(planet.mass,
moon["mass"] * 1.e+16 | units.kg,
moon["eccentricity"],
moon["semimajor_axis"]|units.km,
numpy.deg2rad(moon["mean_anomaly"]),
numpy.deg2rad(moon["inclination"]),
numpy.deg2rad(moon["longitude_oan"]),
numpy.deg2rad(moon["argument_of_peri"]),
delta_t=delta_JD)
single_moon = Particle()
single_moon.type = "moon"
single_moon.name = moon["name"]
single_moon.mass = moon["mass"] * 1.e+16 | units.kg
single_moon.hostname = moon["planet_name"]
single_moon.radius = moon["radius"] | units.km
single_moon.position = r
single_moon.position += planet.position
single_moon.velocity = v
single_moon.velocity += planet.velocity
moons.add_particle(single_moon)
return moons
def new_lunar_system_in_time(time_JD=2457099.5|units.day):
"""
Initial conditions of Solar system --
particle set with the sun + eight moons,
at the center-of-mass reference frame.
Defined attributes:
name, mass, radius, x, y, z, vx, vy, vz
"""
time_0 = 2457099.5 | units.day
delta_JD = time_JD-time_0
solar_system = solar_system_in_time(time_JD)
solar_system[0].type = "star"
solar_system[0].name = "sun"
solar_system[1:].type = "planet"
for pi in solar_system:
moons = get_moons_for_planet(pi, delta_JD=delta_JD)
solar_system.add_particles(moons)
solar_system.move_to_center()
### to compare with JPL, relative positions and velocities need to be corrected for the
# Sun's vectors with respect to the barycenter
#r_s = (3.123390770608490E-03, -4.370830943817017E-04, -1.443425433116342E-04) | units.AU
#v_s = (3.421633816761503E-06, 5.767414405893875E-06, -8.878039607570240E-08) | (units.AU / units.day)
#print sun
#print moons.position.in_(units.AU) + r_s
#print moons.velocity.in_(units.AU/units.day) + v_s
return solar_system
def new_lunar_system(Julian_date=-1|units.day):
return new_lunar_system_in_time(Julian_date)
def new_option_parser():
from amuse.units.optparse import OptionParser
result = OptionParser()
result.add_option("-d", dest="Julian_date", unit=units.day,
type=float, default = 2438871.5|units.day,
help="julian date [%default]")
return result
if __name__ in ('__main__', '__plot__'):
o, arguments = new_option_parser().parse_args()
lunar_system = new_lunar_system(o.Julian_date)
print(lunar_system)
| 21,531
| 65.869565
| 127
|
py
|
amuse
|
amuse-main/src/amuse/ic/flatimf.py
|
"""
Flat initial mass function (IMF)
This module contains functions used to generate realisations of a
logarithmically flat IMF.
"""
import numpy
from amuse.units import units, nbody_system
__all__ = ["new_flat_mass_distribution", "new_flat_mass_distribution_nbody"]
class FlatIMF(object):
def __init__(self, mass_min = 0.1 | units.MSun, mass_max = 125.0 | units.MSun):
self.mass_min = mass_min
self.mass_max = mass_max
self.random = numpy.random
def mass_mean(self):
return ((self.mass_max - self.mass_min) /
numpy.log(self.mass_max / self.mass_min)).as_quantity_in(self.mass_min.unit)
def mass(self, random_number):
return self.mass_min * (self.mass_max / self.mass_min)**random_number
def next_mass(self,N=1):
return self.mass(self.random.random(N))
def next_set(self, number_of_stars):
set_of_masses=self.next_mass(number_of_stars).in_(self.mass_min.unit)
total_mass=set_of_masses.sum()
return (total_mass, set_of_masses)
def new_flat_mass_distribution(number_of_particles, *list_arguments, **keyword_arguments):
"""Returns a logarithmically flat mass distribution in SI units.
:argument mass_min: the minimum mass of the distribution (defaults to 0.1 MSun)
:argument mass_max: the maximum mass of the distribution (defaults to 125.0 MSun)
"""
uc = FlatIMF(*list_arguments, **keyword_arguments)
return uc.next_mass(number_of_particles).as_quantity_in(uc.mass_min.unit)
def new_flat_mass_distribution_nbody(number_of_particles, **keyword_arguments):
"""Returns a logarithmically flat mass distribution in nbody masses.
All masses will be scaled so that the total mass is always 1.0.
:argument mass_min: the minimum mass of the distribution (defaults to 0.1)
:argument mass_max: the maximum mass of the distribution (defaults to 125.0)
"""
if not 'mass_min' in keyword_arguments:
keyword_arguments['mass_min'] = 0.1 | nbody_system.mass
if not 'mass_max' in keyword_arguments:
keyword_arguments['mass_max'] = 125.0 | nbody_system.mass
uc = FlatIMF(**keyword_arguments)
total_mass, result = uc.next_set(number_of_particles)
result *= (1.0 | total_mass.unit) / total_mass
return result
| 2,352
| 36.951613
| 90
|
py
|
amuse
|
amuse-main/src/amuse/ic/molecular_cloud.py
|
"""
Generate a molecular cloud of SPH particles
"""
from amuse.ext.molecular_cloud import molecular_cloud
def new_molecular_cloud(
nf=32, power=-3., targetN=10000, ethep_ratio=0.01,
convert_nbody=None, ekep_ratio=1., seed=None, base_grid=None,
):
return molecular_cloud(
nf=nf, power=power, targetN=targetN, ethep_ratio=ethep_ratio,
convert_nbody=convert_nbody, ekep_ratio=ekep_ratio, seed=seed,
base_grid=base_grid,
).result
| 468
| 28.3125
| 70
|
py
|
amuse
|
amuse-main/src/amuse/ic/fractalcluster.py
|
from amuse.community.fractalcluster.interface import MakeFractalCluster
from amuse.community.fractalcluster.interface import new_fractal_cluster_model
| 151
| 49.666667
| 78
|
py
|
amuse
|
amuse-main/src/amuse/ic/limepy.py
|
from amuse.support.exceptions import AmuseWarning
from amuse.datamodel import Particles, ParticlesWithUnitsConverted
from amuse.units import nbody_system
from amuse.community import LiteratureReferencesMixIn
try:
from ._limepy import limepy, sample
scipy_imported = True
except ImportError:
raise
scipy_imported = False
AmuseWarning("import limepy failed, maybe scipy is not installed")
class Limepy(LiteratureReferencesMixIn):
"""
LIMEPY : Lowered Isothermal Model Explorer in PYthon
for help:
print help(limepy.limepy)
print help(limepy.sample)
Relevant references:
.. [#] Gieles & Zocchi 2015, MNRAS, 454,576
"""
def __init__(self, *args, **kwargs):
LiteratureReferencesMixIn.__init__(self)
kwargs["M"] = 1
kwargs["G"] = 1
kwargs["rv"] = 1
self.model = limepy(*args, **kwargs)
self.kwargs = kwargs
@property
def result(self):
stars = sample(self.model, **self.kwargs)
self.sample = stars
p = Particles(stars.N)
p.mass = stars.m | nbody_system.mass
p.x = stars.x | nbody_system.length
p.y = stars.y | nbody_system.length
p.z = stars.z | nbody_system.length
p.vx = stars.vx | nbody_system.length / nbody_system.time
p.vy = stars.vy | nbody_system.length / nbody_system.time
p.vz = stars.vz | nbody_system.length / nbody_system.time
return p
def new_limepy_model(*args, **kwargs):
conv = kwargs.pop("converter", None)
l = Limepy(*args, **kwargs)
p = l.result
if conv is not None:
p = ParticlesWithUnitsConverted(
p, conv.as_converter_from_si_to_generic())
return p
| 1,724
| 25.953125
| 70
|
py
|
amuse
|
amuse-main/src/amuse/ic/millerscalo.py
|
"""
Miller & Scalo (1979) initial mass function (IMF)
This module contains a function used to generate realisations of the
Miller & Scalo (1979) initial mass function (IMF).
"""
from amuse.ic.brokenimf import new_miller_scalo_mass_distribution
__all__ = ["new_miller_scalo_mass_distribution"]
| 295
| 31.888889
| 69
|
py
|
amuse
|
amuse-main/src/amuse/ic/__init__.py
|
"""
Initial Conditions
This module contains a number of packages with routines to generate initial conditions:
Initial stellar mass generators:
brokenimf - realisations of multiple-part power-law IMFs
flatimf - logarithmically flat IMF
kroupa - Kroupa (2001) initial mass function
millerscalo - Miller & Scalo (1979) initial mass function
salpeter - Salpeter (1955) initial mass function
scalo - Scalo (1986) initial mass function
Initial position generators:
fractalcluster - see amuse.community.fractalcluster
gasplummer - Plummer (1911) models consisting of (SPH) gas particles
isotropic_cloud - Spherical isotropic (Oort) cloud
kingmodel - King (1966) model
limepy - LIMEPY : Lowered Isothermal Model Explorer in PYthon
make_planets_oligarch - Make planets based on the an assumption of oligarchical planetary growth.
mameclot - see amuse.community.mameclot
molecular_cloud - molecular cloud with generated velocity field
plummer - Plummer (1911) model generator
solar_system_moons - Moons in the Solar system
solarsystem - Sun and planets
"""
| 1,229
| 42.928571
| 97
|
py
|
amuse
|
amuse-main/src/amuse/ic/brokenimf.py
|
"""
Broken power-law initial mass function (IMF)
This module contains functions used to generate realisations of multiple-part
power-law IMFs such as Kroupa (2001), Scalo (1986), Miller & Scalo (1979).
"""
import numpy
import numpy.random
from amuse.support import exceptions
from amuse.units import units
from amuse.units.quantities import AdaptingVectorQuantity
__all__ = [
"MultiplePartIMF",
"new_broken_power_law_mass_distribution",
"new_scalo_mass_distribution",
"new_miller_scalo_mass_distribution",
"new_kroupa_mass_distribution",
]
class MultiplePartIMF(object):
def __init__(
self,
mass_boundaries=[0.1, 125.0] | units.MSun,
mass_min=None,
mass_max=None,
alphas=[-2.35],
random=True
):
# Sanity check
if mass_min is not None and mass_max is not None:
if mass_min > mass_max:
raise exceptions.AmuseException(
"mass_min cannot be larger than mass_max!"
)
self.mass_boundaries = mass_boundaries
self.alphas = numpy.array(alphas)
first_bin = 0
if mass_min is not None and mass_min > self.mass_boundaries[0]:
self.mass_boundaries[0] = mass_min
for i, left_boundary in enumerate(self.mass_boundaries[:-1]):
if self.mass_boundaries[i+1] <= mass_min:
# shift the leftmost bin because it won't be used
first_bin += 1
self.mass_boundaries[i+1] = mass_min
else:
break
self.mass_boundaries = self.mass_boundaries[first_bin:]
self.alphas = self.alphas[first_bin:]
last_bin = 0
if mass_max is not None and mass_max < mass_boundaries[-1]:
mass_boundaries[-1] = mass_max
for i, right_boundary in enumerate(self.mass_boundaries[1:]):
if self.mass_boundaries[-1-i] >= mass_max:
# shift the rightmost bin because it won't be used
last_bin -= 1
self.mass_boundaries[last_bin] = mass_max
else:
break
if last_bin < -1:
self.mass_boundaries = self.mass_boundaries[:last_bin+1]
self.alphas = self.alphas[:last_bin+1]
if random:
if random is True:
self.random = numpy.random.random
else:
self.random = random.random_sample
else:
self.random = self.evenly_distributed
self.number_of_bins = len(self.alphas)
self.fraction_per_bin = self.calculate_fraction_per_bin()
self.cumulative_fractions = numpy.array(
[
sum(self.fraction_per_bin[:i])
for i in range(self.number_of_bins+1)
]
)
self.cumulative_fractions[-1] = 1.0 # In case of round-off errors
self.factors = pow(
self.mass_boundaries[1:] / self.mass_boundaries[:-1],
self.alphas + 1.0
) - 1.0
self.inv_alpha1s = numpy.array(
[
numpy.inf
if alpha == -1
else (1.0 / (alpha + 1.0)) for alpha in self.alphas
]
)
def evenly_distributed(self, size=1):
return numpy.linspace(0.0, 1.0, size)
def calculate_fraction_per_bin(self):
result = []
mass_boundaries = self.mass_boundaries.value_in(units.MSun)
for i, alpha in enumerate(self.alphas):
if alpha == -1:
factor = numpy.log(mass_boundaries[i+1] / mass_boundaries[i])
else:
factor = (
mass_boundaries[i+1]**(alpha+1)
- mass_boundaries[i]**(alpha+1)
) / (alpha+1)
j = 0
for j in range(self.number_of_bins - i - 1):
factor *= (
mass_boundaries[-j-2]**(
self.alphas[-j-1]-self.alphas[-j-2]
)
)
result.append(factor)
total = sum(result, 0.0)
return numpy.array(result)/total if bool(total) else numpy.array(result)
def mass_mean(self):
result = 0 | units.MSun
for i in range(self.number_of_bins):
a1 = self.alphas[i] + 1
a2 = self.alphas[i] + 2
m_low = self.mass_boundaries[i]
m_high = self.mass_boundaries[i+1]
if abs(a1) < 1.0e-10:
mean_of_bin = (
(m_high**a2 - m_low**a2)
/ (a2 * numpy.log(m_high/m_low))
)
elif abs(a2) < 1.0e-10:
mean_of_bin = (
(a1 / (m_high**a1 - m_low**a1))
* numpy.log(m_high/m_low)
)
else:
mean_of_bin = (
(a1 / (m_high**a1 - m_low**a1))
* ((m_high**a2 - m_low**a2) / a2)
)
result += self.fraction_per_bin[i] * mean_of_bin
return result
def mass(self, random_numbers):
indices = numpy.searchsorted(
self.cumulative_fractions[:-1], random_numbers, 'right'
) - 1
scaled = (
(random_numbers - self.cumulative_fractions[indices])
/ (
self.cumulative_fractions[indices+1]
- self.cumulative_fractions[indices]
)
)
result = numpy.empty_like(random_numbers)
zerodiv = self.alphas[indices] == -1
normal = numpy.logical_not(zerodiv)
result[zerodiv] = pow(
self.mass_boundaries[1:][indices[zerodiv]]
/ self.mass_boundaries[:-1][indices[zerodiv]],
scaled[zerodiv]
)
result[normal] = pow(
1.0 + self.factors[indices[normal]] * scaled[normal],
self.inv_alpha1s[indices[normal]]
)
return self.mass_boundaries[:-1][indices] * result
def next_mass(self, number_of_stars=1):
return self.mass(
self.random(number_of_stars)
).as_quantity_in(self.mass_boundaries.unit)
def next_set(self, number_of_stars):
set_of_masses = self.next_mass(number_of_stars)
total_mass = set_of_masses.sum()
return (total_mass, set_of_masses)
def new_broken_power_law_mass_distribution(
number_of_particles, *list_arguments, **keyword_arguments
):
"""Returns a broken (multiple-part) power-law mass distribution in SI units.
:argument mass_boundaries: the boundaries of the mass ranges (default: [0.1, 125.0] MSun)
:argument alphas: the exponents of each mass range (default: [-2.35])
"""
return MultiplePartIMF(
*list_arguments, **keyword_arguments
).next_mass(number_of_particles)
def new_scalo_mass_distribution(
number_of_particles,
mass_min=None,
mass_max=None,
random=True,
**keyword_arguments
):
"""Returns a Scalo (1986) mass distribution in SI units, with mass ranges:
[0.10, 0.18, 0.42, 0.62, 1.18, 3.5, 125.0] MSun,
and power-law exponents of each mass range:
[1.6, -1.01, -2.75, -2.08, -3.5, -2.63]
:argument mass_max: the cut-off mass (defaults to 125.0 MSun)
"""
return MultiplePartIMF(
mass_boundaries=[0.10, 0.18, 0.42, 0.62, 1.18, 3.5, 125.0] | units.MSun,
mass_min=mass_min,
mass_max=mass_max,
alphas=[1.6, -1.01, -2.75, -2.08, -3.5, -2.63],
random=random,
**keyword_arguments
).next_mass(number_of_particles)
def new_miller_scalo_mass_distribution(
number_of_particles,
mass_min=None,
mass_max=None,
random=True,
**keyword_arguments
):
"""Returns a Miller & Scalo (1979) mass distribution in SI units, with mass ranges:
[0.1, 1.0, 2.0, 10.0, 125.0] MSun,
and power-law exponents of each mass range:
[-1.25, -2.0, -2.3, -3.3]
:argument mass_max: the cut-off mass (defaults to 125.0 MSun)
"""
return MultiplePartIMF(
mass_boundaries=[0.1, 1.0, 2.0, 10.0, 125.0] | units.MSun,
mass_min=mass_min,
mass_max=mass_max,
alphas=[-1.25, -2.0, -2.3, -3.3],
random=random,
**keyword_arguments
).next_mass(number_of_particles)
def new_kroupa_mass_distribution(
number_of_particles,
mass_min=None,
mass_max=None,
random=True,
**keyword_arguments
):
"""Returns a Kroupa (2001) mass distribution in SI units, with mass ranges:
[0.01, 0.08, 0.5, 100.0] MSun,
and power-law exponents of each mass range:
[-0.3, -1.3, -2.3]
:argument mass_max: the cut-off mass (defaults to 100.0 MSun)
"""
return MultiplePartIMF(
mass_boundaries=[0.01, 0.08, 0.5, 100.0] | units.MSun,
mass_min=mass_min,
mass_max=mass_max,
alphas=[-0.3, -1.3, -2.3],
random=random,
**keyword_arguments
).next_mass(number_of_particles)
| 9,136
| 33.093284
| 93
|
py
|
amuse
|
amuse-main/src/amuse/ic/make_planets_oligarch.py
|
"""
Make planets based on the an assumption of oligarchical planetary growth.
(the formalism of Kokubo & Ida (1998))
After:
@article{0004-637X-807-2-157,
author={Scott Tremaine},
title={The Statistical Mechanics of Planet Orbits},
journal={The Astrophysical Journal},
volume={807},
number={2},
pages={157},
url={http://stacks.iop.org/0004-637X/807/i=2/a=157},
year={2015},
abstract={The final phase of terrestrial planet formation is believed to begin with a large number of planetary on nearly circular, coplanar orbits. Mutual gravitational interactions gradually excite their eccentricities until their orbits cross and they collide and merge; through this process the number of surviving bodies declines until the system contains a small number of planets on well-separated, stable orbits. In this paper we explore a simple statistical model for the orbit distribution of planets formed by this process, based on the sheared-sheet approximation and the ansatz that the planets explore uniformly all of the stable region of phase space. The model provides analytic predictions for the distribution of eccentricities and semimajor axis differences, correlations between orbital elements of nearby planets, and the complete N -planet distribution function, in terms of a single parameter, the that is determined by the planetary masses. The predicted properties are generally consistent with N -body simulations of the giant-impact phase and with the distribution of semimajor axis differences in the Kepler catalog of extrasolar planets. A similar model may apply to the orbits of giant planets if these orbits are determined mainly by dynamical evolution after the planets have formed and the gas disk has disappeared.}
}
Refers to (with the actual method as implemented here):
@article{0004-637X-775-1-53,
author={Brad M. S. Hansen and Norm Murray},
title={Testing in Situ Assembly with the Kepler Planet Candidate Sample},
journal={The Astrophysical Journal},
volume={775},
number={1},
pages={53},
url={http://stacks.iop.org/0004-637X/775/i=1/a=53},
year={2013}
}
Actual model:
@article{0004-637X-581-1-666,
author={Eiichiro Kokubo and Shigeru Ida},
title={Formation of Protoplanet Systems and Diversity of Planetary Systems},
journal={The Astrophysical Journal},
volume={581},
number={1},
pages={666},
url={http://stacks.iop.org/0004-637X/581/i=1/a=666},
year={2002},
}
"""
import numpy
from numpy import random
import time as pytime
import os.path
from amuse.units import quantities
from amuse.units import units
from amuse.units import nbody_system
from amuse.units.core import named_unit
from amuse.units.optparse import OptionParser
from amuse.datamodel import Particle, Particles
from amuse.community.kepler.interface import Kepler
from amuse.io import write_set_to_file
MEarth = named_unit("MEarth", "MEarth", 5.97219e+24 * units.kg)
def get_mass(a, surface_density_factor = 1.0, mstar = 1 | units.MSun):
s = surface_density_factor * (10.0 | (units.g / units.cm**2))
z = 2 * numpy.pi * a * s * ((a / (5.0|units.AU) ) ** -(3.0/2.0)) * 4.0 * a
return (2.0 * z ** 3 / (3.0 * mstar)).sqrt()
def get_orbital_separation(mass, a, mstar = 1 | units.MSun):
return 10.0 * a * (2*mass/(3.0 * mstar)) ** (1.0/3.0)
def get_mass_and_orbital_separation(a, surface_density_factor = 1.0, mstar = 1 | units.MSun):
mass = get_mass(a, surface_density_factor = surface_density_factor, mstar = mstar)
orbital_separation = get_orbital_separation(mass, a, mstar = mstar)
return mass, orbital_separation
def new_distribution(x0, x1, surface_density_factor = 1.0, mstar = 1 | units.MSun):
x = x0
masses = []
positions = []
while x < x1:
mass, orbital_separation = get_mass_and_orbital_separation(x, surface_density_factor = surface_density_factor, mstar = mstar)
masses.append(mass)
positions.append(x)
x += orbital_separation
return (
quantities.as_vector_quantity(masses),
quantities.as_vector_quantity(positions)
)
def is_hit(mass, target_total_mass, accurancy):
return abs((mass - target_total_mass) / target_total_mass) < accurancy
def new_planet_distribution(x0, x1, target_total_mass, accurancy, max_iterations = 1000, mstar = 1 | units.MSun):
min_surface_density_factor = 0.1
max_surface_density_factor = 10000.0
current_surface_density_factor = min_surface_density_factor
mass, pos = new_distribution(x0,x1,current_surface_density_factor, mstar = mstar)
total_mass = mass.sum()
iteration = 0
while not is_hit(total_mass, target_total_mass, accurancy):
#print iteration, total_mass / (1 | MEarth), current_surface_density_factor
iteration += 1
if iteration >= max_iterations:
break
if total_mass < target_total_mass:
min_surface_density_factor = current_surface_density_factor
elif total_mass > target_total_mass:
max_surface_density_factor = current_surface_density_factor
current_surface_density_factor = (min_surface_density_factor + max_surface_density_factor) / 2.0
mass, pos = new_distribution(x0,x1,current_surface_density_factor, mstar = mstar)
total_mass = mass.sum()
return mass, pos, current_surface_density_factor
def new_rotation_matrix_from_euler_angles(phi, theta, chi):
cosp=numpy.cos(phi)
sinp=numpy.sin(phi)
cost=numpy.cos(theta)
sint=numpy.sin(theta)
cosc=numpy.cos(chi)
sinc=numpy.sin(chi)
#see wikipedia: http://en.wikipedia.org/wiki/Rotation_matrix
return numpy.array(
[[cost*cosc, -cosp*sinc + sinp*sint*cosc, sinp*sinc + cosp*sint*cosc],
[cost*sinc, cosp*cosc + sinp*sint*sinc, -sinp*cosc + cosp*sint*sinc],
[-sint, sinp*cost, cosp*cost]])
def rotate(position, velocity, phi, theta, psi): # theta and phi in radians
Runit = position.unit
Vunit = velocity.unit
matrix = new_rotation_matrix_from_euler_angles(phi, theta, psi)
return (numpy.dot(matrix, position.value_in(Runit)) | Runit,
numpy.dot(matrix, velocity.value_in(Vunit)) | Vunit)
# select Eurler angles randomly.
def random_Euler_angles():
phi = 2*numpy.pi*random()
theta = numpy.acos(1-2*random())
chi = 2*numpy.pi*random()
return phi, theta, chi
def posvel_from_orbital_elements(Mstar, semimajor_axis, eccentricity, kepler, rng = None):
if rng is None:
rng = random
mean_anomaly = rng.uniform(0, 2*numpy.pi, 1)
kepler.initialize_from_elements(
Mstar,
semimajor_axis,
eccentricity,
mean_anomaly=mean_anomaly)
position = quantities.as_vector_quantity(kepler.get_separation_vector())
velocity = quantities.as_vector_quantity(kepler.get_velocity_vector())
return position, velocity
def make_planets(central_particle, masses, radii, density = 3 | units.g/units.cm**3, phi=None, theta=None, eccentricity = 0.0, kepler = None, rng = None):
volumes = masses / density
planet_radii = (3.0 * volumes / (4.0 * numpy.pi))**(1.0/3.0)
n = len(masses)
planet_particles = Particles(n)
planet_particles.semimajor_axis = radii
if eccentricity is None:
eccentricity = numpy.abs(rng.normal(-0.00001,0.00001,n))
planet_particles.eccentricity = eccentricity
planet_particles.mass = masses
planet_particles.radius = planet_radii
if phi is None:
phi = numpy.radians(rng.uniform(0.0, 90.0, 1)[0])#rotate under x
if theta is None:
theta0 = numpy.radians((rng.normal(-90.0,90.0,1)[0]))#rotate under y
theta0 = 0
theta_inclination = numpy.radians(rng.normal(0, 1.0, n ))
theta_inclination[0] = 0
theta = theta0 + theta_inclination
#psi = numpy.radians(rng.uniform(0, 180, 1))[0] #0 # numpy.radians(90) # numpy.radians(rng.uniform(0, 180, 1))[0]
psi = numpy.radians(rng.uniform(0.0, 180.0, 1))[0] #0 # numpy.radians(90) # numpy.radians(rng.uniform(0, 180, 1))[0]
com_particle = central_particle.copy()
for x, t in zip(iter(planet_particles), theta):
pos,vel = posvel_from_orbital_elements(com_particle.mass + x.mass, x.semimajor_axis, x.eccentricity, kepler, rng)
pos,vel = rotate(pos, vel, 0, 0, psi) # theta and phi in radians
pos,vel = rotate(pos, vel, 0, t, 0) # theta and phi in radians
pos,vel = rotate(pos, vel, phi, 0, 0) # theta and phi in radians
x.position = pos + com_particle.position
x.velocity = vel + com_particle.velocity
if False:
two_body = Particles(particles=[com_particle, x])
print("dp:", (com_particle.position - two_body.center_of_mass()).as_quantity_in(units.AU))
com_particle.mass = two_body.mass.sum()
com_particle.position = two_body.center_of_mass()
com_particle.velocity = two_body.center_of_mass_velocity()
#planet_particles.position += central_particle.position
#planet_particles.velocity += central_particle.velocity
return planet_particles
def new_system(
star_mass = 1|units.MSun,
star_radius = 1|units.RSun,
disk_minumum_radius = 0.05 | units.AU,
disk_maximum_radius = 10 | units.AU,
disk_mass = 20 | MEarth,
accurancy = 0.0001,
planet_density = 3 | units.g/units.cm**3,
rng = None,
kepler = None):
central_particle = Particle()
central_particle.mass = star_mass
central_particle.position = (0,0,0) | units.AU
central_particle.velocity = (0,0,0) | units.kms
central_particle.radius = star_radius
if rng is None:
rng = numpy.random
converter = nbody_system.nbody_to_si(1|units.MSun, 1 | units.AU)
if kepler is None:
kepler = Kepler(converter)
kepler.initialize_code()
m, r, f = new_planet_distribution(
disk_minumum_radius, disk_maximum_radius,
disk_mass,
accurancy
)
planets = make_planets(
central_particle,
m, r,
density = planet_density,
phi = 0, theta = None,
kepler = kepler,
rng = rng
)
central_particle.planets = planets
kepler.stop()
p = Particles()
p.add_particle(central_particle)
return p
def new_option_parser():
result = OptionParser()
result.add_option("--seed",
dest="seed", type="int", default = -1,
help="random number seed [%default]")
result.add_option("-o", "--output",
dest="output_filename", default = "star.h5",
help="name of the output filename [%default]")
result.add_option("-m", "--star-mass", unit=units.MSun, type="float", default = 1|units.MSun,
dest="star_mass", help='mass of the star [%default]')
result.add_option("-r", "--star-radius", unit=units.RSun, type="float", default = 1|units.RSun,
dest="star_radius", help='radius of the star [%default]')
result.add_option("--disk-r0", unit=units.AU, type="float", default = 1|units.AU,
dest="disk_minumum_radius", help='minimum radius of the disk [%default]')
result.add_option("--disk-r1", unit=units.AU, type="float", default = 100|units.AU,
dest="disk_maximum_radius", help='maximum radius of the disk [%default]')
result.add_option("--disk-mass", unit=MEarth, type="float", default = 100|MEarth,
dest="disk_mass", help='mass of the disk [%default]')
result.add_option("--planet-density", unit=units.g/units.cm**3, type="float", default = 3 | units.g/units.cm**3,
dest="planet_density", help='density of the planets (used for planet radii calculation) [%default]')
result.add_option("--accurancy", type="float", default = 0.0001,
dest="accurancy", help='how accurate should the disk mass be integrated to[%default]')
#result.add_option("--plot",
# action="store_true", dest="make_plot", default=False,
# help="make a plot of the planets")
return result
def main(
star_mass = 1|units.MSun,
star_radius = 1|units.RSun,
disk_minumum_radius = 0.05 | units.AU,
disk_maximum_radius = 10 | units.AU,
disk_mass = 200 | MEarth,
accurancy = 0.0001,
planet_density = 3 | units.g/units.cm**3,
output_filename = 'star.h5',
seed = -1):
if seed < 0:
rng = random.RandomState()
else:
rng = random.RandomState(seed)
output = new_system(
star_mass,
star_radius,
disk_minumum_radius,
disk_maximum_radius,
disk_mass,
accurancy,
planet_density,
rng = rng)
star = output[0]
print("Number of planets generated:", len(star.planets))
print("Total mass:", star.planets.mass.sum().as_quantity_in(MEarth))
for i, planet in enumerate(star.planets):
print("Planet: {0: 3d} , mass: {1: 8.3f} MEarth, a: {2: 8.2f} AU".format(i, planet.mass.value_in(MEarth), planet.semimajor_axis.value_in(units.AU)))
write_set_to_file(output, output_filename, 'hdf5', version="2.0",append_to_file = False)
if __name__ == "__main__":
main(**new_option_parser().parse_args()[0].__dict__)
| 13,570
| 38.797654
| 1,350
|
py
|
amuse
|
amuse-main/src/amuse/ic/mameclot.py
|
from amuse.community.mameclot.interface import mameclot
| 56
| 27.5
| 55
|
py
|
amuse
|
amuse-main/src/amuse/ic/isotropic_cloud.py
|
"""
Spherical isotropic (Oort) cloud -- initial conditions for a particle set
See for example:
* Duncan, M.; Quinn, T.; Tremaine, S. -- http://adsabs.harvard.edu/abs/1987AJ.....94.1330D
* Feng, F.; Bailer-Jones, C. A. L. -- http://adsabs.harvard.edu/abs/2014MNRAS.442.3653F
* Dybczynski, P. A. -- http://adsabs.harvard.edu/abs/2002A%26A...396..283D
Initial conditions -- given by distributions of orbital elements:
semi-major axes -- power law, default: dn/da ~ a^(-1.5),
eccentricities -- dn/de ~ e,
constrain on the minimum pericenter,
isotropic orbits -- distribution of orbital inclinations: cos(i) = -1--1,
longitude of ascending node: 0--2pi,
argument of periastron: 0--2pi,
mean anomaly: 0--2pi,
equal mass particles.
"""
import numpy
from amuse.units import units, nbody_system
from amuse.datamodel import Particles
from amuse.community.kepler.interface import Kepler
def random_power_min_max(size, x_min, x_max, exp_plus_one):
"""
returns random floats in the interval [x_min,x_max] drawn from distribution
pdf(x) = const * x**(exp_plus_one-1), x_min <= x <= x_max;
assuming: x_min < x_max, exp_plus_one != 0
"""
r = numpy.random.random(size=size)
x_min_gamma = x_min**exp_plus_one
x_max_gamma = x_max**exp_plus_one
return (x_min_gamma + (x_max_gamma - x_min_gamma)*r)**(1./exp_plus_one)
def relative_position_and_velocity_from_orbital_elements(mass1,
mass2,
semimajor_axis,
eccentricity,
mean_anomaly,
seed=None):
"""
Function that returns relative positions and velocity vectors or orbiters with masses
mass2 of the central body with mass mass1 in Cartesian coordinates;
for vectors of orbital elements -- semi-major axes, eccentricities, mean anomalies.
3D orientation of orbits (inclination, longitude of ascending node and argument of periapsis) are random.
(cos(incl) is uniform -1--1, longitude of ascending node and argument of periapsis are uniform 0--2pi)
Assuming mass1 is static in the center [0,0,0] m, [0,0,0] km/s (that is mass2<<mass1)
"""
position_vectors = []
velocity_vectors = []
converter = nbody_system.nbody_to_si(1|units.MSun,1|units.AU)
kepler = Kepler(converter)
kepler.initialize_code()
r_vec = (0.,0.,0.) | units.AU
v_vec = (0.,0.,0.) | units.kms
# to change seed for each particle
if seed is not None:
i=0
for m2_i, a_i, ecc_i, ma_i in zip(mass2, semimajor_axis, eccentricity, mean_anomaly):
#print m2_i, a_i, ecc_i, ma_i
if seed is not None:
kepler.set_random(seed+i)
i=i+1
kepler.initialize_from_elements(mass=(mass1+m2_i),semi=a_i,ecc=ecc_i,mean_anomaly=ma_i,random_orientation=-1)
ri = kepler.get_separation_vector()
vi = kepler.get_velocity_vector()
# this is to get ~half of the orbits retrograde (that is with inclination
# of 90--180 degrees) --> velocity = -velocity
vel_vec_dir = numpy.random.random()
if (vel_vec_dir<=0.5):
vel_orientation = 1.
else:
vel_orientation = -1.
position_vectors.append([ri[0], ri[1], ri[2]])
velocity_vectors.append([vel_orientation*vi[0], vel_orientation*vi[1], vel_orientation*vi[2]])
kepler.stop()
return position_vectors, velocity_vectors
def ecc_random_power_with_min_peri(n, semi, min_peri, power=2.):
"""
random distribution in eccentricity P(e)~e
(power = actual_exponent + 1)
with minimum pericenter of min_peri
for given semi-major axes semi
"""
x = numpy.random.power(power,size=n)
peri = semi*(1.-x)
while numpy.any(peri<min_peri):
filter_small_peri = (peri<min_peri)
n_new = sum(filter_small_peri)
#print "\t updating q", peri.min().in_(units.AU), n_new
x_random_new = numpy.random.power(power,size=n_new)
x_new = 1.*x
x_new[filter_small_peri] = x_random_new
x = 1.*x_new
peri = semi*(1.-x)
return x
class SphericalIsotropicCloud(object):
def __init__(self,
targetN,
m_star=1.|units.MSun,
m_cloud=0.|units.MSun,
a_min=3000.|units.AU,
a_max=10000.|units.AU,
q_min=32.|units.AU,
gamma=-1.5,
seed=None):
self.targetN = targetN
self.m_star = m_star
self.m_cloud = m_cloud
self.a_min = a_min
self.a_max = a_max
self.q_min = q_min
self.gamma = gamma
self.seed = seed
if (self.q_min is not None):
if (self.q_min > self.a_min):
self.a_min_q_corr = self.q_min
else:
self.a_min_q_corr = self.a_min
else:
self.a_min_q_corr = self.a_min
def new_model(self):
if self.seed is not None:
numpy.random.seed(self.seed)
a_in_au = random_power_min_max(self.targetN,
self.a_min_q_corr.value_in(units.AU),
self.a_max.value_in(units.AU),
self.gamma+1.)
a = a_in_au * 1.|units.AU
ecc = ecc_random_power_with_min_peri(self.targetN, a, self.q_min, power=2.)
mean_anomaly = 2.*numpy.pi * numpy.random.random(size=self.targetN)
m_comets = (self.m_cloud / self.targetN) * numpy.ones_like(ecc)
position_vectors, velocity_vectors = \
relative_position_and_velocity_from_orbital_elements(self.m_star,
m_comets,
a,
ecc,
mean_anomaly,
seed=self.seed)
return (m_comets, position_vectors, velocity_vectors)
@property
def result(self):
masses, position_vectors, velocity_vectors = self.new_model()
result = Particles(self.targetN)
result.mass = masses
result.position = position_vectors
result.velocity = velocity_vectors
return result
def new_isotropic_cloud(number_of_particles, *list_arguments, **keyword_arguments):
"""
Spherical isotropic cloud ~ Oort cloud given by distributions of orbital elements:
semi-major axes -- power law, default: dn/da ~ a^(-1.5),
eccentricities -- dn/de ~ e,
constrain on the minimum pericenter,
isotropic orbits -- distribution of orbital inclinations: cos(i) = -1--1,
longitude of ascending node: 0--2pi,
argument of periastron: 0--2pi,
mean anomaly: 0--2pi,
equal mass particles
The default values correspond to papers:
* Duncan, M.; Quinn, T.; Tremaine, S. -- http://adsabs.harvard.edu/abs/1987AJ.....94.1330D
* Feng, F.; Bailer-Jones, C. A. L. -- http://adsabs.harvard.edu/abs/2014MNRAS.442.3653F (their DQT model)
:argument number_of_particles: number of particles to include in the cloud
:argument m_star: mass of the central star
:argument m_cloud: total mass of the cloud (particles are equal mass)
:argument a_min: minimal semimajor axis
:argument a_max: maximal semimajor axis, a_min < a_max
:argument q_min: minimal pericenter
:argument gamma: exponent of the semimajor axis distribution, f(a) ~ a^(gamma)
:argument seed: random seed -- set to reproduce exactly the same IC
"""
uc = SphericalIsotropicCloud(number_of_particles, *list_arguments, **keyword_arguments)
return uc.result
if __name__ in ('__main__'):
cloud = new_isotropic_cloud(10)
print(cloud)
| 7,649
| 39.263158
| 113
|
py
|
amuse
|
amuse-main/src/amuse/ic/scalo.py
|
"""
Scalo (1986) initial mass function (IMF)
This module contains a function used to generate realisations of the Scalo (1986)
initial mass function (IMF).
"""
from amuse.ic.brokenimf import new_scalo_mass_distribution
__all__ = ["new_scalo_mass_distribution"]
| 263
| 28.333333
| 82
|
py
|
amuse
|
amuse-main/src/amuse/ic/kingmodel.py
|
"""
King (1966) model generator
This module contains a function used to create King models.
"""
import math
import numpy
from amuse.support import exceptions
from amuse.units import nbody_system
from amuse import datamodel
__all__ = ["new_king_model"]
class MakeKingModel(object):
def __init__(self, number_of_particles, W0, convert_nbody = None, do_scale = False,
beta = 0.0, verbose = False,center_model=True):
self.number_of_particles = number_of_particles
self.convert_nbody = convert_nbody
self.center_model=center_model
self.do_scale = do_scale
self.verbose = verbose
self.beta = beta
self.W0 = W0
self.beta_w0 = beta*W0
self.scale_fac = math.exp(self.beta_w0)
self.YMAX = 4.0 # Note: make sure YMAX is a float.
self.NG = 1000
self.g_integral = self.compute_g_integral()
self.v33 = self.compute_v33()
# // profile
self.NM = 2500
self.rr=[]; self.d=[]; self.v2=[]; self.psi=[]; self.zm=[]
self.NINDX = 100
self.index=[]
def compute_v33(self):
v33 = []
for i in range(self.NG+1):
v33.append(self.scale_fac * math.pow(((self.YMAX/self.NG) * i), 3) / 3.0)
return v33
def compute_g_integral(self):
dy = self.YMAX/self.NG
g = [0.0]
for i in range(self.NG):
g.append(g[i]+self.trapzd_gaus2(i*dy,(i+1)*dy))
return g
# Trapezoid Rule for integration, after NR.
def trapzd_gaus2(self, a, b):
eps = 1.e-10
max_steps = 50
previous_sum = -1.0e30
for i in range(max_steps):
sum = self.trapint_gaus2(a, b, i, previous_sum)
if (abs(sum - previous_sum) < eps * abs(previous_sum)): return sum
previous_sum = sum
return 0.0
# Integrate func from a to b in n steps, using the trapezoid rule.
def trapint_gaus2(self, a, b, n, previous_sum):
if (n == 0):
return 0.5 * (b - a) * (self.gaus2(a) + self.gaus2(b))
else:
base = 2**(n-1)
dx = (b - a) / base
x = a + 0.5 * dx
sum = 0.0
for i in range(base):
sum = sum + self.gaus2(x)
x = x + dx
return 0.5 * (previous_sum + (b - a)/base * sum)
def gaus2(self, x):
return x*x*math.exp(-x*x)
def gg_integral(self, y, g4_flag):
# Array g contains the indefinite integral (from 0) of y^2 exp(-y^2) dy,
# up to a maximum value of YMAX, i.e.
#
# g[i] = integral{0 to Y} y^2 exp(-y^2) dy,
#
# where Y = i*YMAX/NG (i = 0,...,NG).
#
# Function computes g2 = integral{0 to y} y^2 exp(-y^2) dy
# and g4 = integral{0 to y} y^4 exp(-y^2) dy.
if (y >= self.YMAX):
g2 = self.g_integral[self.NG]
else:
yindx = self.NG * y / self.YMAX
intyindx = int(yindx)
g2 = self.g_integral[intyindx] + (yindx-intyindx)*(self.g_integral[intyindx+1]-self.g_integral[intyindx])
if (g4_flag):
return (g2, 1.5*g2 - 0.5*y**3*math.exp(-y*y))
else:
return (g2, 0.0)
# Return density d and local velocity dispersion v2,
# given scaled potential psi (< 0).
def get_dens_and_vel(self, psi, v2_flag):
if (psi >= -self.beta_w0):
if (v2_flag): return (0.0, 1.0)
else: return 0.0
# // Distribution function is
# //
# // f(r,v) = A exp(-psi) (exp(-v^2 / 2 sig^2) - exp(psi - beta*psi0)),
# //
# // where psi = phi/sig^2 and psi0 = -w0.
# //
# // Density is the integral of 4 pi v^2 f, velocity dispersion v2
# // is (integral of 4 pi v^4 f) / density.
p_max = -psi - self.beta_w0 # // v_max^2 / (2 sig^2)
y_max = math.sqrt(p_max)
ep = math.exp(-psi)
(g2, g4) = self.gg_integral(y_max, v2_flag)
dens = ep * g2 - self.scale_fac * y_max * p_max / 3
# // Note that this expression for dens excludes an overall factor
# // of 8 pi sqrt(2) sig^3 A. Scaling to the central density
# // is handled elsewhere (in rhs).
if (v2_flag):
v2 = 2 * (ep * g4 - 0.2 * self.scale_fac * y_max * p_max * p_max) / dens
return (dens, v2)
else:
return dens
# // The unit of v2 is sig^2.
def rhs(self, y, x):
# // Define RHS of ODE, for use by rk4.
ypr = []
ypr.append(y[1])
if (x <= 0):
d = 1
else:
d = (self.get_dens_and_vel(y[0]/x, False)) * self.dc_inverse
# // d is rho/rho_0
# // False suppresses vel
ypr.append(9 * x * d)
return ypr
# // Runge-Kutta-4 method
def step(self, y, x, dx, N):
# Doesn't look very efficient...
dy1=[]; dy2=[]; dy3=[]; dy4=[]
y1=[]; y2=[]; y3=[]; y4=[]
dydx = self.rhs(y, x)
for i in range(N):
dy1.append(dx*dydx[i])
y1.append(y[i] + 0.5*dy1[i])
dydx = self.rhs(y1, x+0.5*dx)
for i in range(N):
dy2.append(dx*dydx[i])
y2.append(y[i] + 0.5*dy2[i])
dydx = self.rhs(y2, x+0.5*dx)
for i in range(N):
dy3.append(dx*dydx[i])
y3.append(y[i] + dy3[i])
dydx = self.rhs(y3, x+dx)
for i in range(N):
dy4.append(dx*dydx[i])
y[i] = y[i] + (dy1[i] + 2*dy2[i] + 2*dy3[i] + dy4[i])/6.0
return y
def rk4(self, x, x_next, y, N, dx):
# // Integrate the y(x) from x to x_next, using an integration step of dx.
# // On entry y is y at the initial x. On exit, x is replaced by x_next
# // and y is y(x).
while (x < x_next - .5*dx): # // NOTE!! Beware of rounding error!
y = self.step(y, x, dx, N)
x = x + dx
return (x, y)
def poisson(self):
# // Self-contained 1-D (spherical) Poisson's equation solver.
# // Currently knows about normal and lowered King models.
# //
# // Input: nmax is the maximum number of points allowed
# // w0 is the dimensionless central potential
# // iout allows messages if nonzero
#
# // Output: x is scaled radius (r/rc)
# // d is scaled density (1 at center)
# // v2 is scaled velocity dispersion (1 at center)
# // psi is scaled potential (-W0 at center)
# // zm is cumulative mass (scaling from x, d scalings)
# // nprof is the actual number of points generated
# // v20 is the central 3-D velocity dispersion (unit = sig^2)
RLIN = 0.25
NLIN = 105
RMAX = 1e4
nmax = self.NM
psi0 = - abs(self.W0)
# // Initialize at center of cluster.
y = [0.0, psi0]
xn = 0.0
self.rr.append(0.0)
self.psi.append(psi0)
self.zm.append(0.0)
# // Establish density scaling factor.
(density, velocity_dispersion) = self.get_dens_and_vel(psi0, True)
self.d.append(density)
self.v2.append(velocity_dispersion)
self.dc_inverse = 1./density
fac = math.pow(10, (math.log10(RMAX/RLIN) / (nmax-NLIN)))
#// Poisson's equation is:
#//
#// (1/r^2) d/dr (r^2 dphi/dr) = 4 pi G rho,
#//
#// where r is radius, phi is potential, and rho is density, given
#// (for equal-mass stars) by
#//
#// rho = {integral (v < ve)} 4 pi v^2 f(v) dv,
#//
#// where ve is the escape velocity,
#//
#// ve^2 = -2 phi.
#//
#// The (3-D) velocity distribution is
#//
#// f(v) = A (exp(-v^2 / 2 sig^2)
#// - exp(-ve^2 / 2 sig^2)),
#//
#// where sig^2 is a 1-D velocity dispersion (not quite the
#// central velocity dispersion, except in the limit of infinite
#// central potential). In King's (1966) paper, he uses
#// j^2 = 1 / (2 sig^2).
#//
#// Following King, we define the core radius rc by
#//
#// rc^2 = 9 sig^2 / (4 pi G rho0)
#//
#// and the dimensionless depth as
#//
#// W0 = -phi0 / sig^2,
#//
#// where rho0 and phi0 are the central density and potential,
#// respectively.
#//
#// We then scale as follows:
#//
#// x = r / rc
#//
#// d = rho / rho0
#//
#// psi = phi / sig^2,
#//
#// to obtain
#//
#// (x psi)'' = 9 x d,
#//
#// where ' = d/dx.
#//
#// We integrate this ODE from the cluster center (x = 0, d = 1,
#// psi = -W0) to the tidal radius (d = 0) by defining
#//
#// y(0) = (x psi)
#// y(1) = y(0)'
#//
#// We cover the first RLIN core radii linearly with NLIN points;
#// the remaining coverage is logarithmic, out to RMAX core radii,
#// if necessary. We stop when d <= 0.
stopped = False
for i in range(1,nmax+1):
xo = xn
if (i <= NLIN):
xn = (RLIN * i) / NLIN
else:
xn = fac * xo
dx = 0.051*(xn-xo)
(xo, y) = self.rk4(xo, xn, y, 2, dx)
# // N.B. Remember that y(1) is x*psi and xo is updated by step.
xn = xo
self.rr.append(xn)
self.psi.append(y[0] / xn)
(density, velocity_dispersion) = self.get_dens_and_vel(self.psi[i], True)
self.d.append(density)
self.v2.append(velocity_dispersion)
if (density < 0):
# // Density is negative, calculation is over.
# // Interpolate to the tidal radius.
self.rr[i] = self.rr[i-1] + (self.rr[i] - self.rr[i-1]) / (0.1 - self.d[i]/self.d[i-1])
self.d[i] = 0
self.v2[i] = 0
self.zm.append(self.rr[i] * y[1] - y[0])
if (density <= 0):
stopped = True
break
if not stopped: i = nmax
nprof = i
# // Scale d and v2 to their central values. Save v2_0 (unit = sig^2).
v2_0 = self.v2[0]
d_0 = self.d[0]
c_zm = 4.0 * math.pi / 9.0
self.d[:] = [x/d_0 for x in self.d]
self.v2[:] = [x/v2_0 for x in self.v2]
self.zm[:] = [x*c_zm for x in self.zm]
return nprof, v2_0
def coordinates_from_spherical(self, radius, theta, phi):
x = radius * numpy.sin( theta ) * numpy.cos( phi )
y = radius * numpy.sin( theta ) * numpy.sin( phi )
z = radius * numpy.cos( theta )
return [x,y,z]
def setpos(self):
# // Obtain a random position for body b from the King profile
# // and return the scaled potential at that location.
# // Choose radius randomly from the mass distribution.
rno = numpy.random.uniform()
i = int(self.NINDX * rno)
found_index = False
for i1 in range(self.index[i],self.index[i+1]+2): #(i1 = self.indx[i]; i1 <= indx[i+1]+1; i1++)
if (self.zm[i1] > rno):
found_index = True
break
if (not found_index):
raise exceptions.AmuseException("makeking: error in getpos")
rfac = (rno - self.zm[i1-1]) / (self.zm[i1] - self.zm[i1-1])
radius = self.rr[i1-1] + rfac * (self.rr[i1] - self.rr[i1-1])
potential = self.psi[i1-1] + rfac * (self.psi[i1] - self.psi[i1-1])
# // Angular position random.
theta = numpy.arccos(numpy.random.uniform(-1.0, 1.0))
phi = numpy.random.uniform(0.0, 2.0*math.pi)
return self.coordinates_from_spherical(radius, theta, phi), potential
def setvel(self, potential):
#// Obtain a random velocity for body b from the King profile
#// given its scaled potential.
# // Array v33[] contains the second term in the integral for the density,
# // namely exp(beta*W0) * v_esc^3 / 3 (scaling v^2 by 2 sig^2, as usual).
# // As with g[], the array indices run from 0 to NG, spanning a range 0 to
# // YMAX, i.e. the cumulative distribution function for v is
# //
# // exp(-p) * g[i] - v33[i],
# //
# // where y = i*YMAX/NG (i = 0,...,NG) and v = sqrt(2)*sig*y (sig = 1 here).
# // Choose speed randomly from the distribution at this radius.
v = 0
if (potential < -self.beta_w0):
pfac = math.exp(-potential)
ymax = math.sqrt(-potential-self.beta_w0)
# // Will obtain v by bisection. Determine maximum possible
# // range in the index i.
il = 0
iu = int(((self.NG/self.YMAX) * math.sqrt(-potential))) # // Binning OK for W0 < 16,
# // *only* if beta >= 0.
if (iu > self.NG):
iu = self.NG
rl = 0
ru = pfac * self.g_integral[iu] - self.v33[iu]
rno = numpy.random.uniform(0.0, ru)
while (iu - il > 1):
im = (il + iu) // 2
rm = pfac * self.g_integral[im] - self.v33[im]
if (rm > rno):
iu = im
ru = rm
else:
il = im
rl = rm
# // Maximum possible range of il here (for beta = 0) is
# // 0 to NG*sqrt(-p)/YMAX.
# // Maximum possible value of v (for beta = 0) is the local
# // escape speed, sqrt(-2*p).
v = (self.YMAX/self.NG) * math.sqrt(2.0) * (il + (rno - rl)/(ru - rl))
# // Direction is random.
theta = numpy.arccos(numpy.random.uniform(-1.0, 1.0))
phi = numpy.random.uniform(0.0, 2.0*math.pi)
return self.coordinates_from_spherical(v, theta, phi)
def makeking(self):
#// Create a King model, and optionally initialize an N-body system
#// with total mass = n, core radius = 1.
if (self.W0 > 16):
raise exceptions.AmuseException("makeking: must specify w0 < 16")
# // Compute the cluster density/velocity/potential profile
(nprof, v20) = self.poisson()
zm = self.zm
d = self.d
rr = self.rr
v2 = self.v2
psi = self.psi
if not (len(zm) == nprof+1 and len(d) == nprof+1 and
len(rr) == nprof+1 and len(v2) == nprof+1 and
len(psi) == nprof+1):
print(len(zm), len(d), len(rr), len(v2), len(psi), nprof+1)
raise exceptions.AmuseException("Error in result of Poisson")
# // Determine statistics and characteristic scales of the King model.
rho0 = 1 / zm[nprof]# // Central density for total mass = 1
# // Unit of velocity = sig, where rc^2 = 9 sig^2 / (4 pi G rho0)
sig = math.sqrt(4.0 * math.pi * rho0 / 9.0)# // This 3 was v20 in the f77 version...
# // v20 is central vel. disp. / sig^2
# // Scale the zm array to unit total mass.
inv_total_mass = 1.0 / zm[nprof]
zm[:] = [x*inv_total_mass for x in zm]
# // Index the mass distribution, and determine the core mass and
# // the half-mass radius.
# // By construction, rr[indx[j]] and rr[indx[j+1]] bracket the
# // radius containing a fraction j / NINDX of the total mass.
self.index.append(0)
dz = 1.0/self.NINDX
z = dz
for j in range(1,nprof):
if (rr[j] < 1): jcore = j
if (zm[j] < 0.5): jhalf = j
if (zm[j] > z):
self.index.append(j - 1)
z = z + dz
self.index.append(nprof)
if not (len(self.index)==self.NINDX+1):
raise exceptions.AmuseException("Error in length of indx")
zmcore = zm[jcore] + (zm[jcore+1] - zm[jcore]) * (1 -
rr[jcore]) / (rr[jcore+1] - rr[jcore])
rhalf = rr[jhalf] + (rr[jhalf+1] - rr[jhalf]) * (0.5 -
zm[jhalf]) / (zm[jhalf+1] - zm[jhalf])
# // Compute the kinetic and potential energies, and determine the
# // virial radius and ratio.
kin = 0; pot =0
for i in range(nprof):
kin = kin + (zm[i+1] - zm[i]) * (v2[i+1] + v2[i])
pot = pot - (zm[i+1] - zm[i]) * (zm[i+1] + zm[i]) / (rr[i+1] + rr[i])
kin *= 0.25*sig*sig*v20
rvirial = -0.5/pot
# // Initialize the N-body system.
if self.verbose:
print(" King model, w0 = ",self.W0,", Rt/Rc = ",rr[nprof],", Rh/Rc = ",rhalf,", Mc/M = ", zmcore)
# // Write essential model information
print("initial_mass", 1.0)
print("initial_rtidal_over_rvirial", rr[nprof] / (0.25/kin))
# // Assign positions and velocities. Note that it may actually
# // be preferable to do this in layers instead.
masses = numpy.zeros(self.number_of_particles) + (1.0 / self.number_of_particles)
positions = []
velocities = []
# // Convenient to have the "unscaled" system
# // be as close to standard units as possible, so rescale position
# // and velocity with 'xfac' and 'vfac' to force
# // the virial radius to 1. (Steve, 9/04)
xfac = 1.0/rvirial
vfac = 1.0/math.sqrt(xfac)
for i in range(self.number_of_particles):
(position, potential) = self.setpos()
velocity = self.setvel(potential)
# // Unit of length = rc.
# // Unit of velocity = sig.
position[:] = [xfac*comp for comp in position]
velocity[:] = [vfac*comp*sig for comp in velocity]
positions.append(position)
velocities.append(velocity)
# // System is in virial equilibrium in a consistent set of units
# // with G, core radius, and total mass = 1.
return (masses, positions, velocities)
@property
def result(self):
masses, positions, velocities = self.makeking()
result = datamodel.Particles(self.number_of_particles)
result.mass = nbody_system.mass.new_quantity(masses)
result.position = nbody_system.length.new_quantity(positions)
result.velocity = nbody_system.speed.new_quantity(velocities)
result.radius = 0 | nbody_system.length
if self.center_model:
result.move_to_center()
if self.do_scale:
result.scale_to_standard()
if not self.convert_nbody is None:
result = datamodel.ParticlesWithUnitsConverted(result, self.convert_nbody.as_converter_from_si_to_generic())
result = result.copy()
return result
def new_king_model(number_of_particles, W0, *list_arguments, **keyword_arguments):
"""
Create a King model with the given number of particles and King dimensionless
depth W0. Returns a set of particles with equal mass and positions and velocities
distributed to fit a King distribution model. The model is centered around the
origin. Positions and velocities are optionally scaled such that the kinetic and
potential energies are 0.25 and -0.5 in nbody-units, respectively.
:argument number_of_particles: Number of particles to include in the King model
:argument W0: King dimensionless depth, allowed range: < 0, 16 ]
:argument convert_nbody: When given will convert the resulting set to SI units
:argument do_scale: scale the result to exact nbody units (M=1, K=0.25, U=-0.5)
:argument beta: Steve's rescaling parameter (< 1) [0]. Models with b > 0 are just
rescaled King models; models with b < 0 approach isothermal spheres as
b --> -infinity.
:argument verbose: Be verbose (output is suppressed by default) [False]
"""
uc = MakeKingModel(number_of_particles, W0, *list_arguments, **keyword_arguments)
return uc.result
| 20,594
| 39.944334
| 120
|
py
|
amuse
|
amuse-main/src/amuse/ic/_limepy/sample.py
|
# -*- coding: utf-8 -*-
from __future__ import division
import numpy
import scipy
from numpy import exp, sqrt, pi, sin, cos
from scipy.special import gammainc, dawsn, erfi
from scipy import random
from scipy import optimize
from math import factorial
class sample:
def __init__(self, mod, **kwargs):
r""""
Sample positions and velocities from DF generated by LIMEPY
Parameters:
mod : Python object
Model generated by LIMEPY
N : scalar, optional
Number of points to be generated; default=1000
seed : scaler, optional
Random seed
verbose : bool, optional
Print diagnostics; default=False
"""
self._set_params_and_init(mod, **kwargs)
self._set_masses(mod)
self._sample_r(mod)
self._sample_v(mod)
self._to_cartesian()
if (self.verbose): self._summary()
def _set_params_and_init(self, mod, **kwargs):
if not mod.converged: raise ValueError(" Error: This model has not converged, abort sampling ...")
if (mod.model=="spes"):
raise ValueError("Sampling from SPES model not implemented ...")
self.seed = 199
self.verbose = False
self.N = 1000
if kwargs is not None:
for key, value in kwargs.items():
setattr(self, key, value)
random.seed(self.seed)
if (mod.multi):
# N is recalculated in case of multi mass
self.Nj = numpy.array(mod.Mj/mod.mj, dtype='int')
self.N = sum(self.Nj)
if min(self.Nj)==0: raise ValueError(" Error: One of the mass components has zero stars!")
self.mod = mod
self.ani = True if min(mod.raj)/mod.rt < 3 else False
def _set_masses(self, mod):
# Create mass array
if not mod.multi:
self.m = numpy.zeros(self.N) + mod.M/self.N
self.ra = mod.ra
if mod.multi:
self.Nstart = numpy.zeros(mod.nmbin,dtype='int')
self.Nend = numpy.zeros(mod.nmbin,dtype='int')
for j in range(mod.nmbin):
self.Nstart[j] = int(sum(self.Nj[0:j]))
self.Nend[j] = int(self.Nstart[j] + self.Nj[j])
self.m = numpy.zeros(self.N)
self.ra = numpy.zeros(self.N)
self.s2j = numpy.zeros(self.N)
for j in range(mod.nmbin):
self.m[self.Nstart[j]:self.Nend[j]] = mod.mj[j]
self.ra[self.Nstart[j]:self.Nend[j]] = mod.raj[j]
self.s2j[self.Nstart[j]:self.Nend[j]] = mod.s2j[j]
if (self.verbose):
print(" N as computed from Mj/mj = ",self.Nj)
def _sample_r(self, m):
# Sample radial distances from cumulative mass profile
if (self.verbose): print(" sample r ...")
ran = random.rand(self.N)
if not m.multi:
self.r = numpy.interp(ran, m.mc/m.mc[-1], m.r)
if m.multi:
self.r = numpy.zeros(self.N)
for j in range(m.nmbin):
s, e = self.Nstart[j], self.Nend[j]
m.mcj[j][0] = 0.5*m.mcj[j][1]
self.r[s:e] = numpy.interp(ran[s:e], m.mcj[j]/m.mcj[j][-1], m.r)
# get dimensionless potential
self.phihat = m.interp_phi(self.r)/m.s2
return
def _sample_v(self, m):
# Sample random values for x = k**1.5
if (self.verbose): print(" sample v ...")
self.xmax= self.phihat**1.5
nx = 10
self.nx = nx
frac = numpy.linspace(0,1,nx+1)
self.x = numpy.zeros(len(self.r))
for j in range(1,nx):
self.x = numpy.vstack((self.x, self.xmax*frac[j]))
self.x = numpy.vstack((self.x, self.xmax))
self.k, self.v, self.rfinal = [], [], []
for j in range(self.mod.nmbin):
if (self.verbose): print(" set-up segments for velocity cdf ...")
self.ycum = numpy.zeros(self.N)
self.y = self._pdf_k32(self.r, self.phihat, self.x[0], j)
for i in range(1,nx):
self.y = numpy.vstack((self.y, self._pdf_k32(self.r, self.phihat, self.x[i], j)))
self.y = numpy.vstack((self.y, 0*self.r, self.x[-1]))
if (self.verbose): print(" compute cdf ...")
self._compute_cdf()
if (self.verbose): print(" (rejection) sampling of k^3/2 values ...")
self._sample_k(j)
self.r = self.rfinal
self.phihat = m.interp_phi(self.r)/m.s2
self.phi = -self.phihat*m.s2 - m.G*m.M/m.rt
self._sample_angles(self.N)
def _compute_cdf(self):
for j in range(len(self.x)-1):
dy = self.y[j]*(self.x[j+1] - self.x[j])
self.ycum = numpy.vstack((self.ycum, self.ycum[-1]+dy))
def _Eg(self,x,s):
return exp(x)*gammainc(s,x) if s>0 else exp(x)
def _pdf_k32(self, r, f, x, j):
# PDF of k^3/2
g = self.mod.g
x13 = x**(1./3)
x23 = x**(2./3)
sig2fac = self.mod.s2/self.mod.s2j[j]
E = (f-x23)*sig2fac
c = (x>0)
func = numpy.zeros(len(x))
if (sum(c)>0):
if (self.ani):
p = r/self.mod.raj[j]
F = dawsn(x13*p*sqrt(sig2fac))/p
func[c] = F[c]/(x13[c]*sqrt(sig2fac))*self._Eg(E[c],g)
else:
func[c] = self._Eg(E[c],g)
if (sum(~c)>0): func[~c] = self._Eg(E[~c],g)
return func
def _sample_k(self, jbin):
# y(x) = y_j
# cdf(x) = ycum_j + y_j*(x - x_j)
# x = R/y_j + x_j
N = self.N
iter=0
c = numpy.zeros(N, dtype='bool')+True
if self.mod.multi:
sta, end = self.Nstart[jbin], self.Nend[jbin]
c[0:sta] = False
c[end::] = False
ycum = self.ycum[:,c]
rtmp = self.r[c]
ftmp = self.phihat[c]
y = self.y[:,c]
x = self.x[:,c]
if self.mod.multi:
c = numpy.zeros(self.Nj[jbin], dtype='bool')+True
while (sum(c) > 0):
nc = sum(c)
ycum = ycum[:,c]
rtmp = rtmp[c]
ftmp = ftmp[c]
y = y[:,c]
x = x[:,c]
R = random.rand(nc)*ycum[-1]
xtmp = numpy.zeros(nc)
P = numpy.zeros(nc)
for j in range(self.nx):
cr = (R>=ycum[j])&(R<ycum[j+1])
if (sum(cr)>0):
xtmp[cr] = (R[cr]-ycum[j,cr])/y[j,cr] + x[j,cr]
P[cr] = y[j,cr]
R2 = random.rand(nc)*P
f = self._pdf_k32(rtmp, ftmp, xtmp, jbin)
c = (R2>f)
if (iter==0):
xsamp = xtmp[~c]
r = rtmp[~c]
else:
xsamp = numpy.r_[xsamp, xtmp[~c]]
r = numpy.r_[r, rtmp[~c]]
iter+=1
# Assign final velocities and update r because of shuffling
self.k = numpy.r_[self.k, xsamp**(2./3)]
self.v = numpy.r_[self.v, sqrt(2*xsamp**(2./3)*self.mod.s2)]
self.rfinal = numpy.r_[self.rfinal, r]
def _pdf_angle(self, q, *args):
# Sample random values for: q = cos(theta)
# P(q) = erfi(sqrt(k)*p*q)/erfi(sqrt(k)*p)
a, R = args
return R - erfi(a*q)/erfi(a)
def _sample_angles(self,N):
if (self.verbose): print(" sample angles ...")
R = random.rand(N)
if self.ani:
# Anisotropic systems sample angles: cdf(q) = erfi(a*q)/erfi(a), a = sqrt(k)*p
p = self.r/self.ra
a = p*sqrt(self.k)
if self.mod.multi:
a *= sqrt(self.mod.s2/self.s2j)
self.q = numpy.zeros(N)
for j in range(N):
self.q[j] = optimize.brentq(self._pdf_angle, 0, 1, args=(a[j], R[j]))
else:
# Isotropic: cdf(q) = q
self.q = R
self.vr = self.v*self.q*random.choice((-1,1),size=self.N)
self.vt = self.v*sqrt(1-self.q**2)
def _to_cartesian(self):
if (self.verbose): print(" convert to cartesian coordinates ...")
r = self.r
r2 = r**2
R1 = random.rand(self.N)
R2 = random.rand(self.N)
self.x = (1-2*R1)*self.r
self.y = sqrt(r2 - self.x**2)*cos(2*pi*R2)
self.z = sqrt(r2 - self.x**2)*sin(2*pi*R2)
if (self.ani):
R1 = random.rand(self.N)
vphi = self.vt*cos(2*pi*R1)
vtheta = self.vt*sin(2*pi*R1)
theta = numpy.arccos(self.z/r)
phi = numpy.arctan2(self.y, self.x)
self.vx = self.vr*sin(theta)*cos(phi) + vtheta*cos(theta)*cos(phi) - vphi*sin(phi)
self.vy = self.vr*sin(theta)*sin(phi) + vtheta*cos(theta)*sin(phi) + vphi*cos(phi)
self.vz = self.vr*cos(theta) - vtheta*sin(theta)
else:
v2 = self.v**2
R1 = random.rand(self.N)
R2 = random.rand(self.N)
self.vx = (1-2*R1)*self.v
self.vy = sqrt(v2 - self.vx**2)*cos(2*pi*R2)
self.vz = sqrt(v2 - self.vx**2)*sin(2*pi*R2)
def _summary(self):
print(" done! ")
m = self.mod
f = -self.phihat*m.s2 - m.G*m.M/m.rt
print(" U: sample = %12.4e; model = %12.4e"%(0.5*sum(self.m*f), m.U))
print(" K: sample = %12.4e; model = %12.4e"%(sum(0.5*self.m*self.v**2), m.K))
print(" Q: sample = %12.4e; model = %12.4e"%(sum(0.5*self.m*self.v**2)/(0.5*sum(self.m*f)), m.K/m.U))
print(" 2Kr/Kt: sample = %12.4f; model = %12.4f"%(2*sum(self.vr**2)/sum(self.vt**2),2*m.Kr/m.Kt))
if m.multi:
print("\n Components: ")
for j in range(m.nmbin):
c=(self.m==m.mj[j])
print(" Kj: sample = %12.4e; model = %12.4e"%(sum(0.5*self.m[c]*self.v[c]**2), m.Kj[j]))
for j in range(m.nmbin):
c=(self.m==m.mj[j])
print(" 2Kr/Ktj: sample = %12.4e; model = %12.4e"%(2*sum(self.vr[c]**2)/sum(self.vt[c]**2),2*m.Krj[j]/m.Ktj[j]))
| 10,121
| 32.186885
| 128
|
py
|
amuse
|
amuse-main/src/amuse/ic/_limepy/limepy.py
|
# -*- coding: utf-8 -*-
import numpy
import scipy
from scipy.interpolate import BPoly, interp1d, UnivariateSpline
from numpy import exp, sqrt, pi, sin, cos, log10
from scipy.special import gamma, gammainc, hyp1f1
from scipy.integrate import ode, simps, quad
from math import factorial, sinh
# Authors: Mark Gieles, Alice Zocchi (Surrey 2015)
class limepy:
def __init__(self, phi0, g, **kwargs):
r"""
(MM, A) LIMEPY
(Multi-Mass, Anisotropic) Lowered Isothermal Model Explorer in Python
This code solves the models presented in Gieles & Zocchi 2015 (GZ15),
and calculates radial profiles for some useful quantities. The models
are defined by the distribution function (DF) of equation (1) in GZ15.
Model parameters:
=================
phi0 : scalar, required
Central dimensionless potential
g : scalar, required
Order of truncation (0<= g < 3.5; 0=Woolley, 1=King, 2=Wilson)
ra : scalar, required for anisotropic models
Anisotropy radius; default=1e8
mj : list, required for multi-mass system
Mean mass of each component; default=None
Mj : list, required for multi-mass system
Total mass of each component; default=None
delta : scalar, optional
Index in s_j = s x mu_j^-delta; default=0.5
See equation (24) in GZ15
eta : scalar, optional
Index in ra_j = ra x mu_j^eta; default=0
See equation (25) in GZ15
Input for scaling:
==================
G : scalar, optional
Final scaled gravitationsl const; default=0.004302 [(km/s)^2 pc/Msun]
M : scalar, optional
Final scaled mass; default=10^5
r0, rh, rv, rt : scalar, optional
Final scaled radius; default=rh=3
Options:
========
project : bool, optional
Compute model properties in projection; default=False
meanmassdef : string [global|central]
Definition of <m> in mu_j = m_j/<m>; default='global'
potonly : bool, optional
Fast solution by solving potential only; default=False
max_step : scalar, optional
Maximum step size for ode output; default=1e10
verbose : bool, optional
Print diagnostics; default=False
ode_atol : absolute tolerance parameter for ode solver; default=1e-7
ode_rtol : relative tolerance parameter for ode solver; default=1e-7
Output variables:
=================
All models:
-----------
rhat, phihat, rhohat : radius, potential and density in model units
r, phi, rho : as above, in scaled units
v2, v2r, v2t : total, radial and tangential mean-square velocity
beta : anisotropy profile (equation 32, GZ15)
mc : enclosed mass profile
r0, rh, rv, rt : radii (King, half-mass, virial, truncation)
K, Kr, Kt : kinetic energy: total, radial, tangential
U, Q : potential energy, virial ratio
A : constant in DF (equation 1, GZ15)
volume : phase-space volume occupied by model
nstep : number of integration steps (depends on ode_rtol & ode_atol)
converged : bool flag to indicate whether model was solved
Projected models:
-----------------
Sigma : surface (mass) density
v2p : line-of-sight mean-square velocity
v2R, v2T : radial and tangential component of mean-square velocity
on plane of the sky
Multi-mass models:
------------------
Properties of each component:
phi0j : dimensionless central potential
rhohatj : dimensionless density
rhoj : density profile
v2j : mean-square velocity profile
v2rj, v2tj : radial and tangential component of mean-square velocity
profile
r0j, raj : radii (King, anisotropy)
Kj : kinetic energy
Krj, Ktj : radial/tangential component of kinetic energy
Projected multi-mass models:
---------------------------
Properties of each component:
Sigmaj : surface (mass) density
v2pj : line-of-sight mean-square velocity profile
v2Rj, v2Tj : radial and tangential component on the plane of the sky
of the mean-square velocity profile
Examples:
=========
Construct a Woolley model with phi0 = 7 and print r_t/r_0 and r_v/r_h
>>> k = limepy(7, 0)
>>> print k.rt/k.r0, k.rv/k.rh
>>> 19.1293426415 1.17783663028
Construct a Michie-King model and print ratio of anisotropy radius over
half-mass radius and the Polyachenko & Shukhman (1981) anisotropy
parameter
>>> a = limepy(7, 1, ra=5)
>>> print a.ra/a.rh, 2*a.Kr/a.Kt
>>> 1.03377960149 1.36280949941
Create a Wilson model with phi0 = 12 in Henon/N-body units: G = M =
r_v = 1 and print the normalisation constant A of the DF and the
value of the DF in the centre:
>>> w = limepy(12, 2, G=1, M=1, rv=1)
>>> print w.A, w.df(0,0)
>>> [ 0.00800902] [ 1303.40270676]
Multi-mass model in physical units with r_h = 3 pc and M = 10^5 M_sun
and print central densities of each bin over the total central density
and the half-mass radius + half-mass radius in projection
>>> m = limepy(7, 1, mj=[0.3,1,5], Mj=[9,3,1], rh=3, M=1e5,project=True,\
...: meanmassdef='central')
>>> print m.alpha, m.rh, m.rhp
>>> [ 0.30721416 0.14103549 0.55175035] 3.0 2.25494426759
"""
# Set parameters and scales
self._set_kwargs(phi0, g, **kwargs)
self.rhoint0 = [self._rhoint(self.phi0, 0, self.ramax)]
# In case of multi-mass model, iterate to find central densities
# (see Section 2.2 in GZ15)
if (self.multi):
# Feb 2016: New method to iterate on the MF.
# First solve isotropic model
ratmp = self.ra*1.0
self.ra = self.ramax*1.0
self._init_multi(self.mj, self.Mj)
while self.diff > self.diffcrit:
self._poisson(True)
if (not self.converged):
error = "Error: rmax reached in mf iteration"
raise ValueError(error)
else:
self._set_alpha()
if self.niter > self.max_mf_iter:
self.converged=False
error = "Error: maximum number of iterations reached "
raise ValueError(error)
# Now solve anisotropic multimass
if ratmp < self.ramax:
self.diff = 1
self.ra = ratmp*1.0
self._set_mass_function_variables()
while self.diff > self.diffcrit:
self._poisson(True)
if (not self.converged):
error = "Error: rmax reached in mf iteration"
raise ValueError(error)
else:
self._set_alpha()
if self.niter > self.max_mf_iter:
self.converged=False
error ="Error: maximum number of iterations reached"
raise ValueError(error)
self.r0 = 1.0
if (self.multi): self.r0j = sqrt(self.s2j)*self.r0
# ROT
if (self.rot):
self._poisson_rot()
else:
# Solve Poisson equation to get the potential
self._poisson(self.potonly)
if (self.multi): self.Mj = self._Mjtot
# Optional scaling
if (self.scale): self._scale()
# Optional computation of model properties in projection
if (self.project): self._project()
# Optional output
if (self.verbose):
print("\n Model properties: ")
print(" ----------------- ")
print(" phi0 = %5.2f; g = %4.2f"%(self.phi0, self.g))
print(" Converged = %s"%(self.converged))
if (self.potonly):
print(" M = %10.3f; U = %10.4f "%(self.M, self.U))
else:
out1 = (self.M,self.U,self.K,-self.K/self.U,2*self.Kr/self.Kt)
frm = " M = %10.3e; U = %9.3e; K = %9.3e; Q = %6.4f; "
frm += " 2Kr/Kt = %5.3f"
print(frm%out1)
out2 = (self.rv/self.rh, self.rh/self.r0)
out2 += (self.rt/self.r0, self.ra/self.rh)
frm = " rv/rh = %4.3f; rh/r0 = %6.3f; "
frm += "rt/r0 = %7.3f; ra/rh = %7.3f"
print(frm%out2)
def _set_kwargs(self, phi0, g, **kwargs):
""" Set parameters and scales """
if (g<0): raise ValueError("Error: g must be larger or equal to 0")
if (g>=3.5): raise ValueError("Error: for g>=3.5 models are infinite")
self.model = "limepy"
# ROT
self.omega = 0
self.phi0, self.g = phi0, g
self._MS, self._RS, self._GS = None, None, None
self.scale_radius = None
self.scale = False
self.project = False
self.meanmassdef='global'
self.maxr = 1e10
self.max_step = self.maxr
self.diffcrit = 1e-8
self.max_arg_exp = 700 # Maximum argument for exponent and hyp1f1 func
self.max_mf_iter = 100 # Maximum number of iterations to find rho0j
self.minimum_phi = 1e-8 # Stop criterion for integrator
self.mf_iter_index = 0.5
self.ode_atol = 1e-7
self.ode_rtol = 1e-7
self.nmbin, self.delta, self.eta = 1, 0.5, 0.0
self.G = 9.0/(4.0*pi)
self.mu, self.alpha = numpy.array([1.0]), numpy.array([1.0])
self.s2 = 1.0
self.s2j = numpy.array([1.0])
self.niter = 0
self.potonly, self.multi, self.verbose = [False]*3
self.ra, self.ramax = 1e8, 1e8
self.nstep=1
self.converged=True
self._interpolator_set=False
if kwargs is not None:
for key, value in kwargs.items():
# Check for scaling input
if key == 'G':
self._GS, self.scale = value, True
elif key == 'M':
self._MS, self.scale = value, True
elif key == 'r0':
if self.scale_radius is None:
self._RS,self.scale_radius,self.scale = value,'r0', True
else:
error="Can not set scale radius to r0,already set to %s"
raise ValueError(error%self.scale_radius)
elif key == 'rh':
if self.scale_radius is None:
self._RS, self.scale_radius, self.scale=value,'rh', True
else:
error="Can not set scale radius to rh,already set to %s"
raise ValueError(error%self.scale_radius)
elif key == 'rv':
if self.scale_radius is None:
self._RS, self.scale_radius, self.scale=value,'rv', True
else:
error="Can not set scale radius to rv,already set to %s"
raise ValueError(error%self.scale_radius)
elif key == 'rt':
if self.scale_radius is None:
self._RS, self.scale_radius, self.scale=value,'rt', True
else:
error="Can not set scale radius to rt,already set to %s"
raise ValueError(error%self.scale_radius)
else:
# Set input parameters
setattr(self, key, value)
if (self.scale):
if self._MS is None:
self._MS = 1e5
if (self.verbose):
print(" No mass-scale provided, set to default M = 1e5")
if self._RS is None:
self._RS, self.scale_radius = 3, 'rh'
if (self.verbose):
print(" No radius-scale provided, set to default rh = 3")
if self._GS is None:
self._GS = 0.004302
if (self.verbose):
print(" No G provided, set to default: G = 0.004302")
if (self.verbose):
vars=(self._GS, self._MS, self.scale_radius, self._RS)
print(" Model scaled to: G = %s, M = %s, %s = %s"%vars)
if 'mj' in kwargs and 'Mj' in kwargs:
self.multi=True
if len(self.Mj) is not len(self.mj):
raise ValueError("Error: Mj and mj must have same length")
if ('mj' not in kwargs and 'Mj' in kwargs) or \
('Mj' not in kwargs and 'mj' in kwargs):
raise ValueError("Error: Supply both mj and Mj")
self.raj = numpy.array([self.ra])
if self.potonly and self.project:
raise ValueError('Error: You must not use potonly and project')
self.rot = False
if self.omega > 0:
print(" Warning: ROTATION PART NOT FINISHED! ")
self.rot = True
return
def _logcheck(self, t, y):
""" Logs steps and checks for final values """
if (t>0): self.r, self._y = numpy.r_[self.r, t], numpy.c_[self._y, y]
self.nstep+=1
return 0 if (y[0]>self.minimum_phi) else -1
def _set_mass_function_variables(self):
""" Multi-mass models: Set properties for each mass bin """
if self.meanmassdef=='global':
Nj = self.Mj/self.mj
self.mmean = sum(self.Mj/sum(Nj))
elif self.meanmassdef=='central':
self.mmean = sum(self.mj*self.alpha) # equation (26) GZ15
else:
raise ValueError(" meanmass must be 'global' or 'central'")
self.mu = self.mj/self.mmean
self.s2j = self.mu**(-2*self.delta) # equation (24) GZ15
self.raj = self.ra*self.mu**self.eta # equation (25) GZ15
self.phi0j = self.phi0/self.s2j
self.rhoint0 = numpy.zeros(self.nmbin)
for j in range(self.nmbin):
self.rhoint0[j] = self._rhoint(self.phi0j[j], 0, self.ramax)
def _init_multi(self, mj, Mj):
"""
Initialise parameters and arrays for multi-mass system
(Section 2.2 in GZ15)
"""
self.multi=True
self.mj = numpy.array(mj)
self.Mj = numpy.array(Mj)
self.nmbin = len(mj)
# Set trial value for alpha_j array, will be updated in iterations
self.alpha = self.Mj/sum(self.Mj)
self._set_mass_function_variables()
self.diff = 1
def _set_alpha(self):
""" Set central rho_j for next iteration """
# The power of mf_iter_index = 0.5. This is lower than the recommended
# value of 1 as used in Da Costa & Freeman 1976 and Gunn & Griffin 1979.
# Better convergence is reached for a smaller value, but a user may
# experiment with larger values to gain speed.
self.alpha *= (self.Mj/self._Mjtot)**self.mf_iter_index
self.alpha/=sum(self.alpha)
self._set_mass_function_variables()
self.diff = sum((self._Mjtot/sum(self._Mjtot) -
self.Mj/sum(self.Mj))**2)/len(self._Mjtot)
self.niter+=1
self.nstep=1
if (self.verbose):
fracd,Mjit="", ""
for j in range(self.nmbin):
M1 = self._Mjtot[j]/sum(self._Mjtot)
M2 = self.Mj[j]/sum(self.Mj)
fracd=fracd+"%7.3f "%(( M1 - M2)/M2)
Mjit=Mjit+"%7.3f "%(self._Mjtot[j]/sum(self._Mjtot))
out = (self.niter, self.mf_iter_index, self.diff, self.converged*1,\
fracd, Mjit)
frm = " %2i; ind=%3.1f; diff= %6.1e; conv= %s;"
frm += " fdiff=%s; Mjtot=%s"
print(frm%out)
def _poisson(self, potonly):
""" Solves Poisson equation """
# y = [phi, u_j, U, K_j], where u = -M(<r)/G
# Initialize
self.r = numpy.array([0])
self._y = numpy.r_[self.phi0, numpy.zeros(self.nmbin+1)]
if (not potonly): self._y = numpy.r_[self._y,numpy.zeros(2*self.nmbin)]
self._y = numpy.r_[self._y, 0]
# Ode solving using Runge-Kutta integator of order 4(5) 'dopri5'
# (Hairor, Norsett& Wanner 1993)
max_step = self.maxr if (potonly) else self.max_step
sol = ode(self._odes)
sol.set_integrator('dopri5',nsteps=1e6,max_step=max_step,
atol=self.ode_atol,rtol=self.ode_rtol)
sol.set_solout(self._logcheck)
sol.set_f_params(potonly)
sol.set_initial_value(self._y,0)
sol.integrate(self.maxr)
# Extrapolate to r_t:
# phi(r) =~ a(r_t -r)
# a = GM/r_t^2
GM = -self.G*sum(sol.y[1:1+self.nmbin])
p = 2*sol.y[0]*self.r[-1]/GM
if (p<=0.5):
rtfac = (1 - sqrt(1-2*p))/p
self.rt = rtfac*self.r[-1] if (rtfac > 1) else 1.0000001*self.r[-1]
else:
self.rt = 1.000001*self.r[-1]
# Set the converged flag to True if successful
if (self.rt < self.maxr)&(sol.successful()):
self.converged=True
else:
self.converged=False
# Calculate the phase space volume occupied by the model
dvol = (4./3*pi)**2*(self.rt**3-self.r[-1]**3)*0.5
dvol *= (2*self._y[0,-1])**1.5
self.volume = self._y[-1][-1]+dvol
# Fill arrays needed if potonly=True
self.r = numpy.r_[self.r, self.rt]
self.rhat = self.r*1.0
self.phihat = numpy.r_[self._y[0,:], 0]
self.phi = self.phihat*1.0
self._Mjtot = -sol.y[1:1+self.nmbin]/self.G
self.M = sum(self._Mjtot)
# Save the derivative of the potential for the potential interpolater
dphidr = numpy.sum(self._y[1:1+self.nmbin,1:],axis=0)/self.r[1:-1]**2
self.dphidrhat1 = numpy.r_[0, dphidr, -self.G*self.M/self.rt**2]
self.A = self.alpha/(2*pi*self.s2j)**1.5/self.rhoint0
if (not self.multi):
self.mc = -numpy.r_[self._y[1,:], self._y[1,-1]]/self.G
if (self.multi):
self.mc = sum(-self._y[1:1+self.nmbin,:]/self.G)
self.mc = numpy.r_[self.mc, self.mc[-1]]
# Compute radii to be able to scale in case potonly=True
self.U = self._y[1+self.nmbin,-1] - 0.5*self.G*self.M**2/self.rt
# Get half-mass radius from cubic interpolation, because the half-mass
# radius can be used as a scale length, this needs to be done
# accurately, a linear interpolation does not suffice. Because the
# density array is not known yet at this point, we need a temporary
# evaluation of density in the vicinity of r_h
ih = numpy.searchsorted(self.mc, 0.5*self.mc[-1])-1
rhotmp=numpy.zeros(2)
for j in range(self.nmbin):
phi = self.phihat[ih:ih+2]/self.s2j[j]
rhotmp += self.alpha[j]*self._rhohat(phi, self.r[ih:ih+2], j)
drdm = 1./(4*pi*self.r[ih:ih+2]**2*rhotmp)
rmc_and_derivs = numpy.vstack([[self.r[ih:ih+2]],[drdm]]).T
self.rh = BPoly.from_derivatives(self.mc[ih:ih+2], rmc_and_derivs)(0.5*self.mc[-1])
self.rv = -0.5*self.G*self.M**2/self.U
# Additional stuff
if (not potonly):
# Calculate kinetic energy (total, radial, tangential)
self.K = numpy.sum(sol.y[2+self.nmbin:2+2*self.nmbin])
self.Kr = numpy.sum(sol.y[2+2*self.nmbin:2+3*self.nmbin])
self.Kt = self.K - self.Kr
# Calculate density and velocity dispersion components
if (not self.multi):
self.rhohat = self._rhohat(self.phihat, self.r, 0)
self.rho = self.rhohat*1.0
self.v2, self.v2r, self.v2t = \
self._get_v2(self.phihat, self.r, self.rhohat, 0)
# For multi-mass models, calculate quantities for each mass bin
if (self.multi):
for j in range(self.nmbin):
phi = self.phihat/self.s2j[j]
rhohatj = self._rhohat(phi, self.r, j)
v2j, v2rj, v2tj = self._get_v2(phi, self.r, rhohatj, j)
v2j, v2rj, v2tj = (q*self.s2j[j] for q in [v2j,v2rj,v2tj])
betaj = self._beta(self.r, v2rj, v2tj)
kj = self._y[2+self.nmbin+j,:]
krj = self._y[2+2*self.nmbin+j,:]
ktj = kj - krj
mcj = -numpy.r_[self._y[1+j,:], self._y[1+j,-1]]/self.G
rhj = numpy.interp(0.5*mcj[-1], mcj, self.r)
if (j==0):
self.rhohatj = rhohatj
self.rhohat = self.alpha[0] * self.rhohatj
self.v2j, self.v2rj, self.v2tj = v2j, v2rj, v2tj
self.v2 = self._Mjtot[j]*v2j/self.M
self.v2r = self._Mjtot[j]*v2rj/self.M
self.v2t = self._Mjtot[j]*v2tj/self.M
self.betaj = betaj
self.kj, self.krj, self.ktj = kj, krj, ktj
self.Kj, self.Krj = kj[-1], krj[-1]
self.ktj = self.kj - self.krj
self.Ktj = self.Kj - self.Krj
self.rhj, self.mcj = rhj, mcj
else:
self.rhohatj = numpy.vstack((self.rhohatj, rhohatj))
self.rhohat += self.alpha[j]*rhohatj
self.v2j = numpy.vstack((self.v2j, v2j))
self.v2rj = numpy.vstack((self.v2rj, v2rj))
self.v2tj = numpy.vstack((self.v2tj, v2tj))
self.v2 += self._Mjtot[j]*v2j/self.M
self.v2r += self._Mjtot[j]*v2rj/self.M
self.v2t += self._Mjtot[j]*v2tj/self.M
self.betaj = numpy.vstack((self.betaj, betaj))
self.kj = numpy.vstack((self.kj, kj))
self.krj = numpy.vstack((self.krj, krj))
self.ktj = numpy.vstack((self.ktj, ktj))
self.Kj = numpy.r_[self.Kj, kj[-1]]
self.Krj = numpy.r_[self.Krj, krj[-1]]
self.Ktj = numpy.r_[self.Ktj, ktj[-1]]
self.rhj = numpy.r_[self.rhj,rhj]
self.mcj = numpy.vstack((self.mcj, mcj))
self.rho = self.rhohat*1.0
self.rhoj = self.rhohatj*1.0
# Calculate anisotropy profile (equation 32 of GZ15)
self.beta = self._beta(self.r, self.v2r, self.v2t)
def _rhohat(self, phi, r, j):
"""
Wrapper for _rhoint when either: both phi or r are arrays, or both
are scalar
"""
if not hasattr(phi,"__len__"): phi = numpy.array([phi])
if not hasattr(r,"__len__"): r = numpy.array([r])
n = max([phi.size, r.size])
rhohat = numpy.zeros(n)
for i in range(n):
if (phi[i]<self.max_arg_exp) or (numpy.isnan(phi[i])):
rhohat[i] = self._rhoint(phi[i], r[i], self.raj[j])
rhohat[i] /= self.rhoint0[j]
else:
# For large phi compute the ratio in one go (Section 4.1, GZ15)
rhohat[i] = exp(phi[i]-self.phi0j[j]) if (self.multi) else 0
return rhohat
def _rhoint(self, phi, r, ra):
"""
Dimensionless density integral as a function of phi and r (scalar)
"""
# Isotropic case first (equation 8, GZ15)
rhoint = exp(phi)*gammainc(self.g + 1.5, phi)
# Anisotropic case, add r-dependent part explicitly (equation 11, GZ15)
if (self.ra < self.ramax) and (phi>0) and (r>0):
p, g = r/ra, self.g
p2 = p**2
g3, g5, fp2 = g+1.5, g+2.5, phi*p2
func = hyp1f1(1, g5, -fp2) if fp2 < self.max_arg_exp else g3/fp2
rhoint += p2*phi**(g+1.5)*func/gamma(g5)
rhoint /= (1+p2)
return rhoint
def _get_v2(self, phi, r, rho, j):
v2 = numpy.zeros(r.size)
v2r, v2t = numpy.zeros(r.size), numpy.zeros(r.size)
for i in range(r.size-1):
v2[i], v2r[i], v2t[i] = self._rhov2int(phi[i], r[i], self.raj[j])
v2[i] /= rho[i]*self.rhoint0[j]
v2r[i] /= rho[i]*self.rhoint0[j]
v2t[i] /= rho[i]*self.rhoint0[j]
return v2, v2r, v2t
def _rhov2int(self, phi, r, ra):
"""Compute dimensionless pressure integral for phi, r """
# Isotropic case first (equation 9, GZ15)
rhov2r = exp(phi)*gammainc(self.g + 2.5, phi)
rhov2 = 3*rhov2r
rhov2t = 2*rhov2r
# Add anisotropy, add parts depending explicitly on r
# (see equations 12, 13, and 14 of GZ15)
if (ra < self.ramax) and (r>0) and (phi>0):
p, g = r/ra, self.g
p2 = p**2
p12 = 1+p2
g3, g5, g7, fp2 = g+1.5, g+2.5, g+3.5, phi*p2
P1 = p2*phi**g5/gamma(g7)
H1 = hyp1f1(1, g7, -fp2) if fp2 <self.max_arg_exp else g5/fp2
H2 = hyp1f1(2, g7, -fp2) if fp2 <self.max_arg_exp else g5*g3/fp2**2
rhov2r += P1*H1
rhov2r /= p12
rhov2t /= p12
rhov2t += 2*P1*(H1/p12 + H2)
rhov2t /= p12
rhov2 = rhov2r + rhov2t
return rhov2, rhov2r, rhov2t
def _beta(self, r, v2r, v2t):
""" Calculate the anisotropy profile """
beta = numpy.zeros(r.size)
if (self.ra < self.ramax):
c = (v2r>0.)
# Equation (32), GZ15
beta[c] = 1.0 - 0.5*v2t[c]/v2r[c]
return beta
def _odes(self, x, y, potonly):
""" Solve ODEs """
# y = [phi, u_j, U, K_j], where u = -M(<r)/G
if (self.multi):
derivs = [numpy.sum(y[1:1+self.nmbin])/x**2] if (x>0) else [0]
for j in range(self.nmbin):
phi = y[0]/self.s2j[j]
derivs.append(-9.0*x**2*self.alpha[j]*self._rhohat(phi, x, j))
dUdx = 2.0*pi*numpy.sum(derivs[1:1+self.nmbin])*y[0]/9.
else:
derivs = [y[1]/x**2] if (x>0) else [0]
derivs.append(-9.0*x**2*self._rhohat(y[0], x, 0))
dUdx = 2.0*pi*derivs[1]*y[0]/9.
derivs.append(dUdx)
# Calculate pressure tensor components for all the mass bins
if (not potonly): #dK_j/dx
rhov2j, rhov2rj = [], []
for j in range(self.nmbin):
rv2, rv2r, rv2t = self._rhov2int(y[0]/self.s2j[j],
x, self.raj[j])
P = self.alpha[j]*self.s2j[j]*2*pi*x**2*rv2/self.rhoint0[j]
rhov2j.append(P)
Pr = self.alpha[j]*self.s2j[j]*2*pi*x**2*rv2r/self.rhoint0[j]
rhov2rj.append(Pr)
for j in range(self.nmbin):
derivs.append(rhov2j[j])
for j in range(self.nmbin):
derivs.append(rhov2rj[j])
dVdvdr = (4*pi)**2*x**2 * (2*y[0])**1.5/3 if (x>0) and (y[0]>0) else 0
derivs.append(dVdvdr)
return derivs
# ROT: UNDER CONSTRUCTIONS ##############
def _poisson_rot(self):
self._init_rot()
diff_rot = 1e99
while (diff_rot > self.diff_rot_crit):
# Compute density
rho_l = self._rhohat_rot()
self.rho_l = rho_l
# Compute potential
diff_rot = 0
# def _phil_rot(self):
# phi_l = numpy.zeros(len(self.r)*nl).reshape(len(self.r), nl)
# phi_l[:,0] = self.phi0*sqrt(2)
def legendre_Ul(self, l, theta):
il = l/2.0
dl = 1.0/2**l
m = numpy.arange(il+1)
cm = gamma(2*l-2*m+1)*(-1)**m/(gamma(m+1)*gamma(l-m+1)*gamma(l-2*m+1))
gm = cos(theta)**(l-2*m)
Pl = dl*numpy.sum(cm*gm)
return sqrt((2*l+1)/2)*Pl
def _rhohat_rot(self):
for ip in range(len(self.r)):
for it in range(self.ntheta):
self.rhon_g[ip][it] = self._rhoint_rot(self.phin_g[ip][it], self.r[ip], self.theta[it])
nl = int(self.lmax/2+1)
rho_l = numpy.zeros(len(self.r)*nl).reshape(len(self.r), nl)
for il in range(nl):
l = 2*il
for ir in range(len(self.r)):
Ul = numpy.zeros(len(self.theta))
for it in range(self.ntheta):
Ul[it] = self.legendre_Ul(l, self.theta[it])
rho_l[ir][il] = -2.0 * simps(self.rhon_g[ir]*Ul, x=cos(self.theta))
return rho_l
def _rhoint_rot(self, phi, r, theta):
# Compute eq 3 for scalar phi, r and theta
g, om = self.g, self.omega
Q = 3*sqrt(2)*r*sin(theta)
# Eq 3
integ = quad(lambda x: exp(phi-x)*gammainc(g, phi-x)*numpy.sinh(om*Q*x**0.5), 0, phi)[0]
return integ/(om*Q*gamma(1.5))
def _init_rot(self):
self.lmax = 6
self.diff_rot_crit = 1e-3
# Grid params
self.ntheta = (2*self.lmax + 1)
# Compute spherical model first
self._poisson(True)
phin = self.phi
self.theta = numpy.linspace(1e-4, 0.5*pi, self.ntheta)
# Set up grid
self.r_g, self.theta_g = numpy.meshgrid(self.r, self.theta, indexing ='ij')
self.phin_g, tmp = numpy.meshgrid(self.phi, self.theta, indexing ='ij')
self.rhon_g = self.phin_g*0.0
# Fudge TBD
self.r[0] = 0.5*self.r[1]
# Make copy for iterations
self.phin_prev_g = self.phin_g*1.0
return
################
def _setup_phi_interpolator(self):
""" Setup interpolater for phi, works on scalar and arrays """
# Generate piecewise 3th order polynomials to connect the discrete
# values of phi obtained from from Poisson, using dphi/dr
self._interpolator_set = True
if (self.scale):
phi_and_derivs = numpy.vstack([[self.phi],[self.dphidr1]]).T
else:
phi_and_derivs = numpy.vstack([[self.phihat],[self.dphidrhat1]]).T
self._phi_poly = BPoly.from_derivatives(self.r,phi_and_derivs)
def _scale(self):
""" Scales the model to the units set in the input: GS, MS, RS """
Mstar = self._MS/self.M
Gstar = self._GS/self.G
if (self.scale_radius=='r0'): Rstar = self._RS/self.r0
if (self.scale_radius=='rh'): Rstar = self._RS/self.rh
if (self.scale_radius=='rv'): Rstar = self._RS/self.rv
if (self.scale_radius=='rt'): Rstar = self._RS/self.rt
v2star = Gstar*Mstar/Rstar
# Update the scales that define the system (see Section 2.1.2 of GZ15)
self.G *= Gstar
self.rs = Rstar
self.s2 *= v2star
self.s2j *= v2star
# Anisotropy radii
self.ra, self.raj, self.ramax = (q*Rstar for q in [self.ra,
self.raj,
self.ramax])
# Scale all variable needed when run with potonly=True
self.r, self.r0, self.rt = (q*Rstar for q in [self.rhat,
self.r0, self.rt])
self.rh, self.rv = (q*Rstar for q in [self.rh,self.rv])
self.M *= Mstar
self.phi = self.phihat * v2star
self.dphidr1 = self.dphidrhat1 * v2star/Rstar
self.mc *= Mstar
self.U *= Mstar*v2star
self.A *= Mstar/(v2star**1.5*Rstar**3)
self.volume *= v2star**1.5*Rstar**3
# Scale density, velocity dispersion components, kinetic energy
self.rho = self.rhohat*Mstar/Rstar**3
if (not self.potonly):
self.rho = self.rhohat*Mstar/Rstar**3
self.v2, self.v2r, self.v2t = (q*v2star for q in [self.v2,
self.v2r,self.v2t])
self.K,self.Kr,self.Kt=(q*Mstar*v2star for q in [self.K, self.Kr,
self.Kt])
if (self.multi):
self.rhoj = self.rhohatj * Mstar/Rstar**3
for j in range(self.nmbin):
self.rhoj[j] *= self.alpha[j]
self.Mj *= Mstar # 28/1/19 Thanks to William
self.mcj *= Mstar
self.rhj *= Rstar
self.v2j,self.v2rj,self.v2tj=(q*v2star for q in
[self.v2j, self.v2rj,self.v2tj])
self.kj *= Mstar*v2star
self.Krj *= Mstar*v2star
self.Ktj *= Mstar*v2star
self.Kj *= Mstar*v2star
def _tonp(self, q):
q = numpy.array([q]) if not hasattr(q,"__len__") else numpy.array(q)
return q
def _project(self):
"""
Compute projected mass density (Sigma) and projected <v2> profiles
"""
# Initialise the projected quantities:
# R is the projected (2d) distance from the center, Sigma is the
# projected density, v2p is the line-of-sight velocity dispersion,
# v2R and v2T are the radial and tangential velocity dispersion
# components projected on the plane of the sky
# Initialise some arrays
R = self.r
Sigma = numpy.zeros(self.nstep)
v2p = numpy.zeros(self.nstep)
v2R = numpy.zeros(self.nstep)
v2T = numpy.zeros(self.nstep)
mcp = numpy.zeros(self.nstep)
if (self.multi):
Sigmaj = numpy.zeros((self.nmbin, self.nstep))
v2pj = numpy.zeros((self.nmbin, self.nstep))
v2Rj = numpy.zeros((self.nmbin, self.nstep))
v2Tj = numpy.zeros((self.nmbin, self.nstep))
mcpj = numpy.zeros((self.nmbin, self.nstep)) # TBD
# Project model properties for each R
for i in range(self.nstep-1):
c = (self.r >= R[i])
r = self.r[c]
z = sqrt(abs(r**2 - R[i]**2)) # avoid small neg. values
Sigma[i] = 2.0*abs(simps(self.rho[c], x=z))
betaterm1 = 1 if i==0 else 1-self.beta[c]*R[i]**2/self.r[c]**2
# eq 41 in paper has a small mistake: (1-R^2)/r^2 should be (1-R^2/r^2) as below
betaterm2 = 1 - self.beta[c] if i==0 else 1-self.beta[c]*(1-R[i]**2/self.r[c]**2)
v2p[i] = abs(2.0*simps(betaterm1*self.rho[c]*self.v2r[c], x=z))
v2p[i] /= Sigma[i]
v2R[i] = abs(2.0*simps(betaterm2*self.rho[c]*self.v2r[c], x=z))
v2R[i] /= Sigma[i]
v2T[i] = abs(simps(self.rho[c]*self.v2t[c], x=z))
v2T[i] /= Sigma[i]
# Cumulative mass in projection
if (i>0):
x = self.r[i-1:i+1]
mcp[i] = mcp[i-1] + 2*pi*simps(x*Sigma[i-1:i+1], x=x)
mcp[-1] = mcp[-2]
# Radius containing half the mass in projection
self.rhp = numpy.interp(0.5*mcp[-1], mcp, self.r)
if (self.multi):
for j in range(self.nmbin):
Sigmaj[j,i] = 2.0*simps(self.rhoj[j,c], x=z)
if (i==0):
betaterm1 = 1
betaterm2 = 1 -self.betaj[j,c]
else:
betaterm1 = 1-self.betaj[j,c]*R[i]**2/self.r[c]**2
# eq 41 in paper has a small mistake: (1-R^2)/r^2 should be (1-R^2/r^2) as below
betaterm2 = 1-self.betaj[j,c]*(1-R[i]**2/self.r[c]**2)
v2int = simps(betaterm1*self.rhoj[j,c]*self.v2rj[j,c], x=z)
v2pj[j,i] = abs(2.0*v2int)
v2pj[j,i] /= Sigmaj[j,i]
v2int = simps(betaterm2*self.rhoj[j,c]*self.v2rj[j,c], x=z)
v2Rj[j,i] = abs(2.0*v2int)
v2Rj[j,i] /= Sigmaj[j,i]
v2Tj[j,i] = abs(simps(self.rhoj[j,c]*self.v2tj[j,c], x=z))
v2Tj[j,i] /= Sigmaj[j,i]
self.R, self.Sigma = R, Sigma
self.v2p, self.v2R, self.v2T = v2p, v2R, v2T
self.mcp = mcp
# TBD: Compute half-mass radii in projection
if (self.multi):
self.Sigmaj = Sigmaj
self.v2pj, self.v2Rj, self.v2Tj = v2pj, v2Rj, v2Tj
return
def get_Paz(self, az_data, R_data, jns):
"""
Computes probability of line of sight acceleration at projected R : P(az|R)
"""
# Under construction !!!
# Return P(az|R)
az_data = abs(az_data) # Consider only positive values
# Assumes units of az [m/s^2] if self.G ==0.004302, else models units
# Conversion factor from [pc (km/s)^2/Msun] -> [m/s^2]
az_fac = 1./3.0857e10 if (self.G==0.004302) else 1
if (R_data < self.rt):
nz = self.nstep # Number of z value equal to number of r values
zt = sqrt(self.rt**2 - R_data**2) # maximum z value at R
z = numpy.logspace(log10(self.r[1]), log10(zt), nz)
spl_Mr = UnivariateSpline(self.r, self.mc, s=0, ext=1) # Spline for enclosed mass
r = sqrt(R_data**2 + z**2) # Local r array
az = self.G*spl_Mr(r)*z/r**3 # Acceleration along los
az[-1] = self.G*spl_Mr(self.rt)*zt/self.rt**3 # Ensure non-zero final data point
az *= az_fac # convert to [m/s^2]
az_spl = UnivariateSpline(z, az, k=4, s=0, ext=1) # 4th order needed to find max (can be done easier?)
zmax = az_spl.derivative().roots() # z where az = max(az), can be done without 4th order spline?
azt = az[-1] # acceleration at the max(z) = sqrt(r_t**2 - R**2)
# Setup spline for rho(z)
if jns == 0 and self.nmbin == 1:
rho = self.rho
else:
rho = self.rhoj[jns]
rho_spl = UnivariateSpline(self.r, rho, ext=1, s=0)
rhoz = rho_spl(sqrt(z**2 + R_data**2))
rhoz_spl = UnivariateSpline(z, rhoz, ext=1, s=0)
# Now compute P(a_z|R)
# There are 2 possibilities depending on R:
# (1) the maximum acceleration occurs within the cluster boundary, or
# (2) max(a_z) = a_z,t (this happens when R ~ r_t)
nr, k = nz, 3 # bit of experimenting
# Option (1): zmax < max(z)
if len(zmax)>0:
zmax = zmax[0] # Take first entry for the rare cases with multiple peaks
# Set up 2 splines for the inverse z(a_z) for z < zmax and z > zmax
z1 = numpy.linspace(z[0], zmax, nr)
z2 = (numpy.linspace(zmax, z[-1], nr))[::-1] # Reverse z for ascending az
z1_spl = UnivariateSpline(az_spl(z1), z1, k=k, s=0, ext=1)
z2_spl = UnivariateSpline(az_spl(z2), z2, k=k, s=0, ext=1)
# Option 2: zmax = max(z)
else:
zmax = z[-1]
z1 = numpy.linspace(z[0], zmax, nr)
z1_spl = UnivariateSpline(az_spl(z1), z1, k=k, s=0, ext=1)
# Maximum acceleration along this los
azmax = az_spl(zmax)
# Now determine P(az_data|R)
if (az_data < azmax):
z1 = max([z1_spl(az_data), z[0]]) # first radius where az = az_data
Paz = rhoz_spl(z1)/abs(az_spl.derivatives(z1)[1])
if (az_data> azt):
# Find z where a_z = a_z,t
z2 = z2_spl(az_data)
Paz += rhoz_spl(z2)/abs(az_spl.derivatives(z2)[1])
# Normalize to 1
Paz /= rhoz_spl.integral(0, zt)
self.z = z
self.az = az
self.Paz = Paz
self.azmax = azmax
self.zmax = zmax
else:
self.Paz = 0
else:
self.Paz = 0
return
def interp_phi(self, r):
""" Returns interpolated potential at r, works on scalar and arrays """
if not hasattr(r,"__len__"): r = numpy.array([r])
if (not self._interpolator_set): self._setup_phi_interpolator()
phi = numpy.zeros([r.size])
inrt = (r<self.rt)
# Use 3th order polynomials to interp, using phi'
if (sum(inrt)>0): phi[inrt] = self._phi_poly(r[inrt])
return phi
def df(self, *arg):
"""
Returns the value of the normalised DF at a given position in phase
space, can only be called after solving Poisson's equation
Arguments can be:
- r, v (isotropic single-mass models)
- r, v, j (isotropic multi-mass models)
- r, v, theta, j (anisotropic models)
- x, y, z, vx, vy, vz, j (all models)
Here j specifies the mass bin, j=0 for single mass
Works with scalar and array input
"""
if (len(arg)<2) or (len(arg)==5) or (len(arg)==6) or (len(arg)>7):
raise ValueError("Error: df needs 2, 3, 4 or 7 arguments")
if (len(arg)<=3) and (self.ra<self.ramax):
raise ValueError("Error: model is anisotropy, more input needed")
if len(arg) == 2:
r, v = (self._tonp(q) for q in arg)
j = 0
if len(arg) == 3:
r, v = (self._tonp(q) for q in arg[:-1])
j = arg[-1]
if len(arg) == 4:
r, v, theta = (self._tonp(q) for q in arg[:-1])
j = arg[-1]
if len(arg) < 7: r2, v2 = r**2, v**2
if len(arg) == 7:
x, y, z, vx, vy, vz = (self._tonp(q) for q in arg[:-1])
j = arg[-1]
r2 = x**2 + y**2 + z**2
v2 = vx**2 + vy**2 + vz**2
r, v = sqrt(r2), sqrt(v2)
# Interpolate potential and calculate escape velocity as a
# function of the distance from the center
phi = self.interp_phi(r)
vesc2 = 2.0*phi # Note: phi > 0
DF = numpy.zeros([max(r.size, v.size)])
if (len(r) == len(v2)):
# Bitwise & needed to allow for possibility that r and v2 are arrays
c = (r<self.rt) & (v2<vesc2)
if (len(r) == 1) and (len(v2) > 1):
c = (v2<vesc2)
if (r>self.rt): c=False
if (len(r) > 1) and (len(v2) == 1):
# Bitwise & needed to allow for possibility that r and v2 are arrays
c = (r<self.rt) & (numpy.zeros(len(r))+v2<vesc2)
if (sum(c)>0):
# Compute the DF: equation (1), GZ15
E = (phi-0.5*v2)/self.s2j[j] # Dimensionless positive energy
DF[c] = exp(E[c])
if (self.g>0): DF[c] *= gammainc(self.g, E[c])
if (len(arg)==7): J2 = v2*r2 - (x*vx + y*vy + z*vz)**2
if (len(arg)==4): J2 = sin(theta)**2*v2*r2
if (len(arg)<=3): J2 = numpy.zeros(len(c))
DF[c] *= exp(-J2[c]/(2*self.raj[j]**2*self.s2j[j]))
DF[c] *= self.A[j]
else:
DF = numpy.zeros(max(len(r),len(v)))
return DF
| 43,751
| 37.856128
| 114
|
py
|
amuse
|
amuse-main/src/amuse/ic/_limepy/__init__.py
|
# -*- coding: utf-8 -*-
__author__ = 'Mark Gieles, Alice Zocchi'
__email__ = 'm.gieles@surrey.ac.uk, a.zocchi@surrey.ac.uk'
__version__ = '0.1.1'
from .limepy import limepy
from .sample import sample
| 204
| 17.636364
| 58
|
py
|
amuse
|
amuse-main/src/amuse/plot/mapper.py
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Make 2D maps from SPH particles using FiMap
"""
import logging
import numpy
from amuse.units import units, constants, nbody_system
from amuse.datamodel.rotation import new_rotation_matrix, rotate
from amuse.community.fi import FiMap
def gas_mean_molecular_weight(
h2ratio=0.5,
):
"Return mean molecular weight of hydrogen gas"
meanmwt = (
(
2.0 * h2ratio
+ (1. - 2. * h2ratio)
+ 0.4
) /
(
0.1 + h2ratio + (1. - 2. * h2ratio)
)
) | units.amu
return meanmwt
def u_to_temperature(
internal_energy,
meanmwt=gas_mean_molecular_weight(),
gamma=5/3,
):
"""
Convert internal energy to temperature, by default assumes all gas is
molecular hydrogen and gamma = 5/3.
"""
temperature = (
(gamma - 1) * meanmwt * internal_energy
/ constants.kB
)
return temperature
def temperature_to_u(
temperature,
meanmwt=gas_mean_molecular_weight(),
gamma=5/3,
):
"""
Convert temperature to internal energy, by default assumes all gas is
molecular hydrogen and gamma = 5/3.
"""
internal_energy = (
constants.kB * temperature
/ ((gamma - 1) * meanmwt)
)
return internal_energy
class MapHydro():
class Maps():
"Store all calculated maps"
def __init__(self):
self.counts = None
self.mass = None
self.temperature = None
self.vx = None
self.vy = None
self.vz = None
def __init__(self, gas=None, stars=None, sinks=None):
"""
Sets up MapHydro instance. Maps are created as-needed.
Usage:
mapper = MapHydro(gas=gas, stars=None, sinks=None)
mapper.width = 10 | units.pc
mapper.bins = 800
mapper.origin = (0, 0, 0) | units.pc
counts_map = mapper.counts
density_map = mapper.density
vx_map = mapper.vx
vy_map = mapper.vy
temperature_map = mapper.temperature
mapper.stop()
"""
self.__bins_x = 800
self.__bins_y = 800
self.__width = 1 | units.pc
self.__axis_x = 'x'
self.__axis_y = 'y'
self.__axis_z = 'z'
self.__origin = [0., 0., 0.] | units.pc
self.__maps = self.Maps()
self.__unit_mass = units.MSun
self.__unit_length = units.pc
self.__unit_time = units.Myr
self.__unit_speed = units.kms
self.__unit_temperature = units.K
self.__mapper = None
self.__gas = gas
self.__stars = stars
self.__sinks = sinks
self.__state = "INIT"
self.__phi = 0 | units.deg
self.__theta = 0 | units.deg
self.__psi = 0 | units.deg
self.__constant_mass = False
if not gas.is_empty():
if self.__gas.mass.std() == 0 | self.__unit_mass:
self.__constant_mass = self.__gas[0].mass
def set_unit_length(self, unit=units.pc):
# need to assert this is indeed a length
self.__unit_length = unit
def rotate(
self,
phi=0 | units.deg,
theta=0 | units.deg,
psi=0 | units.deg,
):
dphi = phi - self.__phi
dtheta = theta - self.__theta
dpsi = psi - self.__psi
self.__phi = phi
self.__theta = theta
self.__psi = psi
if self.__stars is not None:
if not self.__stars.is_empty():
rotate(self.__stars, dphi, dtheta, dpsi)
if self.__sinks is not None:
if not self.__sinks.is_empty():
rotate(self.__sinks, dphi, dtheta, dpsi)
if self.__state == "RUN":
rotation_matrix = new_rotation_matrix(
self.__phi, self.__theta, self.__psi,
).transpose()
self.__mapper.parameters.upvector = numpy.inner(
rotation_matrix,
[0, 1, 0],
)
self.__mapper.parameters.projection_direction = numpy.inner(
rotation_matrix,
[0, 0, -1],
)
del self.__maps
self.__maps = self.Maps()
def stop(self):
"Clean up"
if self.__mapper is not None:
self.__mapper.stop()
self.__mapper = None
del self.__gas
del self.__maps
self.__maps = self.Maps()
self.__state = "STOP"
def __new_gas_mapper(self):
"Start a new mapper instance"
converter = nbody_system.nbody_to_si(100 | units.MSun, 1000 | units.pc)
gas = self.__gas
# x_axis = self.__axis_x
# y_axis = self.__axis_y
mapper = FiMap(converter, mode="openmp", redirection="none")
# if not hasattr(gas, "radius"):
# gas.radius = gas.h_smooth
mapper.particles.add_particles(gas)
rotation_matrix = new_rotation_matrix(
self.__phi, self.__theta, self.__psi,
).transpose()
mapper.parameters.upvector = numpy.inner(
rotation_matrix,
[0, 1, 0],
)
mapper.parameters.projection_direction = numpy.inner(
rotation_matrix,
[0, 0, -1],
)
mapper.parameters.image_target = self.__origin
mapper.parameters.image_width = self.__width
mapper.parameters.image_size = [self.__bins_x, self.__bins_y]
self.__mapper = mapper
self.__state = "RUN"
@property
def axes(self):
"Get axes"
return (self.__axis_x, self.__axis_y, self.__axis_z)
@axes.setter
def axes(self, axes):
"Set axes"
self.__axis_x = axes[0]
self.__axis_y = axes[1]
self.__axis_z = axes[2]
@property
def phi(self):
return self.__phi
@property
def theta(self):
return self.__theta
@property
def psi(self):
return self.__psi
@property
def xmin(self):
"Return smallest value on x axis"
return self.origin[0] - (self.width/2)
@property
def xmax(self):
"Return largest value on x axis"
return self.origin[0] + (self.width/2)
@property
def ymin(self):
"Return smallest value on x axis"
return self.origin[1] - (self.height/2)
@property
def ymax(self):
"Return largest value on x axis"
return self.origin[1] + (self.height/2)
@property
def extent(self):
"Return image extent"
return (
self.xmin.value_in(self.__unit_length),
self.xmax.value_in(self.__unit_length),
self.ymin.value_in(self.__unit_length),
self.ymax.value_in(self.__unit_length),
)
@property
def origin(self):
"Get origin (rotated)"
rotation_matrix = new_rotation_matrix(
self.__phi, self.__theta, self.__psi,
).transpose()
return self.__origin.dot(rotation_matrix)
@origin.setter
def origin(self, origin=[0., 0., 0.] | units.pc):
"Set origin offset"
delta_origin = -self.__origin
for i, o_i in enumerate(origin):
delta_origin[i] += o_i
self.__origin = origin
if self.__state in ["RUN"]:
self.__mapper.parameters.image_target = self.__origin
@property
def height(self):
"Get height of map"
return self.__width * (self.__bins_y / self.__bins_x)
@property
def width(self):
"Get width of map"
return self.__width
@width.setter
def width(self, width=1 | units.pc):
"Set width of map"
self.__width = width
self.__state = "EDIT"
@property
def bins(self):
"Get number of bins"
return self.__bins_x, self.__bins_y
@bins.setter
def bins(self, bins):
"Set number of bins"
if isinstance(bins, (int)):
self.__bins_x = bins
self.__bins_y = bins
elif isinstance(bins, (list, tuple)):
self.__bins_x = bins[0]
self.__bins_y = bins[1]
else:
raise TypeError("bins needs to be 'int', 'tuple' or 'list'")
self.__state = "EDIT"
@property
def counts(self):
"Return a counts map"
if (
(self.__maps.counts is not None)
and (self.__state != "EDIT")
):
return self.__maps.counts
if self.__state != "RUN":
self.__new_gas_mapper()
self.__mapper.particles.weight = 1
self.__maps.counts = self.__mapper.image.pixel_value.transpose()
return self.__maps.counts
@property
def mass(self):
"Return a mass map"
if self.__constant_mass:
return self.counts * self.__constant_mass
if (
(self.__maps.mass is not None)
and (self.__state != "EDIT")
):
return self.__maps.mass
if self.__state != "RUN":
self.__new_gas_mapper()
self.__mapper.particles.weight = self.__gas.mass.value_in(
self.__unit_mass)
self.__maps.mass = self.__mapper.image.pixel_value.transpose(
) | self.__unit_mass
return self.__maps.mass
@property
def column_density(self):
"Return a column density map"
length_x = self.__width / self.__bins_x
length_y = length_x * (self.__bins_y / self.__bins_x)
pixel_size = length_x * length_y
map_mass = self.mass
return map_mass / pixel_size
@property
def temperature(self):
"Return a temperature map"
if (
(self.__maps.temperature is not None)
and (self.__state != "EDIT")
):
return self.__maps.temperature
if self.__state != "RUN":
self.__new_gas_mapper()
gas = self.__gas
if hasattr(gas, "mu"):
print(f"h2ratio: {gas.mu.mean()}")
meanmwt = gas.mu
elif hasattr(gas, "h2ratio"):
print(f"h2ratio: {gas.h2ratio.mean()}")
meanmwt = gas_mean_molecular_weight(gas.h2ratio)
else:
meanmwt = gas_mean_molecular_weight()
temperature = u_to_temperature(gas.u, meanmwt=meanmwt)
print(f"temperature range: {min(temperature)} - {max(temperature)}")
self.__mapper.particles.weight = temperature.value_in(
self.__unit_temperature)
# counts = self.counts
self.__maps.temperature = numpy.nan_to_num(
self.__mapper.image.pixel_value.transpose(),
# / counts,
nan=0,
) | self.__unit_temperature
print(
f"min/max: {self.__maps.temperature.min()} "
f"- {self.__maps.temperature.max()}"
)
return self.__maps.temperature
@property
def vx(self):
"Return a vx map"
if (
(self.__maps.vx is not None)
and (self.__state != "EDIT")
):
return self.__maps.vx
if self.__state != "RUN":
self.__new_gas_mapper()
gas = self.__gas
self.__mapper.particles.weight = gas.vx.value_in(self.__unit_speed)
self.__maps.vx = self.__mapper.image.pixel_value.transpose(
) | self.__unit_speed
return self.__maps.vx
@property
def vy(self):
"Return a vy map"
if (
(self.__maps.vy is not None)
and (self.__state != "EDIT")
):
return self.__maps.vy
if self.__state != "RUN":
self.__new_gas_mapper()
gas = self.__gas
self.__mapper.particles.weight = gas.vy.value_in(self.__unit_speed)
self.__maps.vy = self.__mapper.image.pixel_value.transpose(
) | self.__unit_speed
return self.__maps.vy
@property
def vz(self):
"Return a vz map"
if (
(self.__maps.vz is not None)
and (self.__state != "EDIT")
):
return self.__maps.vz
if self.__state != "RUN":
self.__new_gas_mapper()
gas = self.__gas
self.__mapper.particles.weight = gas.vz.value_in(self.__unit_speed)
self.__maps.vz = self.__mapper.image.pixel_value.transpose(
) | self.__unit_speed
return self.__maps.vz
@property
def gas(self):
"Return gas"
return self.__gas
@property
def stars(self):
"Return stars"
return self.__stars
@property
def sinks(self):
"Return sinks"
return self.__sinks
| 12,634
| 26.527233
| 79
|
py
|
amuse
|
amuse-main/src/amuse/plot/__init__.py
|
from ._plot import *
| 21
| 10
| 20
|
py
|
amuse
|
amuse-main/src/amuse/plot/hydro.py
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Plot hydro and/or stars
"""
import os
import sys
import logging
import numpy
import copy
import argparse
import matplotlib
import matplotlib.pyplot as plt
# import matplotlib.cm as cm
from amuse.datamodel import Particles
from amuse.io import read_set_from_file
from amuse.units import units, nbody_system
from amuse.units.quantities import as_vector_quantity
from amuse.datamodel.rotation import new_rotation_matrix
from amuse.plot.mapper import MapHydro
logger = logging.getLogger(__name__)
def velocity_divergence(vx_field, vy_field, dx, velocity_unit=units.kms):
# Return divergence of velocity fields
div = (numpy.ufunc.reduce(
numpy.add,
[
-1 * numpy.gradient(vx_field.value_in(velocity_unit), axis=1),
-1 * numpy.gradient(vy_field.value_in(velocity_unit), axis=0),
]
) | velocity_unit) / dx
return div
def plot_column_density(
plot_axes,
maps,
unit_col_density=units.MSun * units.pc**-2,
vmin=-1,
vmax=4,
cmap='viridis',
):
cmap = copy.copy(matplotlib.colormaps[cmap])
cmap.set_bad('k', alpha=1.0)
column_density = maps.column_density
logscale = numpy.log10(column_density.value_in(unit_col_density))
return plot_axes.imshow(
logscale,
extent=maps.extent,
vmin=vmin,
vmax=vmax,
origin='lower',
cmap=cmap,
)
def plot_temperature(
plot_axes,
maps,
vmin=0,
vmax=5,
cmap="inferno",
):
cmap = copy.copy(matplotlib.colormaps[cmap])
cmap.set_bad('k', alpha=1.0)
temperature_map = maps.temperature
logscale_temperature_map = numpy.log10(
temperature_map.value_in(units.K)
)
return plot_axes.imshow(
logscale_temperature_map,
extent=maps.extent,
vmin=vmin,
vmax=vmax,
cmap=cmap,
origin="lower",
)
def plot_divergence(
plot_axes,
maps,
x_axis="vx",
y_axis="vy",
contours=False,
normalise_by_counts=True,
vmin=None,
vmax=None,
div_unit=units.Myr**-1,
):
dx = maps.width / maps.bins[0]
dy = maps.width / maps.bins[1]
assert (dx == dy), "dx/dy are spaced differently!"
x_range = numpy.arange(
maps.xmin.value_in(units.pc), maps.xmax.value_in(units.pc),
(maps.width / maps.bins[0]).value_in(units.pc),
)
y_range = numpy.arange(
maps.ymin.value_in(units.pc), maps.ymax.value_in(units.pc),
(maps.height / maps.bins[1]).value_in(units.pc),
)
x_grid, y_grid = numpy.meshgrid(x_range, y_range)
div = velocity_divergence(
getattr(maps, x_axis) / maps.counts,
getattr(maps, y_axis) / maps.counts,
dx,
)
if not normalise_by_counts:
div = div * maps.mass
if contours:
levels = 1 / ([-4, -10, -100, 100, 10, 4] | units.Myr)
return plot_axes.contour(
x_grid, y_grid,
div.value_in(div_unit),
levels=levels.value_in(div_unit),
# colors=["blue", "red"],
# cmap="coolwarm",
cmap='bwr',
)
minmax = max(-div.min(), div.max())
if not vmin:
vmin = -minmax
if not vmax:
vmax = minmax
# minmax = 500
# print(minmax)
# print(vmin, vmax)
return plot_axes.imshow(
div.value_in(div_unit),
extent=maps.extent,
vmin=vmin.value_in(div_unit),
vmax=vmax.value_in(div_unit),
cmap='bwr',
origin='lower',
)
def new_figure(
aspect=1,
colorbar_width=0 | units.cm,
title_margin=0 | units.cm,
xlabel_margin=0.9 | units.cm,
ylabel_margin=1.25 | units.cm,
right_padding=0.18 | units.cm,
top_padding=0.15 | units.cm,
# plot_style="default",
):
"Return a new figure and a new axes object"
# /plt.style.use(plot_style)
fig = plt.figure()
# Get the width of the figure - this is the fixed value
# height will depend on aspect and other attributes
figure_width = (fig.get_figwidth() | units.inch)
# Calculate in 'figure units'
left_frac = (ylabel_margin) / figure_width
right_frac = (colorbar_width + right_padding) / figure_width
if colorbar_width > 0 | units.cm:
right_frac += (ylabel_margin) / figure_width
left = left_frac
width = 1 - left - right_frac
# now we set the figure height to get the aspect ratio right
width_cm = aspect * width * figure_width
figure_height = width_cm + top_padding + title_margin + xlabel_margin
fig.set_figheight(figure_height.value_in(units.inch))
bottom_frac = (xlabel_margin) / figure_height
top_frac = (title_margin + top_padding) / figure_height
bottom = bottom_frac
height = 1 - bottom - top_frac
axes = fig.add_axes(
[
left,
bottom,
width,
height,
]
)
if colorbar_width > 0 | units.cm:
cax_width = (colorbar_width) / figure_width
colorbar_axes = fig.add_axes(
[
left+width,
bottom,
cax_width,
height,
]
)
return fig, axes, colorbar_axes
return fig, axes
def plot_hydro_and_stars(
maps,
fig=None,
ax=None,
title="",
plot="column density",
length_unit=units.parsec,
colorbar=True,
**kwargs
):
"Plot gas and stars"
maps.set_unit_length(length_unit)
if fig:
if ax is None:
ax = fig.gca()
ax.cla()
# for artist in ax.lines + ax.collections:
# artist.remove()
cax = False
else:
if colorbar:
fig, ax, cax = new_figure(
colorbar_width=0.2 | units.cm
)
else:
fig, ax = new_figure()
cax = False
if "stars" in plot:
ax.set_facecolor('black')
gasplot = False
if plot == "column density":
gasplot = plot_column_density(ax, maps)
gasplot_unit = units.MSun * units.pc**-2
elif plot == "temperature":
gasplot = plot_temperature(ax, maps)
gasplot_unit = units.K
elif plot == "divergence":
gasplot = plot_divergence(
ax,
maps,
normalise_by_counts=True,
div_unit=units.Myr**-1,
)
elif plot in ["hubble", "hubbledust"]:
from amuse.plot.fresco.fresco import make_image as fresco_image
if plot == "hubbledust":
extinction = True
else:
extinction = False
converter = nbody_system.nbody_to_si(1 | units.pc, 1 | units.MSun)
image = fresco_image(
stars=maps.stars,
gas=maps.gas if extinction is True else None,
image_width=maps.width,
image_size=maps.bins,
return_vmax=False,
converter=converter,
extinction=extinction,
# **kwargs
)
plt.imshow(
image,
extent=maps.extent,
origin="lower",
)
cmap = copy.copy(matplotlib.colormaps["coolwarm"])
if (
(maps.stars is not None)
and not maps.stars.is_empty()
):
s = 1 * (
(maps.stars.mass / (7 | units.MSun))**(3.5 / 2)
)
# s = 0.5
x = getattr(maps.stars, 'x').value_in(length_unit)
y = getattr(maps.stars, 'y').value_in(length_unit)
z = getattr(maps.stars, 'z').value_in(length_unit)
c = (
"cyan" if plot in [
"temperature",
]
else "white"
)
ax.scatter(x, y, s=s, c=c, lw=0)
ax.set_xlabel("%s (%s)" % (maps.axes[0], length_unit))
ax.set_ylabel("%s (%s)" % (maps.axes[1], length_unit))
ax.set_xlim(maps.extent[0], maps.extent[1])
ax.set_ylim(maps.extent[2], maps.extent[3])
if cax:
cbar = plt.colorbar(gasplot, cax=cax)
if gasplot_unit == units.MSun * units.pc**-2:
cbar.set_label("log10(M$_{\odot}$ / parsec$^2$)")
elif gasplot_unit == units.Myr**-1:
cbar.set_label("Myr$^{-1}$")
elif gasplot_unit == units.K:
cbar.set_label("log10(temp [K])")
else:
cbar.set_label("%s" % gasplot_unit)
return gasplot
def new_argument_parser():
"Parse command line arguments"
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
parser.add_argument(
'-s',
dest='starsfilename',
default='',
help='file containing stars (optional)',
)
parser.add_argument(
'-g',
dest='gasfilename',
default='',
help='file containing gas (optional)',
)
parser.add_argument(
'-o',
dest='imagefilename',
default='test',
help='write image to this file',
)
parser.add_argument(
'-n',
dest='bins',
default=800,
type=int,
help='number of bins',
)
parser.add_argument(
'-x',
dest='x',
default=0 | units.pc,
type=units.pc,
help='Central X coordinate',
)
parser.add_argument(
'-y',
dest='y',
default=0 | units.pc,
type=units.pc,
help='Central Y coordinate',
)
parser.add_argument(
'-z',
dest='z',
default=0 | units.pc,
type=units.pc,
help='Central Z coordinate',
)
parser.add_argument(
'-w',
dest='w',
default=10 | units.pc,
type=units.pc,
help='Width',
)
parser.add_argument(
'--com',
dest='use_com',
action='store_true',
default=False,
help='Center on center of mass',
)
parser.add_argument(
'-X',
dest='x_axis',
default='x',
help='Horizontal axis',
)
parser.add_argument(
'-Y',
dest='y_axis',
default='y',
help='Vertical axis',
)
parser.add_argument(
'-Z',
dest='z_axis',
default='z',
help='Line-of-sight axis',
)
parser.add_argument(
'-f',
dest='followfilename',
default=None,
help=(
'file containing star keys to center on (optional)\n'
' implies --com'
),
)
# parser.add_argument(
# '--length',
# dest='length_unit',
# default='parsec',
# help='Length unit (default: parsec)',
# )
return parser.parse_args()
def main():
args = new_argument_parser()
# length_unit = getattr(units, args.length_unit)
length_unit = units.pc
gasfilename = args.gasfilename
starsfilename = args.starsfilename
imagefilename = args.imagefilename
followfilename = args.followfilename
bins = args.bins
finish = as_vector_quantity([args.x, args.y, args.z])
width_finish = args.w
x_axis = args.x_axis
y_axis = args.y_axis
z_axis = args.z_axis
bins = args.bins
plots = []
if followfilename is not None:
use_com = True
else:
use_com = args.use_com
if os.path.isfile(starsfilename):
stars = read_set_from_file(
starsfilename,
"amuse",
) if starsfilename != "" else Particles()
else:
stars = Particles()
if gasfilename:
gas = read_set_from_file(
gasfilename,
"amuse",
)
if hasattr(gas, "itype"):
gas = gas[gas.itype == 1]
# gas.h_smooth = gas.h
else:
gas = Particles()
if not gas.is_empty():
plots += ["column density"]
if hasattr(gas, 'u'):
plots.append("temperature")
if not gas.is_empty():
mtot = gas.total_mass()
com = mtot * gas.center_of_mass()
time = gas.get_timestamp()
else:
mtot = 0 | units.MSun
com = [0, 0, 0] | units.pc * units.MSun
time = False
if not stars.is_empty():
mtot += stars.total_mass()
com += stars.total_mass() * stars.center_of_mass()
if not time:
time = stars.get_timestamp()
com = com / mtot
if use_com:
if followfilename is not None:
followstars = read_set_from_file(
followfilename, close_file=True,
)
center_on_these_stars = followstars.get_intersecting_subset_in(
stars,
)
if center_on_these_stars.is_empty():
print("Stars not found")
sys.exit()
com = center_on_these_stars.center_of_mass()
finish = com
if time is None:
print('Unable to get timestamp, set time to 0 Myr.')
time = 0.0 | units.Myr
maps = MapHydro(gas, stars)
maps.axes = (x_axis, y_axis, z_axis)
maps.bins = bins
def xyz_to_xzy():
maps.rotate(90 | units.deg, 0 | units.deg, 0 | units.deg)
def xyz_to_zyx():
maps.rotate(0 | units.deg, 90 | units.deg, 0 | units.deg)
def xyz_to_yzx():
maps.rotate(0 | units.deg, 90 | units.deg, 90 | units.deg)
maps.origin = finish
maps.width = width_finish
if x_axis == "x" and y_axis == "z":
xyz_to_xzy()
elif x_axis == "y" and y_axis == "z":
xyz_to_yzx()
for plot in plots:
gasplot = plot_hydro_and_stars(
maps,
title="time = %06.2f %s" % (
time.value_in(units.Myr),
units.Myr,
),
plot=plot,
length_unit=length_unit,
)
plotname = (
plot.replace(" ", "_")
+ "-" + imagefilename + ".png"
)
plt.savefig(
plotname,
)
if __name__ == "__main__":
main()
| 13,863
| 24.674074
| 75
|
py
|
amuse
|
amuse-main/src/amuse/plot/_plot.py
|
try:
import matplotlib.pyplot as native_plot
from mpl_toolkits.mplot3d import Axes3D
except ImportError:
class FakePlotLibrary(object):
def stub(self, *args, **kwargs):
raise Exception("No plot library available")
def __getattr__(self, name):
raise Exception("matplotlib not present")
native_plot = FakePlotLibrary()
import numpy
try:
from pynbody.array import SimArray
from pynbody.snapshot import SimSnap
try:
from pynbody.snapshot import new
except:
from pynbody.snapshot import _new as new
import pynbody.plot.sph as pynbody_sph
HAS_PYNBODY = True
except ImportError:
HAS_PYNBODY = False
from amuse.support.exceptions import AmuseException
from amuse.units import units, constants
from amuse.units import quantities
from amuse.support import console
auto_label = "{0}"
custom_label = "{0} {1}"
class UnitlessArgs(object):
current_plot = None
@classmethod
def strip(self, *args, **kwargs):
if self.current_plot is native_plot.gca():
args = [arg.as_quantity_in(unit) if quantities.is_quantity(arg) else arg
for arg, unit in map(lambda *x : tuple(x), args, self.arg_units)]
self.clear()
self.current_plot = native_plot.gca()
for arg in args:
if quantities.is_quantity(arg):
arg = console.current_printing_strategy.convert_quantity(arg)
self.stripped_args.append(arg.value_in(arg.unit))
self.arg_units.append(arg.unit)
self.unitnames_of_args.append("["+str(arg.unit)+"]")
else:
self.stripped_args.append(arg)
self.arg_units.append(None)
self.unitnames_of_args.append("")
return self.stripped_args
@classmethod
def clear(self):
self.stripped_args = []
self.arg_units = []
self.unitnames_of_args = []
@classmethod
def value_in(self, unit, *args):
if len(args) < 1:
return args
if unit is not None:
args = [arg.value_in(unit) for arg in args]
if len(args) > 1:
return args
else:
return args[0]
@classmethod
def value_in_x_unit(self, *args):
return self.value_in(UnitlessArgs.arg_units[0], *args)
@classmethod
def value_in_y_unit(self, *args):
return self.value_in(UnitlessArgs.arg_units[1], *args)
@classmethod
def value_in_z_unit(self, *args):
return self.value_in(UnitlessArgs.arg_units[2], *args)
@classmethod
def x_label(self, s=None):
unit_name = self.unitnames_of_args[0]
return self.label(s, unit_name)
@classmethod
def y_label(self, s=None):
unit_name = self.unitnames_of_args[1]
return self.label(s, unit_name)
@classmethod
def z_label(self, s=None):
unit_name = self.unitnames_of_args[2]
return self.label(s, unit_name)
@classmethod
def label(self, s, unit_name):
if s is None:
return auto_label.format(unit_name)
else:
return custom_label.format(s, unit_name)
def latex_support():
from matplotlib import rc
#rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})
#rc('font',**{'family':'serif','serif':['Palatino']})
rc('text', usetex=True)
def plot(*args, **kwargs):
args = UnitlessArgs.strip(*args, **kwargs)
result = native_plot.plot(*args, **kwargs)
native_plot.xlabel(UnitlessArgs.x_label())
native_plot.ylabel(UnitlessArgs.y_label())
return result
def plot3(*args, **kwargs):
args = UnitlessArgs.strip(*args, **kwargs)
fig = native_plot.figure()
ax = fig.gca(projection='3d')
return ax.plot(*args, **kwargs)
def semilogx(*args, **kwargs):
args = UnitlessArgs.strip(*args, **kwargs)
result = native_plot.semilogx(*args, **kwargs)
native_plot.xlabel(UnitlessArgs.x_label())
native_plot.ylabel(UnitlessArgs.y_label())
return result
def semilogy(*args, **kwargs):
args = UnitlessArgs.strip(*args, **kwargs)
result = native_plot.semilogy(*args, **kwargs)
native_plot.xlabel(UnitlessArgs.x_label())
native_plot.ylabel(UnitlessArgs.y_label())
return result
def loglog(*args, **kwargs):
args = UnitlessArgs.strip(*args, **kwargs)
result = native_plot.loglog(*args, **kwargs)
native_plot.xlabel(UnitlessArgs.x_label())
native_plot.ylabel(UnitlessArgs.y_label())
return result
def scatter(x, y, **kwargs):
args = UnitlessArgs.strip(x,y)
result = native_plot.scatter(*UnitlessArgs.stripped_args, **kwargs)
native_plot.xlabel(UnitlessArgs.x_label())
native_plot.ylabel(UnitlessArgs.y_label())
return result
def fill_between(x, y1, y2, **kwargs):
x, y1 = UnitlessArgs.strip(x,y1)
y2 = UnitlessArgs.value_in_y_unit(y2)
result = native_plot.fill_between(x, y1, y2, **kwargs)
native_plot.xlabel(UnitlessArgs.x_label())
native_plot.ylabel(UnitlessArgs.y_label())
return result
def hist(x, **kwargs):
args = UnitlessArgs.strip(x)
result = native_plot.hist(args[0], **kwargs)
UnitlessArgs.unitnames_of_args.append("")
return result
def errorbar(*args, **kwargs):
for label in ['yerr', 'xerr']:
if label in kwargs:
args += (kwargs.pop(label),)
else:
args += (None,)
yerr, xerr = args[2:4]
args1 = UnitlessArgs.strip(*args[:2])
if xerr is not None:
xerr = UnitlessArgs.value_in_x_unit(xerr)
if yerr is not None:
yerr = UnitlessArgs.value_in_y_unit(yerr)
args = args1 + [yerr, xerr]
result = native_plot.errorbar(*args, **kwargs)
native_plot.xlabel(UnitlessArgs.x_label())
native_plot.ylabel(UnitlessArgs.y_label())
return result
def text(x, y, s, **kwargs):
strp_x, strp_y = UnitlessArgs.strip(x, y)
return native_plot.text(strp_x, strp_y, s, **kwargs)
def xlabel(s, *args, **kwargs):
if not '[' in s:
s = UnitlessArgs.x_label(s)
return native_plot.xlabel(s, *args, **kwargs)
def ylabel(s, *args, **kwargs):
if not '[' in s:
s = UnitlessArgs.y_label(s)
return native_plot.ylabel(s, *args, **kwargs)
def xlim(*args, **kwargs):
if len(UnitlessArgs.arg_units) == 0:
raise AmuseException("Cannot call xlim function before plotting")
args = UnitlessArgs.value_in_x_unit(*args)
for name in ("xmin", "xmax"):
if name in kwargs:
kwargs[name] = UnitlessArgs.value_in_x_unit(kwargs[name])
native_plot.xlim(*args, **kwargs)
def ylim(*args, **kwargs):
if len(UnitlessArgs.arg_units) == 0:
raise AmuseException("Cannot call ylim function before plotting")
args = UnitlessArgs.value_in_y_unit(*args)
for name in ("ymin", "ymax"):
if name in kwargs:
kwargs[name] = UnitlessArgs.value_in_y_unit(kwargs[name])
native_plot.ylim(*args, **kwargs)
def axvline(x, **kwargs):
x_number = UnitlessArgs.value_in_x_unit(x)
return native_plot.axvline(x_number, **kwargs)
def axhline(y, **kwargs):
y_number = UnitlessArgs.value_in_y_unit(y)
return native_plot.axhline(y_number, **kwargs)
def circle_with_radius(x, y, radius, **kwargs):
x, y = UnitlessArgs.strip(x, y)[:2]
radius = UnitlessArgs.value_in_x_unit(radius)
circle = native_plot.Circle((x, y), radius, **kwargs)
return native_plot.gca().add_artist(circle)
def fix_xyz_axes(X, Y, Z):
if not (X.shape == Z.shape and Y.shape == Z.shape):
X, Y = numpy.meshgrid(X, Y)
return X, Y, Z
def log_norm(Z, vmin, vmax):
# for log scale, 0 is considered a missing value
masked_Z = numpy.ma.masked_equal(Z, 0.0, copy=False)
vmin = UnitlessArgs.value_in_z_unit(vmin) if vmin else masked_Z.min()
vmax = UnitlessArgs.value_in_z_unit(vmax) if vmax else masked_Z.max()
from matplotlib.colors import LogNorm
return masked_Z, LogNorm(vmin=vmin, vmax=vmax)
def fix_pcolor_norm(args, kwargs):
args = [a for a in args]
if 'vlog' in kwargs and kwargs['vlog']:
zmin = kwargs.pop("vmin", None)
zmax = kwargs.pop("vmax", None)
args[2], kwargs['norm']= log_norm(args[2], zmin, zmax)
del kwargs['vlog']
else:
for name in ("vmin", "vmax"):
if name in kwargs:
kwargs[name] = UnitlessArgs.value_in_z_unit(kwargs[name])
return args, kwargs
def has_log_scaling(array):
diff = numpy.diff(array)
if numpy.all(diff - diff[0] < diff[0]/10.):
return False
logdiff = numpy.diff(numpy.log10(array))
if numpy.all(logdiff - logdiff[0] < logdiff[0]/10.):
return True
raise AmuseException("This method cannot be used for non regular arrays")
def imshow_color_plot(x, y, z, label=None, add_colorbar=False, **kwargs):
"""
Plot a density matrix as a color map using imshow,
this gives a smoother image then pcolor(mesh)
It only works if x and y are regular (linear or logarithmic).
"""
X, Y, Z = UnitlessArgs.strip(x, y, z)
X, Y, Z = fix_xyz_axes(X, Y, Z)
xlow = X[0,0]
xhigh = X[-1,-1]
ylow = Y[0,0]
yhigh = Y[-1,-1]
extent = (xlow, xhigh, ylow, yhigh)
(X, Y, Z), kwargs = fix_pcolor_norm((X, Y, Z), kwargs)
kwargs['origin'] = 'lower'
kwargs['aspect'] = 'auto'
kwargs['extent'] = extent
cax = native_plot.imshow(Z, **kwargs)
if has_log_scaling(X[0,:]):
native_plot.gca().set_xscale('log')
if has_log_scaling(Y[:,0]):
native_plot.gca().set_yscale('log')
native_plot.xlabel(UnitlessArgs.x_label())
native_plot.ylabel(UnitlessArgs.y_label())
if add_colorbar:
bar = native_plot.colorbar(cax)
bar.set_label(UnitlessArgs.z_label(label))
return cax, bar
else:
return cax
def pcolor(*args, **kwargs):
stripped_args = UnitlessArgs.strip(*args)
stripped_args, kwargs = fix_pcolor_norm(stripped_args, kwargs)
result = native_plot.pcolor(*stripped_args, **kwargs)
native_plot.xlabel(UnitlessArgs.x_label())
native_plot.ylabel(UnitlessArgs.y_label())
return result
def pcolormesh(*args, **kwargs):
stripped_args = UnitlessArgs.strip(*args)
stripped_args, kwargs = fix_pcolor_norm(stripped_args, kwargs)
result = native_plot.pcolormesh(*stripped_args, **kwargs)
native_plot.xlabel(UnitlessArgs.x_label())
native_plot.ylabel(UnitlessArgs.y_label())
return result
def contour(*args, **kwargs):
if len(args)%2 == 0:
stripped_args = UnitlessArgs.strip(*args[:-1])
levels = args[-1]
z_unit = UnitlessArgs.arg_units[-1]
if quantities.is_quantity(levels):
stripped_args.append(levels.value_in(z_unit))
else:
stripped_args = UnitlessArgs.strip(*args)
if 'levels' in kwargs:
levels = kwargs['levels']
z_unit = UnitlessArgs.arg_units[-1]
if quantities.is_quantity(levels):
kwargs['levels'] = levels.value_in(z_unit)
result = native_plot.contour(*stripped_args, **kwargs)
native_plot.xlabel(UnitlessArgs.x_label())
native_plot.ylabel(UnitlessArgs.y_label())
return result
def smart_length_units_for_vector_quantity(quantity):
length_units = [units.Mpc, units.kpc, units.parsec, units.AU, units.RSun, units.km]
total_size = max(quantity) - min(quantity)
for length_unit in length_units:
if total_size > (1 | length_unit):
return length_unit
return units.m
def sph_particles_plot(particles, u_range = None, min_size = 100, max_size = 10000,
alpha = 0.1, gd_particles=None, width=None, view=None):
"""
Very simple and fast procedure to make a plot of the hydrodynamics state of
a set of SPH particles. The particles must have the following attributes defined:
position, u, h_smooth.
For a more accurate plotting procedure, see for example:
examples/applications/christmas_card_2010.py
:argument particles: the SPH particles to be plotted
:argument u_range: range of internal energy for color scale [umin, umax]
:argument min_size: minimum size to use for plotting particles, in pixel**2
:argument max_size: maximum size to use for plotting particles, in pixel**2
:argument alpha: the opacity of each particle
:argument gd_particles: non-SPH particles can be indicated with white circles
:argument view: the (physical) region to plot [xmin, xmax, ymin, ymax]
"""
positions = particles.position
us = particles.u
h_smooths = particles.h_smooth
x, y, z = positions.x, positions.y, positions.z
z, x, y, us, h_smooths = z.sorted_with(x, y, us, h_smooths)
if u_range:
u_min, u_max = u_range
else:
u_min, u_max = min(us), max(us)
log_u = numpy.log((us / u_min)) / numpy.log((u_max / u_min))
clipped_log_u = numpy.minimum(numpy.ones_like(log_u), numpy.maximum(numpy.zeros_like(log_u), log_u))
red = 1.0 - clipped_log_u**4
blue = clipped_log_u**4
green = numpy.minimum(red, blue)
colors = numpy.transpose(numpy.array([red, green, blue]))
n_pixels = native_plot.gcf().get_dpi() * native_plot.gcf().get_size_inches()
current_axes = native_plot.gca()
try:
current_axes.set_facecolor('#101010')
except:
current_axes.set_axis_bgcolor('#101010')
if width is not None:
view = width * [-0.5, 0.5, -0.5, 0.5]
if view:
current_axes.set_aspect("equal", adjustable = "box")
length_unit = smart_length_units_for_vector_quantity(view)
current_axes.set_xlim(view[0].value_in(length_unit),
view[1].value_in(length_unit), emit=True, auto=False)
current_axes.set_ylim(view[2].value_in(length_unit),
view[3].value_in(length_unit), emit=True, auto=False)
phys_to_pix2 = n_pixels[0]*n_pixels[1] / ((view[1]-view[0])**2 + (view[3]-view[2])**2)
else:
current_axes.set_aspect("equal", adjustable = "datalim")
length_unit = smart_length_units_for_vector_quantity(x)
phys_to_pix2 = n_pixels[0]*n_pixels[1] / ((max(x)-min(x))**2 + (max(y)-min(y))**2)
sizes = numpy.minimum(numpy.maximum((h_smooths**2 * phys_to_pix2), min_size), max_size)
x = x.as_quantity_in(length_unit)
y = y.as_quantity_in(length_unit)
scatter(x, y, s=sizes, c=colors, edgecolors="none", alpha=alpha)
if gd_particles:
scatter(gd_particles.x, gd_particles.y, c='w', marker='o')
xlabel('x')
ylabel('y')
def convert_particles_to_pynbody_data(particles, length_unit=units.kpc, pynbody_unit="kpc"):
if not HAS_PYNBODY:
raise AmuseException("Couldn't find pynbody")
if hasattr(particles, "u"):
pynbody_data = new(gas=len(particles))
else:
pynbody_data = new(dm=len(particles))
pynbody_data._filename = "AMUSE"
if hasattr(particles, "mass"):
pynbody_data['mass'] = SimArray(particles.mass.value_in(units.MSun), "Msol")
if hasattr(particles, "position"):
pynbody_data['x'] = SimArray(particles.x.value_in(length_unit), pynbody_unit)
pynbody_data['y'] = SimArray(particles.y.value_in(length_unit), pynbody_unit)
pynbody_data['z'] = SimArray(particles.z.value_in(length_unit), pynbody_unit)
if hasattr(particles, "velocity"):
pynbody_data['vx'] = SimArray(particles.vx.value_in(units.km / units.s), "km s^-1")
pynbody_data['vy'] = SimArray(particles.vy.value_in(units.km / units.s), "km s^-1")
pynbody_data['vz'] = SimArray(particles.vz.value_in(units.km / units.s), "km s^-1")
if hasattr(particles, "h_smooth"):
pynbody_data['smooth'] = SimArray(particles.h_smooth.value_in(length_unit), pynbody_unit)
if hasattr(particles, "rho"):
pynbody_data['rho'] = SimArray(particles.rho.value_in(units.g / units.cm**3),
"g cm^-3")
if hasattr(particles, "temp"):
pynbody_data['temp'] = SimArray(particles.temp.value_in(units.K), "K")
elif hasattr(particles, "u"):
# pynbody_data['u'] = SimArray(particles.u.value_in(units.km**2 / units.s**2), "km^2 s^-2")
temp = 2.0/3.0 * particles.u * mu() / constants.kB
pynbody_data['temp'] = SimArray(temp.value_in(units.K), "K")
return pynbody_data
def mu(X = None, Y = 0.25, Z = 0.02, x_ion = 0.1):
"""
Compute the mean molecular weight in kg (the average weight of particles in a gas)
X, Y, and Z are the mass fractions of Hydrogen, of Helium, and of metals, respectively.
x_ion is the ionisation fraction (0 < x_ion < 1), 1 means fully ionised
"""
if X is None:
X = 1.0 - Y - Z
elif abs(X + Y + Z - 1.0) > 1e-6:
raise AmuseException("Error in calculating mu: mass fractions do not sum to 1.0")
return constants.proton_mass / (X*(1.0+x_ion) + Y*(1.0+2.0*x_ion)/4.0 + Z*x_ion/2.0)
def _smart_length_units_for_pynbody_data(length):
length_units = [(units.Gpc, "Gpc"), (units.Mpc, "Mpc"), (units.kpc, "kpc"),
(units.parsec, "pc"), (units.AU, "au"), (1.0e9*units.m, "1.0e9 m"),
(1000*units.km, "1000 km"), (units.km, "km")]
for length_unit, pynbody_unit in length_units:
if length > (1 | length_unit):
return length_unit, pynbody_unit
return units.m, "m"
def pynbody_column_density_plot(particles, width=None, qty='rho', units=None,
sideon=False, faceon=False, **kwargs):
if not HAS_PYNBODY:
raise AmuseException("Couldn't find pynbody")
if width is None:
width = 2.0 * particles.position.lengths_squared().amax().sqrt()
length_unit, pynbody_unit = _smart_length_units_for_pynbody_data(width)
pyndata = convert_particles_to_pynbody_data(particles, length_unit, pynbody_unit)
UnitlessArgs.strip([1]|length_unit, [1]|length_unit)
if sideon:
function = pynbody_sph.sideon_image
elif faceon:
function = pynbody_sph.faceon_image
else:
function = pynbody_sph.image
if units is None and qty == 'rho':
units = 'm_p cm^-2'
result = function(pyndata, width=width.value_in(length_unit), qty=qty, units=units, **kwargs)
UnitlessArgs.current_plot = native_plot.gca()
return result
def effective_iso_potential_plot(gravity_code,
omega,
center_of_rotation = [0, 0]|units.AU,
xlim = [-1.5, 1.5] | units.AU,
ylim = [-1.5, 1.5] | units.AU,
resolution = [1000, 1000],
number_of_contours = 20,
fraction_screen_filled = 0.5,
quadratic_contour_levels = True,
contour_kwargs = dict(),
omega2 = None,
center_of_rotation2 = [0, 0]|units.AU,
fraction_screen_filled2 = 0.2,
projection3D=False):
"""
Create a contour plot of the effective potential of particles in a gravity code.
The code needs to support 'get_potential_at_point' only, so it can also be an
instance of Bridge.
:argument gravity_code: an instance of a gravity code
:argument omega: The angular velocity of the system
:argument center_of_rotation: The (2D) center around which the system rotates, usually the center of mass
:argument xlim: Range in x coordinate; width of window
:argument ylim: Range in y coordinate; width of window
:argument resolution: Number of points to sample potential for x and y direction
:argument number_of_contours: How many contour lines to plot
:argument fraction_screen_filled: Lowest contour will enclose this fraction of the screen
:argument quadratic_contour_levels: Quadratic or linear scaling between contour levels
:argument contour_kwargs: Optional keyword arguments for pyplot.contour
"""
UnitlessArgs.strip(xlim, ylim)
xlim, ylim = UnitlessArgs.stripped_args
x_num = numpy.linspace(xlim[0], xlim[1], resolution[0])
y_num = numpy.linspace(ylim[0], ylim[1], resolution[1])
x_num, y_num = numpy.meshgrid(x_num, y_num)
x = (x_num | UnitlessArgs.arg_units[0]).flatten()
y = (y_num | UnitlessArgs.arg_units[1]).flatten()
zeros = x.aszeros()
potential = gravity_code.get_potential_at_point(zeros, x, y, zeros)
potential -= omega**2 * ((x-center_of_rotation[0])**2 + (y-center_of_rotation[1])**2) / 2.0
if projection3D:
from matplotlib import cm
ax = native_plot.gca(projection='3d')
Z = potential.number.reshape(resolution[::-1])
levels = set_contour_levels(potential, number_of_contours, fraction_screen_filled, quadratic_contour_levels)
Z = numpy.maximum(Z, levels[0])
ax.plot_surface(x_num, y_num, Z, rstride=1, cstride=1, cmap=cm.spectral,
linewidth=0, antialiased=False, vmin=levels[0], vmax=3*levels[-1]-2*levels[0])
ax.set_xlabel('X')
ax.set_xlim(-1, 1)
ax.set_ylabel('Y')
ax.set_ylim(-1, 1)
ax.set_zlabel('Z')
ax.set_zlim(levels[0], levels[-1])
return potential
levels = set_contour_levels(potential, number_of_contours, fraction_screen_filled, quadratic_contour_levels)
CS = native_plot.contour(x_num, y_num, potential.number.reshape(resolution[::-1]), levels, **contour_kwargs)
#~native_plot.clabel(CS, inline=1, fontsize=10)
if omega2 is None:
return potential
potential2 = potential - omega2**2 * ((x-center_of_rotation2[0])**2 + (y-center_of_rotation2[1])**2) / 2.0
#~levels = set_contour_levels(potential, number_of_contours2, fraction_screen_filled2, quadratic_contour_levels2)
levels = set_contour_levels(potential2, number_of_contours, fraction_screen_filled2, quadratic_contour_levels)
CS = native_plot.contour(x_num, y_num, potential2.number.reshape(resolution[::-1]), levels, **contour_kwargs)
return potential.reshape(resolution[::-1]), potential2.reshape(resolution[::-1])
def set_contour_levels(potential, number_of_contours, fraction_screen_filled, quadratic_contour_levels):
uniform = numpy.linspace(0.0, 1.0, number_of_contours)
V_max = potential.amax().number
V_min = potential.sorted().number[int(len(potential)*(1-fraction_screen_filled))]
if quadratic_contour_levels:
levels = V_min + (V_max-V_min) * uniform * (2 - uniform)
else:
levels = V_min + (V_max-V_min) * uniform
return levels
| 22,278
| 35.463175
| 117
|
py
|
amuse
|
amuse-main/src/amuse/test/amusetest.py
|
import unittest
import numpy
import os
import sys
import inspect
import tempfile
from amuse.support import _Defaults
from amuse.support import exceptions
from amuse.support import literature
from amuse.support import options
from amuse.support.core import late
from amuse.support import get_amuse_root_dir
from amuse.units.quantities import none
from amuse.units.quantities import Quantity
from amuse.units.quantities import to_quantity
from amuse.units.quantities import is_quantity
_MAX_LENGTH = 80
def safe_repr(obj, short=False):
try:
result = repr(obj)
except Exception:
result = object.__repr__(obj)
if not short or len(result) < _MAX_LENGTH:
return result
return result[:_MAX_LENGTH] + ' [truncated]...'
class SkipTest(exceptions.AmuseException):
pass
class TestCase(unittest.TestCase):
PRECISION = int(round(numpy.log10(2.0/(numpy.finfo(numpy.double).eps))))-1
def setUp(self):
literature.TrackLiteratureReferences.suppress_output()
def _check_comparable(self, first, second):
if is_quantity(first):
# if the second is not a quantity and the first does not have the none unit then
# we are comparing a quantity with a non-quanity
if not is_quantity(second) and not first.unit.base == none.base:
raise TypeError("Cannot compare quantity: {0} with non-quantity: {1}.".format(first, second))
elif is_quantity(second):
# by definition the first is not a quantity, so only check if second unit is not none
if not second.unit.base == none.base:
raise TypeError("Cannot compare non-quantity: {0} with quantity: {1}.".format(first, second))
def _convert_to_numeric(self, first, second, in_units):
if in_units:
return (first.value_in(in_units), second.value_in(in_units))
elif is_quantity(first) or is_quantity(second):
return (to_quantity(first).value_in(to_quantity(second).unit),
to_quantity(second).value_in(to_quantity(second).unit))
else:
return (first, second)
def _convert_to_vectors(self, first, second):
x = first if is_quantity(first) else numpy.array(first)
y = second if is_quantity(second) else numpy.array(second)
try:
# Using numpy broadcasting to convert the arguments to arrays with equal length:
return (x+(y*0)).flatten(), (y+(x*0)).flatten()
except:
#raise
raise TypeError("Arguments do not have compatible shapes for broadcasting")
def _raise_exceptions_if_any(self, failures, first, second, err_fmt_string, msg, *args):
if len(failures) == 1:
if failures[0]:
raise self.failureException(msg or err_fmt_string.format(first, second, *args))
elif any(failures):
first, second = self._convert_to_vectors(first, second)
err_list = [("@{0}, ".format(i)+err_fmt_string.format(first[i], second[i], *args))
for (i,b) in enumerate(failures) if b]
err = '\n'.join(err_list)
raise self.failureException(msg or err)
def failUnlessEqual(self, first, second, msg = None, in_units = None):
self._check_comparable(first, second)
first_num, second_num = self._convert_to_numeric(first, second, in_units)
failures = numpy.array(first_num != second_num).flatten()
self._raise_exceptions_if_any(failures, first, second, '{0} != {1}', msg)
assertEqual = failUnlessEqual
assertEquals = failUnlessEqual
def failUnlessAlmostEqual(self, first, second, places=7, msg=None, in_units=None):
"""Fail if the two objects are unequal as determined by their
difference rounded to the given number of decimal places
(default 7) and comparing to zero.
Note that decimal places (from zero) are usually not the same
as significant digits (measured from the most signficant digit).
The AmuseTestcase differs from the defaulat unittest.Testcase in that
it implements an abs function that can handle quantities.
If the base unit for the test (in_units) is not supplied, the
difference of the two objects is evaluated in units of [second.unit].
"""
self._check_comparable(first, second)
first_num, second_num = self._convert_to_numeric(first, second, in_units)
failures = numpy.array(numpy.round(second_num - first_num, places) != 0).flatten()
self._raise_exceptions_if_any(failures, first, second, '{0} != {1} within {2} places', msg, places)
assertAlmostEqual = failUnlessAlmostEqual
assertAlmostEquals = failUnlessAlmostEqual
def failUnlessAlmostRelativeEqual(self, first, second, places=None, msg=None):
self._check_comparable(first, second)
first_num, second_num = self._convert_to_numeric(first, second, None)
if places is None:
places = self.PRECISION
if places <= 0:
places = self.PRECISION + places
maxRelativeError = 0.1 ** places
diff = numpy.abs(second_num - first_num)
is_one_zero = second_num * first_num == 0.0
is_failure_for_one_zero = diff >= (maxRelativeError)
first_for_div = first_num + (is_one_zero * 1.0)
second_for_div = second_num + (is_one_zero * 1.0)
relative_error = numpy.maximum(numpy.abs(diff /(first_for_div)), numpy.abs(diff /(second_for_div)))
is_failure_for_both_nonzero = relative_error >= maxRelativeError
failures = numpy.where(is_one_zero, is_failure_for_one_zero, is_failure_for_both_nonzero)
failures = failures.flatten()
self._raise_exceptions_if_any(failures, first, second, "{0!r} != {1!r} within {2!r} places", msg, places)
assertAlmostRelativeEqual = failUnlessAlmostRelativeEqual
assertAlmostRelativeEquals = failUnlessAlmostRelativeEqual
def assertIsOfOrder(self, first, second, msg=None):
ratio = first*1.0/second
if isinstance(ratio, Quantity):
raise self.failureException(msg or "Units of {0!r} and {1!r} do not match.".format(first, second))
failures = numpy.array(numpy.round(numpy.log10(ratio)) != 0).flatten()
self._raise_exceptions_if_any(failures, first, second, '{0} is not of order {1}', msg)
def assertIsWithinFraction(self, first, second, fraction=0.05, msg=None):
ratio = first*1.0/second
if isinstance(ratio, Quantity):
raise self.failureException(msg or "Units of {0!r} and {1!r} do not match.".format(first, second))
failures = numpy.array(abs(ratio) < 0).flatten()
self._raise_exceptions_if_any(failures, first, second, '{0} is not of order {1}', msg)
def assertRaises(self, exception, callable, *list_args, **keyword_args):
if 'expected_message' in keyword_args:
exception_message = keyword_args.pop('expected_message')
try:
callable(*list_args, **keyword_args)
except exception as ex:
self.assertEqual(str(ex), exception_message)
else:
raise self.failureException("Exception '{0}' was not raised.".format(exception))
else:
unittest.TestCase.assertRaises(self, exception, callable, *list_args, **keyword_args)
def assertGreaterEqual(self, a, b, msg=None):
"""Just like self.assertTrue(a >= b), but with a nicer default message."""
if not a >= b:
standardMsg = '%s not greater than or equal to %s' % (repr(a), repr(b))
self.fail(self._formatMessage(msg, standardMsg))
def assertLess(self, a, b, msg=None):
"""Just like self.assertTrue(a < b), but with a nicer default message."""
if not a < b:
standardMsg = '%s not less than %s' % (repr(a), repr(b))
self.fail(self._formatMessage(msg, standardMsg))
def run(self, result=None):
if hasattr(unittest, 'SkipTest'):
return unittest.TestCase.run(self, result)
if result is None:
result = self.defaultTestResult()
result.startTest(self)
testMethod = getattr(self, self._testMethodName)
try:
try:
self.setUp()
except KeyboardInterrupt:
raise
except:
result.addError(self, sys.exc_info())
return
ok = False
try:
testMethod()
ok = True
except self.failureException:
result.addFailure(self, sys.exc_info())
except SkipTest as ex:
ok = True
pass
except KeyboardInterrupt:
raise
except:
result.addError(self, sys.exc_info())
try:
self.tearDown()
except KeyboardInterrupt:
raise
except:
result.addError(self, sys.exc_info())
ok = False
if ok:
result.addSuccess(self)
finally:
result.stopTest(self)
@staticmethod
def skip(reason):
try:
from pytest import skip
skip(reason)
except ImportError:
if hasattr(unittest, 'SkipTest'):
raise unittest.SkipTest(reason)
else:
raise SkipTest(reason)
@staticmethod
def get_path_to_results():
return get_path_to_results()
@staticmethod
def get_amuse_root_dir():
return get_amuse_root_dir()
class TestWithMPI(TestCase):
def setUp(self):
TestCase.setUp(self)
from amuse.rfi.core import is_mpd_running
self.assertTrue(is_mpd_running(), "MPICH2 mpd deamon process not running, cannot run this test as it requires MPI")
def tearDown(self):
from amuse.rfi.core import stop_interfaces
#leave the distributed code alone, stop the rest
#stop_interfaces(exceptions= ['DistributedAmuseInterface'])
def new_instance(self, factory, *arguments, **kwarguments):
try:
return factory(*arguments, **kwarguments)
except Exception as message:
if os.path.exists(os.path.join(os.path.dirname(inspect.getfile(factory)),'src')):
raise
self.skip("Tried to instantiate a new object of the code with type '{0}', but this code is not available".format(factory))
@classmethod
def new_instance_of_an_optional_code(cls, factory, *arguments, **kwarguments):
try:
return factory(*arguments, **kwarguments)
except Exception as message:
cls.skip("Tried to instantiate a new object of the optional code with type '{0}', but this code is not available".format(factory))
@staticmethod
def can_compile_modules():
return TestDefaults().can_run_tests_to_compile_modules
@classmethod
def check_can_compile_modules(cls):
if not cls.can_compile_modules():
cls.skip('will not run tests that compile codes')
@classmethod
def check_for_mpi(cls):
if not cls.is_mpi_enabled():
cls.skip('mpi is not enabled')
@staticmethod
def is_mpi_enabled():
try:
from amuse import config
if hasattr(config,'mpi'):
return config.mpi.is_enabled
except ImportError:
return True
class TestDefaults(_Defaults):
@late
def temporarydir(self):
dirname = tempfile.mkdtemp(dir="./")
print(f"generating temporary dir for test results: {dirname}")
return dirname
@options.option(sections=['test'])
def path_to_results(self):
name_of_testresults_directory = self.name_of_testresults_directory
if os.path.exists(os.path.abspath(name_of_testresults_directory)):
if os.access(os.path.abspath(name_of_testresults_directory), os.W_OK):
return os.path.abspath(name_of_testresults_directory)
amuse_root_dir = self.amuse_root_dir
test_results_dir = os.path.join(amuse_root_dir, self.name_of_testresults_directory)
if os.path.exists(test_results_dir):
try:
f = open(os.path.join(test_results_dir, 'test.txt'), 'w')
f.close()
return test_results_dir
except IOError as ex:
pass
else:
return self.temporarydir
@options.option(sections=['test'])
def name_of_testresults_directory(self):
return self.temporarydir
@options.option(type='boolean', sections=['test'])
def can_run_tests_to_compile_modules(self):
return True
_testdefaults=TestDefaults()
def get_path_to_results():
return _testdefaults.path_to_results
| 12,939
| 36.947214
| 142
|
py
|
amuse
|
amuse-main/src/amuse/test/compile_tools.py
|
import os
import subprocess
import time
import shlex
import numpy
import shutil
from amuse.rfi.tools import create_java
from amuse.rfi.tools import create_c
from amuse.rfi.tools import create_fortran
from amuse.rfi.core import config
from amuse.test.amusetest import get_amuse_root_dir
def get_mpicc_name():
try:
from amuse import config
is_configured = hasattr(config, 'mpi')
except ImportError:
is_configured = False
if is_configured:
return config.mpi.mpicc
else:
return os.environ['MPICC'] if 'MPICC' in os.environ else 'mpicc'
def get_mpicxx_name():
try:
from amuse import config
is_configured = hasattr(config, 'mpi')
except ImportError:
is_configured = False
if is_configured:
return config.mpi.mpicxx
else:
return os.environ['MPICXX'] if 'MPICXX' in os.environ else 'mpicxx'
def get_mpicc_flags():
try:
from amuse import config
is_configured = hasattr(config, 'compilers')
except ImportError:
is_configured = False
if is_configured:
return config.compilers.cc_flags
else:
return ""
def get_mpicxx_flags():
try:
from amuse import config
is_configured = hasattr(config, 'compilers')
except ImportError:
is_configured = False
if is_configured:
return config.compilers.cxx_flags
else:
return ""
def get_mpif90_name():
try:
from amuse import config
is_configured = hasattr(config, 'mpi')
except ImportError:
is_configured = False
if is_configured:
return config.mpi.mpif95
else:
return os.environ['MPIFC'] if 'MPIFC' in os.environ else 'mpif90'
def get_mpif90_arguments():
name = get_mpif90_name()
return list(shlex.split(name))
def has_fortran_iso_c_binding():
try:
from amuse import config
is_configured = hasattr(config, 'mpi')
except ImportError:
is_configured = False
if is_configured:
return config.compilers.fc_iso_c_bindings
else:
return False
def get_ld_flags():
try:
from amuse import config
is_configured = hasattr(config, 'compilers')
except ImportError:
is_configured = False
if is_configured:
return config.compilers.ld_flags
else:
return ""
def wait_for_file(filename):
for dt in [0.01, 0.01, 0.02, 0.05]:
if os.path.exists(filename):
return
time.sleep(dt)
def open_subprocess(arguments, stdin=None):
process = subprocess.Popen(
arguments,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=True
)
stdout, stderr = process.communicate(input=stdin)
return process, stdout, stderr
def c_compile(objectname, string, extra_args=[]):
if os.path.exists(objectname):
os.remove(objectname)
mpicc = get_mpicc_name()
arguments = [mpicc]
arguments.extend(get_mpicc_flags().split())
rootdir = get_amuse_root_dir()
arguments.extend(["-I", rootdir + "/lib/stopcond", "-x", "c", "-c"]
+ extra_args + ["-o", objectname, "-"])
process, stderr, stdout = open_subprocess(arguments, stdin=string)
if process.returncode == 0:
wait_for_file(objectname)
if process.returncode != 0 or not os.path.exists(objectname):
raise Exception("Could not compile {0}\nstdout:\n{1}\nstderr:\n{2}\narguments:\n{3}".format(objectname, stdout, stderr, ' '.join(arguments)))
def cxx_compile(objectname, string, extra_args=[]):
if os.path.exists(objectname):
os.remove(objectname)
mpicxx = get_mpicxx_name()
arguments = [mpicxx]
arguments.extend(get_mpicxx_flags().split())
rootdir = get_amuse_root_dir()
arguments.extend(["-I", rootdir + "/lib/stopcond", "-x", "c++", "-c"]
+ extra_args + ["-o", objectname, "-"])
process, stderr, stdout = open_subprocess(arguments, stdin=string)
if process.returncode == 0:
wait_for_file(objectname)
if process.returncode != 0 or not os.path.exists(objectname):
raise Exception("Could not compile {0}\nstdout:\n{1}\nstderr:\n{2}\narguments:\n{3}".format(objectname, stdout, stderr, ' '.join(arguments)))
def c_build(exename, objectnames, extra_args=[]):
if os.path.exists(exename):
os.remove(exename)
mpicxx = get_mpicxx_name()
arguments = [mpicxx]
arguments.extend(objectnames)
arguments.append("-o")
arguments.append(exename)
if 'LIBS' in os.environ:
libs = os.environ['LIBS'].split()
arguments.extend(libs)
arguments.extend(get_ld_flags().split())
arguments.extend(extra_args)
process, stderr, stdout = open_subprocess(arguments)
if process.returncode == 0:
wait_for_file(exename)
if process.returncode != 0 or not (os.path.exists(exename)
or os.path.exists(exename+'.exe')):
raise Exception("Could not build {0}\nstdout:\n{1}\nstderr:\n{2}\narguments:\n{3}".format(exename, stdout, stderr, ' '.join(arguments)))
def build_worker(codestring, path_to_results, specification_class, write_header=True,
extra_args=[], needs_mpi = False):
path = os.path.abspath(path_to_results)
codefile = os.path.join(path, "code.o")
headerfile = os.path.join(path, "worker_code.h")
interfacefile = os.path.join(path, "interface.o")
exefile = os.path.join(path, "c_worker")
c_compile(codefile, codestring)
uc = create_c.GenerateACHeaderStringFromASpecificationClass()
uc.specification_class = specification_class
uc.needs_mpi = needs_mpi
header = uc.result
if write_header:
with open(headerfile, "w") as f:
f.write(header)
extra_args=extra_args+["-I",path]
uc = create_c.GenerateACSourcecodeStringFromASpecificationClass()
uc.specification_class = specification_class
uc.needs_mpi = needs_mpi
code = uc.result
cxx_compile(interfacefile, code if write_header else header+"\n\n"+code,
extra_args=extra_args)
c_build(exefile, [interfacefile, codefile], extra_args=extra_args)
return exefile
def c_pythondev_compile(objectname, string):
root, ext = os.path.splitext(objectname)
sourcename = root + '.c'
amuse_root = get_amuse_root_dir()
if os.path.exists(objectname):
os.remove(objectname)
with open(sourcename, "w") as f:
f.write(string)
mpicc = get_mpicc_name()
arguments = [mpicc]
arguments.extend(get_mpicc_flags().split())
arguments.extend(["-I",numpy.get_include()])
arguments.extend(["-I", amuse_root + "/lib/stopcond","-I", amuse_root + "/lib/amuse_mpi", "-fPIC", "-c", "-o", objectname, sourcename])
arguments.extend(shlex.split(config.compilers.pythondev_cflags))
process, stderr, stdout = open_subprocess(arguments)
if process.returncode == 0:
wait_for_file(objectname)
if process.returncode != 0 or not os.path.exists(objectname):
raise Exception("Could not compile {0}\nstdout:\n{1}\nstderr:\n{2}\narguments:\n{3}".format(objectname, stdout, stderr, ' '.join(arguments)))
def c_pythondev_build(exename, objectnames):
if os.path.exists(exename):
os.remove(exename)
mpicxx = get_mpicxx_name()
arguments = [mpicxx]
arguments.extend(objectnames)
arguments.extend(shlex.split(config.compilers.pythondev_ldflags))
arguments.append("-o")
arguments.append(exename)
if 'LIBS' in os.environ:
libs = os.environ['LIBS'].split()
arguments.extend(libs)
arguments.extend(get_ld_flags().split())
process, stderr, stdout = open_subprocess(arguments)
if process.returncode == 0:
wait_for_file(exename)
if process.returncode != 0 or not (os.path.exists(exename) or os.path.exists(exename+'.exe')):
raise Exception("Could not build {0}\nstdout:\n{1}\nstderr:\n{2}\narguments:\n{3}".format(exename, stdout, stderr, ' '.join(arguments)))
def c_pythondev_buildso(soname, objectnames):
if os.path.exists(soname):
os.remove(soname)
amuse_root = get_amuse_root_dir()
mpicxx = get_mpicxx_name()
arguments = [mpicxx]
arguments.extend(objectnames)
arguments.extend(shlex.split(config.compilers.pythondev_ldflags))
arguments.append("-shared")
arguments.append("-o")
arguments.append(soname)
arguments.append("-L"+amuse_root+"/lib/amuse_mpi")
arguments.append("-lamuse_mpi")
if 'LIBS' in os.environ:
libs = os.environ['LIBS'].split()
arguments.extend(libs)
arguments.extend(get_ld_flags().split())
process, stderr, stdout = open_subprocess(arguments)
if process.returncode == 0:
wait_for_file(soname)
if process.returncode != 0 or not (os.path.exists(soname)):
raise Exception("Could not build {0}\nstdout:\n{1}\nstderr:\n{2}\narguments:\n{3}".format(soname, stdout, stderr, ' '.join(arguments)))
def fortran_pythondev_buildso(soname, objectnames):
if os.path.exists(soname):
os.remove(soname)
amuse_root = get_amuse_root_dir()
arguments = get_mpif90_arguments()
arguments.extend(objectnames)
arguments.extend(shlex.split(config.compilers.pythondev_ldflags))
arguments.append("-shared")
arguments.append("-o")
arguments.append(soname)
arguments.append("-L"+amuse_root+"/lib/amuse_mpi")
arguments.append("-lamuse_mpi")
if 'LIBS' in os.environ:
libs = os.environ['LIBS'].split()
arguments.extend(libs)
arguments.extend(get_ld_flags().split())
process, stderr, stdout = open_subprocess(arguments)
if process.returncode == 0:
wait_for_file(soname)
if process.returncode != 0 or not (os.path.exists(soname)):
raise Exception("Could not build {0}\nstdout:\n{1}\nstderr:\n{2}\narguments:\n{3}".format(soname, stdout, stderr, ' '.join(arguments)))
def fortran_compile(objectname, string, extra_args=[]):
if os.path.exists(objectname):
os.remove(objectname)
root, ext = os.path.splitext(objectname)
sourcename = root + '.f90'
with open(sourcename, "w") as f:
f.write(string)
arguments = get_mpif90_arguments()
arguments.extend(["-g",
"-I{0}/lib/forsockets".format(get_amuse_root_dir())]
+ extra_args + ["-c", "-o", objectname, sourcename])
arguments.append("-Wall")
process, stderr, stdout = open_subprocess(arguments)
process.wait()
if process.returncode == 0:
wait_for_file(objectname)
if process.returncode != 0 or not os.path.exists(objectname):
raise Exception("Could not compile {0}\nstdout:\n{1}\nstderr:\n{2}\narguments:\n{3}".format(objectname, stdout, stderr, ' '.join(arguments)))
def fortran_build(exename, objectnames, extra_args=[]):
if os.path.exists(exename):
os.remove(exename)
arguments = get_mpif90_arguments()
arguments.extend(objectnames)
arguments.append("-L{0}/lib/forsockets".format(get_amuse_root_dir()))
arguments.append("-Wall")
arguments.append("-lforsockets")
arguments.extend(extra_args)
arguments.append("-o")
arguments.append(exename)
arguments.extend(get_ld_flags().split())
process, stderr, stdout = open_subprocess(arguments)
if process.returncode == 0:
wait_for_file(exename)
if process.returncode != 0 or not os.path.exists(exename):
raise Exception("Could not build {0}\nstdout:\n{1}\nstderr:\n{2}\narguments:\n{3}".format(exename, stdout, stderr, ' '.join(arguments)))
def build_java_worker(codestring, path_to_results, specification_class):
path = os.path.abspath(path_to_results)
exefile = os.path.join(path,"java_worker")
#generate interface class
interfacefile = os.path.join(path,"CodeInterface.java")
uc = create_java.GenerateAJavaInterfaceStringFromASpecificationClass()
uc.specification_class = specification_class
interface = uc.result
with open(interfacefile, "w") as f:
f.write(interface)
#generate worker class
workerfile = os.path.join(path,"Worker.java")
uc = create_java.GenerateAJavaSourcecodeStringFromASpecificationClass()
uc.specification_class = specification_class
worker = uc.result
with open(workerfile, "w") as f:
f.write(worker)
#write code imlementation to a file
codefile = os.path.join(path,"Code.java")
with open(codefile, "w") as f:
f.write(codestring)
#compile all code
if not config.java.is_enabled:
raise Exception("java not enabled")
javac = config.java.javac
if not os.path.exists(javac):
raise Exception("java compiler not available")
jar = config.java.jar
jarfile = 'worker.jar'
tmpdir = os.path.join(path, "_tmp")
shutil.rmtree(tmpdir, ignore_errors=True)
os.mkdir(tmpdir)
returncode = subprocess.call(
[javac, "-d", tmpdir, "Worker.java", "CodeInterface.java", "Code.java"],
cwd = path,
)
if returncode != 0:
print("Could not compile worker")
#make jar file
returncode = subprocess.call(
[jar, '-cf', 'worker.jar', '-C', tmpdir, '.'],
cwd = path,
)
if returncode != 0:
print("Could not compile worker")
#generate worker script
uc = create_java.GenerateAJavaWorkerScript()
uc.specification_class = specification_class
uc.code_dir = path
worker_script = uc.result
with open(exefile, "w") as f:
f.write(worker_script)
os.chmod(exefile, 0o777)
return exefile
def build_fortran_worker(codestring, path_to_results, interface, needs_mpi = True,
extra_fflags=[], extra_ldflags=[]):
path = os.path.abspath(path_to_results)
codefile = os.path.join(path,"code.o")
interfacefile = os.path.join(path,"interface.o")
exefile = os.path.join(path,"fortran_worker")
fortran_compile(codefile, codestring, extra_args=extra_fflags)
uc = create_fortran.GenerateAFortranSourcecodeStringFromASpecificationClass()
uc.specification_class = interface
uc.needs_mpi = needs_mpi
string = uc.result
fortran_compile(interfacefile, string, extra_args=extra_fflags)
fortran_build(exefile, [interfacefile, codefile], extra_args=extra_ldflags )
return exefile
| 14,500
| 28.593878
| 149
|
py
|
amuse
|
amuse-main/src/amuse/test/__init__.py
| 0
| 0
| 0
|
py
|
|
amuse
|
amuse-main/src/amuse/test/suite/__init__.py
| 0
| 0
| 0
|
py
|
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_kepler.py
|
import os
import sys
import time
from amuse.test.amusetest import TestWithMPI
import numpy
import math
from amuse.units import nbody_system
from amuse.units import units, constants
from amuse import datamodel
from amuse.ic.plummer import new_plummer_model
from amuse.community.kepler_orbiters.interface import Kepler
class TestKeplerOrbiters(TestWithMPI):
def test0(self):
instance = Kepler()
instance.stop()
def new_system_of_sun_and_earth(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
return stars
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = Kepler(convert_nbody) # , redirection="none")#, debugger="xterm")
instance.initialize_code()
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.central_particle.add_particle(stars[0])
earth = instance.orbiters.add_particle(stars[1])
instance.commit_particles()
instance.evolve_model(365 | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_at_start = earth.position.value_in(units.AU)[0]
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(position_at_start, position_after_full_rotation, 6)
instance.evolve_model(365.0 + (365.0 / 2) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 3)
instance.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 3)
instance.cleanup_code()
instance.stop()
| 2,456
| 32.202703
| 86
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_phantom.py
|
from amuse.test.amusetest import TestWithMPI
import os
import sys
import numpy
import math
from amuse.community.phantom.interface import PhantomInterface, Phantom
from amuse.datamodel import Particles
from amuse.units import nbody_system
from amuse.units import units
from amuse import datamodel
from amuse.ic import plummer
from amuse.ic.plummer import new_plummer_model
from amuse.test.suite.codes_tests.gd_tests import (
_TestGravitationalDynamicsInterface,
)
try:
from matplotlib import pyplot
HAS_MATPLOTLIB = True
except ImportError:
HAS_MATPLOTLIB = False
class TestPhantomInterface(TestWithMPI):
def gravity_code_interface(self):
return PhantomInterface
def reference_includes(self):
return "Price"
def starting_particle_index(self):
return 1
def test_initialise(self):
interface = self.gravity_code_interface()
instance = self.new_instance_of_an_optional_code(interface)
instance.initialize_code()
instance.stop()
def test_literature_reference(self):
interface = self.gravity_code_interface()
instance = self.new_instance_of_an_optional_code(interface)
instance.initialize_code()
reference_string = self.reference_includes()
self.assertTrue(
reference_string in instance.all_literature_references_string()
)
instance.stop()
def test_add_and_retrieve_particles(self):
interface = self.gravity_code_interface()
instance = self.new_instance_of_an_optional_code(interface)
instance.initialize_code()
# Phantom won't work with fewer than 7 particles!
n = 7
values = [1.0 * i for i in range(1, n)]
instance.new_particle(
values,
values,
values,
values,
values,
values,
values,
)
error = instance.commit_particles()
self.assertEqual(error, 0)
retrieved_state = instance.get_state(self.starting_particle_index())
self.assertEqual(1.0, retrieved_state['mass'])
retrieved_state = instance.get_state(
self.starting_particle_index()+n-2
)
instance.cleanup_code()
# For any particle other than a sink, Phantom has one fixed mass!
self.assertEqual(1.0, retrieved_state['mass'])
instance.stop()
def test_add_and_retrieve_sph_particles(self):
interface = self.gravity_code_interface()
instance = self.new_instance_of_an_optional_code(interface)
instance.initialize_code()
# Phantom won't work with fewer than 7 particles!
n = 100
values = [1.0 * i for i in range(1, n)]
instance.new_sph_particle(
values,
values,
values,
values,
values,
values,
values,
values,
)
error = instance.commit_particles()
self.assertEqual(error, 0)
retrieved_state = instance.get_state(self.starting_particle_index())
self.assertEqual(1.0, retrieved_state['mass'])
retrieved_state = instance.get_state(
self.starting_particle_index()+n-2
)
instance.cleanup_code()
# For any particle other than a sink, Phantom has one fixed mass!
self.assertEqual(1.0, retrieved_state['mass'])
instance.stop()
def test_parameters(self):
interface = self.gravity_code_interface()
# instance = self.new_instance_of_an_optional_code(interface)
instance = interface(redirection="none")
instance.initialize_code()
gamma, error = instance.get_gamma()
self.assertEqual(0, error)
self.assertEqual(1., gamma)
ieos, error = instance.get_ieos()
self.assertEqual(0, error)
self.assertEqual(1, ieos)
class TestPhantom(TestWithMPI):
def test_initialise(self):
instance = Phantom()
instance.stop()
def test_add_gasparticles(self):
n_particles = 10
instance = Phantom()
gas = Particles(n_particles)
gas.mass = 1 | nbody_system.mass
gas.x = numpy.arange(n_particles) | nbody_system.length
gas.y = numpy.arange(n_particles) | nbody_system.length
gas.z = 0 | nbody_system.length
gas.velocity = [0, 0, 0] | nbody_system.speed
gas.u = 0 | nbody_system.speed**2
instance.gas_particles.add_particles(gas)
self.assertEqual(10, len(instance.gas_particles))
instance.stop()
| 4,583
| 31.510638
| 76
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_create_dir.py
|
from amuse.test import amusetest
import os.path
import shutil
import subprocess
import sys
from amuse.rfi.tools import create_dir
class CreateADirectoryAndPopulateItWithFilesForACommunityCodeTest(amusetest.TestWithMPI):
def setUp(self):
self.check_can_compile_modules()
def test1(self):
instance = create_dir.CreateADirectoryAndPopulateItWithFilesForACCode()
instance.name_of_the_code_interface_class = 'TestCode'
self.assertEqual(instance.name_of_the_community_code, 'testcode')
self.assertTrue(instance.path_of_the_community_code.endswith('testcode'))
def test2(self):
root = self.get_path_to_results()
working_dir = os.path.join(root, 'testcode')
print(working_dir)
if os.path.exists(working_dir):
shutil.rmtree(working_dir)
instance = create_dir.CreateADirectoryAndPopulateItWithFilesForACCode()
instance.name_of_the_code_interface_class = 'TestCode'
instance.path_of_the_root_directory = root
# ~ if create_dir.CreateADirectoryAndPopulateItWithFiles().amuse_root_dir == os.getcwd():
# ~ self.assertEqual(instance.reference_to_amuse_path,'../..')
instance.start()
self.assertTrue(os.path.exists(working_dir))
self.assertTrue(os.path.exists(os.path.join(working_dir, 'interface.py')))
self.assertTrue(os.path.exists(os.path.join(working_dir, 'Makefile')))
call = subprocess.Popen(
'make',
cwd=working_dir,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
outputstring, errorstring = call.communicate()
self.assertEqual(call.returncode, 0)
self.assertTrue(os.path.exists(os.path.join(working_dir, 'testcode_worker')))
sys.path.insert(0, root)
try:
__import__('testcode.interface')
except:
self.fail("import of code failed")
module = sys.modules['testcode.interface']
instance = module.TestCode()
result = instance.echo_int(12)
self.assertEqual(result, 12)
instance.stop()
del sys.path[0]
self.assertTrue(os.path.exists(os.path.join(working_dir, 'worker_code.cc')))
call = subprocess.Popen(
['make', 'clean'],
cwd=working_dir,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
outputstring, errorstring = call.communicate()
print(errorstring)
self.assertFalse(os.path.exists(os.path.join(working_dir, 'worker_code.cc')))
self.assertEqual(call.returncode, 0)
if os.path.exists(working_dir):
shutil.rmtree(working_dir)
def test3(self):
root = self.get_path_to_results()
working_dir = os.path.join(root, 'testcodef')
print(working_dir)
if os.path.exists(working_dir):
shutil.rmtree(working_dir)
instance = create_dir.CreateADirectoryAndPopulateItWithFilesForAFortranCode()
instance.name_of_the_code_interface_class = 'TestCodeF'
instance.path_of_the_root_directory = root
# ~ if create_dir.CreateADirectoryAndPopulateItWithFiles().amuse_root_dir == os.getcwd():
# ~ self.assertEqual(instance.reference_to_amuse_path,'../..')
instance.start()
self.assertTrue(os.path.exists(working_dir))
self.assertTrue(os.path.exists(os.path.join(working_dir, 'interface.py')))
self.assertTrue(os.path.exists(os.path.join(working_dir, 'Makefile')))
call = subprocess.Popen(
'make',
cwd=working_dir,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
outputstring, errorstring = call.communicate()
print(errorstring)
self.assertEqual(call.returncode, 0)
self.assertTrue(os.path.exists(os.path.join(working_dir, 'testcodef_worker')))
sys.path.insert(0, root)
try:
__import__('testcodef.interface')
except:
self.fail("import of code failed")
module = sys.modules['testcodef.interface']
instance = module.TestCodeF()
result = instance.echo_int(12)
self.assertEqual(result, 12)
instance.stop()
del sys.path[0]
self.assertTrue(os.path.exists(os.path.join(working_dir, 'worker_code.f90')))
call = subprocess.Popen(
['make', 'clean'],
cwd=working_dir,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
outputstring, errorstring = call.communicate()
print(errorstring)
self.assertFalse(os.path.exists(os.path.join(working_dir, 'worker_code.f90')))
self.assertEqual(call.returncode, 0)
# if os.path.exists(working_dir):
# shutil.rmtree(working_dir)
| 4,881
| 29.898734
| 97
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_encounters.py
|
from amuse.test import amusetest
from amuse.units import units
from amuse.units import constants
from amuse.units import nbody_system
import numpy
import time
import sys
from amuse.datamodel import Particles
from amuse.datamodel import Particle
from amuse.couple import encounters
# codes to use
from amuse.community.kepler.interface import Kepler
from amuse.community.smalln.interface import SmallN
def new_binary(
mass1, mass2, semi_major_axis,
eccentricity=0, keyoffset=1,
is_at_periapsis=True,
G=nbody_system.G
):
total_mass = mass1 + mass2
mass_fraction_particle_1 = mass1 / (total_mass)
binary = Particles(keys=range(keyoffset, keyoffset+2))
binary[0].mass = mass1
binary[1].mass = mass2
binary.child1 = None
binary.child2 = None
mu = G * total_mass
if is_at_periapsis:
velocity = numpy.sqrt(mu / semi_major_axis * ((1.0 + eccentricity)/(1.0 - eccentricity)))
radius = semi_major_axis * (1.0 - eccentricity)
else:
velocity = numpy.sqrt(mu / semi_major_axis * ((1.0 - eccentricity)/(1.0 + eccentricity)))
radius = semi_major_axis * (1.0 + eccentricity)
binary[0].position = ((1.0 - mass_fraction_particle_1) * radius * [1.0, 0.0, 0.0])
binary[1].position = -(mass_fraction_particle_1 * radius * [1.0, 0.0, 0.0])
binary[0].velocity = ((1.0 - mass_fraction_particle_1) * velocity * [0.0, 1.0, 0.0])
binary[1].velocity = -(mass_fraction_particle_1 * velocity * [0.0, 1.0, 0.0])
return binary
class TryHandleEncounter(encounters.AbstractHandleEncounter, encounters.SelectNeighboursByDistanceMixin):
def __init__(self,
kepler_code,
G=nbody_system.G
):
encounters.AbstractHandleEncounter.__init__(
self,
kepler_code,
G
)
encounters.SelectNeighboursByDistanceMixin.__init__(self)
class TestAbstractHandleEncounter(amusetest.TestWithMPI):
def new_kepler(self):
x = Kepler()
x.initialize_code()
return x
def test1(self):
particles_in_encounter = Particles(2)
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [1, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [0, 0, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.5, 0] | nbody_system.speed
particles_in_encounter.radius = 0 | nbody_system.length
particles_in_field = Particles(5)
particles_in_field.mass = [1, 2, 3, 4, 5] | nbody_system.mass
particles_in_field[0].position = [2, 0, 0] | nbody_system.length
particles_in_field[1].position = [1.5, 0, 0] | nbody_system.length
particles_in_field[2].position = [0.5, 1, 0] | nbody_system.length
particles_in_field[3].position = [0.5, -0.5, 0] | nbody_system.length
particles_in_field[4].position = [0, 0, 2] | nbody_system.length
particles_in_field.velocity = [0, 0.0, 0] | nbody_system.speed
particles_in_field.radius = 0 | nbody_system.length
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.particles_in_field.add_particles(particles_in_field)
x.execute()
self.assertAlmostRelativeEqual(x.large_scale_of_particles_in_the_encounter, 1.0 | nbody_system.length)
self.assertAlmostRelativeEqual(x.small_scale_of_particles_in_the_encounter, 3.0 | nbody_system.length)
self.assertEqual(len(x.particles_close_to_encounter), 3)
self.assertAlmostRelativeEqual(x.particles_close_to_encounter.mass, [2, 3, 4] | nbody_system.mass)
def test2(self):
particles_in_encounter = Particles(keys=(1, 2))
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [1, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [0, 0, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.5, 0] | nbody_system.speed
particles_in_encounter.radius = 0 | nbody_system.length
particles_in_field = Particles(keys=(5,))
particles_in_field.mass = 2 | nbody_system.mass
particles_in_field.position = [-0.5, 0, 0] | nbody_system.length
particles_in_field.velocity = [0, 0.5, 0] | nbody_system.speed
particles_in_field.radius = 0 | nbody_system.length
particles_in_multiples = Particles()
particles_in_multiples.add_particle(particles_in_encounter[0])
multiple = particles_in_multiples[0]
multiple.components = Particles(keys=(3, 4))
multiple.components.mass = 0.5 | nbody_system.mass
multiple.components[0].position = [0, 0.1, 0] | nbody_system.length
multiple.components[1].position = [0, -0.1, 0] | nbody_system.length
multiple.components[0].velocity = [0, 0, 0.2] | nbody_system.speed
multiple.components[1].velocity = [0, 0.1, -0.2] | nbody_system.speed
multiple.components.child1 = None
multiple.components.child2 = None
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.particles_in_field.add_particles(particles_in_field)
x.existing_multiples.add_particles(particles_in_multiples)
x.execute()
self.assertEqual(len(x.all_singles_in_encounter), 3)
self.assertEqual(len(x.all_singles_in_evolve), 4)
self.assertAlmostRelativeEqual(x.all_singles_in_evolve.mass, [0.5, 0.5, 1.0, 2.0] | nbody_system.mass)
self.assertEqual(len(x.released_singles), 2)
print(x.particles_after_encounter)
child1 = x.particles_after_encounter[-2]
child2 = x.particles_after_encounter[-1]
print(child1.position)
print(child2.position)
self.assertAlmostRelativeEqual(child1.position, [1, 0.1, 0] | nbody_system.length)
self.assertAlmostRelativeEqual(child1.velocity, [0, 0.5, 0.2] | nbody_system.speed)
self.assertAlmostRelativeEqual(child2.position, [1, -0.1, 0] | nbody_system.length)
self.assertAlmostRelativeEqual(child2.velocity, [0, 0.6, -0.2] | nbody_system.speed)
def test3(self):
particles_in_encounter = Particles(keys=(1, 2))
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [1, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [0, 0, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.0, 0] | nbody_system.speed
particles_in_encounter.radius = 0 | nbody_system.length
particles_in_field = Particles(keys=(2, 4, 5, 6, 7,))
particles_in_field.mass = [1, 2, 3, 4, 5] | nbody_system.mass
particles_in_field[0].position = [2, 0, 0] | nbody_system.length
particles_in_field[1].position = [1.5, 0, 0] | nbody_system.length
particles_in_field[2].position = [0.5, 1, 0] | nbody_system.length
particles_in_field[3].position = [0.5, -0.5, 0] | nbody_system.length
particles_in_field[4].position = [0, 0, 2] | nbody_system.length
particles_in_field.velocity = [0, 0, 0] | nbody_system.speed
particles_in_field.radius = 0 | nbody_system.length
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.particles_in_field.add_particles(particles_in_field)
simple_binary = new_binary(
1 | nbody_system.mass,
1 | nbody_system.mass,
0.2 | nbody_system.length
)
def evolve_singles_in_encounter_until_end_state():
particles = x.singles_and_multiples_after_evolve
particles.add_particles(x.all_singles_in_encounter)
particles.child1 = None
particles.child2 = None
root_particle = particles.add_particle(Particle(
key=10,
mass=2.0 | nbody_system.mass,
position=particles[0:2].center_of_mass(),
velocity=particles[0:2].center_of_mass_velocity(),
))
root_particle.child1 = particles[0]
root_particle.child2 = particles[1]
particles[0].position = simple_binary[0].position + root_particle.position
particles[1].position = simple_binary[1].position + root_particle.position
particles[0].velocity = simple_binary[0].velocity + root_particle.velocity
particles[1].velocity = simple_binary[1].velocity + root_particle.velocity
x.evolve_singles_in_encounter_until_end_state = evolve_singles_in_encounter_until_end_state
x.determine_structure_of_the_evolved_state = lambda: 1
x.execute()
self.assertEqual(len(x.new_multiples), 1)
self.assertEqual(len(x.new_binaries), 1)
multiple = x.new_multiples[0]
self.assertEqual(len(multiple.components), 2)
self.assertAlmostRelativeEqual(multiple.components[0].position, simple_binary[0].position)
self.assertAlmostRelativeEqual(multiple.components[1].position, simple_binary[1].position)
def test4(self):
particles_in_encounter = Particles(keys=(1, 2))
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [1, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [0, 0, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.0, 0] | nbody_system.speed
particles_in_encounter.radius = 0 | nbody_system.length
particles_in_field = Particles(keys=(3, 4, 5, 6, 7,))
particles_in_field.mass = [1, 2, 3, 4, 5] | nbody_system.mass
particles_in_field[0].position = [2, 0, 0] | nbody_system.length
particles_in_field[1].position = [1.5, 0, 0] | nbody_system.length
particles_in_field[2].position = [0.5, 1, 0] | nbody_system.length
particles_in_field[3].position = [0.5, -0.5, 0] | nbody_system.length
particles_in_field[4].position = [0, 0, 2] | nbody_system.length
particles_in_field.velocity = [0, 0, 0] | nbody_system.speed
particles_in_field.radius = 0 | nbody_system.length
binaries = Particles(keys=(20,))
binaries[0].child1 = particles_in_encounter[0]
binaries[0].child2 = particles_in_encounter[1]
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.particles_in_field.add_particles(particles_in_field)
x.existing_binaries.add_particles(binaries)
simple_binary = new_binary(
1 | nbody_system.mass,
1 | nbody_system.mass,
0.2 | nbody_system.length
)
def evolve_singles_in_encounter_until_end_state():
particles = x.singles_and_multiples_after_evolve
particles.add_particles(x.all_singles_in_encounter)
particles.child1 = None
particles.child2 = None
root_particle = particles.add_particle(Particle(
key=10,
mass=2.0 | nbody_system.mass,
position=particles[0:2].center_of_mass(),
velocity=particles[0:2].center_of_mass_velocity(),
))
root_particle.child1 = particles[0]
root_particle.child2 = particles[1]
particles[0].position = simple_binary[0].position + root_particle.position
particles[1].position = simple_binary[1].position + root_particle.position
particles[0].velocity = simple_binary[0].velocity + root_particle.velocity
particles[1].velocity = simple_binary[1].velocity + root_particle.velocity
x.evolve_singles_in_encounter_until_end_state = evolve_singles_in_encounter_until_end_state
x.determine_structure_of_the_evolved_state = lambda: 1
x.execute()
self.assertEqual(len(x.new_multiples), 1)
self.assertEqual(len(x.new_binaries), 0)
self.assertEqual(len(x.updated_binaries), 1)
self.assertEqual(x.updated_binaries[0], binaries[0])
def test5(self):
particles_in_encounter = Particles(keys=(1, 2))
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [1, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [0, 0, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.0, 0] | nbody_system.speed
particles_in_encounter.radius = 0 | nbody_system.length
particles_in_field = Particles(keys=(2, 4, 5, 6, 7,))
particles_in_field.mass = [1, 2, 3, 4, 5] | nbody_system.mass
particles_in_field[0].position = [2, 0, 0] | nbody_system.length
particles_in_field[1].position = [1.5, 0, 0] | nbody_system.length
particles_in_field[2].position = [0.5, 1, 0] | nbody_system.length
particles_in_field[3].position = [0.5, -0.5, 0] | nbody_system.length
particles_in_field[4].position = [0, 0, 2] | nbody_system.length
particles_in_field.velocity = [0, 0, 0] | nbody_system.speed
particles_in_field.radius = 0 | nbody_system.length
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.parameters.hard_binary_factor = 1
x.small_scale_factor = 1
x.particles_in_encounter.add_particles(particles_in_encounter)
x.particles_in_field.add_particles(particles_in_field)
simple_binary = new_binary(
1 | nbody_system.mass,
1 | nbody_system.mass,
2 | nbody_system.length
)
def evolve_singles_in_encounter_until_end_state():
particles = x.singles_and_multiples_after_evolve
particles.add_particles(x.all_singles_in_encounter)
particles.child1 = None
particles.child2 = None
root_particle = particles.add_particle(Particle(
key=10,
mass=2.0 | nbody_system.mass,
position=particles[0:2].center_of_mass(),
velocity=particles[0:2].center_of_mass_velocity(),
))
root_particle.child1 = particles[0]
root_particle.child2 = particles[1]
particles[0].position = simple_binary[0].position + root_particle.position
particles[1].position = simple_binary[1].position + root_particle.position
particles[0].velocity = simple_binary[0].velocity + root_particle.velocity
particles[1].velocity = simple_binary[1].velocity + root_particle.velocity
x.evolve_singles_in_encounter_until_end_state = evolve_singles_in_encounter_until_end_state
x.determine_structure_of_the_evolved_state = lambda: 1
x.execute()
# no multiples as the binary is larger than the
# hard binary scale
self.assertEqual(len(x.new_multiples), 0)
self.assertEqual(len(x.new_binaries), 0)
def test6(self):
particles_in_encounter = Particles(keys=(1, 2, 3))
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [1, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [0, 0, 0] | nbody_system.length
particles_in_encounter[2].position = [0, 0.5, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.0, 0] | nbody_system.speed
particles_in_encounter.radius = 0 | nbody_system.length
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.small_scale_factor = 1.0
simple_binary_1 = new_binary(
1 | nbody_system.mass,
1 | nbody_system.mass,
0.4 | nbody_system.length
)
simple_binary_top = new_binary(
2 | nbody_system.mass,
1 | nbody_system.mass,
2 | nbody_system.length
)
def evolve_singles_in_encounter_until_end_state():
particles = x.singles_and_multiples_after_evolve
particles.add_particles(x.all_singles_in_encounter)
particles.child1 = None
particles.child2 = None
inner_binary_particle = particles.add_particle(Particle(
key=10,
mass=2.0 | nbody_system.mass,
position=particles[0:2].center_of_mass(),
velocity=particles[0:2].center_of_mass_velocity(),
))
inner_binary_particle.child1 = particles[0]
inner_binary_particle.child2 = particles[1]
particles[0].position = simple_binary_1[0].position + inner_binary_particle.position
particles[1].position = simple_binary_1[1].position + inner_binary_particle.position
particles[0].velocity = simple_binary_1[0].velocity + inner_binary_particle.velocity
particles[1].velocity = simple_binary_1[1].velocity + inner_binary_particle.velocity
root_particle = particles.add_particle(Particle(
key=11,
mass=3.0 | nbody_system.mass,
position=particles.center_of_mass(),
velocity=particles.center_of_mass_velocity(),
))
root_particle.child1 = inner_binary_particle
root_particle.child2 = particles[2]
inner_binary_particle.position = simple_binary_top[0].position + root_particle.position
particles[2].position = simple_binary_top[1].position + root_particle.position
inner_binary_particle.velocity = simple_binary_top[0].velocity + root_particle.velocity
particles[2].velocity = simple_binary_top[1].velocity + root_particle.velocity
x.evolve_singles_in_encounter_until_end_state = evolve_singles_in_encounter_until_end_state
x.determine_structure_of_the_evolved_state = lambda: 1
x.execute()
# no multiples as the binary is larger than the
# hard binary scale
self.assertEqual(len(x.new_multiples), 1)
self.assertEqual(len(x.new_binaries), 1)
multiple = x.new_multiples[0]
self.assertEqual(len(multiple.components), 2)
self.assertAlmostRelativeEqual(multiple.components[0].key, particles_in_encounter[0].key)
self.assertAlmostRelativeEqual(multiple.components[1].key, particles_in_encounter[1].key)
def test7(self):
particles_in_encounter = Particles(keys=(1, 2, 3))
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [1, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [0, 0, 0] | nbody_system.length
particles_in_encounter[2].position = [0, 0.5, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.0, 0] | nbody_system.speed
particles_in_encounter.radius = 0 | nbody_system.length
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.particles_in_encounter.add_particles(particles_in_encounter)
multiples = Particles()
particle_in_multiples = multiples.add_particle(particles_in_encounter[2])
particle_in_multiples.components = Particles(keys=(4, 5))
particle_in_multiples.components.mass = 1 | nbody_system.mass
particle_in_multiples.components[0].position = [0, 0, 0.2] | nbody_system.length
particle_in_multiples.components[1].position = [0, 0, -0.2] | nbody_system.length
particle_in_multiples.components.velocity = [0, 0.0, 0] | nbody_system.speed
particle_in_multiples.components.child1 = None
particle_in_multiples.components.child2 = None
x.existing_multiples.add_particles(multiples)
def evolve_singles_in_encounter_until_end_state():
particles = x.singles_and_multiples_after_evolve
particles.add_particles(x.all_singles_in_encounter)
print(particles)
particles.child1 = None
particles.child2 = None
x.evolve_singles_in_encounter_until_end_state = evolve_singles_in_encounter_until_end_state
x.determine_structure_of_the_evolved_state = lambda: 1
x.execute()
# no multiples as the binary is larger than the
# hard binary scale
self.assertEqual(len(x.new_multiples), 0)
self.assertEqual(len(x.new_binaries), 0)
self.assertEqual(len(x.dissolved_multiples), 1)
self.assertEqual(len(x.released_singles), 2)
self.assertTrue(particle_in_multiples.components[0] in x.released_singles)
self.assertTrue(particle_in_multiples.components[1] in x.released_singles)
def xtest8(self):
particles_in_encounter = Particles(3)
particles_in_encounter.mass = 1. | nbody_system.mass
particles_in_encounter[0].position = [0., 0., 0.] | nbody_system.length
particles_in_encounter[1].position = [1., 0., 0.] | nbody_system.length
particles_in_encounter[2].position = [2., 0., 0.] | nbody_system.length
particles_in_encounter.velocity = [0., 0.5, 0.] | nbody_system.speed
particles_in_encounter.radius = [0.5, 1., 0.2] | nbody_system.length
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.execute()
self.assertAlmostRelativeEqual(x.large_scale_of_particles_in_the_encounter, 2.0 | nbody_system.length)
self.assertAlmostRelativeEqual(x.small_scale_of_particles_in_the_encounter, 1.5 | nbody_system.length)
def test8b(self):
particles_in_encounter = Particles(2)
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [0, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [1, 0, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.5, 0] | nbody_system.speed
particles_in_encounter.radius = [0.5, 0.5] | nbody_system.length
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.execute()
self.assertAlmostRelativeEqual(x.initial_potential_in_field, 0 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.initial_energy, -0.75 | nbody_system.energy)
def test9(self):
particles_in_encounter = Particles(2)
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [0, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [1, 0, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.5, 0] | nbody_system.speed
particles_in_encounter.radius = [0.5, 0.5] | nbody_system.length
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.execute()
self.assertAlmostRelativeEqual(x.initial_potential_in_field, 0 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.initial_energy, -0.75 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.initial_singles_energy, -0.75 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.delta_phi_1, 0 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.initial_multiple_energy, 0 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.final_energy, -0.75 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.delta_phi_2, 0 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.final_multiple_energy, 0 | nbody_system.energy)
def test10(self):
particles_in_encounter = Particles(2)
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [0, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [1, 0, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.5, 0] | nbody_system.speed
particles_in_encounter.radius = [0.5, 0.5] | nbody_system.length
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.particles_in_field.add_particle(Particle(
mass=1 | nbody_system.mass,
position=[5, 0, 0] | nbody_system.length,
velocity=[0, 0, 0] | nbody_system.speed,
radius=0 | nbody_system.length
))
x.execute()
self.assertAlmostRelativeEqual(x.initial_potential_in_field, -0.45 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.initial_energy, -0.75 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.initial_singles_energy, -0.75 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.delta_phi_1, 0 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.initial_multiple_energy, 0 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.final_energy, -0.75 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.delta_phi_2, 0 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.final_multiple_energy, 0 | nbody_system.energy)
def test11(self):
particles_in_encounter = Particles(2)
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [0, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [1, 0, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.5, 0] | nbody_system.speed
particles_in_encounter.radius = [0.5, 0.5] | nbody_system.length
particles_in_multiples = Particles()
particles_in_multiples.add_particle(particles_in_encounter[0])
multiple = particles_in_multiples[0]
multiple.components = Particles(keys=(3, 4))
multiple.components.mass = 0.5 | nbody_system.mass
multiple.components[0].position = [0, 0.1, 0] | nbody_system.length
multiple.components[1].position = [0, -0.1, 0] | nbody_system.length
multiple.components[0].velocity = [0, 0, 0.2] | nbody_system.speed
multiple.components[1].velocity = [0, 0.1, -0.2] | nbody_system.speed
multiple.components.child1 = None
multiple.components.child2 = None
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.particles_in_field.add_particle(Particle(
mass=1 | nbody_system.mass,
position=[5, 0, 0] | nbody_system.length,
velocity=[0, 0, 0] | nbody_system.speed,
radius=0 | nbody_system.length
))
x.existing_multiples.add_particles(particles_in_multiples)
x.execute()
self.assertAlmostRelativeEqual(x.initial_potential_in_field, -0.45 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.initial_energy, -0.75 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.initial_singles_energy, -1.912495 | nbody_system.energy, 4)
self.assertAlmostRelativeEqual(x.delta_phi_1, 0.06500400 | nbody_system.energy, 4)
self.assertAlmostRelativeEqual(x.initial_multiple_energy, -1.2275 | nbody_system.energy, 4)
self.assertAlmostRelativeEqual(x.final_energy, -1.9124959996 | nbody_system.energy, 4)
self.assertAlmostRelativeEqual(x.delta_phi_2, 0 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.final_multiple_energy, 0 | nbody_system.energy)
def test12(self):
particles_in_encounter = Particles(2)
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [0, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [1, 0, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.5, 0] | nbody_system.speed
particles_in_encounter.radius = [0.5, 0.5] | nbody_system.length
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.particles_in_field.add_particle(Particle(
mass=0.1 | nbody_system.mass,
position=[1.5, 0, 0] | nbody_system.length,
velocity=[0, 0, 0] | nbody_system.speed,
radius=1 | nbody_system.length
))
x.execute()
self.assertAlmostRelativeEqual(x.initial_potential_in_field, 0 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.initial_energy, -1.016666 | nbody_system.energy, 4)
self.assertAlmostRelativeEqual(x.initial_singles_energy, -1.016666 | nbody_system.energy, 4)
self.assertAlmostRelativeEqual(x.delta_phi_1, 0 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.initial_multiple_energy, 0 | nbody_system.energy)
def test13(self):
x = TryHandleEncounter(
G=nbody_system.G,
kepler_code=self.new_kepler()
)
x.parameters.hard_binary_factor = 1
self.assertEqual(x.parameters.hard_binary_factor, 1)
self.assertEqual(x.parameters.scatter_factor, 10)
x.parameters.scatter_factor = 2
self.assertEqual(x.parameters.scatter_factor, 2)
self.assertEqual(x.get_scatter_factor(), 2)
class TestKeplerOrbits(amusetest.TestWithMPI):
def new_kepler(self):
x = Kepler()
x.initialize_code()
return x
def test1(self):
x = encounters.KeplerOrbits(self.new_kepler())
binary = new_binary(
1 | nbody_system.mass,
0.5 | nbody_system.mass,
1.2 | nbody_system.length,
)
semimajor_axis, eccentricity = x.get_semimajor_axis_and_eccentricity_for_binary_components(
binary[0],
binary[1]
)
self.assertAlmostRelativeEquals(semimajor_axis, 1.2 | nbody_system.length)
self.assertAlmostRelativeEquals(eccentricity, 0)
def test2(self):
x = encounters.KeplerOrbits(self.new_kepler())
binary = new_binary(
1 | nbody_system.mass,
0.5 | nbody_system.mass,
2.0 | nbody_system.length,
0.5,
is_at_periapsis=False
)
binary.position += [0.1, 0.2, 0.3] | nbody_system.length
binary.velocity += [0.4, 0.5, 0.6] | nbody_system.speed
dpos, dvel = x.compress_binary(
binary,
1.2 | nbody_system.length
)
center_of_mass_before = binary.center_of_mass()
center_of_mass_velocity_before = binary.center_of_mass_velocity()
binary.position += dpos
binary.velocity += dvel
center_of_mass_after = binary.center_of_mass()
center_of_mass_velocity_after = binary.center_of_mass_velocity()
self.assertAlmostRelativeEquals(center_of_mass_before, center_of_mass_after)
self.assertAlmostRelativeEquals(center_of_mass_velocity_before, center_of_mass_velocity_after)
separation = (binary[0].position - binary[1].position).length()
self.assertAlmostRelativeEquals(separation, 1.2 | nbody_system.length)
def test3(self):
x = encounters.KeplerOrbits(self.new_kepler())
binary = new_binary(
1 | nbody_system.mass,
0.5 | nbody_system.mass,
2.0 | nbody_system.length,
0.5,
is_at_periapsis=True
)
binary.position += [0.1, 0.2, 0.3] | nbody_system.length
binary.velocity += [0.4, 0.5, 0.6] | nbody_system.speed
dpos, dvel = x.expand_binary(
binary,
2.5 | nbody_system.length
)
center_of_mass_before = binary.center_of_mass()
center_of_mass_velocity_before = binary.center_of_mass_velocity()
binary.position += dpos
binary.velocity += dvel
center_of_mass_after = binary.center_of_mass()
center_of_mass_velocity_after = binary.center_of_mass_velocity()
self.assertAlmostRelativeEquals(center_of_mass_before, center_of_mass_after, 8)
self.assertAlmostRelativeEquals(center_of_mass_velocity_before, center_of_mass_velocity_after, 8)
separation = (binary[0].position - binary[1].position).length()
self.assertAlmostRelativeEquals(separation, 2.5 | nbody_system.length)
def test4(self):
converter = nbody_system.nbody_to_si(1 | units.MSun, 1 | units.AU)
kepler = Kepler(converter)
kepler.initialize_code()
x = encounters.KeplerOrbits(kepler)
binary = new_binary(
1 | units.MSun,
0.5 | units.MSun,
1.2 | units.AU,
G=constants.G
)
semimajor_axis, eccentricity = x.get_semimajor_axis_and_eccentricity_for_binary_components(
binary[0],
binary[1]
)
self.assertAlmostRelativeEquals(semimajor_axis, 1.2 | units.AU, 8)
self.assertAlmostRelativeEquals(eccentricity, 0)
class TestScaleSystem(amusetest.TestWithMPI):
def new_kepler(self, converter=None):
x = Kepler(converter)
x.initialize_code()
return x
def test1(self):
kepler = encounters.KeplerOrbits(self.new_kepler())
binary = new_binary(
1 | nbody_system.mass,
0.5 | nbody_system.mass,
1.2 | nbody_system.length,
0.5,
is_at_periapsis=False
)
binary.radius = 0 | nbody_system.length
x = encounters.ScaleSystem(kepler)
self.assertTrue((binary[0].position - binary[1].position).length() > 1.5 | nbody_system.length)
x.scale_particles_to_sphere(binary, 0.75 | nbody_system.length)
self.assertTrue((binary[0].position - binary[1].position).length() <= 1.6 | nbody_system.length)
print((binary[0].position - binary[1].position).length())
self.assertTrue((binary[0].position - binary[1].position).length() >= (1.5 - 1e-6) | nbody_system.length)
def test2(self):
kepler = encounters.KeplerOrbits(self.new_kepler())
binary = new_binary(
1 | nbody_system.mass,
0.5 | nbody_system.mass,
1.2 | nbody_system.length,
0.5,
is_at_periapsis=True
)
binary.radius = 0 | nbody_system.length
x = encounters.ScaleSystem(kepler)
self.assertTrue((binary[0].position - binary[1].position).length() < 1.5 | nbody_system.length)
x.scale_particles_to_sphere(binary, 0.75 | nbody_system.length)
self.assertTrue((binary[0].position - binary[1].position).length() <= 1.6 | nbody_system.length)
print((binary[0].position - binary[1].position).length())
self.assertTrue((binary[0].position - binary[1].position).length() >= (1.5 - 1e-6) | nbody_system.length)
def test3(self):
kepler = encounters.KeplerOrbits(self.new_kepler())
particles = Particles(keys=(1, 2))
particles.mass = 1 | nbody_system.mass
particles.child2 = None
particles.child1 = None
particles[0].position = [1, 0, 0] | nbody_system.length
particles[0].velocity = [1, 0.0, 0] | nbody_system.speed
particles[1].position = [-1, 0, 0] | nbody_system.length
particles[1].velocity = [-1, 0.0, 0] | nbody_system.speed
particles.radius = 0 | nbody_system.length
x = encounters.ScaleSystem(kepler)
print((particles[0].position - particles[1].position).length())
self.assertTrue((particles[0].position - particles[1].position).length() > 1.5 | nbody_system.length)
x.scale_particles_to_sphere(particles, 0.75 | nbody_system.length)
self.assertTrue((particles[0].position - particles[1].position).length() <= 1.6 | nbody_system.length)
print(particles)
self.assertTrue((particles[0].position - particles[1].position).length() >= (1.5 - 1e-6) | nbody_system.length)
self.assertAlmostRelativeEquals(particles[0].position, [0.75, 0, 0] | nbody_system.length)
self.assertAlmostRelativeEquals(particles[1].position, [-0.75, 0, 0] | nbody_system.length)
def test4(self):
kepler = encounters.KeplerOrbits(self.new_kepler())
particles = Particles(keys=(1, 2, 3, 4, 5, 6))
particles.child2 = None
particles.child1 = None
particles.mass = 1 | nbody_system.mass
for i in range(3):
position = [0, 0, 0] | nbody_system.length
position[i] = 1 | nbody_system.length
particles[i].position = position
position[i] = -1 | nbody_system.length
particles[i+3].position = position
velocity = [0, 0, 0] | nbody_system.speed
velocity[i] = 1 | nbody_system.speed
particles[i].velocity = velocity
velocity[i] = -1 | nbody_system.speed
particles[i+3].velocity = velocity
particles.radius = 0 | nbody_system.length
x = encounters.ScaleSystem(kepler)
potential_energy0 = particles.potential_energy(G=nbody_system.G)
kinetic_energy0 = particles.kinetic_energy()
x.scale_particles_to_sphere(particles, 0.5 | nbody_system.length)
self.assertAlmostRelativeEquals(particles[0].position, [1/numpy.sqrt(2), 0, 0] | nbody_system.length)
self.assertAlmostRelativeEquals(particles[3].position, [-1/numpy.sqrt(2), 0, 0] | nbody_system.length)
self.assertAlmostRelativeEquals(particles[0].velocity, [1.542, 0, 0] | nbody_system.speed, 3)
self.assertAlmostRelativeEquals(particles[3].velocity, [-1.542, 0, 0] | nbody_system.speed, 3)
potential_energy1 = particles.potential_energy(G=nbody_system.G)
kinetic_energy1 = particles.kinetic_energy()
self.assertAlmostRelativeEquals(potential_energy0 + kinetic_energy0, potential_energy1 + kinetic_energy1)
def test5(self):
converter = nbody_system.nbody_to_si(1 | units.MSun, 1 | units.AU)
kepler = encounters.KeplerOrbits(self.new_kepler(converter))
particles = Particles(keys=(1, 2, 3))
particles.child2 = None
particles.child1 = None
particles.position = [
[-1.28230200e-05, -3.69457095e-05, -2.02383488e-05],
[-2.91749746e-05, -1.21387289e-05, 1.56377986e-07],
[2.92123436e-05, 1.22463965e-05, -9.73992061e-08]
] | units.parsec
particles.velocity = [
[-8685.98414414, -413260.30543051, -135268.19175611],
[19639.55455979, -30251.55372943, 972.69648982],
[-19614.24178601, 31455.88066005, -578.49669843]
] | (units.m / units.s)
particles.mass = [0.14571045, 50., 50.] | units.MSun
particles.radius = [8, 0., 0.0] | units.AU
x = encounters.ScaleSystem(kepler, G=constants.G)
potential_energy0 = particles.potential_energy()
kinetic_energy0 = particles.kinetic_energy()
x.scale_particles_to_sphere(particles, 4 | units.AU)
potential_energy1 = particles.potential_energy()
kinetic_energy1 = particles.kinetic_energy()
self.assertAlmostRelativeEquals(potential_energy0 + kinetic_energy0, potential_energy1 + kinetic_energy1)
class TestHandleEncounter(amusetest.TestWithMPI):
def new_kepler(self):
x = Kepler()
x.initialize_code()
return x
def test1(self):
particles_in_encounter = Particles(keys=(1, 2, 3))
particles_in_encounter.mass = 1. | nbody_system.mass
particles_in_encounter[0].position = [1., 0., 0.] | nbody_system.length
particles_in_encounter[1].position = [0., 0., 0.] | nbody_system.length
particles_in_encounter[2].position = [0., 0.5, 0.] | nbody_system.length
particles_in_encounter.velocity = [0., 0.0, 0.] | nbody_system.speed
particles_in_encounter[2].velocity = [0., 0.0, 3.] | nbody_system.speed
particles_in_encounter.radius = 0. | nbody_system.length
particles_in_field = Particles()
x = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=SmallN(),
interaction_over_code=None,
G=nbody_system.G
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.execute()
self.assertEqual(len(x.new_multiples), 1)
self.assertEqual(len(x.new_binaries), 1)
multiple = x.new_multiples[0]
self.assertEqual(len(multiple.components), 2)
self.assertAlmostRelativeEqual(multiple.components[0].key, particles_in_encounter[0].key)
self.assertAlmostRelativeEqual(multiple.components[1].key, particles_in_encounter[1].key)
self.assertEqual(len(x.captured_singles), 2)
self.assertEqual(x.captured_singles.key, [1, 2])
def test2(self):
particles_in_encounter = Particles(keys=(1, 2))
particles_in_encounter.mass = 2. | nbody_system.mass
particles_in_encounter[0].position = [1., 0., 0.] | nbody_system.length
particles_in_encounter[1].position = [0., 0., 0.] | nbody_system.length
particles_in_encounter.velocity = [0., 0.0, 0.] | nbody_system.speed
particles_in_encounter.radius = 0. | nbody_system.length
binary1 = new_binary(
1. | nbody_system.mass,
1. | nbody_system.mass,
0.01 | nbody_system.length,
keyoffset=30
)
binary2 = new_binary(
1. | nbody_system.mass,
1. | nbody_system.mass,
0.01 | nbody_system.length,
keyoffset=40
)
binaries = Particles(keys=(20, 21))
binaries[0].child1 = binary1[0]
binaries[0].child2 = binary1[1]
binaries[1].child1 = binary2[0]
binaries[1].child2 = binary2[1]
binary1.child1 = None
binary1.child2 = None
binary2.child1 = None
binary2.child2 = None
multiples = Particles()
multiple = particles_in_encounter[0]
multiple.components = binary1
multiples.add_particle(multiple)
multiple = particles_in_encounter[1]
multiple.components = binary2
multiples.add_particle(multiple)
x = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=SmallN(),
interaction_over_code=None,
G=nbody_system.G
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.existing_binaries.add_particles(binaries)
x.existing_multiples.add_particles(multiples)
x.execute()
self.assertEqual(len(x.new_multiples), 2)
self.assertEqual(len(x.new_binaries), 2)
self.assertEqual(len(x.captured_singles), 0)
self.assertEqual(len(x.released_singles), 0)
multiple = x.new_multiples[0]
self.assertEqual(len(multiple.components), 2)
self.assertAlmostRelativeEqual(multiple.components[0].key, binaries[0].child1.key)
self.assertAlmostRelativeEqual(multiple.components[1].key, binaries[1].child1.key)
multiple = x.new_multiples[1]
self.assertEqual(len(multiple.components), 2)
self.assertAlmostRelativeEqual(multiple.components[0].key, binaries[0].child2.key)
self.assertAlmostRelativeEqual(multiple.components[1].key, binaries[1].child2.key)
def test3(self):
particles_in_encounter = Particles(keys=(1, 2))
particles_in_encounter.mass = 2. | nbody_system.mass
particles_in_encounter[0].position = [1., 0., 0.] | nbody_system.length
particles_in_encounter[1].position = [0., 0., 0.] | nbody_system.length
particles_in_encounter.velocity = [0., 0.0, 0.] | nbody_system.speed
particles_in_encounter.radius = 0. | nbody_system.length
binary1 = new_binary(
1. | nbody_system.mass,
1. | nbody_system.mass,
0.01 | nbody_system.length,
keyoffset=30
)
binaries = Particles(keys=(20,))
binaries[0].child1 = binary1[0]
binaries[0].child2 = binary1[1]
binary1.child1 = None
binary1.child2 = None
multiples = Particles()
multiple = particles_in_encounter[0]
multiple.components = binary1
multiples.add_particle(multiple)
x = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=SmallN(),
interaction_over_code=None,
G=nbody_system.G
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.existing_binaries.add_particles(binaries)
x.existing_multiples.add_particles(multiples)
x.execute()
self.assertEqual(len(x.new_multiples), 1)
self.assertEqual(len(x.dissolved_multiples), 1)
self.assertEqual(len(x.new_binaries), 1)
self.assertEqual(len(x.captured_singles), 1)
self.assertEqual(len(x.released_singles), 1)
multiple = x.new_multiples[0]
print(multiple.child1)
self.assertEqual(len(multiple.components), 2)
print(multiple.components)
def test4(self):
particles_in_encounter = Particles(keys=(1, 2))
particles_in_encounter.mass = 1.0 / 20.0 | nbody_system.mass
particles_in_encounter[0].position = [0.303976184547589401, 0.273137803329168094, 0.0] | nbody_system.length
particles_in_encounter[1].position = [0.290167020486133631, 0.273139253307546515, 0.0] | nbody_system.length
particles_in_encounter[0].velocity = [-2.544712989335638387, -1.224759650260411004, 0.0] | nbody_system.speed
particles_in_encounter[1].velocity = [0.898326624897966997, 0.870611747842778838, 0.0] | nbody_system.speed
particles_in_encounter.radius = 0.007 | nbody_system.length
x = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=SmallN(),
interaction_over_code=None,
G=nbody_system.G
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.execute()
self.assertEqual(len(x.new_multiples), 0)
self.assertEqual(len(x.dissolved_multiples), 0)
self.assertEqual(len(x.new_binaries), 0)
self.assertEqual(len(x.captured_singles), 0)
self.assertEqual(len(x.released_singles), 0)
r_before = (particles_in_encounter[0].position - particles_in_encounter[1].position).length()
r_after = (x.particles_after_encounter[0].position - x.particles_after_encounter[1].position).length()
print(r_before, r_after)
self.assertFalse(r_after > (10 * r_before))
def test5(self):
particles_in_encounter = Particles(keys=(1, 2))
particles_in_encounter.mass = 1.0 / 20.0 | nbody_system.mass
particles_in_encounter[0].position = [0.0779377282404, -0.559210143918, 0.0] | nbody_system.length
particles_in_encounter[1].position = [0.07802860386, -0.561207706614, 0.0] | nbody_system.length
particles_in_encounter[0].velocity = [-1.79086847491, -4.88551917358, 0.0] | nbody_system.speed
particles_in_encounter[1].velocity = [2.13208424698, 4.31403500143, 0.0] | nbody_system.speed
particles_in_encounter.radius = 0.001 | nbody_system.length
x = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=SmallN(),
interaction_over_code=None,
G=nbody_system.G
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.execute()
self.assertEqual(len(x.new_multiples), 0)
self.assertEqual(len(x.dissolved_multiples), 0)
self.assertEqual(len(x.new_binaries), 0)
self.assertEqual(len(x.captured_singles), 0)
self.assertEqual(len(x.released_singles), 0)
r_before = (particles_in_encounter[0].position - particles_in_encounter[1].position).length()
r_after = (x.particles_after_encounter[0].position - x.particles_after_encounter[1].position).length()
print(r_before, r_after)
self.assertFalse(r_after > (10 * r_before))
def test6(self):
particles_in_encounter = Particles(keys=(1, 2))
particles_in_encounter.mass = 2 | nbody_system.mass
particles_in_encounter[0].position = [1, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [0, 0, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.0, 0] | nbody_system.speed
particles_in_encounter.radius = 0 | nbody_system.length
particles_in_field = Particles(10)
particles_in_field.mass = 1 | nbody_system.mass
for i in range(len(particles_in_field)):
if i == 5:
j = len(particles_in_field)
else:
j = i
particles_in_field[i].position = [-10 + (2*j), -10 + (2*j), 0] | nbody_system.length
particles_in_field.velocity = [0, 0.0, 0] | nbody_system.speed
particles_in_field.radius = 0 | nbody_system.length
x = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=SmallN(),
interaction_over_code=None,
G=nbody_system.G
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.particles_in_field.add_particles(particles_in_field)
x.execute()
self.assertEqual(len(x.new_multiples), 1)
self.assertEqual(len(x.dissolved_multiples), 0)
self.assertEqual(len(x.new_binaries), 1)
self.assertEqual(len(x.captured_singles), 2)
self.assertEqual(len(x.released_singles), 0)
def test7(self):
particles_in_encounter = Particles(keys=(1, 2))
particles_in_encounter.mass = 2. | nbody_system.mass
particles_in_encounter[0].position = [1., 0., 0.] | nbody_system.length
particles_in_encounter[1].position = [0., 0., 0.] | nbody_system.length
particles_in_encounter.velocity = [0., 0.0, 0.] | nbody_system.speed
particles_in_encounter.radius = 0. | nbody_system.length
binary1 = new_binary(
1. | nbody_system.mass,
1. | nbody_system.mass,
0.01 | nbody_system.length,
keyoffset=30
)
binary_energy = binary1.kinetic_energy() + binary1.potential_energy(G=nbody_system.G)
self.assertAlmostRelativeEqual(binary_energy, -50 | nbody_system.energy)
binaries = Particles(keys=(20,))
binaries[0].child1 = binary1[0]
binaries[0].child2 = binary1[1]
binary1.child1 = None
binary1.child2 = None
multiples = Particles()
multiple = particles_in_encounter[0]
multiple.components = binary1
multiples.add_particle(multiple)
x = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=SmallN(),
interaction_over_code=None,
G=nbody_system.G
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.existing_binaries.add_particles(binaries)
x.existing_multiples.add_particles(multiples)
x.execute()
self.assertEqual(len(x.new_multiples), 1)
self.assertEqual(len(x.new_binaries), 1)
self.assertEqual(len(x.captured_singles), 1)
self.assertEqual(len(x.released_singles), 1)
multiple = x.new_multiples[0]
self.assertEqual(len(multiple.components), 2)
self.assertAlmostRelativeEqual(multiple.components[0].key, binaries[0].child1.key)
self.assertAlmostRelativeEqual(multiple.components[1].key, particles_in_encounter[1].key)
self.assertAlmostRelativeEqual(x.initial_multiple_energy, -50 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.final_multiple_energy, -85.651753404 | nbody_system.energy, 4)
def test8(self):
particles_in_encounter = Particles(keys=(1, 2))
particles_in_encounter[0].mass = 2. | nbody_system.mass
particles_in_encounter[1].mass = 0.1 | nbody_system.mass
particles_in_encounter[0].position = [1., 0., 0.] | nbody_system.length
particles_in_encounter[1].position = [0., 0., 0.] | nbody_system.length
particles_in_encounter.velocity = [0., 0.0, 0.] | nbody_system.speed
particles_in_encounter.radius = 0. | nbody_system.length
binary1 = new_binary(
1. | nbody_system.mass,
1. | nbody_system.mass,
0.01 | nbody_system.length,
keyoffset=30
)
binary_energy = binary1.kinetic_energy() + binary1.potential_energy(G=nbody_system.G)
self.assertAlmostRelativeEqual(binary_energy, -50 | nbody_system.energy)
binaries = Particles(keys=(20,))
binaries[0].child1 = binary1[0]
binaries[0].child2 = binary1[1]
binary1.child1 = None
binary1.child2 = None
multiples = Particles()
multiple = particles_in_encounter[0]
multiple.components = binary1
multiples.add_particle(multiple)
x = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=SmallN(),
interaction_over_code=None,
G=nbody_system.G
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.existing_binaries.add_particles(binaries)
x.existing_multiples.add_particles(multiples)
x.execute()
self.assertEqual(len(x.new_multiples), 0)
self.assertEqual(len(x.updated_multiples), 1)
self.assertEqual(len(x.new_binaries), 0)
self.assertEqual(len(x.captured_singles), 0)
self.assertEqual(len(x.released_singles), 0)
multiple = x.updated_multiples[0]
self.assertEqual(len(multiple.components), 2)
self.assertEqual(multiple.key, multiples[0].key)
self.assertEqual(multiple.components[0].key, binaries[0].child1.key)
self.assertEqual(multiple.components[1].key, binaries[0].child2.key)
self.assertAlmostRelativeEqual(x.initial_multiple_energy, -50 | nbody_system.energy)
self.assertAlmostRelativeEqual(x.final_multiple_energy, -56.2906032319 | nbody_system.energy, 4)
class TestStickyHandleEncounter(amusetest.TestWithMPI):
def test1(self):
particles_in_encounter = Particles(keys=(1, 2))
particles_in_encounter.mass = 1 | nbody_system.mass
particles_in_encounter[0].position = [1, 0, 0] | nbody_system.length
particles_in_encounter[1].position = [0, 0, 0] | nbody_system.length
particles_in_encounter.velocity = [0, 0.0, 0] | nbody_system.speed
particles_in_encounter[0].velocity = [-1, 0.0, 0] | nbody_system.speed
particles_in_encounter.radius = 0 | nbody_system.length
particles_in_field = Particles()
x = encounters.StickyHandleEncounter(
G=nbody_system.G
)
x.particles_in_encounter.add_particles(particles_in_encounter)
x.execute()
self.assertEqual(len(x.new_multiples), 1)
self.assertEqual(len(x.new_binaries), 1)
multiple = x.new_multiples[0]
self.assertEqual(len(multiple.components), 2)
self.assertAlmostRelativeEqual(multiple.components[0].key, particles_in_encounter[0].key)
self.assertAlmostRelativeEqual(multiple.components[1].key, particles_in_encounter[1].key)
self.assertEqual(len(x.captured_singles), 2)
self.assertEqual(x.captured_singles.key, [1, 2])
self.assertAlmostRelativeEqual(multiple.velocity, [-0.5, 0.0, 0] | nbody_system.speed)
self.assertAlmostRelativeEqual(multiple.mass, 2 | nbody_system.mass)
self.assertAlmostRelativeEqual(multiple.radius, 0.5 | nbody_system.length)
self.assertAlmostRelativeEqual(multiple.position, [0.5, 0, 0] | nbody_system.length)
| 56,710
| 42.224848
| 119
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_galactics.py
|
import os
import os.path
import numpy
import platform
from amuse.community import *
from amuse.test.amusetest import TestWithMPI
from amuse.community.galactics.interface import GalactICsInterface, GalactICs
# Change the default for some GalactICs(-Interface) keyword arguments:
default_options = dict()
# default_options = dict(redirection = "none")
class GalactICsInterfaceTests(TestWithMPI):
def test1(self):
print("Testing GalactICsInterface initialization")
instance = GalactICsInterface(**default_options)
self.assertEqual(instance.initialize_code(), 0)
self.assertEqual(instance.set_output_path(instance.get_output_directory()), 0)
self.assertEqual(instance.set_generate_bulge_flag(False), 0)
self.assertEqual(instance.set_generate_disk_flag(False), 0)
self.assertEqual(instance.set_order_of_multipole_expansion(0), 0)
self.assertEqual(instance.commit_parameters(), 0)
self.assertEqual(instance.cleanup_code(), 0)
instance.stop()
def test2(self):
print("Testing GalactICsInterface parameters")
instance = GalactICsInterface(**default_options)
self.assertEqual(instance.initialize_code(), 0)
self.assertEqual(instance.set_output_path(os.path.join(instance.get_output_directory(), "test")), 0)
self.assertEqual(instance.set_generate_halo_flag(False), 0)
self.assertEqual(instance.set_disk_do_center_flag(False), 0)
self.assertEqual(instance.set_number_of_grid_intervals(50000), 0)
self.assertEqual(instance.set_disk_random_seed(-1234), 0)
self.assertEqual(instance.set_halo_outer_radius(250.0), 0)
self.assertEqual(instance.set_bulge_streaming_fraction(0.4), 0)
self.assertEqual([False, 0], list(instance.get_generate_halo_flag().values()))
self.assertEqual([False, 0], list(instance.get_disk_do_center_flag().values()))
self.assertEqual([50000, 0], list(instance.get_number_of_grid_intervals().values()))
self.assertEqual([-1234, 0], list(instance.get_disk_random_seed().values()))
self.assertEqual([250.0, 0], list(instance.get_halo_outer_radius().values()))
self.assertEqual([0.4, 0], list(instance.get_bulge_streaming_fraction().values()))
self.assertEqual(instance.cleanup_code(), 0)
instance.stop()
def slowtest3(self):
print("Testing GalactICsInterface generate_particles")
n_particles_halo = 100
n_particles_bulge = 100
n_particles_disk = 100
number_of_particles = n_particles_disk + n_particles_bulge + n_particles_halo
instance = GalactICsInterface(**default_options)
self.assertEqual(instance.initialize_code(), 0)
self.assertEqual(instance.set_output_path(instance.get_output_directory()), 0)
self.assertEqual(instance.set_halo_number_of_particles(n_particles_halo), 0)
self.assertEqual(instance.set_bulge_number_of_particles(n_particles_bulge), 0)
self.assertEqual(instance.set_disk_number_of_particles(n_particles_disk), 0)
self.assertEqual(instance.commit_parameters(), 0)
self.assertEqual(list(instance.get_number_of_particles_updated().values()), [0, 0])
self.assertEqual(instance.generate_particles(), 0)
self.assertEqual(list(instance.get_number_of_particles_updated().values()), [number_of_particles, 0])
mass_disk, mass_bulge, mass_halo = 26.578816771507263, 14.632800221443176, 1184.2350006103516
masses, errors = instance.get_mass(range(number_of_particles))
self.assertEqual(errors, numpy.zeros(number_of_particles))
self.assertAlmostRelativeEquals(masses, numpy.concatenate((
numpy.ones(n_particles_disk)*mass_disk/n_particles_disk,
numpy.ones(n_particles_bulge)*mass_bulge/n_particles_bulge,
numpy.ones(n_particles_halo)*mass_halo/n_particles_halo,
)), 3)
x_positions, y_positions, z_positions, errors = instance.get_position(range(number_of_particles))
self.assertEqual(errors, numpy.zeros(number_of_particles))
self.assertAlmostEqual(numpy.array([numpy.mean(x_positions), numpy.mean(y_positions),
numpy.mean(z_positions)]), numpy.array([0.0]*3), 5)
self.assertAlmostRelativeEquals(numpy.array([
numpy.mean(abs(x_positions[:n_particles_disk])),
numpy.mean(abs(y_positions[:n_particles_disk])),
numpy.mean(abs(z_positions[:n_particles_disk]))]),
numpy.array([7.3994484072923656, 7.1570298135280606, 0.33854196755215527]), 3)
self.assertAlmostRelativeEquals(numpy.array([
numpy.mean(abs(x_positions[n_particles_disk:n_particles_disk+n_particles_bulge])),
numpy.mean(abs(y_positions[n_particles_disk:n_particles_disk+n_particles_bulge])),
numpy.mean(abs(z_positions[n_particles_disk:n_particles_disk+n_particles_bulge]))]),
numpy.array([1.244429082274437, 1.1639373835548759, 0.8550614269822836]), 3)
self.assertAlmostRelativeEquals(numpy.array([
numpy.mean(abs(x_positions[-n_particles_halo:])),
numpy.mean(abs(y_positions[-n_particles_halo:])),
numpy.mean(abs(z_positions[-n_particles_halo:]))]),
numpy.array([94.242819476127622, 88.41320479869843, 85.234394512176507]), 3)
x_velocities, y_velocities, z_velocities, errors = instance.get_velocity(range(number_of_particles))
self.assertEqual(errors, numpy.zeros(number_of_particles))
self.assertAlmostEqual(numpy.array([numpy.mean(x_velocities), numpy.mean(y_velocities),
numpy.mean(z_velocities)]), numpy.array([0.0]*3))
self.assertAlmostRelativeEquals(numpy.array([
numpy.mean(abs(x_velocities[:n_particles_disk])),
numpy.mean(abs(y_velocities[:n_particles_disk])),
numpy.mean(abs(z_velocities[:n_particles_disk]))]),
numpy.array([1.5026254250109197, 1.5649469271302223, 0.20230436498299242]), 5)
self.assertAlmostRelativeEquals(numpy.array([
numpy.mean(abs(x_velocities[n_particles_disk:])),
numpy.mean(abs(y_velocities[n_particles_disk:])),
numpy.mean(abs(z_velocities[n_particles_disk:]))]),
numpy.array([0.99470628838986164, 0.95913934175856408, 0.9359876788407564]), 5)
self.assertEqual(instance.cleanup_code(), 0)
instance.stop()
def test4(self):
print("Testing GalactICsInterface generate_particles")
number_of_particles_halo = 1000
instance = GalactICsInterface(**default_options)
self.assertEqual(instance.initialize_code(), 0)
self.assertEqual(instance.set_output_path(instance.get_output_directory()), 0)
self.assertEqual(instance.set_halo_number_of_particles(number_of_particles_halo), 0)
self.assertEqual(instance.set_generate_bulge_flag(False), 0)
self.assertEqual(instance.set_generate_disk_flag(False), 0)
self.assertEqual(instance.set_order_of_multipole_expansion(0), 0)
self.assertEqual(instance.commit_parameters(), 0)
self.assertEqual(list(instance.get_number_of_particles_updated().values()), [0, 0])
self.assertEqual(instance.generate_particles(), 0)
self.assertEqual(list(instance.get_number_of_particles_updated().values()), [number_of_particles_halo, 0])
masses, errors = instance.get_mass(range(number_of_particles_halo))
self.assertEqual(errors, numpy.zeros(number_of_particles_halo))
self.assertAlmostRelativeEquals(masses, numpy.ones(number_of_particles_halo)*masses[0])
total_mass = masses.sum()
if platform.processor() == 'ppc64le':
# on ppc64le, the model generation has small differences from intel
# change expected pos
expected_mean_pos = numpy.array([73.5628, 76.251034, 75.53434])
else:
expected_mean_pos = numpy.array([73.768384103536604, 76.03533643054962, 75.176319462463255])
expected_mean_vel = numpy.array([0.92904859858192501, 0.94953939936682585, 0.92897711758688095])
x_positions, y_positions, z_positions, errors = instance.get_position(range(number_of_particles_halo))
self.assertEqual(errors, numpy.zeros(number_of_particles_halo))
self.assertAlmostEqual(numpy.array([numpy.mean(x_positions), numpy.mean(y_positions),
numpy.mean(z_positions)]), numpy.array([0.0]*3), 5)
self.assertAlmostRelativeEquals(numpy.array([numpy.mean(abs(x_positions)), numpy.mean(abs(y_positions)),
numpy.mean(abs(z_positions))]), expected_mean_pos, 3)
x_velocities, y_velocities, z_velocities, errors = instance.get_velocity(range(number_of_particles_halo))
self.assertEqual(errors, numpy.zeros(number_of_particles_halo))
self.assertAlmostEqual(numpy.array([numpy.mean(x_velocities), numpy.mean(y_velocities),
numpy.mean(z_velocities)]), numpy.array([0.0]*3))
self.assertAlmostRelativeEquals(numpy.array([numpy.mean(abs(x_velocities)), numpy.mean(abs(y_velocities)),
numpy.mean(abs(z_velocities))]), expected_mean_vel, 2)
self.assertEqual(instance.cleanup_code(), 0)
instance.stop()
class GalactICsTests(TestWithMPI):
default_unit_converter = nbody_system.nbody_to_si(1.0 | units.kpc, 1.0e6 | units.MSun)
def test1(self):
print("Testing GalactICs initialization")
instance = GalactICs(**default_options)
instance.initialize_code()
instance.parameters.generate_bulge_flag = False
instance.parameters.generate_disk_flag = False
instance.parameters.order_of_multipole_expansion = 0
instance.commit_parameters()
instance.cleanup_code()
instance.stop()
def test2(self):
print("Testing GalactICs parameters (with unit converter)")
instance = GalactICs(self.default_unit_converter, **default_options)
instance.initialize_code()
for par, value in [('generate_halo_flag', True), ('generate_disk_flag', True),
('generate_bulge_flag', True), ('halo_do_center_flag', True),
('bulge_do_center_flag', True), ('disk_do_center_flag', True)]:
self.assertTrue(value is getattr(instance.parameters, par))
setattr(instance.parameters, par, not value)
self.assertFalse(value is getattr(instance.parameters, par))
for par, value in [('number_of_grid_intervals', 90000), ('order_of_multipole_expansion', 10),
('number_of_radial_steps_correction_fns_disk_df', 10),
('number_of_iterations_disk_df', 50), ('halo_number_of_particles', 200000),
('bulge_number_of_particles', 50000), ('disk_number_of_particles', 100000),
('halo_random_seed', -1), ('bulge_random_seed', -1), ('disk_random_seed', -1)]:
self.assertEqual(value, getattr(instance.parameters, par))
setattr(instance.parameters, par, 1)
self.assertEqual(1, getattr(instance.parameters, par))
for par, value in [('halo_outer_radius', 300.0 | nbody_system.length),
('halo_scale_velocity', 3.26331115 | nbody_system.speed),
('halo_scale_radius', 6.06699419 | nbody_system.length),
('halo_truncation_width', 100.0 | nbody_system.length)]:
self.assertEqual(instance.unit_converter.to_si(value),
getattr(instance.parameters, par))
setattr(instance.parameters, par, 3.0 | value.unit)
self.assertEqual(instance.unit_converter.to_si(3.0 | value.unit),
getattr(instance.parameters, par))
self.assertEqual(os.path.join(instance.get_output_directory()), instance.parameters.output_directory)
instance.parameters.output_directory = 'test'
self.assertEqual("test", instance.parameters.output_directory)
instance.cleanup_code()
instance.stop()
def test3(self):
print("Testing GalactICs parameters (nbody units, no converter)")
instance = GalactICs(**default_options)
instance.initialize_code()
for par, value in [('halo_outer_radius', 300.0 | nbody_system.length),
('halo_scale_velocity', 3.26331115 | nbody_system.speed),
('halo_scale_radius', 6.06699419 | nbody_system.length),
('halo_truncation_width', 100.0 | nbody_system.length)]:
self.assertEqual(value, getattr(instance.parameters, par))
setattr(instance.parameters, par, 3.0 | value.unit)
self.assertEqual(3.0 | value.unit, getattr(instance.parameters, par))
instance.cleanup_code()
instance.stop()
def slowtest4(self):
print("Testing GalactICs generate_particles")
n_particles_halo = 100
n_particles_bulge = 100
n_particles_disk = 100
number_of_particles = n_particles_disk + n_particles_bulge + n_particles_halo
instance = GalactICs(**default_options)
instance.initialize_code()
instance.parameters.disk_number_of_particles = n_particles_disk
instance.parameters.bulge_number_of_particles = n_particles_bulge
instance.parameters.halo_number_of_particles = n_particles_halo
instance.commit_parameters()
instance.generate_particles()
self.assertEqual(len(instance.particles), number_of_particles)
self.assertAlmostRelativeEquals(instance.particles.total_mass(), 1225.4466176 | nbody_system.mass, 3)
self.assertAlmostRelativeEquals(instance.particles.kinetic_energy(), 2564.69894361 | nbody_system.energy, 3)
self.assertAlmostRelativeEquals(instance.particles.potential_energy(G=nbody_system.G), -4531.58416742 | nbody_system.energy, 3)
self.assertAlmostRelativeEquals(instance.particles.virial_radius(), 165.694750127 | nbody_system.length, 3)
instance.cleanup_code()
instance.stop()
def test5(self):
print("Testing GalactICs generate_particles")
instance = GalactICs(**default_options)
instance.initialize_code()
instance.parameters.halo_number_of_particles = 1000
instance.parameters.generate_bulge_flag = False
instance.parameters.generate_disk_flag = False
instance.parameters.order_of_multipole_expansion = 0
instance.commit_parameters()
instance.generate_particles()
self.assertEqual(len(instance.particles), 1000)
accuracy = 3
mass_halo = 1178.89297009 | nbody_system.mass
expected_kinetic_energy = 2418.49730735 | nbody_system.energy
self.assertAlmostRelativeEquals(instance.particles.total_mass(), mass_halo, accuracy)
self.assertAlmostRelativeEquals(instance.particles.kinetic_energy(), expected_kinetic_energy, accuracy)
self.assertEqual(len(instance.halo_particles), 1000)
self.assertEqual(len(instance.disk_particles), 0)
self.assertEqual(len(instance.bulge_particles), 0)
instance.cleanup_code()
instance.stop()
def test6(self):
print("Testing GalactICs generate_particles: generate multiple sets")
number_of_particles = 1000
instance = GalactICs(**default_options)
instance.initialize_code()
instance.parameters.halo_number_of_particles = number_of_particles
instance.parameters.generate_bulge_flag = False
instance.parameters.generate_disk_flag = False
instance.parameters.order_of_multipole_expansion = 0
instance.parameters.halo_random_seed = -1.0
instance.commit_parameters()
instance.generate_particles()
set1 = instance.particles.copy()
self.assertEqual(len(set1), number_of_particles)
instance.generate_particles()
set2 = instance.particles.copy()
self.assertEqual(len(set2), number_of_particles)
# GalactICs' random-number generator is re-seeded with 'halo_random_seed'
# each time, and the result should be the same:
for attribute in ["mass", "x", "y", "z", "vx", "vy", "vz"]:
self.assertEqual(getattr(set1, attribute), getattr(set2, attribute))
instance.parameters.halo_random_seed = -42.0
instance.generate_particles()
# halo_random_seed changed: draw a different random set of particles
set3 = instance.particles.copy()
self.assertEqual(len(set3), number_of_particles)
self.assertEqual(set1.mass, set3.mass)
self.assertRaises(self.failureException, self.assertEqual, set1.x, set3.x)
self.assertAlmostRelativeEquals(abs(set1.x).median(), abs(set3.x).median(), 1)
self.assertAlmostRelativeEquals(abs(set1.vy).median(), abs(set3.vy).median(), 1)
instance.cleanup_code()
instance.stop()
def test7(self):
print("Testing GalactICs state")
number_of_particles = 1000
print("First do everything manually:")
instance = GalactICs(**default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.parameters.halo_number_of_particles = number_of_particles
instance.parameters.generate_bulge_flag = False
instance.parameters.generate_disk_flag = False
instance.parameters.order_of_multipole_expansion = 0
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.overridden().generate_particles()
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
instance.invoke_state_change_updated()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
self.assertEqual(len(instance.particles), number_of_particles)
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("initialize_code(), (re)commit_parameters(), update_particle_set(), "
"and cleanup_code() should be called automatically:")
instance = GalactICs(**default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.halo_number_of_particles = number_of_particles
instance.parameters.generate_bulge_flag = False
instance.parameters.generate_disk_flag = False
instance.parameters.order_of_multipole_expansion = 0
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
self.assertEqual(instance.get_number_of_particles_updated(), 0)
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.parameters.halo_random_seed = -42.0
self.assertEqual(instance.get_name_of_current_state(), 'CHANGE_PARAMETERS_EDIT')
self.assertEqual(instance.get_number_of_particles_updated(), 0)
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.generate_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
self.assertEqual(len(instance.particles), number_of_particles)
self.assertEqual(instance.get_number_of_particles_updated(), 0)
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
| 19,410
| 52.473829
| 135
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_galaxia.py
|
from amuse.test import amusetest
from amuse.units import units, nbody_system, constants
from amuse.community.galaxia.interface import BarAndSpirals3D
class TestBarAndSpirals3D(amusetest.TestCase):
def test1(self):
galaxy = BarAndSpirals3D()
self.assertEqual(galaxy.model_time, 0. | units.yr)
def test2(self):
galaxy = BarAndSpirals3D()
vc1 = galaxy.get_velcirc(10. | units.kpc, 0. | units.kpc, 0. | units.kpc)
vc2 = galaxy.get_velcirc(0. | units.kpc, 10. | units.kpc, 0. | units.kpc)
self.assertEqual(vc1, vc2)
self.assertAlmostEqual(vc1, 219.324003066 | units.kms)
| 634
| 34.277778
| 81
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_bonsai2.py
|
from amuse.community import *
from amuse.test.amusetest import TestWithMPI
from amuse.community.bonsai2.interface import Bonsai2Interface, Bonsai2
import numpy
from amuse.units import nbody_system
from amuse.units import units
from amuse import datamodel
from amuse.rfi import channel
from amuse.ic.plummer import new_plummer_model
from amuse.support.exceptions import AmuseException
default_options = dict()
# default_options = dict(redirection="none")
# default_options = dict(redirection="none", debugger="gdb")
class TestBonsaiInterface(TestWithMPI):
def test1(self):
plummer_size = 500
plummer = new_plummer_model(plummer_size)
mass = plummer.mass.number
radius = plummer.radius.number
x = plummer.x.number
y = plummer.y.number
z = plummer.z.number
vx = plummer.vx.number
vy = plummer.vy.number
vz = plummer.vz.number
instance = self.new_instance_of_an_optional_code(Bonsai2Interface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual([0, 0], list(instance.get_number_of_particles().values()))
ids, errors = instance.new_particle(mass, x, y, z, vx, vy, vz, radius)
self.assertEqual(0, errors)
self.assertEqual(list(range(plummer_size)), ids)
self.assertEqual(0, instance.commit_particles())
self.assertEqual([500, 0], list(instance.get_number_of_particles().values()))
masses, errors = instance.get_mass(range(500))
self.assertEqual(0, errors)
self.assertAlmostEqual(0.002, masses)
masses, xs, ys, zs, vxs, vys, vzs, radii, errors = instance.get_state(range(500))
self.assertEqual(0, errors)
self.assertAlmostRelativeEquals(xs, x, 6)
self.assertEqual(0, instance.evolve_model(0.00001))
energy_total_init = instance.get_potential_energy()["potential_energy"] + instance.get_kinetic_energy()["kinetic_energy"]
self.assertEqual(0, instance.evolve_model(1))
energy_total_final = instance.get_potential_energy()["potential_energy"] + instance.get_kinetic_energy()["kinetic_energy"]
self.assertAlmostRelativeEqual(energy_total_init, energy_total_final, 2)
instance.stop()
class TestBonsai(TestWithMPI):
def test1(self):
print("Testing Bonsai initialization")
instance = self.new_instance_of_an_optional_code(Bonsai2, **default_options)
instance.initialize_code()
print("cleaning the code")
instance.cleanup_code()
print("done")
instance.stop()
def test2(self):
print("Testing Bonsai parameters")
instance = self.new_instance_of_an_optional_code(Bonsai2, **default_options)
instance.initialize_code()
self.assertAlmostEqual(instance.parameters.epsilon_squared, 0.0025 | nbody_system.length**2)
self.assertAlmostEqual(instance.parameters.timestep, 1.0 / 64 | nbody_system.time)
instance.parameters.epsilon_squared = 0.01 | nbody_system.length**2
instance.parameters.timestep = 0.001 | nbody_system.time
instance.commit_parameters()
print((instance.parameters.epsilon_squared))
print((instance.parameters.timestep))
self.assertAlmostEqual(instance.parameters.epsilon_squared, 0.01 | nbody_system.length**2)
self.assertAlmostEqual(instance.parameters.timestep, 0.001 | nbody_system.time)
instance.stop()
def test3(self):
print("Testing Bonsai, N-body units")
instance = self.new_instance_of_an_optional_code(Bonsai2, **default_options)
instance.initialize_code()
plummer = new_plummer_model(500)
instance.particles.add_particles(plummer)
self.assertAlmostEqual(instance.particles.mass, 0.002 | nbody_system.mass)
instance.evolve_model(1.0 | nbody_system.time)
self.assertAlmostEqual(instance.model_time, 1.0 | nbody_system.time)
instance.stop()
def test4(self):
print("Testing Bonsai, SI units")
convert_nbody = nbody_system.nbody_to_si(100.0 | units.MSun, 1.0 | units.parsec)
instance = self.new_instance_of_an_optional_code(Bonsai2, convert_nbody, **default_options)
instance.initialize_code()
plummer = new_plummer_model(500, convert_nbody=convert_nbody)
instance.particles.add_particles(plummer)
instance.commit_particles()
instance.evolve_model(1 | nbody_system.time)
instance.stop()
def test5(self):
print("Testing Bonsai remove_particle")
convert_nbody = nbody_system.nbody_to_si(100.0 | units.MSun, 1.0 | units.parsec)
instance = self.new_instance_of_an_optional_code(Bonsai2, convert_nbody, **default_options)
instance.initialize_code()
plummer = new_plummer_model(500, convert_nbody=convert_nbody)
instance.particles.add_particles(plummer)
instance.commit_particles()
instance.particles.remove_particle(plummer[0])
# self.assertRaises(AmuseException, instance.particles.remove_particle, plummer[0],
# expected_message = "Error when calling 'delete_particle' of a 'Bonsai', errorcode is -2")
print(instance.particles[0].mass)
instance.stop()
def test6(self):
print("Testing Bonsai states")
plummer = new_plummer_model(500)
print("First do everything manually:")
instance = self.new_instance_of_an_optional_code(Bonsai2, **default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particles(plummer)
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
mass = instance.particles[0].mass
instance.evolve_model(0.1 | nbody_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print(("initialize_code(), commit_parameters(), commit_particles(), and cleanup_code() should be called " +
"automatically before editing parameters, new_particle(), get_xx(), and stop():"))
instance = self.new_instance_of_an_optional_code(Bonsai2, **default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
timestep = instance.parameters.timestep
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(plummer)
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.1 | nbody_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
def test7(self):
print("Testing Bonsai properties")
numpy.random.seed(12345)
plummer = new_plummer_model(500)
instance = self.new_instance_of_an_optional_code(Bonsai2, **default_options)
instance.particles.add_particles(plummer)
self.assertEqual(instance.model_time, 0.0 | nbody_system.time)
instance.evolve_model(0.0001 | nbody_system.time)
print(instance.model_time)
self.assertTrue(instance.model_time >= 0.0001 | nbody_system.time)
self.assertEqual(instance.model_time, 1.0 * instance.parameters.timestep)
self.assertAlmostEqual(instance.potential_energy, -0.50625962019 | nbody_system.energy)
self.assertAlmostEqual(instance.kinetic_energy, 0.244611829519 | nbody_system.energy)
self.assertAlmostEqual(instance.total_mass, 1.0 | nbody_system.mass)
E0 = instance.kinetic_energy + instance.potential_energy
self.assertRaises(AmuseException, getattr, instance, "total_radius", expected_message="Error when calling 'get_total_radius' of a 'Bonsai2', errorcode is -2, "
"error is 'Called function is not implemented.'")
self.assertRaises(AmuseException, getattr, instance, "center_of_mass_position", expected_message="Error when calling 'get_center_of_mass_position' of a 'Bonsai2', "
"errorcode is -2, error is 'Called function is not implemented.'")
self.assertRaises(AmuseException, getattr, instance, "center_of_mass_velocity", expected_message="Error when calling 'get_center_of_mass_velocity' of a 'Bonsai2', "
"errorcode is -2, error is 'Called function is not implemented.'")
instance.evolve_model(1.0 | nbody_system.time)
self.assertAlmostEqual(instance.model_time, 1.0 | nbody_system.time)
self.assertAlmostEqual(instance.potential_energy, -0.5115 | nbody_system.energy, 4)
self.assertAlmostEqual(instance.kinetic_energy, 0.24986 | nbody_system.energy, 4)
self.assertAlmostEqual(
instance.kinetic_energy + instance.potential_energy,
E0, 4)
instance.particles.remove_particle(plummer[2])
instance.evolve_model(2.0 | nbody_system.time)
instance.particles.remove_particle(plummer[20])
instance.particles.remove_particle(plummer[30])
instance.evolve_model(3.0 | nbody_system.time)
instance.particles.remove_particle(plummer[35])
instance.stop()
"""
def test8(self):
print "Testing Bonsai2 collision_detection"
particles = datamodel.Particles(7)
particles.mass = 0.001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = self.new_instance_of_an_optional_code(Bonsai2)
instance.initialize_code()
instance.parameters.set_defaults()
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEquals(len(collisions.particles(0)), 3)
self.assertEquals(len(collisions.particles(1)), 3)
self.assertEquals(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEquals(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = datamodel.Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print instance.model_time
print instance.particles
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print
print instance.model_time
print instance.particles
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEquals(len(collisions.particles(0)), 1)
self.assertEquals(len(collisions.particles(1)), 1)
self.assertEquals(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEquals(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test9(self):
print "Testing Bonsai2 tree build exception"
plummer = new_plummer_model(50)
#instance = self.new_instance_of_an_optional_code(Bonsai2, **default_options)
instance = self.new_instance_of_an_optional_code(Bonsai2,debugger="gdb", **default_options)
instance.particles.add_particles(plummer)
instance.particles[0].position -= [1e9, 0, 0] | nbody_system.length
self.assertRaises(AmuseException, instance.evolve_model, 1.0 | nbody_system.time, expected_message =
"Error when calling 'evolve_model' of a 'Bonsai2', errorcode is -4, error is "
"'The tree has become too deep, consider the removal of far away particles to prevent a too large box.'")
instance.particles.remove_particle(instance.particles[0])
instance.evolve_model(0.1 | nbody_system.time)
instance.stop()
"""
| 13,384
| 48.94403
| 172
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_gravity_codes.py
|
from amuse.test.amusetest import TestWithMPI
from amuse.community.bhtree.interface import BHTree
from amuse.community.hermite.interface import Hermite
from amuse.community.phigrape.interface import PhiGRAPE
from amuse.community.gadget2.interface import Gadget2
from amuse.community.fi.interface import Fi
from amuse.community.ph4.interface import ph4
from amuse.community.mi6.interface import MI6
import numpy
import time
from amuse.units import units
from amuse.units import nbody_system
from amuse import datamodel
from amuse.ic.plummer import new_plummer_model
class _TestGravityCodes(TestWithMPI):
length_unit = nbody_system.length
speed_unit = nbody_system.speed
mass_unit = nbody_system.mass
time_unit = nbody_system.time
@property
def nbody_converter(self):
return None
def gravity_code_factory(self):
self.skip("abstract test")
def test1(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
particles = new_plummer_model(100, convert_nbody=self.nbody_converter)
particles.radius = 0 | self.length_unit
particles.move_to_center()
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(len(instance.particles), 100)
outer = particles.select(lambda r: r.length() > (0.5 | self.length_unit), ["position"])
print(len(outer))
self.assertTrue(len(outer) > 0)
self.assertTrue(len(outer) < 100)
instance.synchronize_model()
instance.particles.remove_particles(outer)
instance.recommit_particles()
self.assertEqual(len(instance.particles), 100-len(outer))
number_of_particles_in_module = instance.legacy_interface.get_number_of_particles()['number_of_particles']
self.assertEqual(number_of_particles_in_module, 100-len(outer))
instance.stop()
def getset_attribute(self, attributename, attributevalue1, attributevalue2):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
try:
particles = new_plummer_model(100)
particles.move_to_center()
particles.radius = 0.0 | nbody_system.length
instance.particles.add_particles(particles)
instance.commit_particles()
setattr(instance.particles, attributename, attributevalue1)
actual = getattr(instance.particles, attributename)
self.assertAlmostRelativeEqual(actual, attributevalue1)
setattr(instance.particles, attributename, attributevalue2)
actual = getattr(instance.particles, attributename)
print(actual.as_quantity_in(attributevalue2.unit))
self.assertAlmostRelativeEqual(actual, attributevalue2)
finally:
instance.stop()
def test2(self):
self.getset_attribute("radius", 1.0 | self.length_unit, 2.0 | self.length_unit)
def test3(self):
self.getset_attribute("position", [1.0, 2.0, 3.0] | self.length_unit, [5.0, 6.0, 7.0] | self.length_unit)
def test4(self):
self.getset_attribute("velocity", [1.0, 2.0, 3.0] | self.speed_unit, [5.0, 6.0, 7.0] | self.speed_unit)
def test5(self):
self.getset_attribute("mass", 1.0 | self.mass_unit, 2.0 | self.mass_unit)
def test6(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
try:
particles = new_plummer_model(100, convert_nbody=self.nbody_converter)
more_particles = new_plummer_model(50, convert_nbody=self.nbody_converter)
particles.radius = 0 | self.length_unit
more_particles.radius = 1.0 | self.length_unit
particles.move_to_center()
more_particles.move_to_center()
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(len(instance.particles), 100)
instance.synchronize_model()
instance.particles.add_particles(more_particles)
instance.recommit_particles()
number_of_particles_in_module = instance.legacy_interface.get_number_of_particles()['number_of_particles']
self.assertEqual(len(instance.particles), 150)
self.assertEqual(number_of_particles_in_module, 150)
instance.synchronize_model()
instance.particles.remove_particles(particles)
self.assertEqual(len(instance.particles), 50)
instance.recommit_particles()
instance.synchronize_model()
number_of_particles_in_module = instance.legacy_interface.get_number_of_particles()['number_of_particles']
self.assertEqual(len(instance.particles), 50)
self.assertEqual(number_of_particles_in_module, 50)
finally:
instance.stop()
def test7(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
try:
particles = new_plummer_model(100, convert_nbody=self.nbody_converter)
new_particles = new_plummer_model(50, convert_nbody=self.nbody_converter)
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(len(instance.particles), 100)
instance.synchronize_model()
instance.particles.remove_particle(particles[40])
instance.particles.remove_particle(particles[70])
instance.particles.add_particle(new_particles[0])
print(new_particles[0].key)
instance.recommit_particles()
# test the get_mass, get_position and get_velocity functions
# if they are implemented for the code, otherwise will call
# get_state multiple times
# todo, fi fails, need to check with inti
# self.assertAlmostRelativeEqual(instance.particles[-1].mass, new_particles[0].mass)
# self.assertAlmostRelativeEqual(instance.particles[-1].velocity, new_particles[0].velocity)
# self.assertAlmostRelativeEqual(instance.particles[-1].position, new_particles[0].position)
instance.particles.synchronize_to(particles)
self.assertEqual(len(particles), 99)
self.assertEqual(particles[-1], new_particles[0])
finally:
instance.stop()
def test8(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
random = numpy.random.mtrand.RandomState(3456)
particles = new_plummer_model(10, convert_nbody=self.nbody_converter, random=random)
particles.radius = 0.2 | self.length_unit
particles.move_to_center()
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 10)
collision_detection = instance.stopping_conditions.collision_detection
collision_detection.enable()
instance.evolve_model(1 | self.time_unit)
self.assertTrue(collision_detection.is_set())
instance.stop()
def test9(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
instance.parameters.stopping_conditions_out_of_box_size = 2 | self.length_unit
particles = datamodel.Particles(3)
particles.x = [0, 1, 2] | self.length_unit
particles.y = 0 | self.length_unit
particles.z = 0 | self.length_unit
particles.vx = [0, 0, 2] | self.speed_unit
particles.vy = [1, -1, 0] | self.speed_unit
particles.vz = 0 | self.speed_unit
particles.mass = 1 | self.mass_unit
particles.radius = 0.0 | self.length_unit
instance.particles.add_particles(particles)
stopping_condition = instance.stopping_conditions.out_of_box_detection
stopping_condition.enable()
instance.evolve_model(1 | self.time_unit)
print(instance.particles)
print(instance.particles.center_of_mass())
print((instance.particles.position - instance.particles.center_of_mass()).lengths())
self.assertTrue(stopping_condition.is_set())
instance.stop()
def test10(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
particle = datamodel.Particle()
particle.position = [0, 0, 0] | self.length_unit
particle.velocity = [1, -2, 3.0] | self.speed_unit
particle.mass = 1 | self.mass_unit
particle.radius = 0.0 | self.length_unit
instance.particles.add_particle(particle)
instance.evolve_model(1 | self.time_unit)
self.assertAlmostEqual(instance.model_time, 1 | self.time_unit)
self.assertAlmostEqual(instance.kinetic_energy, 7.0 | self.mass_unit * self.speed_unit**2)
self.assertAlmostEqual(instance.potential_energy, 0.0 | self.mass_unit * self.speed_unit**2)
self.assertAlmostEqual(instance.particles[0].position, [1.0, -2.0, 3.0] | self.length_unit)
instance.stop()
def new_gravity_code(self):
self.gravity_code_factory()
class TestBHTreeGravityCode(_TestGravityCodes):
def gravity_code_factory(self):
return BHTree
def test9(self):
self.skip("no support for out of box detection")
class TestHermiteGravityCode(_TestGravityCodes):
def gravity_code_factory(self):
return Hermite
def test10(self):
self.skip("no support for single particle")
class TestPH4GravityCode(_TestGravityCodes):
def gravity_code_factory(self):
return ph4
def test9(self):
self.skip("no support for out of box detection")
class TestMI6GravityCode(_TestGravityCodes):
def gravity_code_factory(self):
return MI6
def test6(self):
self.skip("MI6 crashes on removal and addition of particles")
def test7(self):
self.skip("MI6 crashes on removal and addition of particles")
def test9(self):
self.skip("no support for out of box detection")
def test10(self):
self.skip("no support for single particle")
class TestPhiGRAPEGravityCode(_TestGravityCodes):
def gravity_code_factory(self):
return PhiGRAPE
def slowtestextra0(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory, mode='gpu')
try:
sc = instance.stopping_conditions.collision_detection
n = 1000
instance.parameters.initialize_gpu_once = 1
sc.enable()
particles = new_plummer_model(n, convert_nbody=self.nbody_converter)
particles.radius = 1.0 / n | self.length_unit
particles.move_to_center()
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(len(instance.particles), n)
instance.synchronize_model()
for t in range(1, 101):
instance.evolve_model((t * 0.01) | self.time_unit)
print(sc.is_set())
if sc.is_set():
particle1 = sc.particles(0)[0]
particle2 = sc.particles(1)[0]
newparticle = datamodel.Particles(1)
newparticle.mass = particle1.mass + particle2.mass
newparticle.radius = particle2.radius
newparticle.position = (particle1.position + particle2.position) / 2
newparticle.velocity = (particle1.velocity + particle2.velocity) / 2
instance.particles.remove_particle(particle1)
instance.particles.remove_particle(particle2)
merged = instance.particles.add_particles(newparticle)
print('Remnant:\n', merged)
finally:
instance.stop()
def test9(self):
self.skip("no support for out of box detection")
class TestFiGravityCode(_TestGravityCodes):
def gravity_code_factory(self):
return Fi
def test8(self):
self.skip("no support for collision detection")
def test9(self):
self.skip("no support for out of box detection")
def test10(self):
self.skip("no support for single particle")
class TestGadget2GravityCode(_TestGravityCodes):
length_unit = units.parsec
speed_unit = units.parsec / units.Myr
mass_unit = units.MSun
@property
def nbody_converter(self):
return nbody_system.nbody_to_si(1.0 | units.parsec, 100.0 | units.MSun)
def gravity_code_factory(self):
return Gadget2
def test2(self):
self.skip("no support for setting of radius")
def test8(self):
self.skip("no support for collision detection")
def test9(self):
self.skip("no support for out of box detection")
def test10(self):
self.skip("no support for single particle")
| 13,092
| 38.318318
| 118
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_parameter_doc.py
|
import os
import sys
from amuse.test import amusetest
from amuse.community.bhtree.interface import BHTreeInterface, BHTree
from amuse.community.hermite.interface import HermiteInterface, Hermite
from amuse.community.phigrape.interface import PhiGRAPEInterface, PhiGRAPE
from amuse.units import nbody_system
from amuse.units import units
from amuse import datamodel
class TestParameterDoc(amusetest.TestCase):
def test_bhtree(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.km)
bhtree = BHTree(convert_nbody)
bhtree.parameters.epsilon_squared = 10 | units.km**2
bhtree.parameters.timestep = 1.0 | units.s
bhtree.parameters.opening_angle = 0.1
docstring = bhtree.parameters.__doc__
self.assertTrue("smoothing parameter for gravity calculations (default value:125000.0 m**2)" in docstring)
parameter_str_method_output = str(bhtree.parameters)
self.assertTrue("epsilon_squared: 10000000.0 m**2" in parameter_str_method_output)
self.assertTrue("timestep: 1.0 s" in parameter_str_method_output)
self.assertTrue("opening_angle: 0.1" in parameter_str_method_output)
def test_hermite(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.km)
hermite = Hermite(convert_nbody)
hermite.parameters.epsilon_squared = 10 | units.km**2
docstring = hermite.parameters.__doc__
self.assertTrue("smoothing parameter for gravity calculations (default value:0.0 m**2)" in docstring)
parameter_str_method_output = str(hermite.parameters)
self.assertTrue("epsilon_squared: 10000000.0 m**2" in parameter_str_method_output)
def test_phigrape(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.km)
phigrape = PhiGRAPE(convert_nbody)
phigrape.parameters.epsilon_squared = 10 | units.km**2
docstring = phigrape.parameters.__doc__
print(docstring)
self.assertTrue("smoothing parameter for gravity calculations (default value:0.0 m**2)" in docstring)
self.assertTrue("timestep parameter (default value:0.02" in docstring)
self.assertTrue("parameter to determine the initial timestep (default value:0.01" in docstring)
parameter_str_method_output = str(phigrape.parameters)
self.assertTrue("epsilon_squared: 10000000.0 m**2" in parameter_str_method_output)
self.assertTrue("timestep_parameter: 0.0" in parameter_str_method_output)
self.assertTrue("initial_timestep_parameter: 0.0" in parameter_str_method_output)
| 2,630
| 38.863636
| 114
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_fi.py
|
import os
import sys
import numpy
import time
from amuse.test.amusetest import TestWithMPI
from amuse.community.fi.interface import FiInterface, Fi
from amuse.ext.evrard_test import new_evrard_gas_sphere, MakeEvrardTest
from amuse.ext.spherical_model import new_uniform_spherical_particle_distribution
from amuse.units import nbody_system
from amuse.units import units, constants
from amuse import datamodel
from amuse.rfi import channel
from amuse.ic.plummer import new_plummer_model
class TestFiInterface(TestWithMPI):
def test1(self):
instance = FiInterface()
instance.initialize_code()
instance.stop()
def test2(self):
instance = FiInterface()
instance.initialize_code()
for x, l in [('use_hydro', 1), ('radiate', 0), ('starform', 0), ('cosmo', 1),
('sqrttstp', 0), ('acc_tstp', 1), ('freetstp', 0), ('usequad', 0),
('directsum', 0), ('selfgrav', 1), ('fixthalo', 0),
('adaptive_eps', 0), ('gdgop', 1), ('smoothinput', 0),
('consph', 1), ('sphinit', 1), ('uentropy', 1), ('isotherm', 0),
('eps_is_h', 1), ('balsara', 0), ('mingaseps', 0)]:
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, l))
err = getattr(instance, 'set_'+x)(1)
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, 1))
err = getattr(instance, 'set_'+x)(0)
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, 0))
for x, i in [('firstsnap', 0), ('stepout', 5), ('steplog', 5), ('max_tbin', 4096),
('minppbin', 1), ('targetnn', 32), ('verbosity', 0), ('nsmooth', 64)]:
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, i))
err = getattr(instance, 'set_'+x)(12345)
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, 12345))
for x, r in [('pboxsize', 10000.), ('unitl_in_kpc', 1.), ('unitm_in_msun', 1.e9), ('dtime', 1.),
('tstepcrit', 1.), ('tstpcr2', 0.25), ('freev', 0.5), ('freea', 0.35), ('freevexp', 0.),
('freeaexp', -1.), ('bh_tol', 0.5), ('gdgtol', 0.01), ('nn_tol', 0.1),
('epsgas', 0.005), ('gamma', 1.6666667), ('alpha', 0.5), ('beta', 1.0), ('epssph', 0.01),
('courant', 0.3), ('removgas', 0.25), ('consthsm', 0.2), ('nsmtol', 0.1),
('graineff', 0.05), ('crionrate', 3.6), ('heat_par1', 0.), ('heat_par2', 0.),
('cool_par', 1.), ('optdepth', 0.), ('tcollfac', 1.), ('masscrit', 1.e5),
('sfeff', 0.25), ('tbubble', 3.e7), ('sne_eff', 0.), ('tsnbeg', 3.e6),
('rhomax', 100.), ('eps', 0.)]:
result, err = getattr(instance, 'get_'+x)()
self.assertAlmostEqual(result, r, 7)
err = getattr(instance, 'set_'+x)(0.)
result, err = getattr(instance, 'get_'+x)()
self.assertEqual(result, 0.)
err = getattr(instance, 'set_'+x)(0.12345)
result, err = getattr(instance, 'get_'+x)()
self.assertAlmostEqual(result, 0.12345, 7)
for x, s in [('halofile', 'none'), ('feedback', 'fuv'), ('sfmode', 'gerritsen'),
('hupdatemethod', 'mass'), ('sph_visc', 'sph')]:
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, s))
err = getattr(instance, 'set_'+x)("123")
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, "123"))
instance.stop()
def test3(self):
instance = FiInterface()
instance.initialize_code()
instance.commit_parameters()
instance.new_particle(11.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0)
retrieved_state = instance.get_state(1)
self.assertEqual(11.0, retrieved_state['mass'])
self.assertEqual(2.0, retrieved_state['radius'])
self.assertEqual(instance.get_number_of_particles()['number_of_particles'], 1)
instance.cleanup_code()
instance.stop()
def test4(self):
instance = FiInterface()
instance.initialize_code()
instance.commit_parameters()
instance.new_particle(11.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0)
instance.set_time_step(2.0)
retrieved_state = instance.get_time_step()
self.assertEqual(2.0, retrieved_state['time_step'])
instance.cleanup_code()
instance.stop()
def test5(self):
instance = FiInterface()
instance.initialize_code()
instance.set_eps(0.001)
instance.set_directsum(1)
instance.commit_parameters()
instance.new_particle(
[1.0, 1.0, 1.0],
[0.0, 0.0, 0.0],
[1.0, 0.0, -1.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0])
instance.commit_particles()
self.assertEqual(instance.get_number_of_particles()['number_of_particles'], 3)
instance.synchronize_model()
Ep = instance.get_potential_energy()['potential_energy']
Ek = instance.get_kinetic_energy()['kinetic_energy']
self.assertAlmostEqual(Ek, 0.5, 10)
self.assertAlmostEqual(Ep, -2.5, 10)
instance.delete_particle(2)
instance.recommit_particles()
instance.synchronize_model()
n = instance.get_number_of_particles()['number_of_particles']
Ep = instance.get_potential_energy()['potential_energy']
Ek = instance.get_kinetic_energy()['kinetic_energy']
self.assertEqual(n, 2)
self.assertAlmostEqual(Ek, 0., 10)
self.assertAlmostEqual(Ep, -0.5, 10)
instance.cleanup_code()
instance.stop()
def test5a(self):
instance = FiInterface()
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_eps(0.001))
self.assertEqual(0, instance.set_directsum(1))
instance.new_particle(
[1.0, 1.0],
[0.0, 0.0],
[1.0, -1.0],
[0.0, 0.0],
[0.0, 0.0],
[0.0, 0.0],
[0.0, 0.0],
[0.0, 0.0])
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.commit_parameters())
self.assertAlmostEqual(-0.500, instance.get_potential(1)['potential'], places=1)
print(instance.get_potential([1]))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test6(self):
print("Testing FiInterface get_hydro_state_at_point")
number_sph_particles = 10000
length = 1.0 | units.kpc
mass = 1.0e9 | units.MSun
gas = new_uniform_spherical_particle_distribution(number_sph_particles, length, mass)
mass = [1.0 / number_sph_particles] * number_sph_particles
h = [0.01] * number_sph_particles
x, y, z = gas.x.value_in(units.kpc), gas.y.value_in(units.kpc), gas.z.value_in(units.kpc)
vx, vy, vz = [[0.0] * number_sph_particles] * 3
u = [0.05] * number_sph_particles
indices = range(1, number_sph_particles+1)
instance = FiInterface()
instance.initialize_code()
instance.set_unitl_in_kpc(1.0)
instance.set_unitm_in_msun(1.e9)
instance.set_nsmooth(64)
instance.set_nsmtol(0.2)
instance.set_uentropy(1)
instance.commit_parameters()
instance.new_sph_particle(mass, x, y, z, vx, vy, vz, u, h)
instance.commit_particles()
instance.synchronize_model()
h = instance.get_smoothing_length(indices)['h_smooth']
self.assertIsOfOrder((instance.get_nsmooth()['nsmooth']*1.0 / number_sph_particles)**(1.0/3), h)
hydrostate = instance.get_hydro_state_at_point(0, 0, 0)
density = 1.0 / (4.0/3.0 * numpy.pi * 1.0**3)
self.assertAlmostEqual(hydrostate['rho'], density, places=3)
self.assertAlmostEqual(hydrostate['rhovx'], 0, places=3)
self.assertAlmostEqual(hydrostate['rhovy'], 0, places=3)
self.assertAlmostEqual(hydrostate['rhovz'], 0, places=3)
self.assertAlmostEqual(hydrostate['rhoe'], density*u[0], places=3)
instance.stop()
def test7(self):
instance = FiInterface(mode=FiInterface.MODE_PERIODIC_BOUNDARIES)
instance.initialize_code()
# instance.set_periodic(1)
instance.set_use_hydro(0)
instance.set_selfgrav(0)
print(instance.get_pboxsize())
instance.set_pboxsize(2.)
print(instance.get_pboxsize())
instance.set_dtime(0.1)
instance.commit_parameters()
ids, err = instance.new_particle(
[1.0, 1.0, 1.0],
[0.5, 0.0, 0.0],
[0.0, -0.5, 0.0],
[0.0, 0.0, 0.5],
[1.0, 0.0, 0.0],
[0.0, -1.0, 0.0],
[0.0, 0.0, 1.0])
instance.commit_particles()
instance.evolve_model(0.1)
m, x, y, z, vx, vy, vz, r, err = instance.get_state(ids)
self.assertAlmostEqual(x, [0.6, 0., 0.], places=7)
self.assertAlmostEqual(y, [0., -0.6, 0.], places=7)
self.assertAlmostEqual(z, [0., 0., 0.6], places=7)
instance.evolve_model(1.0)
m, x, y, z, vx, vy, vz, r, err = instance.get_state(ids)
self.assertAlmostEqual(x, [-0.5, 0., 0.], places=7)
self.assertAlmostEqual(y, [0., 0.5, 0.], places=7)
self.assertAlmostEqual(z, [0., 0., -0.5], places=7)
instance.cleanup_code()
instance.stop()
def test8(self):
instance = FiInterface(redirection="none")
instance.initialize_code()
instance.set_use_hydro(0)
instance.set_selfgrav(1)
instance.set_pboxsize(1.0)
instance.set_dtime(0.2)
instance.commit_parameters()
index, err = instance.new_sph_particle(
0.1, # mass
0.5, # x,y,z
0.0,
0.0,
1.0, # vx,vy,vz
0.0,
0.0,
0.0
)
index2, err = instance.new_sph_particle(
0.001, # mass
0.1, # x,y,z
0.0,
0.0,
1.0, # vx,vy,vz
0.0,
0.0,
0.0
)
instance.commit_particles()
instance.evolve_model(0.1)
m, x, y, z, vx, vy, vz, r, err = instance.get_state(index)
self.assertAlmostRelativeEquals(x, 0.5)
nremoved, error = instance.get_number_of_sph_particles_removed()
self.assertEqual(error, 0)
self.assertEqual(nremoved, 0)
instance.evolve_model(0.15)
nremoved, error = instance.get_number_of_sph_particles_removed()
self.assertEqual(error, 0)
self.assertEqual(nremoved, 1)
idremoved, error = instance.get_id_of_removed_sph_particle(0)
self.assertEqual(idremoved, index)
class TestEvrard(TestWithMPI):
def xtest0(self):
evrard = MakeEvrardTest(1000)
mass, x, y, z, vx, vy, vz, u = evrard.new_model()
smooth = numpy.zeros_like(mass)
nb = FiInterface()
nb.initialize_code()
nb.set_stepout(99999)
nb.set_steplog(99999)
nb.set_use_hydro(1)
nb.set_radiate(0)
nb.set_dtime(0.05)
nb.set_gdgop(1)
nb.set_uentropy(1)
nb.set_verbosity(0)
nb.commit_parameters()
ids, error = nb.new_sph_particle(mass, smooth, x, y, z, vx, vy, vz, u)
if [x for x in error if x != 0] != []:
raise Exception
nb.initialize_particles(0.0)
nb.synchronize_model()
Ek, ret = nb.get_kinetic_energy()
Ep, ret = nb.get_potential_energy()
Eth, ret = nb.get_thermal_energy()
self.assertAlmostEqual(Ek, 0., 3)
self.assertAlmostEqual(Ep, -0.6611, 3)
self.assertAlmostEqual(Eth, 0.05, 3)
nb.evolve_model(0.5)
nb.synchronize_model()
Ek, ret = nb.get_kinetic_energy()
Ep, ret = nb.get_potential_energy()
Eth, ret = nb.get_thermal_energy()
self.assertAlmostEqual(Ek, 0.129577, 3)
self.assertAlmostEqual(Ep, -0.831976, 3)
self.assertAlmostEqual(Eth, 0.08567999, 3)
del evrard
nb.stop()
class TestFi(TestWithMPI):
def test0(self):
instance = Fi(nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc))
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.parameters.timestep = 0.5 | units.day
self.assertEqual(instance.parameters.timestep, 0.5 | units.day)
instance.commit_parameters()
instance.commit_particles()
self.assertEqual(instance.parameters.timestep, 0.5 | units.day)
instance.stop()
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = Fi(convert_nbody)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00000001 | units.AU**2
instance.parameters.timestep = 0.5 | units.day
self.assertEqual(instance.parameters.timestep, 0.5 | units.day)
instance.commit_parameters()
stars = datamodel.Particles(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = [0.0, 0.0, 0.0] | units.m
sun.velocity = [0.0, 0.0, 0.0] | units.ms
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = [149.5e6, 0.0, 0.0] | units.km
earth.velocity = [0.0, 29800, 0.0] | units.ms
instance.particles.add_particles(stars)
self.assertEqual(instance.parameters.timestep, 0.5 | units.day)
postion_at_start = earth.position.x
instance.evolve_model(365.0 | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
postion_after_full_rotation = earth.position.x
self.assertAlmostRelativeEqual(postion_at_start, postion_after_full_rotation, 4)
instance.evolve_model(365.0 + (365.0 / 2) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
postion_after_half_a_rotation = earth.position.x
instance.evolve_model(365.0 + (365.0 / 2) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
postion_after_half_a_rotation = earth.position.x
self.assertAlmostRelativeEqual(-postion_at_start, postion_after_half_a_rotation, 3)
instance.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
postion_after_half_a_rotation = earth.position.y
self.assertAlmostRelativeEqual(-postion_at_start, postion_after_half_a_rotation, 4)
instance.cleanup_code()
instance.stop()
def test2(self):
print("Test 2: testing Fi data directory")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = Fi(convert_nbody)
instance.initialize_code()
self.assertTrue('fi/data/input/' in instance.legacy_interface.get_fi_data_directory()['fi_data_directory'])
self.assertEqual(instance.legacy_interface.get_fi_data_directory()['fi_data_directory'],
instance.get_data_directory()+'/')
self.assertEqual(False, instance.parameters.radiation_flag)
instance.parameters.radiation_flag = True
self.assertEqual(True, instance.parameters.radiation_flag)
self.assertEqual(False, instance.parameters.star_formation_flag)
instance.parameters.star_formation_flag = True
self.assertEqual(True, instance.parameters.star_formation_flag)
instance.commit_parameters()
stars = datamodel.Particles(2)
stars.mass = [1.0, 3.0e-6] | units.MSun
stars.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
stars.velocity = [[0.0, 0.0, 0.0], [0.0, 29.8, 0.0]] | units.km / units.s
stars.radius = [1.0, 0.01] | units.RSun
instance.particles.add_particles(stars)
instance.evolve_model(1.0 | nbody_system.time)
instance.cleanup_code()
instance.stop()
def test3(self):
print("Test 3: testing Fi boolean parameters")
instance = Fi(nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc))
instance.initialize_code()
for bool_par in ['radiation_flag', 'star_formation_flag',
'square_root_timestep_flag', 'freeform_timestep_flag', 'quadrupole_moments_flag',
'direct_sum_flag', 'fixed_halo_flag', 'adaptive_smoothing_flag', 'smooth_input_flag',
'isothermal_flag', 'balsara_flag', 'enforce_min_sph_grav_softening_flag']:
self.assertEqual(False, getattr(instance.parameters, bool_par))
setattr(instance.parameters, bool_par, True)
self.assertEqual(True, getattr(instance.parameters, bool_par))
for bool_par in ['acc_timestep_flag', 'self_gravity_flag', 'gadget_cell_opening_flag',
'use_hydro_flag', 'conservative_sph_flag', 'sph_dens_init_flag',
'integrate_entropy_flag', 'eps_is_h_flag']:
self.assertEqual(True, getattr(instance.parameters, bool_par))
setattr(instance.parameters, bool_par, False)
self.assertEqual(False, getattr(instance.parameters, bool_par))
self.assertEqual(instance.parameters.periodic_boundaries_flag, False)
instance.cleanup_code()
instance.stop()
def test4(self):
print("Test 4: testing Fi integer parameters")
instance = Fi(nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc))
instance.initialize_code()
for int_par, value in [('first_snapshot', 0), ('output_interval', 5), ('log_interval', 5),
('maximum_time_bin', 4096), ('minimum_part_per_bin', 1), ('targetnn', 32),
('verbosity', 0), ('n_smooth', 64)]:
self.assertEqual(value, getattr(instance.parameters, int_par))
setattr(instance.parameters, int_par, 1)
self.assertEqual(1, getattr(instance.parameters, int_par))
instance.cleanup_code()
instance.stop()
def test5(self):
print("Test 5: testing Fi double precision parameters")
conv = nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc)
instance = Fi(conv)
instance.initialize_code()
par_names = ['epsilon_squared', 'timestep', 'periodic_box_size', 'code_mass_unit', 'code_length_unit',
'sqrt_timestep_crit_constant', 'acc_timestep_crit_constant', 'free_timestep_crit_constant_v',
'free_timestep_crit_constant_a', 'free_timestep_crit_constant_vexp',
'free_timestep_crit_constant_aexp', 'opening_angle', 'gadget_cell_opening_constant',
'nn_tol', 'gas_epsilon', 'gamma', 'artificial_viscosity_alpha', 'beta', 'sph_artificial_viscosity_eps', 'courant',
'min_gas_part_mass', 'sph_h_const', 'n_smooth_tol', 'grain_heat_eff', 'zeta_cr_ion_rate',
'heat_par1', 'heat_par2', 'cool_par', 'optical_depth', 'star_form_delay_fac', 'star_form_mass_crit',
'star_form_eff', 'supernova_duration', 'supernova_eff', 't_supernova_start', 'max_density']
defaults = [0.0 | nbody_system.length * nbody_system.length, 1.0 | nbody_system.time, 10000.0 | nbody_system.length,
1.0e9 | units.MSun, 1.0 | units.kpc, 1.0, 0.25, 0.5, 0.35,
0.0, -1.0, 0.5, 0.01, 0.1, 0.005 | nbody_system.length, 1.6666667, 0.5, 1.0, 0.01, 0.3,
0.25, 0.2 | nbody_system.length, 0.1, 0.05, 3.6 | 1.8e-17 * units.s**-1, 0.0, 0.0, 1.0,
0.0, 1.0, 1.0e5 | units.MSun, 0.25, 3.0e7 | units.Myr, 0.0, 3.e6 | units.Myr, conv.to_si(100.0 | nbody_system.density)]
defaults = [instance.unit_converter.to_si(val) if not isinstance(val, float) and nbody_system.is_nbody_unit(val.unit) else val for val in defaults]
for double_par, value in zip(par_names, defaults):
self.assertAlmostRelativeEquals(getattr(instance.parameters, double_par), value, 7)
setattr(instance.parameters, double_par, 2 * value)
self.assertAlmostRelativeEquals(getattr(instance.parameters, double_par), 2*value, 7)
instance.cleanup_code()
instance.stop()
def test6(self):
print("Test 6: testing Fi string parameters")
instance = Fi(nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc))
instance.initialize_code()
par_names = ['halofile', 'feedback', 'star_formation_mode', 'h_update_method', 'sph_viscosity', 'fi_data_directory']
defaults = ['none', 'fuv', 'gerritsen', 'mass', 'sph', instance.get_data_directory()+'/']
new_values = ['bct_02_10.halo', 'pres', 'nieuw', 'test', 'sphv', 'test']
for string_par, value, new_value in zip(par_names, defaults, new_values):
print(instance.get_halofile(), getattr(instance.parameters, string_par), end=' ')
self.assertEqual(getattr(instance.parameters, string_par), value)
setattr(instance.parameters, string_par, new_value)
self.assertEqual(getattr(instance.parameters, string_par), new_value)
instance.cleanup_code()
instance.stop()
def test7(self):
print("Test 7: testing Fi SPH particles")
target_number_of_particles = 1000
gas = new_evrard_gas_sphere(target_number_of_particles, do_scale=True, seed=1234)
gas.h_smooth = 0.0 | nbody_system.length
convert_nbody = nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc)
instance = Fi(convert_nbody, redirection="none")
instance.initialize_code()
instance.parameters.timestep = 0.025 | nbody_system.time
instance.parameters.integrate_entropy_flag = True
instance.gas_particles.add_particles(gas)
self.assertAlmostEqual(convert_nbody.to_nbody(instance.kinetic_energy), 0.00 | nbody_system.energy)
self.assertAlmostEqual(convert_nbody.to_nbody(instance.potential_energy), -0.494 | nbody_system.energy, 2)
self.assertAlmostEqual(convert_nbody.to_nbody(instance.thermal_energy), 0.05 | nbody_system.energy)
self.assertAlmostEqual(convert_nbody.to_nbody(instance.total_energy), -0.444 | nbody_system.energy, 2)
instance.evolve_model(10.437 | units.Myr)
instance.synchronize_model()
self.assertAlmostEqual(convert_nbody.to_nbody(instance.kinetic_energy), 0.0566 | nbody_system.energy, 3)
self.assertAlmostEqual(convert_nbody.to_nbody(instance.potential_energy), -0.5661 | nbody_system.energy, 3)
self.assertAlmostEqual(convert_nbody.to_nbody(instance.thermal_energy), 0.0635 | nbody_system.energy, 3)
self.assertAlmostEqual(convert_nbody.to_nbody(instance.total_energy), -0.444 | nbody_system.energy, 2)
instance.cleanup_code()
instance.stop()
def test8(self):
print("Test 8: testing Fi dark matter + SPH particles")
target_number_of_particles = 100
gas = new_evrard_gas_sphere(target_number_of_particles, do_scale=True, seed=1234)
gas.h_smooth = 0.0 | nbody_system.length
dark = datamodel.Particles(2)
dark.mass = [1.0, 3.0e-6] | units.MSun
dark.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
dark.velocity = [[0.0, 0.0, 0.0], [0.0, 29.8, 0.0]] | units.km / units.s
dark.radius = [10.0, 0.1] | units.RSun
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = Fi(convert_nbody)
instance.parameters.eps_is_h_flag = False
instance.parameters.gas_epsilon = 0.4 | units.AU
instance.parameters.timestep = 0.001 | units.yr
# instance.parameters.gadget_cell_opening_constant=0.001
instance.dm_particles.add_particles(dark)
instance.gas_particles.add_particles(gas)
print(convert_nbody.to_nbody(instance.kinetic_energy))
print(convert_nbody.to_nbody(instance.potential_energy))
print(convert_nbody.to_nbody(instance.thermal_energy))
print(convert_nbody.to_nbody(instance.total_energy))
radius = instance.dm_particles.radius
print(instance.gas_particles.radius[0:10].in_(units.AU))
self.assertEqual(dark[0].radius, radius[0])
self.assertEqual(dark[1].radius, radius[1])
self.assertAlmostEqual(convert_nbody.to_nbody(instance.kinetic_energy),
convert_nbody.to_nbody(dark.kinetic_energy()), 3)
self.assertAlmostEqual(convert_nbody.to_nbody(instance.potential_energy), -1.8656 | nbody_system.energy, 3)
self.assertAlmostEqual(convert_nbody.to_nbody(instance.thermal_energy), 0.0500 | nbody_system.energy, 3)
self.assertAlmostEqual(convert_nbody.to_nbody(instance.total_energy), -1.8156 | nbody_system.energy, 3)
instance.evolve_model(1. | units.yr)
print(instance.gas_particles.radius[0:10].in_(units.AU))
self.assertAlmostRelativeEqual(convert_nbody.to_nbody(instance.kinetic_energy), 0.02507 | nbody_system.energy, 3)
self.assertAlmostRelativeEqual(convert_nbody.to_nbody(instance.potential_energy), -2.9630 | nbody_system.energy, 3)
self.assertAlmostRelativeEqual(convert_nbody.to_nbody(instance.thermal_energy), 1.122 | nbody_system.energy, 3)
self.assertAlmostRelativeEqual(convert_nbody.to_nbody(instance.total_energy), -1.8156 | nbody_system.energy, 3)
print(convert_nbody.to_nbody(instance.total_energy))
instance.cleanup_code()
instance.stop()
def test9(self):
print("Test 9: testing Fi dark matter + SPH + star particles")
target_number_of_particles = 100
gas = new_evrard_gas_sphere(target_number_of_particles, do_scale=True, seed=1234)
gas.h_smooth = 0.0 | nbody_system.length
dark = datamodel.Particles(2)
dark.mass = [0.4, 0.4] | nbody_system.mass
dark.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.kpc
dark.velocity = [[100.0, 100.0, 100.0], [1.0, 1.0, 1.0]] | units.km / units.s
dark.radius = [0.0, 0.0] | units.RSun
star = datamodel.Particles(2)
star.mass = [0.02, 0.02] | nbody_system.mass
star.position = [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]] | units.kpc
star.velocity = [[-300.0, -200.0, -100.0], [-6.0, -5.0, -4.0]] | units.km / units.s
star.radius = [0.0, 0.0] | units.RSun
star.tform = [1000.0, 1000.0] | units.Myr
convert_nbody = nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc)
instance = Fi(convert_nbody)
instance.initialize_code()
instance.parameters.verbosity = 0
instance.parameters.timestep = 0.05 | units.Myr
instance.parameters.eps_is_h_flag = False
instance.parameters.gas_epsilon = 0.4 | units.kpc
instance.dm_particles.add_particles(dark)
instance.star_particles.add_particles(star)
instance.gas_particles.add_particles(gas)
print(convert_nbody.to_nbody(instance.kinetic_energy))
print(convert_nbody.to_nbody(instance.potential_energy))
print(convert_nbody.to_nbody(instance.thermal_energy))
print(convert_nbody.to_nbody(instance.total_energy))
print(convert_nbody.to_nbody((instance.dm_particles | instance.star_particles | instance.gas_particles).potential_energy(smoothing_length_squared=instance.parameters.epsilon_squared)))
self.assertAlmostRelativeEqual(convert_nbody.to_nbody(instance.kinetic_energy), 1.7204 | nbody_system.energy, 3)
self.assertAlmostRelativeEqual(convert_nbody.to_nbody(instance.potential_energy), -1.3096 | nbody_system.energy, 3)
self.assertAlmostRelativeEqual(convert_nbody.to_nbody(instance.thermal_energy), 0.0500 | nbody_system.energy)
self.assertAlmostRelativeEqual(convert_nbody.to_nbody(instance.total_energy), 0.461 | nbody_system.energy, 3)
instance.evolve_model(100*instance.parameters.timestep)
print(convert_nbody.to_nbody(instance.kinetic_energy))
print(convert_nbody.to_nbody(instance.potential_energy))
print(convert_nbody.to_nbody(instance.thermal_energy))
print(convert_nbody.to_nbody(instance.total_energy))
self.assertAlmostRelativeEqual(convert_nbody.to_nbody(instance.kinetic_energy), 1.6825 | nbody_system.energy, 3)
self.assertAlmostRelativeEqual(convert_nbody.to_nbody(instance.potential_energy), -1.277 | nbody_system.energy, 3)
self.assertAlmostRelativeEqual(convert_nbody.to_nbody(instance.thermal_energy), 0.05526 | nbody_system.energy, 3)
self.assertAlmostRelativeEqual(convert_nbody.to_nbody(instance.total_energy), 0.461 | nbody_system.energy, 3)
instance.cleanup_code()
instance.stop()
def test10(self):
print("Test 10: testing Fi star particles")
stars = datamodel.Particles(2)
stars.mass = [1.0, 3.00e-6] | units.MSun
stars.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
stars.velocity = [[0.0, 0.0, 0.0], [0.0, 29.8, 0.0]] | units.km / units.s
stars.radius = [1.0, 1.0] | units.RSun # results are nonsense if not (r1 == r2)... ?
stars.tform = [-10.0, -50.0] | units.Myr
instance = Fi(nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)) # , debugger='xterm')
instance.initialize_code()
instance.parameters.timestep = 0.5 | units.day
instance.commit_parameters()
instance.star_particles.add_particles(stars)
self.assertAlmostEqual(instance.star_particles.tform, [-10.0, -50.0] | units.Myr)
instance.star_particles.tform = [-100.0, -500.0] | units.Myr
instance.synchronize_model()
self.assertAlmostEqual(instance.star_particles.tform, [-100.0, -500.0] | units.Myr)
self.assertAlmostEqual(instance.kinetic_energy, 2.6493e+33 | units.J, 3, in_units=1e+33*units.J)
self.assertAlmostEqual(instance.star_particles.kinetic_energy(), 2.6493e+33 | units.J, 3, in_units=1e+33*units.J)
instance.evolve_model(0.5 | units.yr)
self.assertAlmostEqual(instance.star_particles[1].x, -1.0 | units.AU, 2)
instance.evolve_model(1.0 | units.yr)
self.assertAlmostEqual(instance.star_particles[1].x, 1.0 | units.AU, 3)
self.assertAlmostEqual(instance.kinetic_energy, 2.6493e+33 | units.J, 3, in_units=1e+33*units.J)
instance.cleanup_code()
instance.stop()
def test11(self):
print("Test 11: testing Fi (dm+sph+star) particles Superset")
target_number_of_particles = 100
gas = new_evrard_gas_sphere(target_number_of_particles, do_scale=True, seed=1234)
gas.h_smooth = 0.0 | nbody_system.length
number_sph_particles = len(gas)
dark = datamodel.Particles(2)
dark.mass = [0.4, 0.4] | nbody_system.mass
dark.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.kpc
dark.velocity = [[100.0, 100.0, 100.0], [1.0, 1.0, 1.0]] | units.km / units.s
dark.radius = [0.0, 0.0] | units.RSun
star = datamodel.Particles(2)
star.mass = [0.02, 0.02] | nbody_system.mass
star.position = [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]] | units.kpc
star.velocity = [[-300.0, -200.0, -100.0], [-6.0, -5.0, -4.0]] | units.km / units.s
star.radius = [0.0, 0.0] | units.RSun
star.tform = [1000.0, 1000.0] | units.Myr
convert_nbody = nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc)
instance = Fi(convert_nbody)
instance.initialize_code()
self.assertEqual(0, len(instance.particles))
instance.dm_particles.add_particles(dark)
instance.star_particles.add_particles(star)
instance.gas_particles.add_particles(gas)
self.assertEqual(number_sph_particles+4, len(instance.particles))
print("The 'particles' superset can still be used as standard GD 'particles' set.")
default = datamodel.Particles(2)
default.mass = [0.4, 0.4] | nbody_system.mass
default.position = [[0.5, -0.5, 0.04], [1.5, 0.5, 0.08]] | units.kpc
default.velocity = [[10.0, 10.0, 10.0], [10.0, 10.0, 10.0]] | units.km / units.s
default.radius = [0.0, 0.0] | units.RSun
instance.particles.add_particles(default)
self.assertEqual(number_sph_particles+6, len(instance.particles))
print("'>>> print instance.particles' only prints those particle attributes the subsets have in common.")
string_produced_by_print = instance.particles.__str__()
self.assertTrue("mass" in string_produced_by_print)
self.assertTrue("vx" in string_produced_by_print)
self.assertTrue("radius" in string_produced_by_print)
self.assertFalse("tform" in string_produced_by_print)
instance.synchronize_model()
self.assertAlmostRelativeEqual(instance.particles.kinetic_energy(),
instance.dm_particles.kinetic_energy() +
instance.star_particles.kinetic_energy() +
instance.gas_particles.kinetic_energy())
self.assertAlmostRelativeEqual(instance.particles.kinetic_energy(), instance.kinetic_energy)
instance.evolve_model(1.0 | units.yr)
instance.synchronize_model()
self.assertAlmostRelativeEqual(instance.particles.kinetic_energy(), instance.kinetic_energy, -1)
instance.cleanup_code()
instance.stop()
def test12(self):
print("Testing Fi states")
target_number_of_particles = 100
gas = new_evrard_gas_sphere(target_number_of_particles, do_scale=True, seed=1234)
gas.h_smooth = 0.0 | nbody_system.length
dark = datamodel.Particles(2)
dark.mass = [0.4, 0.4] | nbody_system.mass
dark.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | nbody_system.length
dark.velocity = [[0.1, 0.1, 0.1], [1.0, 1.0, 1.0]] | nbody_system.speed
dark.radius = 0.0 | nbody_system.length
print("First do everything manually:")
convert_nbody = nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc)
instance = Fi(convert_nbody)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.gas_particles.add_particles(gas)
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
mass = instance.gas_particles[0].mass
instance.evolve_model(0.001 | nbody_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("initialize_code(), commit_parameters(), (re)commit_particles(), and cleanup_code() should be called "
"automatically before setting parameters, new_xx_particle(), get_xx(), and stop():")
instance = Fi(convert_nbody)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.timestep = 0.001 | nbody_system.time
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
self.assertEqual(instance.parameters.timestep, convert_nbody.to_si(0.001 | nbody_system.time))
instance.gas_particles.add_particles(gas)
instance.dm_particles.add_particles(dark)
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
mass = instance.gas_particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.synchronize_model() # model was already synchronized, but fi doesn't seem to get that...
instance.dm_particles.remove_particles(dark)
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
mass = instance.gas_particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.002 | nbody_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
def test13(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
instance = Fi(redirection="none")
instance.initialize_code()
instance.parameters.stopping_conditions_number_of_steps = 2
self.assertEqual(instance.parameters.stopping_conditions_number_of_steps, 2)
instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2
instance.particles.add_particles(particles)
instance.stopping_conditions.number_of_steps_detection.enable()
instance.evolve_model(10 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
self.assertTrue(instance.model_time < 10 | nbody_system.time)
instance.stop()
def test13a(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
very_short_time_to_evolve = 1 | units.s
very_long_time_to_evolve = 1e9 | nbody_system.time
instance = Fi()
instance.initialize_code()
instance.parameters.stopping_conditions_timeout = very_short_time_to_evolve
self.assertEqual(instance.parameters.stopping_conditions_timeout, very_short_time_to_evolve)
instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2
instance.particles.add_particles(particles)
instance.stopping_conditions.timeout_detection.enable()
start = time.time()
instance.evolve_model(very_long_time_to_evolve)
end = time.time()
self.assertTrue(instance.stopping_conditions.timeout_detection.is_set())
self.assertTrue((end-start) < very_short_time_to_evolve.value_in(units.s) + 2) # 2 = some overhead compensation
instance.stop()
def test13b(self):
print("Test out_of_box_detection stopping condition")
particles = datamodel.Particles(3)
particles.position = [0.0, 0.0, 0.0] | nbody_system.length
particles.velocity = [[-1.0, 0, 0], [1.0, 0, 0], [0.5, 0, 0]] | nbody_system.speed
particles.radius = 0.001 | nbody_system.length
particles.mass = 1.0 | nbody_system.mass
gas = datamodel.Particles(2)
gas.position = [[0.0, 0.5, 0.0], [0.0, -0.5, 0.0]] | nbody_system.length
gas.velocity = [[0.0, 0.5, 0.0], [0.0, -0.25, 0.0]] | nbody_system.speed
gas.radius = 0.001 | nbody_system.length
gas.mass = 1.0 | nbody_system.mass
gas.u = 0.01 | nbody_system.specific_energy
instance = Fi()
instance.initialize_code()
instance.parameters.stopping_conditions_out_of_box_size = 1.0 | nbody_system.length
instance.parameters.self_gravity_flag = False
instance.parameters.timestep = 0.25 | nbody_system.time
self.assertEqual(instance.parameters.stopping_conditions_out_of_box_size, 1.0 | nbody_system.length)
instance.gas_particles.add_particles(gas)
instance.dm_particles.add_particles(particles)
out_of_box_detection = instance.stopping_conditions.out_of_box_detection
out_of_box_detection.enable()
instance.evolve_model(2 | nbody_system.time)
self.assertTrue(out_of_box_detection.is_set())
self.assertAlmostEqual(instance.model_time, 1.0 | nbody_system.time, 3)
self.assertEqual(len(out_of_box_detection.particles()), 3)
self.assertEqual(out_of_box_detection.particles().position.lengths() >=
1.0 | nbody_system.length, [True, True, True])
self.assertEqual(len(out_of_box_detection.particles(1)), 0)
instance.particles.remove_particles(out_of_box_detection.particles())
stopping_conditions_info = str(instance.stopping_conditions).split("\n")
self.assertEqual(stopping_conditions_info[0], "Stopping conditions of a 'Fi' object")
for i, word in enumerate(["supported", "enabled", "set"]):
self.assertTrue(word in stopping_conditions_info[i+1])
self.assertTrue("out_of_box_detection" in stopping_conditions_info[i+1])
instance.evolve_model(1.5 | nbody_system.time)
self.assertFalse(out_of_box_detection.is_set())
self.assertAlmostEqual(instance.model_time, 1.5 | nbody_system.time, 3)
instance.evolve_model(3.0 | nbody_system.time)
self.assertTrue(out_of_box_detection.is_set())
self.assertAlmostEqual(instance.model_time, 2.0 | nbody_system.time, 3)
self.assertEqual(len(out_of_box_detection.particles()), 2)
instance.stop()
def test14(self):
print("Testing Fi get_hydro_state_at_point")
number_sph_particles = 100
convert_nbody = nbody_system.nbody_to_si(1.0 | units.kpc, 1.0e10 | units.MSun)
gas = new_evrard_gas_sphere(number_sph_particles, convert_nbody, seed=1234)
gas.h_smooth = 0.01 | nbody_system.length
instance = Fi(convert_nbody)
instance.parameters.n_smooth = 64
instance.parameters.n_smooth_tol = 0.01
instance.gas_particles.add_particles(gas)
instance.synchronize_model()
coords = [0.0 | units.kpc]*3
hydro_state = instance.get_hydro_state_at_point(*coords)
expected = [3.5540e-19 | units.kg * units.m**-3,
0.0 | units.kg * units.m**-2 / units.s,
0.0 | units.kg * units.m**-2 / units.s,
0.0 | units.kg * units.m**-2 / units.s,
8.445e-10 | units.kg * units.m**-1 * units.s**-2]
for value, expect in zip(hydro_state, expected):
self.assertAlmostRelativeEqual(value, expect, places=3)
coords = [0.1 | units.kpc]*3
hydro_state = instance.get_hydro_state_at_point(*coords)
expected = [4.1789e-19 | units.kg * units.m**-3,
0.0 | units.kg * units.m**-2 / units.s,
0.0 | units.kg * units.m**-2 / units.s,
0.0 | units.kg * units.m**-2 / units.s,
1.0868e-9 | units.kg * units.m**-1 * units.s**-2]
for value, expect in zip(hydro_state, expected):
self.assertAlmostRelativeEqual(value, expect, places=3)
instance.stop()
def test15(self):
print("Testing Fi get_hydro_state_at_point II: uniform sphere")
number_sph_particles = 1000
convert_nbody = nbody_system.nbody_to_si(1.0 | units.kpc, 1.0e10 | units.MSun)
gas = new_uniform_spherical_particle_distribution(number_sph_particles, 1.0 | units.kpc, 1.0e10 | units.MSun)
gas.velocity = [10.0, 20.0, 30.0] | units.km / units.s
gas.h_smooth = 0.01 | nbody_system.length
gas.u = 0.05 | nbody_system.specific_energy
density = (1.0e10 | units.MSun) / (4.0/3.0 * numpy.pi * (1.0 | units.kpc)**3)
instance = Fi(convert_nbody)
instance.parameters.n_smooth = 64
instance.parameters.n_smooth_tol = 0.01
instance.gas_particles.add_particles(gas)
instance.synchronize_model()
coords = [0.0 | units.kpc]*3
rho, rhovx, rhovy, rhovz, rhoe = instance.get_hydro_state_at_point(*coords)
self.assertAlmostRelativeEqual(rho, density, places=3)
self.assertAlmostRelativeEqual(rho, max(instance.gas_particles.rho), places=2)
self.assertIsOfOrder(rho, instance.gas_particles.rho)
self.assertAlmostRelativeEqual(rhovx, density*instance.gas_particles[0].vx, places=3)
self.assertAlmostRelativeEqual(rhovy, density*instance.gas_particles[0].vy, places=3)
self.assertAlmostRelativeEqual(rhovz, density*instance.gas_particles[0].vz, places=3)
self.assertAlmostRelativeEqual(rhoe, density * (instance.gas_particles[0].u +
0.5 * instance.gas_particles[0].velocity.length_squared()), places=2)
coords = [0.1 | units.kpc]*3
rho, rhovx, rhovy, rhovz, rhoe = instance.get_hydro_state_at_point(*coords)
self.assertAlmostRelativeEqual(rho, density, places=3)
self.assertAlmostRelativeEqual(rhovx, density*instance.gas_particles[0].vx, places=3)
self.assertAlmostRelativeEqual(rhovy, density*instance.gas_particles[0].vy, places=3)
self.assertAlmostRelativeEqual(rhovz, density*instance.gas_particles[0].vz, places=3)
self.assertAlmostRelativeEqual(rhoe, density * (instance.gas_particles[0].u +
0.5 * instance.gas_particles[0].velocity.length_squared()), places=2)
instance.stop()
def test16(self):
instance = self.new_instance_of_an_optional_code(Fi)
try:
particles = new_plummer_model(100)
more_particles = new_plummer_model(50)
particles.h_smooth = 0.1 | nbody_system.length
particles.u = 0.1 | nbody_system.speed**2
more_particles.h_smooth = 0.1 | nbody_system.length
more_particles.u = 0.1 | nbody_system.speed**2
particles.move_to_center()
more_particles.move_to_center()
instance.gas_particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(len(instance.particles), 100)
instance.synchronize_model()
instance.gas_particles.add_particles(more_particles)
instance.recommit_particles()
self.assertEqual(len(instance.particles), 150)
instance.synchronize_model()
selected1 = instance.particles.select_array(lambda x: x < 0 | nbody_system.length, ["x",]).copy()
self.assertEqual(len(instance.particles), 150)
instance.particles.remove_particles(selected1)
self.assertEqual(len(instance.particles), 150 - len(selected1))
instance.recommit_particles()
instance.synchronize_model()
selected2 = instance.particles.select_array(lambda x: x > 0 | nbody_system.length, ["x",]).copy()
instance.particles.remove_particles(selected2)
self.assertEqual(len(instance.particles), 150 - len(selected1) - len(selected2))
instance.recommit_particles()
finally:
instance.stop()
def test17(self):
UnitLength = 3.085678e21 | units.cm # ~ 1.0 kpc
UnitMass = 1.989e43 | units.g # 1.0e10 solar masses
UnitVelocity = 1e5 | units.cm / units.s # 1 km/sec
convert_nbody = nbody_system.nbody_to_si(UnitLength, UnitMass)
instance = Fi(convert_nbody, mode=FiInterface.MODE_PERIODIC_BOUNDARIES)
self.assertEqual(instance.parameters.periodic_boundaries_flag, True)
instance.parameters.use_hydro_flag = False
instance.parameters.self_gravity_flag = False
instance.parameters.periodic_box_size = 2.0 | nbody_system.length
instance.parameters.timestep = 0.1 | nbody_system.time
self.assertAlmostEqual(instance.parameters.periodic_box_size, 2.0 | units.kpc, places=6)
three_particles_IC = datamodel.Particles(3)
three_particles_IC.position = [[0.5, 0.0, 0.0], [0.0, -0.5, 0.0], [0.0, 0.0, 0.5]] | nbody_system.length
three_particles_IC.velocity = [[-1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, -1.0]] | nbody_system.speed
three_particles_IC.radius = 0.0 | units.RSun
three_particles_IC.mass = 1.0e10 | units.MSun
instance.dm_particles.add_particles(three_particles_IC)
self.assertAlmostEqual(instance.dm_particles.x, [0.5, 0.0, 0.0] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.y, [0.0, -0.5, 0.0] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.z, [0.0, 0.0, 0.5] | units.kpc, places=6)
instance.evolve_model(0.1 | nbody_system.time)
self.assertAlmostEqual(instance.dm_particles.x, [0.4, 0.0, 0.0] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.y, [0.0, -0.4, 0.0] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.z, [0.0, 0.0, 0.4] | units.kpc, places=6)
instance.evolve_model(1.0 | nbody_system.time)
self.assertAlmostEqual(instance.dm_particles.x, [-0.5, 0.0, 0.0] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.y, [0.0, 0.5, 0.0] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.z, [0.0, 0.0, -0.5] | units.kpc, places=6)
instance.stop()
def test18(self):
particles = datamodel.Particles(10)
particles.x = (numpy.array(range(10)) * 1.0) | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.001 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
instance = Fi()
instance.initialize_code()
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles[0:2]), 2)
self.assertTrue(str(instance.particles[0:2]).find('key') > 0)
instance.stop()
def test19(self):
instance = Fi()
instance.dm_particles.add_particle(datamodel.Particle(
x=1.0 | nbody_system.length,
y=2.0 | nbody_system.length,
z=3.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=2.0 | nbody_system.speed,
vz=3.0 | nbody_system.speed,
mass=1.0 | nbody_system.mass,
))
instance.gas_particles.add_particle(datamodel.Particle(
x=1.0 | nbody_system.length,
y=2.0 | nbody_system.length,
z=4.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=2.0 | nbody_system.speed,
vz=3.0 | nbody_system.speed,
mass=1.0 | nbody_system.mass,
u=1.0 | nbody_system.potential
))
instance.star_particles.add_particle(datamodel.Particle(
x=1.0 | nbody_system.length,
y=2.0 | nbody_system.length,
z=5.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=2.0 | nbody_system.speed,
vz=3.0 | nbody_system.speed,
mass=1.0 | nbody_system.mass,
))
instance.commit_particles()
self.assertEqual(instance.dm_particles[0].radius, 8.0 | nbody_system.length)
self.assertAlmostRelativeEquals(instance.gas_particles[0].h_smooth, 116.754483949 | nbody_system.length, 6)
self.assertEqual(instance.star_particles[0].radius, 8.0 | nbody_system.length)
instance.stop()
instance = Fi()
instance.parameters.adaptive_smoothing_flag = False
instance.dm_particles.add_particle(datamodel.Particle(
x=1.0 | nbody_system.length,
y=2.0 | nbody_system.length,
z=3.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=2.0 | nbody_system.speed,
vz=3.0 | nbody_system.speed,
mass=1.0 | nbody_system.mass,
radius=0.1 | nbody_system.length,
))
instance.gas_particles.add_particle(datamodel.Particle(
x=1.0 | nbody_system.length,
y=2.0 | nbody_system.length,
z=4.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=2.0 | nbody_system.speed,
vz=3.0 | nbody_system.speed,
mass=1.0 | nbody_system.mass,
u=1.0 | nbody_system.potential,
h_smooth=100 | nbody_system.length,
))
instance.star_particles.add_particle(datamodel.Particle(
x=1.0 | nbody_system.length,
y=2.0 | nbody_system.length,
z=5.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=2.0 | nbody_system.speed,
vz=3.0 | nbody_system.speed,
mass=1.0 | nbody_system.mass,
radius=0.2 | nbody_system.length,
))
instance.commit_particles()
self.assertEqual(instance.dm_particles[0].radius, 0.1 | nbody_system.length)
self.assertAlmostRelativeEquals(instance.gas_particles[0].h_smooth, 116.754483949 | nbody_system.length, 6)
self.assertEqual(instance.star_particles[0].radius, 0.2 | nbody_system.length)
instance.stop()
def test20(self):
instance = Fi()
instance.initialize_code()
instance.parameters.use_hydro_flag = 0
instance.parameters.self_gravity_flag = 0
instance.parameters.periodic_box_size = 1 | nbody_system.length
instance.parameters.timestep = 0.2 | nbody_system.time
p1 = instance.gas_particles.add_particle(datamodel.Particle(
x=0.5 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.1 | nbody_system.mass,
u=0.0 | nbody_system.potential
))
p2 = instance.gas_particles.add_particle(datamodel.Particle(
x=0.1 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=0.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.001 | nbody_system.mass,
u=0.0 | nbody_system.potential
))
instance.evolve_model(0.1 | nbody_system.time)
instance.update_particle_set()
self.assertEqual(len(instance.gas_particles), 2)
self.assertAlmostRelativeEquals(instance.gas_particles[0].x, 0.5 | nbody_system.length)
instance.evolve_model(0.15 | nbody_system.time)
instance.update_particle_set()
self.assertEqual(len(instance.gas_particles), 1)
self.assertEqual(instance.gas_particles.mass, [0.001] | nbody_system.mass)
self.assertEqual(instance.gas_particles[0].mass, 0.001 | nbody_system.mass)
self.assertAlmostRelativeEquals(instance.gas_particles[0].x, 0.1 | nbody_system.length)
self.assertAlmostRelativeEquals(instance.gas_particles.x, [0.1] | nbody_system.length)
def test21(self):
instance = Fi()
instance.parameters.use_hydro_flag = 0
instance.parameters.self_gravity_flag = 0
instance.parameters.periodic_box_size = 1 | nbody_system.length
instance.parameters.timestep = 0.2 | nbody_system.time
instance.commit_parameters()
instance.parameters.use_hydro_flag = 1
particles = datamodel.Particles(2)
particles.mass = 0.5 | nbody_system.mass
particles[0].position = [1.0, 0.0, 0.0] | nbody_system.length
particles[1].position = [-1.0, 0.0, 0.] | nbody_system.length
particles.velocity = [0, 0, 0] | nbody_system.speed
particles.u = 0.0 | nbody_system.potential
print(particles)
try:
t = instance.model_time
self.assertEqual(t, 0 | nbody_system.time)
channel = instance.particles.new_channel_to(particles)
self.assertEqual(0, len(instance.particles))
particles.synchronize_to(instance.particles)
self.assertEqual(2, len(instance.particles))
instance.commit_particles()
self.assertEqual(2, len(particles))
instance.particles.synchronize_to(particles)
self.assertEqual(2, len(particles))
channel.copy()
except Exception as ex:
print(ex)
self.fail("requesting the model time should not trigger a commit_particles")
def test22(self):
instance = Fi()
instance.initialize_code()
instance.parameters.use_hydro_flag = 0
instance.parameters.self_gravity_flag = 0
instance.parameters.periodic_box_size = 1 | nbody_system.length
instance.parameters.timestep = 0.2 | nbody_system.time
p1 = instance.gas_particles.add_particle(datamodel.Particle(
x=0.5 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.1 | nbody_system.mass,
u=0.0 | nbody_system.potential
))
p2 = instance.gas_particles.add_particle(datamodel.Particle(
x=0.1 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=0.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.001 | nbody_system.mass,
u=0.0 | nbody_system.potential
))
p3 = instance.gas_particles.add_particle(datamodel.Particle(
x=-0.9 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=-2.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.002 | nbody_system.mass,
u=0.0 | nbody_system.potential
))
instance.evolve_model(0.1 | nbody_system.time)
instance.update_particle_set()
self.assertEqual(len(instance.gas_particles), 3)
self.assertAlmostRelativeEquals(instance.gas_particles[0].x, 0.5 | nbody_system.length)
instance.evolve_model(0.15 | nbody_system.time)
instance.update_particle_set()
self.assertEqual(instance.gas_particles.mass, [0.001] | nbody_system.mass)
self.assertEqual(instance.gas_particles[0].mass, 0.001 | nbody_system.mass)
self.assertEqual(len(instance.gas_particles), 1)
self.assertAlmostRelativeEquals(instance.gas_particles[0].mass, 0.001 | nbody_system.mass)
self.assertAlmostRelativeEquals(instance.gas_particles[0].x, 0.1 | nbody_system.length)
self.assertAlmostRelativeEquals(instance.gas_particles.x, [0.1] | nbody_system.length)
def test23(self):
instance = Fi()
instance.initialize_code()
instance.parameters.use_hydro_flag = 0
instance.parameters.self_gravity_flag = 0
instance.parameters.periodic_box_size = 1 | nbody_system.length
instance.parameters.timestep = 0.2 | nbody_system.time
p1 = instance.gas_particles.add_particle(datamodel.Particle(
x=1.5 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.1 | nbody_system.mass,
u=0.0 | nbody_system.potential
))
p2 = instance.gas_particles.add_particle(datamodel.Particle(
x=0.1 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=0.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.001 | nbody_system.mass,
u=0.0 | nbody_system.potential
))
p3 = instance.gas_particles.add_particle(datamodel.Particle(
x=-1.5 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=-2.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.002 | nbody_system.mass,
u=0.0 | nbody_system.potential
))
instance.commit_particles()
self.assertEqual(len(instance.gas_particles), 3)
self.assertEqual(instance.gas_particles.mass, [0.1, 0.001, 0.002] | nbody_system.mass)
instance.evolve_model(0.15 | nbody_system.time)
instance.update_particle_set()
self.assertEqual(len(instance.gas_particles), 1)
self.assertEqual(instance.gas_particles.mass, [0.001] | nbody_system.mass)
self.assertEqual(instance.gas_particles[0].mass, 0.001 | nbody_system.mass)
self.assertEqual(len(instance.gas_particles), 1)
self.assertAlmostRelativeEquals(instance.gas_particles[0].mass, 0.001 | nbody_system.mass)
self.assertAlmostRelativeEquals(instance.gas_particles[0].x, 0.1 | nbody_system.length)
self.assertAlmostRelativeEquals(instance.gas_particles.x, [0.1] | nbody_system.length)
def test24(self):
instance = Fi()
instance.initialize_code()
instance.parameters.use_hydro_flag = 0
instance.parameters.self_gravity_flag = 0
instance.parameters.periodic_box_size = 1 | nbody_system.length
instance.parameters.timestep = 0.2 | nbody_system.time
p1 = instance.gas_particles.add_particle(datamodel.Particle(
x=0.5 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.1 | nbody_system.mass,
u=0.0 | nbody_system.potential
))
p2 = instance.gas_particles.add_particle(datamodel.Particle(
x=0.1 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=0.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.001 | nbody_system.mass,
u=0.0 | nbody_system.potential
))
# run more than one innerloop step in fi
instance.evolve_model(1 | nbody_system.time)
instance.update_particle_set()
self.assertEqual(len(instance.gas_particles), 1)
self.assertEqual(instance.gas_particles.mass, [0.001] | nbody_system.mass)
self.assertEqual(instance.gas_particles[0].mass, 0.001 | nbody_system.mass)
self.assertAlmostRelativeEquals(instance.gas_particles[0].x, 0.1 | nbody_system.length)
self.assertAlmostRelativeEquals(instance.gas_particles.x, [0.1] | nbody_system.length)
def test25(self):
print("Testing Fi density_limit_detection")
number_gas_particles = 500
UnitLength = 3.085678e21 | units.cm # ~ 1.0 kpc
UnitMass = 1.989e43 | units.g # 1.0e10 solar masses
convert_nbody = nbody_system.nbody_to_si(UnitLength, UnitMass)
gas = new_evrard_gas_sphere(number_gas_particles, convert_nbody, do_scale=True, seed=12345)
instance = Fi(convert_nbody)
instance.initialize_code()
instance.parameters.stopping_condition_maximum_density = 10.0 * UnitMass / UnitLength**3
instance.parameters.timestep = 0.1 | units.Myr
instance.gas_particles.add_particles(gas)
stars = new_plummer_model(5, convert_nbody)
stars.x += 1000 * UnitLength
instance.dm_particles.add_particles(stars)
self.assertIsOfOrder(max(instance.gas_particles.density), UnitMass / UnitLength**3)
density_limit_detection = instance.stopping_conditions.density_limit_detection
density_limit_detection.enable()
instance.evolve_model(10.0 | units.Myr)
print(instance.model_time.as_quantity_in(units.Myr))
print(instance.stopping_conditions)
self.assertTrue(density_limit_detection.is_set())
self.assertTrue(instance.model_time < 10.0 | units.Myr)
self.assertEqual(len(density_limit_detection.particles()), 1)
self.assertTrue((density_limit_detection.particles().density >
10 * UnitMass / UnitLength**3).all())
instance.particles.remove_particles(density_limit_detection.particles())
instance.evolve_model(10.0 | units.Myr)
print(instance.model_time.as_quantity_in(units.Myr))
print(instance.stopping_conditions)
self.assertTrue(density_limit_detection.is_set())
self.assertTrue(instance.model_time < 10.0 | units.Myr)
self.assertEqual(len(density_limit_detection.particles()), 1)
self.assertTrue((density_limit_detection.particles().density >
10 * UnitMass / UnitLength**3).all())
instance.stop()
def test26(self):
print("Testing Fi internal_energy_limit_detection")
number_gas_particles = 500
UnitLength = 3.085678e21 | units.cm # ~ 1.0 kpc
UnitMass = 1.989e43 | units.g # 1.0e10 solar masses
convert_nbody = nbody_system.nbody_to_si(UnitLength, UnitMass)
gas = new_evrard_gas_sphere(number_gas_particles, convert_nbody, do_scale=True, seed=12345)
initial_internal_energy = 0.05 * constants.G * UnitMass / UnitLength
instance = Fi(convert_nbody)
instance.initialize_code()
instance.parameters.timestep = 0.1 | units.Myr
instance.parameters.stopping_condition_maximum_internal_energy = 10 * initial_internal_energy
instance.gas_particles.add_particles(gas)
self.assertAlmostRelativeEquals(instance.gas_particles.u, initial_internal_energy, 8)
internal_energy_limit_detection = instance.stopping_conditions.internal_energy_limit_detection
internal_energy_limit_detection.enable()
instance.evolve_model(10.0 | units.Myr)
print(instance.model_time.as_quantity_in(units.Myr))
print(instance.stopping_conditions)
self.assertTrue(internal_energy_limit_detection.is_set())
self.assertTrue(instance.model_time < 10.0 | units.Myr)
self.assertEqual(len(internal_energy_limit_detection.particles()), 1)
self.assertTrue((internal_energy_limit_detection.particles().u >
10 * initial_internal_energy).all())
instance.particles.remove_particles(internal_energy_limit_detection.particles())
instance.evolve_model(10.0 | units.Myr)
print(instance.model_time.as_quantity_in(units.Myr))
print(instance.stopping_conditions)
self.assertTrue(internal_energy_limit_detection.is_set())
self.assertTrue(instance.model_time < 10.0 | units.Myr)
self.assertEqual(len(internal_energy_limit_detection.particles()), 6)
self.assertTrue((internal_energy_limit_detection.particles().u >
10 * initial_internal_energy).all())
instance.stop()
def test27(self):
print("Testing Fi SPH particle properties")
number_sph_particles = 1000
convert_nbody = nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc)
gas = new_evrard_gas_sphere(number_sph_particles, convert_nbody, seed=1234)
instance = Fi(convert_nbody)
instance.parameters.timestep = 0.05 | nbody_system.time
instance.parameters.integrate_entropy_flag = True
instance.gas_particles.add_particles(gas)
self.assertIsOfOrder(instance.gas_particles.h_smooth,
convert_nbody.to_si(0.5 | nbody_system.length) *
(instance.parameters.n_smooth*1.0/number_sph_particles)**(1.0/3))
self.assertAlmostRelativeEqual(instance.gas_particles.u,
convert_nbody.to_si(0.05 | nbody_system.specific_energy))
# the density of the cloud scales with 1/r:
r_sort, rho_sort = instance.gas_particles.position.lengths().sorted_with(instance.gas_particles.rho)
mean_density = convert_nbody.to_si(3.0/(4.0*numpy.pi) | nbody_system.density)
select = slice(number_sph_particles//2) # select 50% particles closest to center to avoid boundaries
self.assertIsOfOrder(rho_sort[select]/mean_density, r_sort.mean()/r_sort[select])
self.assertAlmostEqual(instance.gas_particles.u * instance.gas_particles.rho,
1.5 * instance.gas_particles.pressure)
self.assertAlmostEqual(instance.gas_particles.du_dt, 0 | units.m**2 * units.s**-3)
u_0 = instance.gas_particles.u.sum()
instance.evolve_model(0.1 | nbody_system.time)
# Collapsing ==> heating:
self.assertTrue(instance.gas_particles.du_dt.sum() >= 0 | units.m**2 * units.s**-3)
self.assertIsOfOrder(instance.gas_particles.du_dt.sum() * convert_nbody.to_si(0.1 | nbody_system.time),
instance.gas_particles.u.sum() - u_0)
instance.stop()
def test28(self):
print("Testing Fi u error")
number_gas_particles = 500
UnitLength = 3.085678e21 | units.cm # ~ 1.0 kpc
UnitMass = 1.989e43 | units.g # 1.0e10 solar masses
convert_nbody = nbody_system.nbody_to_si(UnitLength, UnitMass)
gas = new_evrard_gas_sphere(number_gas_particles, convert_nbody, do_scale=True, seed=12345)
instance = Fi(convert_nbody)
instance.initialize_code()
instance.parameters.stopping_condition_maximum_density = 10.0 * UnitMass / UnitLength**3
instance.parameters.timestep = 0.1 | units.Myr
instance.gas_particles.add_particles(gas)
u = instance.gas_particles.u
gas_particles = instance.gas_particles.copy()
self.assertEqual(u, gas_particles.u)
def test29(self):
instance = Fi()
instance.initialize_code()
instance.parameters.use_hydro_flag = 0
instance.parameters.self_gravity_flag = 1
instance.parameters.epsilon_squared = 0.000000001 | nbody_system.length**2
instance.parameters.timestep = 0.2 | nbody_system.time
x0 = 0.5 | nbody_system.length
p1 = instance.star_particles.add_particle(datamodel.Particle(
x=x0,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=0.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.01 | nbody_system.mass,
))
p2 = instance.star_particles.add_particle(datamodel.Particle(
x=10 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=0.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=100 | nbody_system.mass,
))
# run more than one innerloop step in fi
e0 = instance.kinetic_energy + instance.potential_energy
instance.evolve_model(0.5 | nbody_system.time)
e1 = instance.kinetic_energy + instance.potential_energy
self.assertAlmostRelativeEquals(e0, e1, 4)
print(instance.star_particles[0].position.x)
self.assertAlmostRelativeEquals(instance.star_particles[0].position.x, 0.588896329162 | nbody_system.length, 12)
for i in range(10):
p3 = instance.star_particles.add_particle(datamodel.Particle(
x=100 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=0.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=100 | nbody_system.mass,
))
instance.recommit_particles()
instance.star_particles.remove_particle(p3)
instance.recommit_particles()
e11 = instance.kinetic_energy + instance.potential_energy
self.assertAlmostRelativeEquals(e1, e1, 8)
instance.evolve_model(1.0 | nbody_system.time)
e2 = instance.kinetic_energy + instance.potential_energy
self.assertAlmostRelativeEquals(e0, e1, 4)
self.assertAlmostRelativeEquals(instance.star_particles[0].position.x, 1.06498184266 | nbody_system.length, 11)
def test30(self):
instance = Fi()
instance.initialize_code()
instance.parameters.use_hydro_flag = 0
instance.parameters.self_gravity_flag = 1
instance.parameters.epsilon_squared = 0.000000001 | nbody_system.length**2
instance.parameters.timestep = 0.2 | nbody_system.time
instance.parameters.verbosity = 0
x0 = 0.5 | nbody_system.length
p1 = instance.star_particles.add_particle(datamodel.Particle(
x=x0,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=0.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.01 | nbody_system.mass,
))
p2 = instance.star_particles.add_particle(datamodel.Particle(
x=10 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=0.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=100 | nbody_system.mass,
))
instance.commit_particles()
e0 = instance.kinetic_energy + instance.potential_energy
print("e0:", e0)
for i in range(10):
p3 = instance.star_particles.add_particle(datamodel.Particle(
x=100 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=0.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=100 | nbody_system.mass,
))
instance.recommit_particles()
instance.star_particles.remove_particle(p3)
instance.recommit_particles()
# run more than one innerloop step in fi
instance.evolve_model(0.5 | nbody_system.time)
e1 = instance.kinetic_energy + instance.potential_energy
self.assertAlmostRelativeEquals(e0, e1, 4)
print(instance.star_particles[0].position.x)
self.assertAlmostRelativeEquals(instance.star_particles[0].position.x, 0.588896329162 | nbody_system.length, 12)
instance.evolve_model(1.0 | nbody_system.time)
e2 = instance.kinetic_energy + instance.potential_energy
self.assertAlmostRelativeEquals(e0, e2, 4)
self.assertAlmostRelativeEquals(instance.star_particles[0].position.x, 1.06493331332 | nbody_system.length, 11)
def test31(self):
instance = Fi()
instance.initialize_code()
instance.parameters.use_hydro_flag = 0
instance.parameters.self_gravity_flag = 0
instance.parameters.periodic_box_size = 1 | nbody_system.length
instance.parameters.timestep = 0.2 | nbody_system.time
p1 = instance.gas_particles.add_particle(datamodel.Particle(
x=0.5 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.1 | nbody_system.mass,
u=0.0 | nbody_system.potential
))
p2 = instance.gas_particles.add_particle(datamodel.Particle(
x=0.1 | nbody_system.length,
y=0.0 | nbody_system.length,
z=0.0 | nbody_system.length,
vx=0.0 | nbody_system.speed,
vy=0.0 | nbody_system.speed,
vz=0.0 | nbody_system.speed,
mass=0.001 | nbody_system.mass,
u=0.0 | nbody_system.potential
))
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
self.assertEqual(len(instance.gas_particles), 2)
self.assertAlmostRelativeEquals(instance.gas_particles[0].x, 0.5 | nbody_system.length)
instance.evolve_model(0.15 | nbody_system.time)
instance.synchronize_model()
self.assertEqual(len(instance.gas_particles), 1)
self.assertEqual(instance.gas_particles.mass, [0.001] | nbody_system.mass)
self.assertEqual(instance.gas_particles[0].mass, 0.001 | nbody_system.mass)
self.assertAlmostRelativeEquals(instance.gas_particles[0].x, 0.1 | nbody_system.length)
self.assertAlmostRelativeEquals(instance.gas_particles.x, [0.1] | nbody_system.length)
def test32(self):
print("Testing Fi get_hydro_state_at_point in periodic mode")
gas = datamodel.Particles(8000)
gas.mass = 1.0e10/8000 | units.MSun
x, y, z = numpy.mgrid[-1:0.9:20j, -1:0.9:20j, -1:0.9:20j] | units.kpc
gas.x, gas.y, gas.z = x.flatten(), y.flatten(), z.flatten()
gas.velocity = [0, 0, 0] | units.m / units.s
gas.u = (1 + 0.8 * numpy.sin(gas.x * (numpy.pi | units.kpc**-1))) | nbody_system.specific_energy
instance = Fi(nbody_system.nbody_to_si(1.0 | units.km/units.s, 1.0 | units.kpc), mode='periodic', redirection="none")
instance.parameters.self_gravity_flag = False
instance.parameters.periodic_box_size = 2.0 | units.kpc
instance.gas_particles.add_particles(gas)
self.assertAlmostRelativeEqual(instance.gas_particles.total_mass(), 1.0e10 | units.MSun, 3)
self.assertAlmostRelativeEqual(instance.thermal_energy, 1.0e10 | units.MSun * units.km**2 * units.s**-2, 3)
number_of_points = 100
in_domain = numpy.linspace(-1.0, 1.0, 100) | units.kpc
domain_border = numpy.ones(100) | units.kpc
state_left = instance.get_hydro_state_at_point(-domain_border, in_domain, in_domain)
state_right = instance.get_hydro_state_at_point(domain_border, in_domain, in_domain)
for var_left, var_right in zip(state_left, state_right):
self.assertAlmostRelativeEqual(var_left, var_right, 10)
state_back = instance.get_hydro_state_at_point(in_domain, -domain_border, in_domain)
state_front = instance.get_hydro_state_at_point(in_domain, domain_border, in_domain)
for var_front, var_back in zip(state_front, state_back):
self.assertAlmostRelativeEqual(var_front, var_back, 10)
state_bottom = instance.get_hydro_state_at_point(in_domain, in_domain, -domain_border)
state_top = instance.get_hydro_state_at_point(in_domain, in_domain, domain_border)
for var_top, var_bottom in zip(state_top, state_bottom):
self.assertAlmostRelativeEqual(var_top, var_bottom, 10)
self.assertAlmostRelativeEqual(state_left[0].mean(), 1.25e9 | units.MSun * units.kpc**-3, 2)
self.assertAlmostRelativeEqual(state_back[0].mean(), 1.25e9 | units.MSun * units.kpc**-3, 2)
self.assertAlmostRelativeEqual(state_bottom[0].mean(), 1.25e9 | units.MSun * units.kpc**-3, 2)
self.assertAlmostRelativeEqual(state_left[4].mean(), 1.25e9 | units.MSun * units.kpc**-3 * units.km**2 * units.s**-2, 2)
self.assertAlmostRelativeEqual(state_back[4].mean(), 1.25e9 | units.MSun * units.kpc**-3 * units.km**2 * units.s**-2, 2)
self.assertAlmostRelativeEqual(state_bottom[4].mean(), 1.25e9 | units.MSun * units.kpc**-3 * units.km**2 * units.s**-2, 2)
# With x=cst, variations in u (and therefore in rhoe) should be small
self.assertAlmostEqual(state_left[4].std() / (1.25e9 | units.MSun * units.kpc**-3 * units.km**2 * units.s**-2), 0.0, 2)
# Over the entire x domain, variations in rhoe should equal the sine amplitude (=0.8) times the rms(sine) over a whole period (=sqrt(.5))
self.assertAlmostEqual(state_back[4].std() / (1.25e9 | units.MSun * units.kpc**-3 * units.km**2 * units.s**-2), 0.8 * numpy.sqrt(0.5), 1)
self.assertAlmostEqual(state_bottom[4].std() / (1.25e9 | units.MSun * units.kpc**-3 * units.km**2 * units.s**-2), 0.8 * numpy.sqrt(0.5), 1)
instance.stop()
| 81,088
| 46.755595
| 192
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_sphray.py
|
import os.path
import numpy
from amuse.test.amusetest import TestWithMPI
from amuse.community.sphray.interface import SPHRayInterface, SPHRay
from amuse.units import units
from amuse.datamodel import Particles, create_particle_set
from amuse.datamodel import Particle
from amuse.io import read_set_from_file
# default_options = dict(redirection="none")
default_options = {}
class TestSPHRayInterface(TestWithMPI):
def setUp(self):
super(TestWithMPI, self).setUp()
def test1(self):
print("Test 1: initialization")
instance = SPHRayInterface(**default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_sphray_data_directory(instance.data_directory))
self.assertEqual(0, instance.set_sphray_output_directory(instance.output_directory))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test2(self):
print("Test 2: add, commit_particles")
instance = SPHRayInterface(**default_options)
self.assertEqual(0, instance.set_sphray_data_directory(instance.data_directory))
self.assertEqual(0, instance.set_sphray_output_directory(instance.output_directory))
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
input_file = os.path.join(os.path.dirname(__file__), "test_sphray_data_4K")
mass, hsml, x, y, z, rho, xe, u = self.read_gas_file(input_file)
number_of_gas_particles = len(x)
indices, errors = instance.new_gas_particle(mass, hsml, x, y, z, rho, xe, u)
self.assertEqual(errors, [0]*number_of_gas_particles)
self.assertEqual(indices, list(range(1, number_of_gas_particles+1)))
input_file = os.path.join(os.path.dirname(__file__), "test_sphray_data_sources_001.1")
L, xs, ys, zs, spctype = self.read_src_file(input_file)
number_of_src_particles = len(xs)
s_indices, errors = instance.new_src_particle(L, xs, ys, zs, spctype)
self.assertEqual(errors, [0]*number_of_src_particles)
self.assertEqual(s_indices, list(range(number_of_gas_particles+1, number_of_src_particles+number_of_gas_particles+1)))
self.assertEqual(0, instance.commit_particles())
mass2, hsml2, x2, y2, z2, rho2, xe2, u2, error = instance.get_state_gas(indices)
self.assertAlmostEqual((mass-mass2), numpy.zeros_like(x), 7)
self.assertAlmostEqual((hsml-hsml2), numpy.zeros_like(x), 7)
self.assertAlmostEqual((x-x2)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((y-y2)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((z-z2)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((rho-rho2), numpy.zeros_like(x), 7)
# self.assertAlmostEqual((xe-xe2), numpy.zeros_like(x), 7)
self.assertAlmostEqual((u-u2), numpy.zeros_like(x), 7)
L2, xs2, ys2, zs2, spctype2, error = instance.get_state_src(s_indices)
self.assertAlmostEqual((L-L2), numpy.zeros_like(xs), 7)
self.assertAlmostEqual((xs-xs2)/13200., numpy.zeros_like(xs), 7)
self.assertAlmostEqual((ys-ys2)/13200., numpy.zeros_like(xs), 7)
self.assertAlmostEqual((zs-zs2)/13200., numpy.zeros_like(xs), 7)
self.assertAlmostEqual((spctype-spctype2), numpy.zeros_like(xs), 7)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test3(self):
print("Test 3: add, commit_particles, setters, remove")
instance = SPHRayInterface(**default_options)
self.assertEqual(0, instance.set_sphray_data_directory(instance.data_directory))
self.assertEqual(0, instance.set_sphray_output_directory(instance.output_directory))
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
input_file = os.path.join(os.path.dirname(__file__), "test_sphray_data_4K")
mass, hsml, x, y, z, rho, xe, u = self.read_gas_file(input_file)
number_of_gas_particles = len(x)
indices, errors = instance.new_gas_particle(mass, hsml, x, y, z, rho, xe, u)
self.assertEqual(errors, [0]*number_of_gas_particles)
self.assertEqual(indices, list(range(1, number_of_gas_particles+1)))
input_file = os.path.join(os.path.dirname(__file__), "test_sphray_data_sources_001.1")
L, xs, ys, zs, spctype = self.read_src_file(input_file)
number_of_src_particles = len(xs)
s_indices, errors = instance.new_src_particle(L, xs, ys, zs, spctype)
self.assertEqual(errors, [0]*number_of_src_particles)
self.assertEqual(s_indices, list(range(number_of_gas_particles+1, number_of_src_particles+number_of_gas_particles+1)))
self.assertEqual(0, instance.commit_particles())
mass2, hsml2, x2, y2, z2, rho2, xe2, u2, error = instance.get_state_gas(indices)
self.assertAlmostEqual((mass-mass2), numpy.zeros_like(x), 7)
self.assertAlmostEqual((hsml-hsml2), numpy.zeros_like(x), 7)
self.assertAlmostEqual((x-x2)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((y-y2)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((z-z2)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((rho-rho2), numpy.zeros_like(x), 7)
# self.assertAlmostEqual((xe-xe2), numpy.zeros_like(x), 7)
self.assertAlmostEqual((u-u2), numpy.zeros_like(x), 7)
L2, xs2, ys2, zs2, spctype2, error = instance.get_state_src(s_indices)
self.assertAlmostEqual((L-L2), numpy.zeros_like(xs), 7)
self.assertAlmostEqual((xs-xs2)/13200., numpy.zeros_like(xs), 7)
self.assertAlmostEqual((ys-ys2)/13200., numpy.zeros_like(xs), 7)
self.assertAlmostEqual((zs-zs2)/13200., numpy.zeros_like(xs), 7)
self.assertAlmostEqual((spctype-spctype2), numpy.zeros_like(xs), 7)
error = instance.set_state_gas(100, 1., 2., 3., 4., 5., 6., 7., 8.)
self.assertEqual(0, error)
error = instance.set_state_gas(10000, 1., 2., 3., 4., 5., 6., 7., 8.)
self.assertEqual(-1, error)
m, h, x, y, z, rho, xe, u, error = instance.get_state_gas(100)
self.assertEqual(0, error)
self.assertAlmostEqual(m, 1., 7)
self.assertAlmostEqual(h, 2., 7)
self.assertAlmostEqual(x, 3., 7)
self.assertAlmostEqual(y, 4., 7)
self.assertAlmostEqual(z, 5., 7)
self.assertAlmostEqual(rho, 6., 7)
# self.assertAlmostEqual(xe, 7., 7)
self.assertAlmostEqual(u, 8., 7)
error = instance.remove_gas_particle(100)
self.assertEqual(0, error)
error = instance.remove_gas_particle(100)
self.assertEqual(-4, error)
error = instance.set_state_src(4097, 1., 2., 3., 4., 5.)
self.assertEqual(0, error)
error = instance.set_state_src(10000, 1., 2., 3., 4., 5.)
self.assertEqual(-1, error)
L, x, y, z, s, error = instance.get_state_src(4097)
self.assertEqual(0, error)
self.assertAlmostEqual(L, 1., 7)
self.assertAlmostEqual(x, 2., 7)
self.assertAlmostEqual(y, 3., 7)
self.assertAlmostEqual(z, 4., 7)
self.assertAlmostEqual(s, 5., 7)
error = instance.remove_src_particle(4097)
self.assertEqual(0, error)
error = instance.remove_src_particle(4097)
self.assertEqual(-4, error)
instance.recommit_particles()
error = instance.remove_gas_particle(100)
self.assertEqual(-1, error)
error = instance.remove_gas_particle(4097)
self.assertEqual(-1, error)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test4(self):
print("Test 2: set, get time")
instance = SPHRayInterface(**default_options)
self.assertEqual(0, instance.set_sphray_data_directory(instance.data_directory))
self.assertEqual(0, instance.set_sphray_output_directory(instance.output_directory))
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
input_file = os.path.join(os.path.dirname(__file__), "test_sphray_data_4K")
mass, hsml, x, y, z, rho, xe, u = self.read_gas_file(input_file)
number_of_gas_particles = len(x)
indices, errors = instance.new_gas_particle(mass, hsml, x, y, z, rho, xe, u)
self.assertEqual(errors, [0]*number_of_gas_particles)
self.assertEqual(indices, list(range(1, number_of_gas_particles+1)))
input_file = os.path.join(os.path.dirname(__file__), "test_sphray_data_sources_001.1")
L, xs, ys, zs, spctype = self.read_src_file(input_file)
number_of_src_particles = len(xs)
s_indices, errors = instance.new_src_particle(L, xs, ys, zs, spctype)
self.assertEqual(errors, [0]*number_of_src_particles)
self.assertEqual(s_indices, list(range(number_of_gas_particles+1, number_of_src_particles+number_of_gas_particles+1)))
self.assertEqual(0, instance.commit_particles())
time, err = instance.get_time()
self.assertEqual(0, err)
self.assertEqual(0., time)
err = instance.set_time(123.)
self.assertEqual(-1, err) # because we don't know whether it is safe yet
time, err = instance.get_time()
instance.stop()
self.assertEqual(0, err)
self.assertEqual(123., time)
def test5(self):
instance = SPHRayInterface()
instance.initialize_code()
for x, l in [('isothermal', 0), ('H_caseA', 1), ('He_caseA', 1)]:
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, l))
err = getattr(instance, 'set_'+x)(1)
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, 1))
err = getattr(instance, 'set_'+x)(0)
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, 0))
for x, l in [('iontempsolver', 2), ('boundary', 0)]:
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, l))
err = getattr(instance, 'set_'+x)(1)
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, 1))
err = getattr(instance, 'set_'+x)(0)
result, err = getattr(instance, 'get_'+x)()
self.assertEqual((x, result), (x, 0))
for x, l in [('raynumber', 1000000.), ('boxsize', 13.2), ("defaultspectype", -1.)]:
result, err = getattr(instance, 'get_'+x)()
self.assertAlmostEqual(result, l, 6)
err = getattr(instance, 'set_'+x)(1.)
result, err = getattr(instance, 'get_'+x)()
self.assertAlmostEqual(result, 1., 6)
err = getattr(instance, 'set_'+x)(0)
result, err = getattr(instance, 'get_'+x)()
self.assertAlmostEqual(result, 0., 6)
result, err = instance.get_globalHefraction()
self.assertEqual(err, 0)
self.assertEqual(result, 0.)
err = instance.set_globalHefraction(0.1)
instance.stop()
self.assertEqual(err, -2)
def test6(self):
print("Test 3: add, commit_particles, setters, remove with velocity")
instance = SPHRayInterface(**default_options)
self.assertEqual(0, instance.set_sphray_data_directory(instance.data_directory))
self.assertEqual(0, instance.set_sphray_output_directory(instance.output_directory))
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
input_file = os.path.join(os.path.dirname(__file__), "test_sphray_data_4K")
mass, hsml, x, y, z, rho, xe, u, vx, vy, vz = self.read_gas_file_vel(input_file)
number_of_gas_particles = len(x)
indices, errors = instance.new_gas_particle(mass, hsml, x, y, z, rho, xe, u, vx, vy, vz)
self.assertEqual(errors, [0]*number_of_gas_particles)
self.assertEqual(indices, list(range(1, number_of_gas_particles+1)))
input_file = os.path.join(os.path.dirname(__file__), "test_sphray_data_sources_001.1")
L, xs, ys, zs, spctype = self.read_src_file(input_file)
number_of_src_particles = len(xs)
s_indices, errors = instance.new_src_particle(L, xs, ys, zs, spctype)
self.assertEqual(errors, [0]*number_of_src_particles)
self.assertEqual(s_indices, list(range(number_of_gas_particles+1, number_of_src_particles+number_of_gas_particles+1)))
self.assertEqual(0, instance.commit_particles())
mass2, hsml2, x2, y2, z2, rho2, xe2, u2, error = instance.get_state_gas(indices)
vx2, vy2, vz2, error = instance.get_vel_gas(indices)
self.assertAlmostEqual((mass-mass2), numpy.zeros_like(x), 7)
self.assertAlmostEqual((hsml-hsml2), numpy.zeros_like(x), 7)
self.assertAlmostEqual((x-x2)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((y-y2)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((z-z2)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((vx-vx2)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((vy-vy2)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((vz-vz2)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((rho-rho2), numpy.zeros_like(x), 7)
# self.assertAlmostEqual((xe-xe2), numpy.zeros_like(x), 7)
self.assertAlmostEqual((u-u2), numpy.zeros_like(x), 7)
L2, xs2, ys2, zs2, spctype2, error = instance.get_state_src(s_indices)
self.assertAlmostEqual((L-L2), numpy.zeros_like(xs), 7)
self.assertAlmostEqual((xs-xs2)/13200., numpy.zeros_like(xs), 7)
self.assertAlmostEqual((ys-ys2)/13200., numpy.zeros_like(xs), 7)
self.assertAlmostEqual((zs-zs2)/13200., numpy.zeros_like(xs), 7)
self.assertAlmostEqual((spctype-spctype2), numpy.zeros_like(xs), 7)
error = instance.set_state_gas(100, 1., 2., 3., 4., 5., 6., 7., 8.)
self.assertEqual(0, error)
error = instance.set_vel_gas(100, 9., 10., 11.)
self.assertEqual(0, error)
error = instance.set_state_gas(10000, 1., 2., 3., 4., 5., 6., 7., 8.)
self.assertEqual(-1, error)
m, h, x, y, z, rho, xe, u, error = instance.get_state_gas(100)
vx, vy, vz, error = instance.get_vel_gas(100)
self.assertEqual(0, error)
self.assertAlmostEqual(m, 1., 7)
self.assertAlmostEqual(h, 2., 7)
self.assertAlmostEqual(x, 3., 7)
self.assertAlmostEqual(y, 4., 7)
self.assertAlmostEqual(z, 5., 7)
self.assertAlmostEqual(rho, 6., 7)
# self.assertAlmostEqual(xe, 7., 7)
self.assertAlmostEqual(u, 8., 7)
self.assertAlmostEqual(vx, 9., 7)
self.assertAlmostEqual(vy, 10., 7)
self.assertAlmostEqual(vz, 11., 7)
error = instance.remove_gas_particle(100)
self.assertEqual(0, error)
error = instance.remove_gas_particle(100)
self.assertEqual(-4, error)
error = instance.set_state_src(4097, 1., 2., 3., 4., 5.)
self.assertEqual(0, error)
error = instance.set_state_src(10000, 1., 2., 3., 4., 5.)
self.assertEqual(-1, error)
L, x, y, z, s, error = instance.get_state_src(4097)
self.assertEqual(0, error)
self.assertAlmostEqual(L, 1., 7)
self.assertAlmostEqual(x, 2., 7)
self.assertAlmostEqual(y, 3., 7)
self.assertAlmostEqual(z, 4., 7)
self.assertAlmostEqual(s, 5., 7)
error = instance.remove_src_particle(4097)
self.assertEqual(0, error)
error = instance.remove_src_particle(4097)
self.assertEqual(-4, error)
instance.recommit_particles()
error = instance.remove_gas_particle(100)
self.assertEqual(-1, error)
error = instance.remove_gas_particle(4097)
self.assertEqual(-1, error)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def read_gas_file(self, filename):
p = read_set_from_file(filename, 'amuse')
mass = p.mass.number
hsml = p.smoothing_length.number
x = p.x.number
y = p.y.number
z = p.z.number
rho = p.rho.number
u = p.internal_energy.number
xe = numpy.zeros_like(x)
return mass, hsml, x, y, z, rho, xe, u
def read_gas_file_vel(self, filename):
p = read_set_from_file(filename, 'amuse')
mass = p.mass.number
hsml = p.smoothing_length.number
x = p.x.number
y = p.y.number
z = p.z.number
vx = numpy.random.random(len(mass))
vy = numpy.random.random(len(mass))
vz = numpy.random.random(len(mass))
rho = p.rho.number
u = p.internal_energy.number
xe = numpy.zeros_like(x)
return mass, hsml, x, y, z, rho, xe, u, vx, vy, vz
def read_src_file(self, filename):
f = open(filename)
lines = f.readlines()
f.close()
L = []
x = []
y = []
z = []
spctype = []
for line in lines:
l = line.split()
if len(l) == 9:
L.append(float(l[6]))
x.append(float(l[0]))
y.append(float(l[1]))
z.append(float(l[2]))
spctype.append(float(l[7]))
return numpy.array(L), numpy.array(x), numpy.array(y), numpy.array(z), numpy.array(spctype)
class TestSPHRay(TestWithMPI):
def setUp(self):
super(TestWithMPI, self).setUp()
def test0(self):
print("test1: basic startup and flow")
instance = SPHRay()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.parameters.box_size = 100 | units.parsec
self.assertAlmostRelativeEquals(instance.parameters.box_size, 100 | units.parsec, 7)
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
self.assertAlmostRelativeEquals(instance.parameters.box_size, 100 | units.parsec, 7)
instance.cleanup_code()
instance.stop()
def test1(self):
print("test1: adding particles")
instance = SPHRay()
gasparts = self.read_gas_file(os.path.join(os.path.dirname(__file__), "test_sphray_data_4K"))
srcparts = self.read_src_file(os.path.join(os.path.dirname(__file__), "test_sphray_data_sources_001.1"))
self.assertEqual(len(instance.gas_particles), 0)
self.assertEqual(len(instance.src_particles), 0)
instance.gas_particles.add_particles(gasparts)
instance.src_particles.add_particles(srcparts)
self.assertEqual(len(instance.gas_particles), len(gasparts))
self.assertEqual(len(instance.src_particles), len(srcparts))
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
gaspart2 = instance.gas_particles.copy()
self.assertAlmostRelativeEquals(gasparts.position, gaspart2.position, 6)
self.assertAlmostRelativeEquals(gasparts.rho, gaspart2.rho, 6)
self.assertAlmostRelativeEquals(gasparts.u, gaspart2.u, 6)
instance.cleanup_code()
instance.stop()
def test2(self):
print("test2: test parameters")
instance = SPHRay()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
for par, val in [("isothermal_flag", False),
("hydrogen_case_A_flag", True), ("helium_case_A_flag", True)]:
val1 = getattr(instance.parameters, par)
self.assertEqual(val, val1)
setattr(instance.parameters, par, False)
val1 = getattr(instance.parameters, par)
self.assertEqual(val1, False)
setattr(instance.parameters, par, True)
val1 = getattr(instance.parameters, par)
self.assertEqual(val1, True)
setattr(instance.parameters, par, False)
val1 = getattr(instance.parameters, par)
self.assertEqual(val1, False)
for par, val in [
("ionization_temperature_solver", 2), ("boundary_condition", 0)]:
val1 = getattr(instance.parameters, par)
self.assertEqual(val, val1)
setattr(instance.parameters, par, 123)
val1 = getattr(instance.parameters, par)
self.assertEqual(val1, 123)
for par, val in [
("spectra_file", "./spectra/thermal1e5.cdf")]:
val1 = getattr(instance.parameters, par)
self.assertEqual(val, val1)
setattr(instance.parameters, par, "somefile")
val1 = getattr(instance.parameters, par)
self.assertEqual(val1, "somefile")
for par, val, tval in [("number_of_rays", 1022.69032205 | (units.Myr**-1), 10000 | units.Myr**-1),
("box_size", 13.2 | units.kpc, 10. | units.kpc),
("default_spectral_type", -1., 1.)]:
val1 = getattr(instance.parameters, par)
self.assertAlmostRelativeEqual(val, val1, 6)
setattr(instance.parameters, par, tval)
val1 = getattr(instance.parameters, par)
self.assertAlmostRelativeEqual(val1, tval, 6)
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.stop()
def test3(self):
instance = SPHRay()
instance.src_particles.add_particle(
Particle(
luminosity=1 | 1e48 * units.s**-1,
x=2 | units.m,
y=3 | units.m,
z=4 | units.m,
SpcType=12.3
)
)
self.assertAlmostRelativeEquals(instance.src_particles.luminosity, 1 | 1e48 * units.s**-1, 6)
self.assertAlmostRelativeEquals(instance.src_particles.x, 2 | units.m, 7)
self.assertAlmostRelativeEquals(instance.src_particles.y, 3 | units.m, 7)
self.assertAlmostRelativeEquals(instance.src_particles.z, 4 | units.m, 7)
self.assertAlmostRelativeEquals(instance.src_particles.SpcType, 12.3, 7)
instance.stop()
def test4(self):
instance = SPHRay()
instance.gas_particles.add_particle(
Particle(
mass=1 | (10**10*units.MSun),
x=2 | units.kpc,
y=3 | units.kpc,
z=4 | units.kpc,
h_smooth=0.1 | (units.kpc),
rho=0.5 | ((10**10*units.MSun) / (units.kpc)**3),
xion=0.01,
u=0.2 | (10**5 * units.cm/units.s)**2
)
)
instance.src_particles.add_particle(
Particle(
luminosity=1 | 1e48 * units.s**-1,
x=2 | units.m,
y=3 | units.m,
z=4 | units.m,
SpcType=12.3
)
)
instance.commit_particles()
self.assertAlmostRelativeEquals(instance.src_particles.luminosity, 1 | 1e48 * units.s**-1, 6)
self.assertAlmostRelativeEquals(instance.src_particles.x, 2 | units.m, 7)
self.assertAlmostRelativeEquals(instance.src_particles.y, 3 | units.m, 7)
self.assertAlmostRelativeEquals(instance.src_particles.z, 4 | units.m, 7)
self.assertAlmostRelativeEquals(instance.src_particles.SpcType, 12.3, 7)
print(instance.src_particles)
instance.stop()
def read_gas_file(self, filename):
p = read_set_from_file(filename, 'amuse')
mass = p.mass.number
hsml = p.smoothing_length.number
x = p.x.number
y = p.y.number
z = p.z.number
rho = p.rho.number
u = p.internal_energy.number
xe = numpy.zeros_like(x)
return create_particle_set(mass=mass | (10**10*units.MSun), h_smooth=hsml | (units.kpc),
x=x | (units.kpc), y=y | (units.kpc), z=z | (units.kpc), rho=rho | ((10**10*units.MSun) / (units.kpc)**3),
xion=xe, u=u | (10**5 * units.cm/units.s)**2)
def read_src_file(self, filename):
f = open(filename)
lines = f.readlines()
f.close()
L = []
x = []
y = []
z = []
spctype = []
for line in lines:
l = line.split()
if len(l) == 9:
L.append(float(l[6]))
x.append(float(l[0]))
y.append(float(l[1]))
z.append(float(l[2]))
spctype.append(float(l[7]))
return create_particle_set(luminosity=numpy.array(L) | (10**48 * units.s**-1),
x=numpy.array(x) | (units.kpc), y=numpy.array(y) | (units.kpc),
z=numpy.array(z) | (units.kpc), SpcType=numpy.array(spctype))
| 25,081
| 43.314488
| 126
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_octgrav.py
|
import os
import sys
import numpy
from amuse.community.octgrav.interface import OctgravInterface, Octgrav
from amuse.test.amusetest import TestWithMPI
from amuse.units import nbody_system
from amuse.units import units
from amuse import datamodel
from amuse.rfi import channel
from amuse.ic.plummer import *
class TestMPIInterface(TestWithMPI):
def test1(self):
instance = self.new_instance_of_an_optional_code(OctgravInterface)
instance.new_particle(11.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0)
retrieved_state = instance.get_state(1)
self.assertEqual(11.0, retrieved_state['mass'])
self.assertEqual(2.0, retrieved_state['radius'])
self.assertEqual(instance.get_number_of_particles()['number_of_particles'], 1)
instance.cleanup_code()
instance.stop()
def test2(self):
instance = self.new_instance_of_an_optional_code(OctgravInterface)
instance.initialize_code()
instance.new_particle(
[1, 10, 100],
[3, 12, 102],
[4, 13, 103],
[5, 14, 104],
[6, 15, 105],
[7, 16, 106],
[8, 17, 107],
[2, 11, 101])
particle1_state = instance.get_state(1)
self.assertEqual(1, particle1_state['mass'])
particle2_state = instance.get_state(2)
self.assertEqual(10, particle2_state['mass'])
instance.delete_particle(1)
size_result = instance.get_number_of_particles()
self.assertEqual(2, size_result['number_of_particles'])
new_particle1_state = instance.get_state(1)
self.assertEqual(10, new_particle1_state['mass'])
new_particle_result = instance.new_particle(
1000,
1002,
1003,
1004,
1005,
1006,
1007,
1001)
self.assertEqual(4, new_particle_result['index_of_the_particle'], 4)
new_particle4_state = instance.get_state(4)
self.assertEqual(1000, new_particle4_state['mass'])
instance.cleanup_code()
instance.stop()
def test3(self):
instance = self.new_instance_of_an_optional_code(OctgravInterface)
instance.initialize_code()
instance.set_eps2(0.1**2)
instance.commit_parameters()
ids = []
for i in range(32):
id, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=i, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
ids.append(id)
self.assertEqual(errorcode, 0)
instance.commit_particles()
potential, errorcode = instance.get_potential(ids[0])
self.assertEqual(errorcode, 0)
excpected_potential = numpy.sum([-10.0 / numpy.sqrt((x+1.0)**2 + 0.1**2) for x in range(31)])
self.assertAlmostRelativeEquals(potential, excpected_potential, 5)
total_potential, errorcode = instance.get_potential_energy()
potentials, errorcode = instance.get_potential(ids)
self.assertAlmostRelativeEquals(total_potential, numpy.sum(potentials * 10.0) / 2.0)
class TestAmuseInterface(TestWithMPI):
def new_system_of_sun_and_earth(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
return stars
def test0(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, units.AU)
instance = self.new_instance_of_an_optional_code(Octgrav, convert_nbody)
instance.initialize_code()
self.assertAlmostRelativeEqual(0.01, instance.parameters.epsilon_squared.value_in(units.AU**2), 2) # default
instance.parameters.epsilon_squared = 0.05 | units.AU**2
self.assertAlmostRelativeEqual(0.05, instance.parameters.epsilon_squared.value_in(units.AU**2), 6)
self.assertAlmostEqual(0.8, instance.parameters.opening_angle, 6) # default
instance.parameters.opening_angle = 0.5
self.assertAlmostEqual(0.5, instance.parameters.opening_angle, 6)
instance.parameters.timestep = 1.0 | units.s
self.assertEqual(1.0 | units.s, instance.parameters.timestep)
instance.stop()
def test1(self):
plummer_size = 500
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
stars = new_plummer_model(plummer_size, convert_nbody)
stars.radius = range(1, plummer_size+1) | units.km
instance = self.new_instance_of_an_optional_code(Octgrav, convert_nbody)
instance.particles.add_particles(stars)
instance.evolve_model(5 | units.day)
energy_total_init = instance.potential_energy + instance.kinetic_energy
instance.evolve_model(100 | units.day)
energy_total_final = instance.potential_energy + instance.kinetic_energy
self.assertAlmostRelativeEqual(energy_total_init, energy_total_final, 2)
instance.stop()
def test2(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = self.new_instance_of_an_optional_code(Octgrav, convert_nbody)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | units.AU**2
instance.parameters.stopping_conditions_number_of_steps = 1
self.assertEqual(instance.parameters.stopping_conditions_number_of_steps, 1)
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
instance.stopping_conditions.number_of_steps_detection.enable()
instance.evolve_model(365.0 | units.day)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
instance.cleanup_code()
instance.stop()
def test3(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
instance = self.new_instance_of_an_optional_code(Octgrav)
instance.initialize_code()
instance.parameters.stopping_conditions_number_of_steps = 20
self.assertEqual(instance.parameters.stopping_conditions_number_of_steps, 20)
instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2
instance.particles.add_particles(particles)
instance.stopping_conditions.number_of_steps_detection.enable()
instance.evolve_model(10 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
self.assertTrue(instance.model_time < 10 | nbody_system.time)
instance.stop()
def test4(self):
plummer_size = 500
stars = new_plummer_model(plummer_size)
stars.radius = 0 | nbody_system.length
instance = self.new_instance_of_an_optional_code(Octgrav)
instance.particles.add_particles(stars)
instance.synchronize_model()
ax, ay, az = instance.get_gravity_at_point(0. | nbody_system.length,
0. | nbody_system.length,
100. | nbody_system.length,
0. | nbody_system.length)
self.assertAlmostEqual(ax.number, 0., 3)
self.assertAlmostRelativeEqual(ay.number, -1./100**2, 3)
self.assertAlmostEqual(az.number, 0., 3)
pot = instance.get_potential_at_point([0., 0.] | nbody_system.length,
[0., 100] | nbody_system.length,
[100., 0.] | nbody_system.length,
[0., 0.] | nbody_system.length)
self.assertAlmostRelativeEqual(pot.number, [-1/100., -1/100.], 3)
instance.stop()
| 8,451
| 38.867925
| 117
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_capreole.py
|
import os
import sys
import numpy
from amuse.test.amusetest import TestWithMPI
from amuse.community.capreole.interface import CapreoleInterface
from amuse.community.capreole.interface import Capreole
from amuse.units import generic_unit_system
from amuse.units import generic_unit_converter
from amuse.units import units
from amuse import datamodel
class TestCapreoleInterface(TestWithMPI):
def test0(self):
instance = CapreoleInterface()
instance.initialize_code()
instance.stop()
def test1(self):
instance = CapreoleInterface()
instance.initialize_code()
instance.setup_mesh(50, 40, 30, 1., 1., 1.)
nx, ny, nz, error = instance.get_mesh_size()
self.assertEqual(nx, 50)
self.assertEqual(ny, 40)
self.assertEqual(nz, 30)
instance.stop()
def test2(self):
instance = CapreoleInterface()
instance.initialize_code()
instance.setup_mesh(50, 50, 50, 1., 1., 1.)
instance.commit_parameters()
instance.set_grid_state(1, 1, 1, 1., 0.1, 0.1, 0.1, 1.)
rho, err = instance.get_grid_density(1, 1, 1)
self.assertEqual(rho, 1.)
rhovx, rhovy, rhovz, err = instance.get_grid_momentum_density(1, 1, 1)
self.assertEqual(rhovx, 0.1)
self.assertEqual(rhovy, 0.1)
self.assertEqual(rhovz, 0.1)
en, err = instance.get_grid_energy_density(1, 1, 1)
self.assertEqual(en, 1.)
rho, rhovx, rhovy, rhovz, en, err = instance.get_grid_state(1, 1, 1)
self.assertEqual(rho, 1.)
self.assertEqual(rhovx, 0.1)
self.assertEqual(rhovy, 0.1)
self.assertEqual(rhovz, 0.1)
self.assertEqual(en, 1.)
instance.stop()
def test3(self):
instance = CapreoleInterface()
instance.initialize_code()
instance.setup_mesh(50, 50, 50, 1., 1., 1.)
instance.commit_parameters()
x, y, z = numpy.indices((50, 50, 50))
x = x.flatten()+1
y = y.flatten()+1
z = z.flatten()+1
rho = 0.25*numpy.ones_like(x)
rhvx = 0.*numpy.ones_like(x)
rhvy = 0.*numpy.ones_like(x)
rhvz = 0.*numpy.ones_like(x)
en = 2.*numpy.ones_like(x)
instance.set_grid_state(x, y, z, rho, rhvx, rhvy, rhvz, en)
rho, rhovx, rhovy, rhovz, en, err = instance.get_grid_state(1, 1, 1)
self.assertEqual(rho, 0.25)
self.assertEqual(rhovx, 0.)
self.assertEqual(rhovy, 0.)
self.assertEqual(rhovz, 0.)
self.assertEqual(en, 2.)
instance.stop()
def test4(self):
instance = CapreoleInterface()
instance.initialize_code()
instance.setup_mesh(50, 50, 50, 1., 1., 1.)
instance.commit_parameters()
x, y, z = numpy.indices((50, 50, 50))
x = x.flatten()+1
y = y.flatten()+1
z = z.flatten()+1
rho = 0.1*numpy.ones_like(x)
rhvx = 0.*numpy.ones_like(x)
rhvy = 0.*numpy.ones_like(x)
rhvz = 0.*numpy.ones_like(x)
en = 0.1*numpy.ones_like(x)
instance.set_grid_state(x, y, z, rho, rhvx, rhvy, rhvz, en)
instance.initialize_grid()
instance.stop()
def test5(self):
instance = CapreoleInterface()
instance.initialize_code()
instance.setup_mesh(40, 40, 40, 1., 1., 1.)
instance.commit_parameters()
x, y, z = numpy.indices((40, 40, 40))
x = x.flatten()+1
y = y.flatten()+1
z = z.flatten()+1
rho = 0.1*numpy.ones_like(x)
rhvx = 0.*numpy.ones_like(x)
rhvy = 0.*numpy.ones_like(x)
rhvz = 0.*numpy.ones_like(x)
en = 0.1*numpy.ones_like(x)
instance.set_grid_state(x, y, z, rho, rhvx, rhvy, rhvz, en)
instance.initialize_grid()
instance.evolve_model(0.01)
tnow, err = instance.get_time()
self.assertAlmostEqual(tnow, 0.01, 15)
instance.evolve_model(0.025)
tnow, err = instance.get_time()
self.assertAlmostEqual(tnow, 0.025, 15)
instance.evolve_model(0.025001)
tnow, err = instance.get_time()
self.assertAlmostEqual(tnow, 0.025001, 15)
instance.evolve_model(0.0321)
tnow, err = instance.get_time()
self.assertAlmostEqual(tnow, 0.0321, 15)
instance.evolve_model(0.0321)
tnow, err = instance.get_time()
self.assertAlmostEqual(tnow, 0.0321, 15)
instance.evolve_model(0.07)
tnow, err = instance.get_time()
self.assertAlmostEqual(tnow, 0.07, 15)
instance.stop()
def test6(self):
instance = CapreoleInterface(number_of_workers=1)
instance.initialize_code()
instance.setup_mesh(150, 10, 30, 1., 1., 1.)
instance.commit_parameters()
x, y, z = numpy.indices((150, 10, 30))
x = x.flatten()+1
y = y.flatten()+1
z = z.flatten()+1
rho = 0.1*numpy.ones_like(x)
rhvx = 0.*numpy.ones_like(x)
rhvy = 0.*numpy.ones_like(x)
rhvz = 0.*numpy.ones_like(x)
en = 0.1*numpy.ones_like(x)
instance.set_grid_state(x, y, z, rho, rhvx, rhvy, rhvz, en)
instance.initialize_grid()
instance.evolve_model(0.01)
x, y, z, err = instance.get_position_of_index(15, 5, 20)
self.assertAlmostEqual(x, 15/150.-1/300., 15)
self.assertAlmostEqual(y, 5/10.-1/20., 15)
self.assertAlmostEqual(z, 20/30.-1/60., 15)
i, j, k, err = instance.get_index_of_position(x, y, z)
self.assertEqual([i, j, k], [15, 5, 20])
instance.stop()
def test7(self):
instance = CapreoleInterface()
instance.initialize_code()
instance.setup_mesh(50, 50, 50, 1., 1., 1.)
instance.commit_parameters()
err = instance.set_gravity_field(1, 2, 3, 1., 0.5, 0.25)
self.assertEqual(err, 0)
fx, fy, fz, err = instance.get_gravity_field(1, 2, 3)
self.assertEqual(fx, 1.)
self.assertEqual(fy, 0.5)
self.assertEqual(fz, 0.25)
instance.stop()
def test8(self):
instance = CapreoleInterface()
instance.initialize_code()
err = instance.set_boundary("periodic", "reflective",
"periodic", "reflective",
"periodic", "reflective")
self.assertEqual(err, -1)
instance.stop()
instance = CapreoleInterface()
instance.initialize_code()
err = instance.set_boundary("reflective", "periodic",
"periodic", "reflective",
"periodic", "reflective")
self.assertEqual(err, -2)
instance.stop()
instance = CapreoleInterface()
instance.initialize_code()
err = instance.set_boundary("periodic", "periodic",
"periodic", "periodic",
"periodic", "periodic")
self.assertEqual(err, 0)
instance.stop()
def test9(self):
instance = CapreoleInterface(number_of_workers=2)
instance.initialize_code()
instance.setup_mesh(50, 50, 50, 1., 1., 1.)
instance.commit_parameters()
instance.set_grid_state(1, 1, 1, 1., 0.1, 0.1, 0.1, 1.)
instance.set_grid_state(50, 50, 50, 2., 0.2, 0.2, 0.2, 2.)
rho, err = instance.get_grid_density(1, 1, 1)
self.assertEqual(rho, 1.)
rhovx, rhovy, rhovz, err = instance.get_grid_momentum_density(1, 1, 1)
self.assertEqual(rhovx, 0.1)
self.assertEqual(rhovy, 0.1)
self.assertEqual(rhovz, 0.1)
en, err = instance.get_grid_energy_density(1, 1, 1)
self.assertEqual(en, 1.)
rho, rhovx, rhovy, rhovz, en, err = instance.get_grid_state(1, 1, 1)
self.assertEqual(rho, 1.)
self.assertEqual(rhovx, 0.1)
self.assertEqual(rhovy, 0.1)
self.assertEqual(rhovz, 0.1)
self.assertEqual(en, 1.)
rho, err = instance.get_grid_density(50, 50, 50)
self.assertEqual(err, 0)
self.assertEqual(rho, 2.)
rhovx, rhovy, rhovz, err = instance.get_grid_momentum_density(50, 50, 50)
self.assertEqual(rhovx, 0.2)
self.assertEqual(rhovy, 0.2)
self.assertEqual(rhovz, 0.2)
en, err = instance.get_grid_energy_density(50, 50, 50)
self.assertEqual(en, 2.)
rho, rhovx, rhovy, rhovz, en, err = instance.get_grid_state(50, 50, 50)
self.assertEqual(rho, 2.)
self.assertEqual(rhovx, 0.2)
self.assertEqual(rhovy, 0.2)
self.assertEqual(rhovz, 0.2)
self.assertEqual(en, 2.)
instance.stop()
def test10(self):
instance = self.new_instance(CapreoleInterface)
instance.initialize_code()
instance.setup_mesh(100, 5, 5, 100.0, 0, 0)
instance.set_boundary("interface", "periodic", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
minx, maxx, miny, maxy, minz, maxz, error = instance.get_boundary_index_range_inclusive(1)
self.assertEqual(error, 0)
self.assertEqual(minx, 1)
self.assertEqual(maxx, 2)
self.assertEqual(miny, 1)
self.assertEqual(maxy, 5)
self.assertEqual(minz, 1)
self.assertEqual(maxz, 5)
for i in range(2, 7):
minx, maxx, miny, maxy, minz, maxz, error = instance.get_boundary_index_range_inclusive(i)
self.assertEqual(error, 0)
self.assertEqual(minx, 1)
self.assertEqual(maxx, 1)
self.assertEqual(miny, 1)
self.assertEqual(maxy, 1)
self.assertEqual(minz, 1)
self.assertEqual(maxz, 1)
def test11(self):
instance = self.new_instance(CapreoleInterface)
instance.initialize_code()
instance.setup_mesh(100, 5, 6, 100.0, 0, 0)
instance.set_boundary("interface", "interface", "interface", "interface", "interface", "interface")
instance.commit_parameters()
for i in range(1, 7):
minx, maxx, miny, maxy, minz, maxz, error = instance.get_boundary_index_range_inclusive(i)
self.assertEqual(error, 0),
self.assertEqual(minx, 1)
self.assertEqual(miny, 1)
self.assertEqual(minz, 1)
if i == 1 or i == 2:
self.assertEqual(maxx, 2)
self.assertEqual(maxy, 5)
self.assertEqual(maxz, 6)
elif i == 3 or i == 4:
self.assertEqual(maxx, 100+4)
self.assertEqual(maxy, 2)
self.assertEqual(maxz, 6)
elif i == 5 or i == 6:
self.assertEqual(maxx, 100+4)
self.assertEqual(maxy, 5+4)
self.assertEqual(maxz, 2)
def test12(self):
instance = self.new_instance(CapreoleInterface)
instance.initialize_code()
instance.setup_mesh(100, 2, 2, 100.0, 100.0, 100.0)
instance.set_boundary("interface", "periodic", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
for i in [1, 2]:
error = instance.set_boundary_state(
i, 1, 1, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
1 # boundary
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i, 1, 1,
1
)
print(rho, rhovx, rhovy, rhovz, rhoen, error)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test13(self):
instance = self.new_instance(CapreoleInterface)
instance.initialize_code()
instance.setup_mesh(100, 2, 2, 100.0, 0, 0)
instance.set_boundary("interface", "interface", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
for i in [1, 2]:
for j in [1, 2]:
error = instance.set_boundary_state(
i, 1, 1, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
j # boundary
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i, 1, 1,
j
)
print(j)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test14(self):
instance = self.new_instance(CapreoleInterface)
instance.initialize_code()
instance.setup_mesh(5, 6, 7, 100.0, 100.0, 100.0)
instance.set_boundary("interface", "interface", "interface", "interface", "interface", "interface")
instance.commit_parameters()
x1range = (2, 6, 7)
x2range = (5+4, 2, 7)
x3range = (5+4, 6+4, 2)
for xrange, j in zip([x1range, x1range, x2range, x2range, x3range, x3range], [1, 2, 3, 4, 5, 6]):
for i0 in range(xrange[0]):
for j0 in range(xrange[1]):
for k0 in range(xrange[2]):
i = (i0 * (xrange[2] * xrange[1])) + (j0 * xrange[2]) + k0
print("boundary:", j, i0+1, j0+1, k0+1)
error = instance.set_boundary_state(
i0+1, j0+1, k0+1, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
j
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0+1, j0+1, k0+1, # index
j
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test15(self):
instance = self.new_instance(CapreoleInterface)
instance.initialize_code()
instance.setup_mesh(100, 5, 4, 100.0, 100.0, 100.0)
instance.set_boundary("interface", "interface", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
dx = 100.0 / 100.0
dy = 100.0 / 5.0
dz = 100.0 / 4.0
for i in [1, 2]:
x, y, z, error = instance.get_boundary_position_of_index(
i, 1, 1,
1
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) - (i * dx))
self.assertAlmostRelativeEquals(y, (0.5 * dy))
self.assertAlmostRelativeEquals(z, (0.5 * dz))
def test16(self):
instance = self.new_instance(CapreoleInterface)
instance.initialize_code()
instance.setup_mesh(100, 5, 4, 100.0, 100.0, 100.0)
instance.set_boundary("interface", "interface", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
dx = 100.0 / 100.0
dy = 100.0 / 5.0
dz = 100.0 / 4.0
for i in [1, 2]:
x, y, z, error = instance.get_boundary_position_of_index(
i, 1, 1,
2
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, 100.0 + (0.5 * dx) + ((i-1) * dx))
self.assertAlmostRelativeEquals(y, (0.5 * dy))
self.assertAlmostRelativeEquals(z, (0.5 * dz))
def test17(self):
instance = self.new_instance(CapreoleInterface)
instance.initialize_code()
instance.setup_mesh(100, 5, 4, 100.0, 100.0, 100.0)
instance.set_boundary("interface", "interface", "interface", "interface", "periodic", "periodic")
instance.commit_parameters()
dx = 100.0 / 100.0
dy = 100.0 / 5.0
dz = 100.0 / 4.0
for i in [1, 2]:
for j in range(1, 6):
x, y, z, error = instance.get_boundary_position_of_index(
i, j, 1,
2
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, 100.0 + (0.5 * dx) + ((i-1) * dx))
self.assertAlmostRelativeEquals(y, (0.5 * dy) + ((j-1) * dy))
self.assertAlmostRelativeEquals(z, (0.5 * dz))
for i in range(1, 100 + 4 + 1):
for j in [1, 2]:
x, y, z, error = instance.get_boundary_position_of_index(
i, j, 1,
3
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) + ((i-2-1) * dx))
self.assertAlmostRelativeEquals(y, 0.0 - ((0.5 * dy) + ((j-1) * dy)))
self.assertAlmostRelativeEquals(z, (0.5 * dz))
x, y, z, error = instance.get_boundary_position_of_index(
i, j, 1,
4
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) + ((i-2-1) * dx))
self.assertAlmostRelativeEquals(y, 100.0 + (0.5 * dy) + ((j-1) * dy))
self.assertAlmostRelativeEquals(z, (0.5 * dz))
def test18(self):
instance = self.new_instance(CapreoleInterface)
instance.initialize_code()
instance.setup_mesh(3, 3, 3, 6, 12, 18)
instance.set_boundary("interface", "interface", "interface", "interface", "interface", "interface")
instance.commit_parameters()
dx = 6.0 / 3.0
dy = 12.0 / 3.0
dz = 18.0 / 3.0
for i in [1, 2]:
for j in range(1, 3+1):
for k in range(1, 3+1):
x, y, z, error = instance.get_boundary_position_of_index(
i, j, k,
2
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, 6.0 + (0.5 * dx) + ((i-1) * dx))
self.assertAlmostRelativeEquals(y, (0.5 * dy) + ((j-1) * dy))
self.assertAlmostRelativeEquals(z, (0.5 * dz) + ((k-1) * dz))
for i in range(1, 3 + 4 + 1):
for j in [1, 2]:
for k in range(1, 3+1):
x, y, z, error = instance.get_boundary_position_of_index(
i, j, k,
3
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) + ((i-2-1) * dx))
self.assertAlmostRelativeEquals(y, 0.0 - ((0.5 * dy) + ((j-1) * dy)))
self.assertAlmostRelativeEquals(z, (0.5 * dz) + ((k-1) * dz))
x, y, z, error = instance.get_boundary_position_of_index(
i, j, k,
4
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) + ((i-2-1) * dx))
self.assertAlmostRelativeEquals(y, 12.0 + (0.5 * dy) + ((j-1) * dy))
self.assertAlmostRelativeEquals(z, (0.5 * dz) + ((k-1) * dz))
for i in range(1, 3 + 4 + 1):
for j in range(1, 3 + 4 + 1):
for k in [1, 2]:
x, y, z, error = instance.get_boundary_position_of_index(
i, j, k,
5
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) + ((i-2-1) * dx))
self.assertAlmostRelativeEquals(y, (0.5 * dy) + ((j-2-1) * dy))
self.assertAlmostRelativeEquals(z, 0.0 - ((0.5 * dz) + ((k-1) * dz)))
x, y, z, error = instance.get_boundary_position_of_index(
i, j, k,
6
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) + ((i-2-1) * dx))
self.assertAlmostRelativeEquals(y, (0.5 * dy) + ((j-2-1) * dy))
self.assertAlmostRelativeEquals(z, 18.0 + (0.5 * dz) + ((k-1) * dz))
def test19(self):
results = []
instance = self.new_instance(CapreoleInterface)
instance.initialize_code()
instance.commit_parameters()
nx, ny, nz, error = instance.get_parallel_decomposition()
self.assertEqual(error, 0)
self.assertEqual(nx, 1)
self.assertEqual(ny, 1)
self.assertEqual(nz, 1)
error = instance.set_parallel_decomposition(2, 1, 1)
self.assertEqual(error, -1)
def test20(self):
results = []
instance = self.new_instance(CapreoleInterface, number_of_workers=4)
instance.initialize_code()
nx, ny, nz, error = instance.get_parallel_decomposition()
self.assertEqual(error, 0)
self.assertEqual(nx, 0)
self.assertEqual(ny, 0)
self.assertEqual(nz, 0)
error = instance.set_parallel_decomposition(2, 1, 2)
self.assertEqual(error, 0)
nx, ny, nz, error = instance.get_parallel_decomposition()
self.assertEqual(error, 0)
self.assertEqual(nx, 2)
self.assertEqual(ny, 1)
self.assertEqual(nz, 2)
error = instance.set_parallel_decomposition(10, 3, 2)
self.assertEqual(error, -1)
def test21(self):
results = []
instance = self.new_instance(CapreoleInterface, number_of_workers=2)
instance.initialize_code()
error = instance.set_parallel_decomposition(1, 2, 1)
self.assertEqual(error, 0)
instance.setup_mesh(10, 30, 10, 100.0, 300.0, 100.0)
instance.set_boundary("interface", "interface", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
for boundary_index in [1, 2]:
for i0 in range(1, 2):
for j0 in range(1, 30+1):
i = j0 * 30 + i0
error = instance.set_boundary_state(
i0, j0, 1, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
boundary_index # boundary
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, 1,
boundary_index
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test22(self):
results = []
instance = self.new_instance(CapreoleInterface, number_of_workers=2)
instance.initialize_code()
error = instance.set_parallel_decomposition(2, 1, 1)
self.assertEqual(error, 0)
instance.setup_mesh(10, 30, 10, 100.0, 300.0, 100.0)
instance.set_boundary("interface", "interface", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
for boundary_index in [1, 2]:
for i0 in range(1, 2):
for j0 in range(1, 30+1):
i = j0 * 30 + i0
error = instance.set_boundary_state(
i0, j0, 1, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
boundary_index # boundary
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, 1,
boundary_index
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test23(self):
results = []
instance = self.new_instance(CapreoleInterface, number_of_workers=3)
instance.initialize_code()
error = instance.set_parallel_decomposition(3, 1, 1)
self.assertEqual(error, 0)
instance.setup_mesh(12, 20, 10, 100.0, 300.0, 100.0)
instance.set_boundary("interface", "interface", "interface", "interface", "periodic", "periodic")
instance.commit_parameters()
for boundaryindex in [3, 4]:
for i0 in range(1, 12+4+1):
for j0 in [1, 2]:
i = (i0 * 15) + j0
error = instance.set_boundary_state(
i0, j0, 1, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
boundaryindex # boundary
)
print(i0, j0)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, 1,
boundaryindex
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test24(self):
results = []
instance = self.new_instance(CapreoleInterface, number_of_workers=3)
instance.initialize_code()
error = instance.set_parallel_decomposition(1, 3, 1)
self.assertEqual(error, 0)
instance.setup_mesh(12, 30, 10, 100.0, 300.0, 100.0)
instance.set_boundary("interface", "interface", "interface", "interface", "periodic", "periodic")
instance.commit_parameters()
for boundaryindex in [3, 4]:
for i0 in range(1, 12+4+1):
for j0 in [1, 2]:
i = (i0 * 15) + j0
error = instance.set_boundary_state(
i0, j0, 1, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
boundaryindex # boundary
)
print(i0, j0)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, 1,
boundaryindex
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test25(self):
results = []
instance = self.new_instance(CapreoleInterface, number_of_workers=3)
instance.initialize_code()
error = instance.set_parallel_decomposition(1, 3, 1)
self.assertEqual(error, 0)
instance.setup_mesh(6, 5, 5, 6.0, 5.0, 5.0)
instance.set_boundary("interface", "interface", "interface", "interface", "interface", "interface")
instance.commit_parameters()
for boundaryindex in [5, 6]:
for i0 in range(1, 6+4+1):
for j0 in range(1, 5+4+1):
for z0 in [1, 2]:
i = (i0 * (5*4)) + (j0 * 4) + z0
error = instance.set_boundary_state(
i0, j0, z0, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
boundaryindex # boundary
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, z0,
boundaryindex
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test26(self):
results = []
instance = self.new_instance(CapreoleInterface, number_of_workers=9)
instance.initialize_code()
error = instance.set_parallel_decomposition(3, 3, 1)
instance.setup_mesh(6, 6, 5, 6.0, 6.0, 5.0)
self.assertEqual(error, 0)
instance.set_boundary("interface", "interface", "interface", "interface", "interface", "interface")
instance.commit_parameters()
for boundaryindex in [5, 6]:
for i0 in range(1, 6+4+1):
for j0 in range(1, 6+4+1):
for z0 in [1, 2]:
i = (i0 * (5*4)) + (j0 * 4) + z0
error = instance.set_boundary_state(
i0, j0, z0, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
boundaryindex # boundary
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, z0,
boundaryindex
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test27(self):
instance = CapreoleInterface()
instance.initialize_code()
gamma, error = instance.get_gamma()
self.assertAlmostRelativeEquals(gamma, 5.0 / 3.0)
instance.set_gamma(1.3)
gamma, error = instance.get_gamma()
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(gamma, 1.3)
instance.stop()
def test28(self):
instance = CapreoleInterface()
instance.initialize_code()
timestep, error = instance.get_timestep()
self.assertEqual(timestep, 0.0)
self.assertEqual(error, 0)
instance.setup_mesh(10, 10, 10, 1., 1., 1.)
instance.commit_parameters()
x, y, z = numpy.indices((10, 10, 10))
x = x.flatten()+1
y = y.flatten()+1
z = z.flatten()+1
rho = 0.1*numpy.ones_like(x)
rhvx = 0.*numpy.ones_like(x)
rhvy = 0.*numpy.ones_like(x)
rhvz = 0.*numpy.ones_like(x)
en = 0.1*numpy.ones_like(x)
instance.set_grid_state(x, y, z, rho, rhvx, rhvy, rhvz, en)
timestep, error = instance.get_timestep()
self.assertEqual(timestep, 0.0)
self.assertEqual(error, 0)
instance.initialize_grid()
timestep, error = instance.get_timestep()
self.assertAlmostRelativeEquals(timestep, 0.03795, 4)
self.assertEqual(error, 0)
error = instance.set_timestep(0.25)
self.assertEqual(error, 0)
timestep, error = instance.get_timestep()
self.assertEqual(timestep, 0.25)
self.assertEqual(error, 0)
instance.stop()
def test29(self):
instance = CapreoleInterface(number_of_workers=1)
self.check_extended_grid(instance)
def xtest30(self):
print("Broken as capreole cannot do periodic boundaries with multiple workers!")
instance = CapreoleInterface(redirection="none", number_of_workers=8)
self.check_extended_grid(instance)
def check_extended_grid(self, instance):
instance.initialize_code()
instance.setup_mesh(8, 8, 8, 1.0, 1.0, 1.0)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
result = instance.commit_parameters()
self.assertEqual(result, 0)
time, error = instance.get_time()
self.assertEqual(error, 0)
self.assertEqual(time, 0.0)
for i in range(8):
error = instance.set_grid_state(i+1, 1, 1, 0.1 * (i+1), 0.2 * (i+1), 0.3 * (i+1), 0.4 * (i+1), 0.5 * (i+1))
self.assertEqual(error, 0)
error = instance.set_grid_state(1, i+1, 1, 0.1 * (i+1), 0.2 * (i+1), 0.3 * (i+1), 0.4 * (i+1), 0.5 * (i+1))
self.assertEqual(error, 0)
error = instance.set_grid_state(1, 1, i+1, 0.1 * (i+1), 0.2 * (i+1), 0.3 * (i+1), 0.4 * (i+1), 0.5 * (i+1))
self.assertEqual(error, 0)
instance.initialize_grid()
for i in range(8):
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(i+1, 1, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, (i+1) * 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(1, i+1, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, (i+1) * 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(1, 1, i+1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, (i+1) * 0.1)
for i in range(2):
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(-(i), 1, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.8 - (i * 0.1))
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(-2, 1, 1)
self.assertEqual(error, -1)
self.assertAlmostRelativeEquals(rho, 0.0)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(8 + i+1, 1, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, (i+1) * 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(8 + 3, 1, 1)
self.assertEqual(error, -1)
self.assertAlmostRelativeEquals(rho, 0.0)
# 2 dimension
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(1, -i, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.8 - (i * 0.1))
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(1, -3, 1)
self.assertEqual(error, -1)
self.assertAlmostRelativeEquals(rho, 0.0)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(1, 8 + i + 1, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, (i+1) * 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(1, 8+3, 1)
self.assertEqual(error, -1)
self.assertAlmostRelativeEquals(rho, 0.0)
# 3 dimension
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(1, 1, -i)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.8 - (i * 0.1))
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(1, -3, 1)
self.assertEqual(error, -1)
self.assertAlmostRelativeEquals(rho, 0.0)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(1, 1, 8 + i + 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, (i+1) * 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(1, 1, 8+3)
self.assertEqual(error, -1)
self.assertAlmostRelativeEquals(rho, 0.0)
instance.stop()
class TestSodShocktube(TestWithMPI):
def test0(self):
N = 100
gamma = 5/3.
g = (gamma-1)/(gamma+1)
b = (gamma-1)/2/gamma
instance = CapreoleInterface()
instance.initialize_code()
instance.setup_mesh(N, N//10, N//10, 1., 0.1, 0.1)
instance.commit_parameters()
x, y, z = numpy.indices((N, N//10, N//10))
x = x.flatten()+1
y = y.flatten()+1
z = z.flatten()+1
gamma = 5./3.
rho = 0.125*numpy.ones_like(x)
rhvx = 0.*numpy.ones_like(x)
rhvy = 0.*numpy.ones_like(x)
rhvz = 0.*numpy.ones_like(x)
en = (0.1/(gamma-1))*numpy.ones_like(x)
instance.set_grid_state(x, y, z, rho, rhvx, rhvy, rhvz, en)
x, y, z = numpy.indices((N//2, N//10, N//10))
x = x.flatten()+1
y = y.flatten()+1
z = z.flatten()+1
rho = 1.*numpy.ones_like(x)
rhvx = 0.*numpy.ones_like(x)
rhvy = 0.*numpy.ones_like(x)
rhvz = 0.*numpy.ones_like(x)
en = (1./(gamma-1))*numpy.ones_like(x)
instance.set_grid_state(x, y, z, rho, rhvx, rhvy, rhvz, en)
instance.initialize_grid()
instance.evolve_model(0.2)
x = numpy.array([0.1, 0.9, 0.6, 0.8])
y = 0.05*numpy.ones_like(x)
z = 0.05*numpy.ones_like(x)
i, j, k, err = instance.get_index_of_position(x, y, z)
rho, rhovx, rhovy, rhovz, en, err = instance.get_grid_state(i, j, k)
vel = numpy.sqrt((rhovx**2+rhovy**2+rhovz**2))/rho
pres = (gamma-1)*(en-0.5*rho*vel**2)
u = pres/(gamma-1)/rho
rhoexp = numpy.zeros_like(x)
rhoexp[0] = 1.
rhoexp[1] = 0.125
rhoexp[2] = rho[0]*(pres[2]/pres[0])**(1/gamma)
rhoexp[3] = rho[1]*(pres[3]+g*pres[1])/(pres[1]+g*pres[3])
for i in range(len(rho)):
self.assertAlmostEqual(rhoexp[i], rho[i], 2)
class TestCapreole(TestWithMPI):
def test0(self):
instance = self.new_instance(Capreole)
instance.initialize_code()
instance.stop()
def test1(self):
instance = self.new_instance(Capreole)
instance.parameters.mesh_size = (10, 10, 5)
instance.parameters.length_x = 1.0 | generic_unit_system.length
instance.parameters.length_y = 1.0 | generic_unit_system.length
instance.parameters.length_z = 1.0 | generic_unit_system.length
instance.parameters.x_boundary_conditions = "periodic", "periodic"
instance.parameters.y_boundary_conditions = "periodic", "periodic"
instance.parameters.z_boundary_conditions = "periodic", "periodic"
self.assertEqual(len(list(instance.itergrids())), 1)
grid = datamodel.Grid(10, 10, 10)
grid.rho = 0.4 | generic_unit_system.density
grid.rhovx = 0.1 | generic_unit_system.momentum_density
grid.rhovy = 0.0 | generic_unit_system.momentum_density
grid.rhovz = 0.0 | generic_unit_system.momentum_density
grid.energy = 0.0 | generic_unit_system.energy_density
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.initialize_grid()
channel = instance.grid.new_channel_to(grid)
channel.copy()
self.assertEqual(grid[1][1][0].rho, 0.4 | generic_unit_system.density)
for x in grid[1].rho.value_in(generic_unit_system.density).flatten():
self.assertEqual(x, 0.4)
# instance.evolve_model(0.12 | generic_unit_system.time)
# for x in instance.grid.rho.value_in(generic_unit_system.density).flatten():
# self.assertEquals(x, 0.1)
# instance.evolve_model(10.0 | generic_unit_system.time)
# for x in instance.grid.rho.value_in(generic_unit_system.density).flatten():
# self.assertEquals(x, 0.1)
instance.stop()
def test2(self):
instance = self.new_instance(Capreole)
instance.parameters.mesh_size = (3, 3, 3)
instance.parameters.length_x = 1.0 | generic_unit_system.length
instance.parameters.length_y = 1.0 | generic_unit_system.length
instance.parameters.length_z = 1.0 | generic_unit_system.length
instance.parameters.x_boundary_conditions = "periodic", "periodic"
instance.parameters.y_boundary_conditions = "periodic", "periodic"
instance.parameters.z_boundary_conditions = "periodic", "periodic"
grid = datamodel.Grid(3, 3, 3)
grid.rho = 0.1 | generic_unit_system.density
grid.rhovx = 0.0 | generic_unit_system.momentum_density
grid.rhovy = 0.0 | generic_unit_system.momentum_density
grid.rhovz = 0.0 | generic_unit_system.momentum_density
grid.energy = 1.0 | generic_unit_system.energy_density
channel = grid.new_channel_to(instance.grid)
channel.copy()
print(instance.grid[1].rho)
self.assertEqual(instance.grid[1][1][0].rho, 0.1 | generic_unit_system.density)
for x in instance.grid[1].rho.value_in(generic_unit_system.density).flatten():
self.assertEqual(x, 0.1)
instance.evolve_model(1.0 | generic_unit_system.time)
for x in instance.grid.rho.value_in(generic_unit_system.density).flatten():
self.assertEqual(x, 0.1)
instance.evolve_model(10.0 | generic_unit_system.time)
for x in instance.grid.rho.value_in(generic_unit_system.density).flatten():
self.assertEqual(x, 0.1)
instance.stop()
def test3(self):
instance = self.new_instance(Capreole)
instance.parameters.mesh_size = (5, 5, 5)
instance.parameters.length_x = 1.0 | generic_unit_system.length
instance.parameters.length_y = 1.0 | generic_unit_system.length
instance.parameters.length_z = 1.0 | generic_unit_system.length
instance.parameters.x_boundary_conditions = "periodic", "periodic"
instance.parameters.y_boundary_conditions = "periodic", "periodic"
instance.parameters.z_boundary_conditions = "periodic", "periodic"
grid = datamodel.Grid(5, 5, 5)
grid.rho = 0.1 | generic_unit_system.density
grid.rhovx = 0.0 | generic_unit_system.momentum_density
grid.rhovy = 0.0 | generic_unit_system.momentum_density
grid.rhovz = 0.0 | generic_unit_system.momentum_density
grid.energy = 1.0 | generic_unit_system.energy_density
channel = grid.new_channel_to(instance.grid)
channel.copy()
self.assertEqual((5, 5, 5), instance.acceleration_grid.shape)
acc_grid = datamodel.Grid(5, 5, 5)
acc_grid.ax = 1 | generic_unit_system.acceleration
acc_grid.ay = 1 | generic_unit_system.acceleration
acc_grid.az = 1 | generic_unit_system.acceleration
# self.assertEquals(acc_grid.acceleration[0][0][0], ( 1,1,1) | generic_unit_system.acceleration)
channel = acc_grid.new_channel_to(instance.acceleration_grid)
channel.copy()
instance.evolve_model(0.1 | generic_unit_system.time)
self.assertAlmostRelativeEquals(instance.grid.rho, grid.rho)
self.assertAlmostRelativeEquals(instance.grid.rhovx, 0.1 * 1.0 * 0.1 | generic_unit_system.momentum_density)
self.assertAlmostRelativeEquals(instance.grid.rhovy, 0.1 * 1.0 * 0.1 | generic_unit_system.momentum_density)
self.assertAlmostRelativeEquals(instance.grid.rhovz, 0.1 * 1.0 * 0.1 | generic_unit_system.momentum_density)
instance.evolve_model(0.3 | generic_unit_system.time)
print(instance.model_time)
self.assertAlmostRelativeEquals(instance.grid.rho, grid.rho)
self.assertAlmostRelativeEquals(instance.grid.rhovx, grid.rho * instance.model_time * acc_grid.ax, 2)
self.assertAlmostRelativeEquals(instance.grid.rhovy, grid.rho * instance.model_time * acc_grid.ay, 2)
self.assertAlmostRelativeEquals(instance.grid.rhovz, grid.rho * instance.model_time * acc_grid.az, 2)
instance.stop()
def test4(self):
converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
1 | units.parsec,
1 | units.Myr,
1 | units.MSun
)
instance = self.new_instance(Capreole, unit_converter=converter)
instance.parameters.mesh_size = (3, 3, 3)
instance.parameters.length_x = 1.0 | units.parsec
instance.parameters.length_y = 1.0 | units.parsec
instance.parameters.length_z = 1.0 | units.parsec
instance.parameters.x_boundary_conditions = "periodic", "periodic"
instance.parameters.y_boundary_conditions = "periodic", "periodic"
instance.parameters.z_boundary_conditions = "periodic", "periodic"
instance.commit_parameters()
density = units.MSun / (units.parsec ** 3)
grid = datamodel.Grid(3, 3, 3)
grid.rho = 0.1 | density
grid.rhovx = 0.0 | units.MSun / (units.Myr * units.parsec ** 2)
grid.rhovy = 0.0 | units.MSun / (units.Myr * units.parsec ** 2)
grid.rhovz = 0.0 | units.MSun / (units.Myr * units.parsec ** 2)
grid.energy = 1.0 | units.MSun / (units.parsec * units.Myr ** 2)
channel = grid.new_channel_to(instance.grid)
channel.copy()
print(instance.grid[1].rho)
self.assertAlmostRelativeEquals(instance.grid[1][1][0].rho, 0.1 | density)
for x in instance.grid[1].rho.value_in(density).flatten():
self.assertAlmostRelativeEquals(x, 0.1)
instance.evolve_model(1.0 | units.Myr)
for x in instance.grid.rho.value_in(density).flatten():
self.assertAlmostRelativeEquals(x, 0.1)
instance.evolve_model(10.0 | units.Myr)
for x in instance.grid.rho.value_in(density).flatten():
self.assertAlmostRelativeEquals(x, 0.1)
instance.stop()
def test5(self):
instance = self.new_instance(Capreole)
instance.parameters.mesh_size = (10, 4, 4)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("interface", "outflow")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.parameters.stopping_conditions_number_of_steps = 1
gamma = 5.0 / 3.0
grid = datamodel.new_regular_grid((10, 4, 4), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.1 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
# instance.grid.boundaries.left.
xbound1 = instance.get_boundary_grid('xbound1')
self.assertEqual(xbound1.shape, (2, 4, 4))
memxbound1 = xbound1.copy()
memxbound1.rho = 0.02 | density
memxbound1.rhovx = 0.2 | momentum
memxbound1.rhovy = 0.0 | momentum
memxbound1.rhovz = 0.0 | momentum
memxbound1.energy = p / (gamma - 1)
memxbound1.energy += 0.5 * (memxbound1.rhovx ** 2 + memxbound1.rhovy ** 2 + memxbound1.rhovz ** 2) / memxbound1.rho
channel = memxbound1.new_channel_to(xbound1)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
rho = instance.grid.rho[..., 0, 0]
print(rho)
print(instance.model_time)
self.assertAlmostRelativeEquals(rho[-1], 0.01 | density)
self.assertTrue(rho[0] > 0.01 | density)
self.assertTrue(instance.grid.rhovx[0, 0, 0] > 0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovx[-1, 0, 0], 0.1 | momentum)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
print(instance.model_time)
rho = instance.grid.rho[..., 0, 0]
print(rho)
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovx[..., 0, 0], 0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test6(self):
instance = self.new_instance(Capreole)
instance.parameters.mesh_size = (10, 4, 4)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("outflow", "interface")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.parameters.stopping_conditions_number_of_steps = 1
gamma = 5.0 / 3.0
grid = datamodel.new_regular_grid((10, 4, 4), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = -0.1 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
# instance.grid.boundaries.left.
xbound = instance.get_boundary_grid('xbound2')
self.assertEqual(xbound.shape, (2, 4, 4))
memxbound = xbound.copy()
memxbound.rho = 0.02 | density
memxbound.rhovx = -0.2 | momentum
memxbound.rhovy = 0.0 | momentum
memxbound.rhovz = 0.0 | momentum
memxbound.energy = p / (gamma - 1)
memxbound.energy += 0.5 * (memxbound.rhovx ** 2 + memxbound.rhovy ** 2 + memxbound.rhovz ** 2) / memxbound.rho
channel = memxbound.new_channel_to(xbound)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
rho = instance.grid.rho[..., 0, 0]
print(rho)
print(instance.model_time)
self.assertAlmostRelativeEquals(rho[0], 0.01 | density)
self.assertTrue(rho[-1] > 0.01 | density)
self.assertTrue(instance.grid.rhovx[-1, 0, 0] < -0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovx[0, 0, 0], -0.1 | momentum)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[..., 0, 0]
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovx[..., 0, 0], -0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test7(self):
instance = self.new_instance(Capreole, number_of_workers=2)
instance.set_parallel_decomposition(1, 2, 1)
instance.parameters.mesh_size = (10, 4, 4)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("interface", "outflow")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.stopping_conditions_number_of_steps = 1
gamma = 5.0 / 3.0
grid = datamodel.new_regular_grid((10, 4, 4), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.1 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
# instance.grid.boundaries.left.
xbound1 = instance.get_boundary_grid('xbound1')
self.assertEqual(xbound1.shape, (2, 4, 4))
memxbound1 = xbound1.copy()
memxbound1.rho = 0.02 | density
memxbound1.rhovx = 0.2 | momentum
memxbound1.rhovy = 0.0 | momentum
memxbound1.rhovz = 0.0 | momentum
memxbound1.energy = p / (gamma - 1)
memxbound1.energy += 0.5 * (memxbound1.rhovx ** 2 + memxbound1.rhovy ** 2 + memxbound1.rhovz ** 2) / memxbound1.rho
channel = memxbound1.new_channel_to(xbound1)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
rho = instance.grid.rho[..., 0, 0]
print(rho)
print(instance.model_time)
self.assertAlmostRelativeEquals(rho[-1], 0.01 | density)
self.assertTrue(rho[0] > 0.01 | density)
self.assertTrue(instance.grid.rhovx[0, 0, 0] > 0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovx[-1, 0, 0], 0.1 | momentum)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
print(instance.model_time)
rho = instance.grid.rho[..., 0, 0]
print(rho)
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovx[..., 0, 0], 0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test8(self):
instance = self.new_instance(Capreole, number_of_workers=1)
# instance.set_parallel_decomposition(2,1,1)
instance.parameters.mesh_size = (4, 10, 4)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("interface", "outflow")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.parameters.stopping_conditions_number_of_steps = 1
gamma = 5.0 / 3.0
grid = datamodel.new_regular_grid((4, 10, 4), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.0 | momentum
grid.rhovy = 0.1 | momentum
grid.rhovz = 0.0 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
ybound = instance.get_boundary_grid('ybound1')
self.assertEqual(ybound.shape, (4+4, 2, 4))
memybound = ybound.copy()
memybound.rho = 0.02 | density
memybound.rhovx = 0.0 | momentum
memybound.rhovy = 0.2 | momentum
memybound.rhovz = 0.0 | momentum
memybound.energy = p / (gamma - 1)
memybound.energy += 0.5 * (memybound.rhovx ** 2 + memybound.rhovy ** 2 + memybound.rhovz ** 2) / memybound.rho
channel = memybound.new_channel_to(ybound)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
print(instance.stopping_conditions.number_of_steps_detection.is_set())
print(instance.grid.rho[0, ..., 0])
rho = instance.grid.rho[0, ..., 0]
self.assertAlmostRelativeEquals(rho[-1], 0.01 | density)
self.assertTrue(rho[0] > 0.01 | density)
self.assertTrue(instance.grid.rhovy[0, 0, 0] > 0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovy[0, -1, 0], 0.1 | momentum)
print(instance.model_time)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[0, ..., 0]
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovy[0, ..., 0], 0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test9(self):
instance = self.new_instance(Capreole, number_of_workers=1)
# instance.set_parallel_decomposition(2,1,1)
instance.parameters.mesh_size = (4, 10, 4)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("outflow", "interface")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.parameters.stopping_conditions_number_of_steps = 1
gamma = 5.0 / 3.0
grid = datamodel.new_regular_grid((4, 10, 4), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.0 | momentum
grid.rhovy = -0.1 | momentum
grid.rhovz = 0.0 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
ybound = instance.get_boundary_grid('ybound2')
self.assertEqual(ybound.shape, (4+4, 2, 4))
memybound = ybound.copy()
memybound.rho = 0.02 | density
memybound.rhovx = 0.0 | momentum
memybound.rhovy = -0.2 | momentum
memybound.rhovz = 0.0 | momentum
memybound.energy = p / (gamma - 1)
memybound.energy += 0.5 * (memybound.rhovx ** 2 + memybound.rhovy ** 2 + memybound.rhovz ** 2) / memybound.rho
channel = memybound.new_channel_to(ybound)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
print(instance.stopping_conditions.number_of_steps_detection.is_set())
print(instance.grid.rho[0, ..., 0])
rho = instance.grid.rho[0, ..., 0]
self.assertAlmostRelativeEquals(rho[0], 0.01 | density)
self.assertTrue(rho[-1] > 0.01 | density)
self.assertTrue(instance.grid.rhovy[0, -1, 0] < 0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovy[0, 0, 0], -0.1 | momentum)
print(instance.model_time)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[0, ..., 0]
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovy[0, ..., 0], -0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test10(self):
instance = self.new_instance(Capreole, number_of_workers=1)
# instance.set_parallel_decomposition(2,1,1)
instance.parameters.mesh_size = (4, 4, 10)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("interface", "outflow")
instance.parameters.stopping_conditions_number_of_steps = 1
gamma = 5.0 / 3.0
grid = datamodel.new_regular_grid((4, 4, 10), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.0 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.1 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
ybound = instance.get_boundary_grid('zbound1')
self.assertEqual(ybound.shape, (4+4, 4+4, 2))
memybound = ybound.copy()
memybound.rho = 0.02 | density
memybound.rhovx = 0.0 | momentum
memybound.rhovy = 0.0 | momentum
memybound.rhovz = 0.2 | momentum
memybound.energy = p / (gamma - 1)
memybound.energy += 0.5 * (memybound.rhovx ** 2 + memybound.rhovy ** 2 + memybound.rhovz ** 2) / memybound.rho
channel = memybound.new_channel_to(ybound)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
rho = instance.grid.rho[0, 0, ...]
print(rho)
self.assertAlmostRelativeEquals(rho[-1], 0.01 | density)
self.assertTrue(rho[0] > 0.01 | density)
self.assertTrue(instance.grid.rhovz[0, 0, 0] > 0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovz[0, 0, -1], 0.1 | momentum)
print(instance.model_time)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[0, 0, ...]
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovz[0, ..., 0], 0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test11(self):
instance = self.new_instance(Capreole, number_of_workers=2)
instance.set_parallel_decomposition(2, 1, 1)
instance.parameters.mesh_size = (4, 4, 10)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("outflow", "interface")
instance.parameters.stopping_conditions_number_of_steps = 1
gamma = 5.0 / 3.0
grid = datamodel.new_regular_grid((4, 4, 10), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.0 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = -0.10 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
ybound = instance.get_boundary_grid('zbound2')
self.assertEqual(ybound.shape, (4+4, 4+4, 2))
memybound = ybound.copy()
memybound.rho = 0.02 | density
memybound.rhovx = 0.0 | momentum
memybound.rhovy = 0.0 | momentum
memybound.rhovz = -0.2 | momentum
memybound.energy = p / (gamma - 1)
memybound.energy += 0.5 * (memybound.rhovx ** 2 + memybound.rhovy ** 2 + memybound.rhovz ** 2) / memybound.rho
channel = memybound.new_channel_to(ybound)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
rho = instance.grid.rho[0, 0, ...]
self.assertAlmostRelativeEquals(rho[0], 0.01 | density)
self.assertTrue(rho[-1] > 0.01 | density)
self.assertTrue(instance.grid.rhovz[0, 0, -1] < 0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovz[0, 0, 0], -0.1 | momentum)
print(instance.model_time)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[0, 0, ...]
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovz[0, 0, ...], -0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test12(self):
instance = self.new_instance(Capreole)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (20.0, 1, 1) | generic_unit_system.length
instance.parameters.mesh_size = (20, 2, 2)
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = inmem.x/(1 | generic_unit_system.length) | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
print(inmem.rho)
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(0.5 | generic_unit_system.length, 0.0 | generic_unit_system.length, 0.0 | generic_unit_system.length)
self.assertEqual(rho, 0.5 | generic_unit_system.density)
for value in numpy.arange(0.5, 19.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value | generic_unit_system.length,
0.5 | generic_unit_system.length,
0.5 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, value | generic_unit_system.density)
for value in numpy.arange(0.0, 0.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, ((0.5 + value) * 0.5 + (0.5-value) * 19.5) | generic_unit_system.density)
for value in numpy.arange(0.0, 0.5, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value + 19.5 | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, (19.5 - (value * 19)) | generic_unit_system.density, 9)
# out of range
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
20.0 | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, 0.0 | generic_unit_system.density, 9)
def test13(self):
instance = self.new_instance(Capreole, number_of_workers=2)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (20.0, 20.0, 4) | generic_unit_system.length
instance.parameters.mesh_length = (20.0, 20.0, 4) | generic_unit_system.length
instance.parameters.mesh_size = (20, 20, 2)
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = (inmem.x + ((inmem.y - (0.5 | generic_unit_system.length)) * 20.0))/(1 | generic_unit_system.length) | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
print(inmem.rho[0], inmem.y[0], inmem.x[0])
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(0.5 | generic_unit_system.length, 0.5 | generic_unit_system.length, 0.0 | generic_unit_system.length)
self.assertEqual(rho, 0.5 | generic_unit_system.density)
for value in numpy.arange(0.5, 19.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value | generic_unit_system.length,
0.5 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, value | generic_unit_system.density)
for x in numpy.arange(8.5, 11.5, 0.25):
for y in numpy.arange(0.5, 19.6, 0.25):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
x | generic_unit_system.length,
y | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, x + (20 * (y-0.5)) | generic_unit_system.density)
def test14(self):
instance = self.new_instance(Capreole, number_of_workers=3)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (20.0, 20.0, 20.0) | generic_unit_system.length
instance.parameters.mesh_length = (20.0, 20.0, 20.0) | generic_unit_system.length
instance.parameters.mesh_size = (20, 20, 20)
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = (
(
inmem.x +
((inmem.y - (0.5 | generic_unit_system.length)) * 20.0) +
((inmem.z - (0.5 | generic_unit_system.length)) * 400.0)
)
/ (1 | generic_unit_system.length) | generic_unit_system.density
)
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(0.5 | generic_unit_system.length, 0.5 | generic_unit_system.length, 0.5 | generic_unit_system.length)
self.assertEqual(rho, 0.5 | generic_unit_system.density)
for value in numpy.arange(0.5, 19.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value | generic_unit_system.length,
0.5 | generic_unit_system.length,
0.5 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, value | generic_unit_system.density)
sample = datamodel.new_regular_grid(
(4, 4, 76),
(2, 2, 19) | generic_unit_system.length
)
sample.x += 9.5 | generic_unit_system.length
sample.y += 9.5 | generic_unit_system.length
sample.z += 0.5 | generic_unit_system.length
x = sample.x.flatten()
y = sample.y.flatten()
z = sample.z.flatten()
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
x,
y,
z
)
half = 0.5 | generic_unit_system.length
self.assertAlmostRelativeEquals(rho, (x + (20 * (y-half)) + (400 * (z-half)))/(1 | generic_unit_system.length) | generic_unit_system.density)
def test15(self):
instance = self.new_instance(Capreole, number_of_workers=1)
self.assertAlmostRelativeEquals(instance.parameters.gamma, 5.0 / 3.0)
instance.parameters.gamma = 1.2
self.assertAlmostRelativeEquals(instance.parameters.gamma, 1.2)
# self.assertAlmostRelativeEquals(instance.parameters.timestep, 0.1 | generic_unit_system.time)
# instance.parameters.timestep = 0.2 | generic_unit_system.time
# self.assertAlmostRelativeEquals(instance.parameters.timestep, 0.2 | generic_unit_system.time)
def test16(self):
instance = self.new_instance(Capreole)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (8, 1, 1) | generic_unit_system.length
instance.parameters.mesh_size = (8, 1, 1)
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = inmem.x/(1 | generic_unit_system.length) | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
print(inmem.rho)
grid = instance.get_extended_grid()
self.assertEqual(grid.shape, (12, 1, 1))
instance.initialize_grid()
self.assertEqual(grid.rho[..., 0, 0], [6.5, 7.5, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 0.5, 1.5] | generic_unit_system.density)
| 77,532
| 42.655968
| 181
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_tupan.py
|
import numpy
import math
from amuse.test.amusetest import TestWithMPI
from amuse.units import nbody_system, units, constants
from amuse.datamodel import Particles
from amuse.ic.plummer import new_plummer_model
try:
from amuse.community.tupan.interface import TupanInterface, Tupan, MODULES_MISSING
except ImportError:
MODULES_MISSING = True
class TestTupanInterface(TestWithMPI):
def test01(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Test TupanInterface initialization")
instance = self.new_instance_of_an_optional_code(TupanInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test02(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Test TupanInterface new_particle / get_state")
instance = self.new_instance_of_an_optional_code(TupanInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
id, error = instance.new_particle(mass=11.0, radius=2.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
self.assertEqual(0, error)
self.assertEqual(0, id)
id, error = instance.new_particle(mass=21.0, radius=5.0, x=10.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
self.assertEqual(0, error)
self.assertEqual(1, id)
self.assertEqual(0, instance.commit_particles())
retrieved_state1 = instance.get_state(0)
retrieved_state2 = instance.get_state(1)
self.assertEqual(0, retrieved_state1['__result'])
self.assertEqual(0, retrieved_state2['__result'])
self.assertEqual(11.0, retrieved_state1['mass'])
self.assertEqual(21.0, retrieved_state2['mass'])
self.assertEqual(0.0, retrieved_state1['x'])
self.assertEqual(10.0, retrieved_state2['x'])
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test03(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Test TupanInterface particle property getters/setters")
instance = self.new_instance_of_an_optional_code(TupanInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([0, 0], list(instance.new_particle(0.01, 1, 0, 0, 0, 1, 0, 0.1).values()))
self.assertEqual([1, 0], list(instance.new_particle(0.02, -1, 0, 0, 0, -1, 0, 0.1).values()))
#### self.assertEquals(-1, instance.get_mass(1)['__result']) # Have to commit first
self.assertEqual(0, instance.commit_particles())
# getters
mass, result = instance.get_mass(0)
self.assertAlmostEqual(0.01, mass)
self.assertEqual(0, result)
radius, result = instance.get_radius(1)
self.assertAlmostEqual(0.1, radius)
self.assertEqual(0, result)
self.assertEqual(-1, instance.get_mass(2)['__result']) # Particle not found
self.assertEqual([1, 0, 0, 0], list(instance.get_position(0).values()))
self.assertEqual([-1, 0, 0, 0], list(instance.get_position(1).values()))
self.assertEqual([0, 1, 0, 0], list(instance.get_velocity(0).values()))
self.assertEqual([0, -1, 0, 0], list(instance.get_velocity(1).values()))
# setters
self.assertEqual(0, instance.set_state(0, 0.01, 1, 2, 3, 4, 5, 6, 0.1))
self.assertEqual([0.01, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.1, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_mass(0, 0.02))
self.assertEqual([0.02, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.1, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_radius(0, 0.2))
self.assertEqual([0.02, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.2, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_position(0, 10, 20, 30))
self.assertEqual([0.02, 10.0, 20.0, 30.0, 4.0, 5.0, 6.0, 0.2, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_velocity(0, 40, 50, 60))
self.assertEqual([0.02, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 0.2, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test04(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Test TupanInterface parameters")
instance = self.new_instance_of_an_optional_code(TupanInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual([0.03125, 0], list(instance.get_eta().values()))
self.assertEqual(0, instance.set_eta(0.001))
self.assertEqual([0.001, 0], list(instance.get_eta().values()))
self.assertEqual([0.0, 0], list(instance.get_begin_time().values()))
self.assertEqual(0, instance.set_begin_time(1.0))
self.assertEqual([1.0, 0], list(instance.get_begin_time().values()))
self.assertEqual(["sia21h.dkd", 0], list(instance.get_integrator_method().values()))
self.assertEqual(0, instance.set_integrator_method("bogus"))
self.assertEqual(["bogus", 0], list(instance.get_integrator_method().values()))
self.assertEqual(-1, instance.commit_parameters())
self.assertEqual(0, instance.set_integrator_method("sakura"))
self.assertEqual(["sakura", 0], list(instance.get_integrator_method().values()))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.set_pn_order(7))
self.assertEqual([7, 0], list(instance.get_pn_order().values()))
self.assertEqual(-1, instance.commit_parameters())
self.assertEqual(0, instance.set_clight(1024))
self.assertEqual([1024, 0], list(instance.get_clight().values()))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test05(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Test TupanInterface evolve_model, binary")
instance = self.new_instance_of_an_optional_code(TupanInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([0, 0], list(instance.new_particle(0.5, 0.5, 0, 0, 0, 0.5, 0, 0.001).values()))
self.assertEqual([1, 0], list(instance.new_particle(0.5, -0.5, 0, 0, 0, -0.5, 0, 0.001).values()))
self.assertEqual(0, instance.commit_particles())
P = 2 * math.pi
self.assertEqual(0, instance.evolve_model(P / 2)) # half an orbit
for result, expected in zip(instance.get_position(0).values(), [-0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 2)
self.assertEqual(0, instance.evolve_model(P)) # full orbit
for result, expected in zip(instance.get_position(0).values(), [0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 2)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
class TestTupan(TestWithMPI):
default_converter = nbody_system.nbody_to_si(1.0e4 | units.MSun, 1.0 | units.AU)
def new_sun_earth_system(self):
particles = Particles(2)
particles.mass = [1.0, 3.0037e-6] | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * particles.total_mass() / (1.0 | units.AU)).sqrt()
return particles
def test01(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing Tupan initialization")
instance = self.new_instance_of_an_optional_code(Tupan, self.default_converter)
instance.initialize_code()
instance.commit_parameters()
instance.cleanup_code()
instance.stop()
def xtest02(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing Tupan parameters")
instance = self.new_instance_of_an_optional_code(Tupan, self.default_converter)
instance.initialize_code()
self.assertEqual(instance.parameters.epsilon_squared,
instance.unit_converter.to_si(0.0 | nbody_system.length**2))
self.assertEqual(instance.parameters.timestep_parameter, 0.125)
for par, value in [('epsilon_squared_star_star', 0.0 | nbody_system.length**2),
('epsilon_squared_star_blackhole', 0.0 | nbody_system.length**2),
('epsilon_squared_blackhole_blackhole', 0.0 | nbody_system.length**2),
('initial_timestep_parameter', 1.0e-4),
('timestep_parameter_stars', 0.1),
('timestep_parameter_supermassive_black_holes', 0.4),
('timestep_parameter_intermediate_mass_black_holes', 0.4),
('max_relative_energy_error', 5.0e-5),
('maximum_timestep', 1.0/1024.0 | nbody_system.time),
('smbh_mass', 1.0 | nbody_system.mass)]:
self.assertEqual(instance.unit_converter.to_si(value),
getattr(instance.parameters, par))
setattr(instance.parameters, par, 3.0 | value.unit)
self.assertEqual(instance.unit_converter.to_si(3.0 | value.unit),
getattr(instance.parameters, par))
# epsilon_squared is an alias for epsilon_squared_star_star, so epsilon_squared also has become 3:
self.assertEqual(instance.parameters.epsilon_squared,
instance.unit_converter.to_si(3.0 | nbody_system.length**2))
instance.parameters.epsilon_squared = 0.1 | nbody_system.length**2
self.assertEqual(instance.parameters.epsilon_squared,
instance.unit_converter.to_si(0.1 | nbody_system.length**2))
# timestep_parameter is an alias for timestep_parameter_stars, so timestep_parameter also has become 3:
self.assertEqual(instance.parameters.timestep_parameter, 3.0)
instance.parameters.timestep_parameter = 0.01
self.assertEqual(instance.parameters.timestep_parameter, 0.01)
self.assertEqual(instance.parameters.include_smbh, False)
instance.parameters.include_smbh = True
self.assertEqual(instance.parameters.include_smbh, True)
self.assertEqual(instance.parameters.calculate_postnewtonian, True)
instance.parameters.calculate_postnewtonian = False
self.assertEqual(instance.parameters.calculate_postnewtonian, False)
self.assertEqual(instance.parameters.drink, "Vodka martini. Shaken, not stirred.")
instance.stop()
def test03(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing Tupan particles")
instance = self.new_instance_of_an_optional_code(Tupan, self.default_converter)
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(self.new_sun_earth_system())
instance.commit_particles()
self.assertAlmostEqual(instance.particles.mass, [1.0, 3.0037e-6] | units.MSun)
self.assertAlmostEqual(instance.particles.radius, 1.0 | units.RSun)
self.assertAlmostEqual(instance.particles.position,
[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU)
self.assertAlmostEqual(instance.particles.velocity,
[[0.0, 0.0, 0.0], [0.0, 29.7885, 0.0]] | units.km / units.s, 3)
instance.cleanup_code()
instance.stop()
def xtest04(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing Tupan evolve_model, 2 particles orbiting the SMBH")
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = ((constants.G * (10001.0 | units.MSun) / (1.0 | units.AU)).sqrt() +
(constants.G * (10000.0 | units.MSun) / (1.0 | units.AU)).sqrt())
particles.move_to_center()
print(particles)
instance = self.new_instance_of_an_optional_code(Tupan, self.default_converter)
instance.initialize_code()
# instance.parameters.include_smbh = True
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
P_corrected = (P) * (2.0 / (1.0 + math.sqrt(1.0001)))
position_at_start = primary.position.x
instance.evolve_model(P_corrected / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3)
instance.evolve_model(P_corrected / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3)
instance.evolve_model(P_corrected)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3)
instance.cleanup_code()
instance.stop()
def test05(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing Tupan evolve_model, 2 particles, no SMBH")
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * (2.0 | units.MSun) / (2.0 | units.AU)).sqrt()
particles.move_to_center()
print(particles)
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Tupan, converter)
instance.initialize_code()
instance.parameters.integrator_method = "sakura"
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3)
instance.cleanup_code()
instance.stop()
def test06(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing Tupan evolve_model, earth-sun system, no SMBH")
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Tupan, converter, )
instance.initialize_code()
# instance.parameters.smbh_mass = 0.0 | units.MSun
instance.commit_parameters()
instance.particles.add_particles(self.new_sun_earth_system())
instance.commit_particles()
earth = instance.particles[1]
position_at_start = earth.position.x
instance.evolve_model(0.25 | units.yr)
self.assertAlmostRelativeEqual(position_at_start, earth.position.y, 3)
instance.evolve_model(0.5 | units.yr)
self.assertAlmostRelativeEqual(position_at_start, -earth.position.x, 3)
instance.evolve_model(1.0 | units.yr)
self.assertAlmostRelativeEqual(position_at_start, earth.position.x, 3)
instance.cleanup_code()
instance.stop()
def test07(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing effect of Tupan parameter epsilon_squared")
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
particles = self.new_sun_earth_system()
particles.rotate(0.0, 0.0, -math.pi/4)
particles.move_to_center()
tan_initial_direction = particles[1].vy/particles[1].vx
self.assertAlmostEqual(tan_initial_direction, math.tan(math.pi/4))
tan_final_direction = []
for log_eps2 in range(-9, 10, 2):
instance = self.new_instance_of_an_optional_code(Tupan, converter)
instance.initialize_code()
instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU ** 2
# instance.parameters.smbh_mass = 0.0 | units.MSun
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.25 | units.yr)
tan_final_direction.append(instance.particles[1].velocity[1] /
instance.particles[1].velocity[0])
instance.cleanup_code()
instance.stop()
# Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees
self.assertAlmostEqual(tan_final_direction[0], math.tan(3 * math.pi / 4.0), 2)
# Large values of epsilon_squared should result in ~ no interaction
self.assertAlmostEqual(tan_final_direction[-1], tan_initial_direction, 2)
# Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2
delta = [abs(tan_final_direction[i+1]-tan_final_direction[i]) for i in range(len(tan_final_direction)-1)]
self.assertEqual(delta[len(tan_final_direction)/2 - 1], max(delta))
def xtest08(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing Tupan get_gravity_at_point and get_potential_at_point")
instance = self.new_instance_of_an_optional_code(Tupan)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
# instance.parameters.smbh_mass = 0.0 | nbody_system.mass
particles = Particles(2)
particles.mass = 1.0 | nbody_system.mass
particles.radius = 0.0 | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, 1.0 | nbody_system.length, zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fx0, -1.0 * fx1)
fx = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0)
self.assertAlmostEqual(potential0, potential1)
instance.stop()
def test09(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing Tupan evolve_model and getters energy, plummer sphere, no SMBH")
converter = nbody_system.nbody_to_si(1.0e2 | units.MSun, 1.0 | units.parsec)
instance = self.new_instance_of_an_optional_code(Tupan, converter)
instance.parameters.timestep_parameter = 1.0/256
instance.initialize_code()
# instance.parameters.smbh_mass = 0.0 | units.MSun
instance.commit_parameters()
numpy.random.seed(987654321)
instance.particles.add_particles(new_plummer_model(100, convert_nbody=converter))
instance.commit_particles()
kinetic_energy = instance.kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy, 2.12292810174e+37 | units.J, 10)
self.assertAlmostRelativeEqual(potential_energy, -4.33511391248e+37 | units.J, 10)
initial_total_energy = kinetic_energy + potential_energy
instance.evolve_model(0.1 | nbody_system.time)
kinetic_energy = instance.kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy, 2.1362368884e+37 | units.J, 4)
self.assertAlmostRelativeEqual(potential_energy, -4.34842269914e+37 | units.J, 4)
self.assertAlmostRelativeEqual(potential_energy + kinetic_energy, initial_total_energy, 4)
instance.cleanup_code()
instance.stop()
def xtest10(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing Tupan collision_detection")
particles = Particles(7)
particles.mass = 0.00000001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = self.new_instance_of_an_optional_code(Tupan)
instance.initialize_code()
instance.parameters.set_defaults()
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 3)
self.assertEqual(len(collisions.particles(1)), 3)
self.assertEqual(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print(instance.model_time)
print(instance.particles)
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print()
print(instance.model_time)
print(instance.particles)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test11(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing Tupan properties")
numpy.random.seed(12345)
particles = new_plummer_model(100, do_scale=True)
particles.position += [1, 2, 3] | nbody_system.length
cluster_velocity = [4, 5, 6] | nbody_system.speed
particles.velocity += cluster_velocity
external_kinetic_energy = (0.5 | nbody_system.mass) * cluster_velocity.length_squared()
instance = self.new_instance_of_an_optional_code(Tupan)
instance.particles.add_particles(particles)
kinetic_energy = instance.kinetic_energy - external_kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy, 0.25 | nbody_system.energy, 10)
self.assertAlmostRelativeEqual(potential_energy, -0.5 | nbody_system.energy, 10)
self.assertAlmostRelativeEqual(instance.total_mass, 1.0 | nbody_system.mass, 10)
self.assertAlmostRelativeEqual(instance.center_of_mass_position,
[1, 2, 3] | nbody_system.length, 10)
self.assertAlmostRelativeEqual(instance.center_of_mass_velocity,
[4, 5, 6] | nbody_system.speed, 10)
initial_total_energy = kinetic_energy + potential_energy
instance.evolve_model(0.1 | nbody_system.time)
self.assertAlmostRelativeEqual(instance.model_time, 0.1 | nbody_system.time, 3)
kinetic_energy = instance.kinetic_energy - external_kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy+potential_energy, -0.25 | nbody_system.energy, 3)
self.assertAlmostRelativeEqual(instance.total_mass, 1.0 | nbody_system.mass, 3)
self.assertAlmostRelativeEqual(instance.center_of_mass_position,
[1.4, 2.5, 3.6] | nbody_system.length, 3)
self.assertAlmostRelativeEqual(instance.center_of_mass_velocity,
[4, 5, 6] | nbody_system.speed, 3)
instance.cleanup_code()
instance.stop()
| 26,869
| 48.212454
| 114
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_interface.py
|
from amuse.test.amusetest import TestWithMPI
from amuse.community.interface import gd
from amuse.community.interface.gd import GravitationalDynamicsInterface
from amuse.rfi.tools import create_definition
from amuse.rfi.tools.create_definition import CodeDocStringProperty
from amuse.rfi.core import LegacyFunctionSpecification
class TestGravitationalDynamics(TestWithMPI):
def test1(self):
x = GravitationalDynamicsInterface()
function = GravitationalDynamicsInterface.new_particle
specification = function.specification
self.assertTrue(specification.description.startswith("Define a new particle"))
def test2(self):
specification = LegacyFunctionSpecification()
specification.name = 'test'
specification.addParameter('one', 'd', specification.IN, 'first parameter')
specification.description = 'Example function'
x = create_definition.CreateDescriptionOfAFunctionSpecification()
x.specification = specification
x.start()
self.assertTrue(x.out.string.find('void test(float64 one)') > 0)
self.assertTrue(x.out.string.find('Example function') >= 0)
self.assertTrue(x.out.string.find(':param one:') > 0)
def test3(self):
specification = LegacyFunctionSpecification()
specification.name = 'test'
specification.addParameter('one', 'd', specification.IN, 'first parameter')
specification.result_type = 'i'
specification.result_doc = 'an integer'
specification.description = 'Example function'
x = create_definition.CreateDescriptionOfAFunctionSpecification()
x.specification = specification
x.start()
self.assertTrue(x.out.string.find('int32 test(float64 one)') > 0)
self.assertTrue(x.out.string.find(':returns:') > 0)
def test4(self):
specification = LegacyFunctionSpecification()
specification.name = 'test'
specification.addParameter('one', 'd', specification.IN, 'first parameter')
specification.result_type = 'i'
specification.result_doc = 'an integer'
specification.description = 'Example function'
x = create_definition.CreateFortranStub()
x.specification = specification
x.start()
self.assertTrue(x.out.string.find('FUNCTION test(one)') >= 0)
self.assertTrue(x.out.string.find('END FUNCTION') > 0)
self.assertTrue(x.out.string.find('DOUBLE PRECISION :: one') > 0)
def test5(self):
class WithLegacyDocStringProperty(object):
def __init__(self):
"orignal doc"
pass
@property
def specification(self):
specification = LegacyFunctionSpecification()
specification.name = 'test'
specification.addParameter('one', 'd', specification.IN, 'first parameter')
specification.result_type = 'i'
specification.result_doc = 'an integer'
specification.description = 'Example function'
return specification
__doc__ = CodeDocStringProperty()
self.assertEqual("orignal doc", WithLegacyDocStringProperty.__doc__)
instance = WithLegacyDocStringProperty()
instance_documentation = WithLegacyDocStringProperty().__doc__
self.assertTrue(instance_documentation.find('FUNCTION test(one)') >= 0)
def test6(self):
print("Testing description of Legacy Function with output parameter")
specification = LegacyFunctionSpecification()
specification.name = 'test'
specification.addParameter('one', 'd', specification.OUT, 'first parameter')
specification.result_type = 'i'
specification.result_doc = 'an integer'
specification.description = 'Example function'
x = create_definition.CreateDescriptionOfAFunctionSpecification()
x.specification = specification
x.start()
self.assertTrue(x.out.string.find('int32 test(float64 * one)') > 0)
self.assertTrue(x.out.string.find(':returns:') > 0)
def test7(self):
print("Testing __str__ of Legacy Function")
specification = LegacyFunctionSpecification()
specification.name = 'test'
specification.addParameter('one', 'f', specification.IN, 'first parameter, type: float')
specification.addParameter('two', 'd', specification.OUT, 'second parameter, type double')
specification.result_type = 'i'
specification.result_doc = 'an integer'
specification.description = 'Example function'
self.assertEqual(str(specification), "function: int test(float one)\noutput: double two, int __result")
| 4,738
| 40.938053
| 111
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_mesa_15140.py
|
from amuse.test.amusetest import TestWithMPI, get_path_to_results
import sys
import os.path
from subprocess import PIPE, Popen
import numpy
from amuse.community.mesa_r15140.interface import MESA, MESAInterface
from amuse.support.exceptions import AmuseException
from amuse.units import units
from amuse.datamodel import Particles
from amuse.datamodel import Particle
from amuse.ext.spherical_model import EnclosedMassInterpolator
def set_mesa_paths_instance(instance):
instance.set_MESA_paths(
instance.default_path_to_inlist,
instance.default_path_to_MESA,
instance.default_path_to_MESA_data,
instance.get_output_directory(),
'',
instance.default_tmp_dir
)
class TestMESAInterface(TestWithMPI):
def test1(self):
print("Testing initialization of the interface...")
instance = self.new_instance_of_an_optional_code(MESAInterface)
if instance is None:
print("MESA was not built. Skipping test.")
return
status = instance.initialize_code()
self.assertEqual(status, 0)
set_mesa_paths_instance(instance)
instance.stop()
def test2(self):
print(
"Testing get/set of metallicity (tests new ZAMS model "
"implicitly)..."
)
print(
"The first time this test will take quite some time"
" to generate new starting models."
)
instance = self.new_instance_of_an_optional_code(MESAInterface)
if instance is None:
print("MESA was not built. Skipping test.")
return
status = instance.initialize_code()
self.assertEqual(status, 0)
set_mesa_paths_instance(instance)
(metallicity, error) = instance.get_metallicity()
self.assertEqual(0, error)
self.assertEqual(0.02, metallicity)
for x in [0.04, 0.02, 0.01, 0.00]:
error = instance.set_metallicity(x)
self.assertEqual(0, error)
(metallicity, error) = instance.get_metallicity()
self.assertEqual(0, error)
self.assertEqual(x, metallicity)
instance.stop()
def test3(self):
print("Testing basic operations: new_particle...")
instance = self.new_instance_of_an_optional_code(MESAInterface)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
(
maximum_number_of_stars, error
) = instance.get_maximum_number_of_stars()
self.assertEqual(0, error)
self.assertEqual(maximum_number_of_stars, 10)
status = instance.initialize_code()
self.assertEqual(status, 0)
number_of_stars = 1
for i in range(number_of_stars):
(
index_of_the_star, error
) = instance.new_particle(0.5+i*1.0/number_of_stars)
self.assertEqual(0, error)
self.assertEqual(index_of_the_star, i+1)
instance.stop()
def test4(self):
print("Testing basic operations: evolve...")
instance = self.new_instance_of_an_optional_code(MESAInterface)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
instance.initialize_code()
(index_of_the_star, error) = instance.new_particle(1.0)
self.assertEqual(0, error)
self.assertEqual(index_of_the_star, 1)
self.assertEqual(0, instance.commit_particles())
initial_dt = 1.0e5
dt_factor = 1.2
instance.set_time_step(index_of_the_star, initial_dt)
self.assertEqual([initial_dt, 0], list(instance.get_time_step(index_of_the_star).values()))
self.assertEqual(0, instance.evolve_for(index_of_the_star, initial_dt))
self.assertEqual(
[initial_dt, 0],
list(instance.get_age(index_of_the_star).values())
)
target_end_time = 3.0e5 # (years)
self.assertEqual(
0, instance.evolve_for(
index_of_the_star, target_end_time-initial_dt
)
)
self.assertTrue(
instance.get_age(index_of_the_star)['age'] >= target_end_time
)
(L_of_the_star, error) = instance.get_luminosity(index_of_the_star)
self.assertEqual(0, error)
self.assertAlmostEqual(L_of_the_star, 0.725, 1)
(M_of_the_star, error) = instance.get_mass(index_of_the_star)
self.assertEqual(0, error)
self.assertAlmostEqual(M_of_the_star, 1.000, 3)
(T_of_the_star, error) = instance.get_temperature(index_of_the_star)
self.assertEqual(0, error)
self.assertAlmostEqual(T_of_the_star, 5650.998, -2)
instance.stop()
def slowtest5(self):
print(
"Testing evolve with varying Z (tests new ZAMS model "
"implicitly)..."
)
print(
"If the required starting models do not exist, this test will "
"take quite some time to generate them."
)
instance = self.new_instance_of_an_optional_code(MESAInterface)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
status = instance.initialize_code()
self.assertEqual(status, 0)
metallicities = [0.00, 0.01, 0.02, 0.04]
luminosities = [1.717, 0.938, 0.725, 0.592]
for (i, (Z, L)) in enumerate(zip(metallicities, luminosities)):
status = instance.set_metallicity(Z)
self.assertEqual(0, status)
(index_of_the_star, status) = instance.new_pre_ms_particle(1.0)
self.assertEqual(0, status)
self.assertEqual(index_of_the_star, i+1)
instance.evolve_for(index_of_the_star, 5.0e5)
(
L_of_the_star, status
) = instance.get_luminosity(index_of_the_star)
self.assertEqual(0, status)
self.assertAlmostEqual(L_of_the_star, L, 1)
instance.stop()
def test6(self):
print("Testing MESA stop conditions...")
instance = self.new_instance_of_an_optional_code(MESAInterface)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
(value, error) = instance.get_max_age_stop_condition()
self.assertEqual(0, error)
self.assertEqual(1.0e36, value)
for x in range(10, 14):
error = instance.set_max_age_stop_condition(10 ** x)
self.assertEqual(0, error)
(value, error) = instance.get_max_age_stop_condition()
self.assertEqual(0, error)
self.assertEqual(10 ** x, value)
(value, error) = instance.get_min_timestep_stop_condition()
self.assertEqual(0, error)
self.assertEqual(1.0e-6, value)
for x in range(-9, -2):
error = instance.set_min_timestep_stop_condition(10.0 ** x)
self.assertEqual(0, error)
(value, error) = instance.get_min_timestep_stop_condition()
self.assertEqual(0, error)
self.assertEqual(10.0 ** x, value)
instance.stop()
def test7(self):
print("Testing MESA parameters...")
instance = self.new_instance_of_an_optional_code(MESAInterface)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
(index_of_the_star, error) = instance.new_particle(1.0)
(value, error) = instance.get_mixing_length_ratio(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(2.0, value)
for x in [1.0, 1.5, 3.0]:
error = instance.set_mixing_length_ratio(index_of_the_star, x)
self.assertEqual(0, error)
(value, error) = instance.get_mixing_length_ratio(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(x, value)
(value, error) = instance.get_semi_convection_efficiency(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(0.0, value)
for x in [0.1, 0.04, 0.001]:
error = instance.set_semi_convection_efficiency(index_of_the_star, x)
self.assertEqual(0, error)
(value, error) = instance.get_semi_convection_efficiency(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(x, value)
instance.stop()
def test8(self):
print("Testing MESA wind parameters...")
instance = self.new_instance_of_an_optional_code(MESAInterface)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
(index_of_the_star, error) = instance.new_particle(1.0)
(value, error) = instance.get_RGB_wind_scheme(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual('', value)
for x, name in enumerate(['Reimers', 'Blocker', 'de jager', 'Dutch']):
error = instance.set_RGB_wind_scheme(index_of_the_star, x)
self.assertEqual(0, error)
(value, error) = instance.get_RGB_wind_scheme(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(x, value)
(value, error) = instance.get_AGB_wind_scheme(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual('', value)
for x, name in enumerate(['Reimers', 'Blocker', 'de jager', 'Dutch']):
error = instance.set_AGB_wind_scheme(index_of_the_star, x)
self.assertEqual(0, error)
(value, error) = instance.get_AGB_wind_scheme(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(x, value)
(value, error) = instance.get_reimers_wind_efficiency(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(0.0, value)
for x in [0.0, 0.1, 0.5, 1.0]:
error = instance.set_reimers_wind_efficiency(index_of_the_star, x)
self.assertEqual(0, error)
(value, error) = instance.get_reimers_wind_efficiency(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(x, value)
(value, error) = instance.get_blocker_wind_efficiency(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(0.0, value)
for x in [0.0, 0.1, 0.5, 1.0]:
error = instance.set_blocker_wind_efficiency(index_of_the_star, x)
self.assertEqual(0, error)
(value, error) = instance.get_blocker_wind_efficiency(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(x, value)
(value, error) = instance.get_de_jager_wind_efficiency(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(0.0, value)
for x in [0.0, 0.1, 0.5, 1.0]:
error = instance.set_de_jager_wind_efficiency(index_of_the_star, x)
self.assertEqual(0, error)
(value, error) = instance.get_de_jager_wind_efficiency(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(x, value)
(value, error) = instance.get_dutch_wind_efficiency(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(0.0, value)
for x in [0.0, 0.1, 0.5, 1.0]:
error = instance.set_dutch_wind_efficiency(index_of_the_star, x)
self.assertEqual(0, error)
(value, error) = instance.get_dutch_wind_efficiency(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(x, value)
instance.stop()
class TestMESA(TestWithMPI):
def test1(self):
print("Testing initialization and default MESA parameters...")
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
instance.initialize_code()
self.assertEqual(0.02 | units.no_unit, instance.parameters.metallicity)
self.assertEqual(
1.0e36 | units.julianyr, instance.parameters.max_age_stop_condition
)
instance.parameters.max_age_stop_condition = 1.0e2 | units.Myr
self.assertEqual(
1.0e2 | units.Myr, instance.parameters.max_age_stop_condition
)
instance.stop()
def test2(self):
# FIXME seems to be a mismatch between the definition of "yr" between
# MESA and AMUSE, and time_step and age.
print("Testing basic operations: evolve and get_...")
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
evo_star = instance.particles.add_particle(
Particle(mass=1.0 | units.MSun)
)
self.assertEqual(len(instance.particles), 1)
# instance.commit_particles()
initial_dt = 1.0e5 | units.julianyr
dt_factor = 1.2
time_step = evo_star.time_step
self.assertAlmostEqual(time_step, initial_dt)
evo_star.evolve_one_step()
age_of_the_star = evo_star.age
self.assertAlmostEqual(age_of_the_star, initial_dt)
target_end_time = 3.0e5 | units.julianyr
evo_star.evolve_for(
target_end_time - age_of_the_star
)
self.assertTrue(
evo_star.age >= target_end_time
)
L_of_the_star = evo_star.luminosity
self.assertAlmostEqual(L_of_the_star, 0.725 | units.LSun, 1)
M_of_the_star = evo_star.mass
self.assertAlmostEqual(M_of_the_star, 1.000 | units.MSun, 3)
T_of_the_star = evo_star.temperature
self.assertAlmostEqual(T_of_the_star, 5650.998 | units.K, -2)
instance.stop()
def test3(self):
print("Testing basic operations: evolve_model and channels...")
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
instance.initialize_code()
instance.commit_parameters()
stars = Particles(1)
mass = 10. | units.MSun
stars.mass = mass
instance.particles.add_particles(stars)
instance.commit_particles()
from_code_to_model = instance.particles.new_channel_to(stars)
from_code_to_model.copy()
self.assertEqual(stars[0].mass, mass)
self.assertAlmostRelativeEqual(
stars[0].luminosity, 5841. | units.LSun, 1
)
instance.evolve_model()
from_code_to_model.copy()
self.assertAlmostEqual(stars[0].mass, mass, 5)
self.assertAlmostRelativeEqual(
stars[0].luminosity, 5820.85 | units.LSun, 1
)
instance.stop()
def slowtest4(self):
print("Testing stellar type...")
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
instance.initialize_code()
instance.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 5.0 | units.MSun
instance.particles.add_particles(stars)
instance.commit_particles()
from_code_to_model = instance.particles.new_channel_to(stars)
from_code_to_model.copy()
previous_type = 15 | units.stellar_type
results = []
current_time = 0 | units.Myr
while current_time < (101 | units.Myr):
if not star.stellar_type == previous_type:
print((star.age, star.mass, star.stellar_type))
results.append((star.age, star.mass, star.stellar_type))
previous_type = star.stellar_type
instance.evolve_model()
from_code_to_model.copy()
current_time = star.age
self.assertEqual(len(results), 4)
times = (
0.0 | units.Myr,
81.6 | units.Myr,
99.9 | units.Myr,
100.3 | units.Myr
)
for result, expected in zip(results, times):
self.assertAlmostEqual(
result[0].value_in(units.Myr), expected.value_in(units.Myr), 1
)
masses = (
5.000 | units.MSun,
5.000 | units.MSun,
5.000 | units.MSun,
5.000 | units.MSun
)
for result, expected in zip(results, masses):
self.assertAlmostEqual(
result[1].value_in(units.MSun),
expected.value_in(units.MSun),
3
)
types = (
"Main Sequence star",
"First Giant Branch",
"Core Helium Burning",
"First Asymptotic Giant Branch"
)
for result, expected in zip(results, types):
self.assertEqual(str(result[2]), expected)
instance.stop()
def test5(self):
print("Testing evolve_model for particle set...")
instance = self.new_instance_of_an_optional_code(MESA)
set_mesa_paths_instance(instance)
masses = [0.5, 1.0] | units.MSun
# FIXME updated max_age, as time step seems to be larger now
max_age = 1.0e6 | units.julianyr
number_of_stars = len(masses)
stars = Particles(number_of_stars)
stars.mass = masses
instance.initialize_code()
self.assertEqual(
instance.parameters.max_age_stop_condition, 1e36 | units.julianyr
)
instance.parameters.max_age_stop_condition = max_age
self.assertEqual(instance.parameters.max_age_stop_condition, max_age)
instance.particles.add_particles(stars)
instance.commit_particles()
from_code_to_model = instance.particles.new_channel_to(stars)
instance.evolve_model(end_time=0.5e6 | units.julianyr)
from_code_to_model.copy()
for i in range(number_of_stars):
self.assertTrue(stars[i].age.value_in(units.julianyr) >= 0.5e6)
self.assertTrue(stars[i].age <= max_age)
self.assertTrue(stars[i].mass <= masses[i])
self.assertTrue(stars[i].age+stars[i].time_step <= max_age)
# FIXME this stopping condition doesn't seem implemented yet
# self.assertRaises(
# AmuseException, instance.evolve_model, end_time=2*max_age,
# expected_message=(
# "Error when calling 'evolve_for' of a 'MESA', "
# "errorcode is -12, error is "
# "'Evolve terminated: Maximum age reached.'"
# )
# )
instance.stop()
def test6(self):
print("Test for obtaining the stellar structure model")
stars = Particles(2)
stars.mass = [1.0, 10.0] | units.MSun
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(stars)
instance.commit_particles()
instance.evolve_model()
self.assertEqual(instance.particles.get_number_of_zones(), [3832, 2468])
self.assertEqual(len(instance.particles[0].get_mass_profile()), 3832)
self.assertAlmostEqual(
instance.particles[0].get_mass_profile().sum(), 1.0
)
self.assertRaises(
AmuseException, instance.particles.get_mass_profile,
expected_message=(
"Querying mass profiles of more than one particle at a time "
"is not supported."
)
)
print(instance.particles)
self.assertEqual(
len(instance.particles[1].get_density_profile()), 2468
)
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_luminosity_profile()[-1],
1.0 | units.LSun)
self.assertIsOfOrder(
instance.particles[0].get_pressure_profile()[0],
1.0e17 | units.barye)
delta_mass = (
instance.particles[0].get_mass_profile()
* instance.particles[0].mass
)
radius1 = instance.particles[0].get_radius_profile()
radius2 = radius1[:-1]
radius2.prepend(0 | units.m)
delta_radius_cubed = (radius1**3 - radius2**3)
# FIXME the test below doesn't pass for [1]*3832
# but it passes for [0.99888]*3832?
# self.assertAlmostEqual(
# instance.particles[0].get_density_profile()
# / (delta_mass/(4./3.*numpy.pi*delta_radius_cubed)),
# [1]*3832, places=3
# )
self.assertAlmostEqual(
instance.particles[1].get_mu_profile(), [0.62]*2468 | units.amu,
places=1
)
instance.stop()
def test7(self):
print("Test for obtaining the stellar composition structure")
stars = Particles(1)
stars.mass = 1.0 | units.MSun
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(stars)
instance.commit_particles()
instance.evolve_model()
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()
species_IDs = instance.particles[0].get_IDs_of_species()
species_masses = instance.particles[0].get_masses_of_species()
self.assertEqual(number_of_zones, 3832)
self.assertEqual(number_of_species, 8)
self.assertEqual(len(species_names), number_of_species)
self.assertEqual(len(composition), number_of_species)
self.assertEqual(len(composition[0]), number_of_zones)
self.assertEqual(
species_names,
['h1', 'he3', 'he4', 'c12', 'n14', 'o16', 'ne20', 'mg24']
)
self.assertEqual(
species_IDs,
# [2, 5, 6, 38, 51, 69, 114, 168]
[1, 2, 3, 4, 5, 6, 7, 8]
)
self.assertAlmostEqual(
species_masses,
[
1.0078250, 3.0160293, 4.0026032, 12.0, 14.0030740, 15.9949146,
19.9924401, 23.9850417
] | units.amu,
places=5
)
self.assertAlmostEqual(composition[:1, -1].sum(), 0.7)
self.assertAlmostEqual(
composition[1:3, -1].sum(),
(0.3) - instance.parameters.metallicity
)
self.assertAlmostEqual(
composition[3:, -1].sum(),
instance.parameters.metallicity
)
self.assertAlmostEqual(
composition.sum(axis=0),
[1.0]*number_of_zones
)
instance.stop()
def slowtest8(self):
print(
"Test for obtaining the stellar composition structure - "
"evolved star with zero metalicity"
)
stars = Particles(1)
stars.mass = 1.0 | units.MSun
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
instance.initialize_code()
instance.parameters.metallicity = 0.0
instance.commit_parameters()
instance.particles.add_particles(stars)
instance.commit_particles()
instance.evolve_model(5.85 | units.Gyr)
self.assertTrue(instance.particles[0].age >= 5.85 | units.Gyr)
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()
species_IDs = instance.particles[0].get_IDs_of_species()
self.assertEqual(number_of_zones, 578)
self.assertEqual(number_of_species, 8)
self.assertEqual(len(species_names), number_of_species)
self.assertEqual(len(composition), number_of_species)
self.assertEqual(len(composition[0]), number_of_zones)
self.assertEqual(
species_names,
['h1', 'he3', 'he4', 'c12', 'n14', 'o16', 'ne20', 'mg24']
)
self.assertEqual(
species_IDs,
[2, 5, 6, 38, 51, 69, 114, 168]
)
self.assertAlmostEqual(
composition[:1, number_of_zones-1].sum(), 0.76 | units.none
)
self.assertAlmostEqual(
composition[1:3, number_of_zones-1].sum(), 0.24 | units.none
)
self.assertAlmostEqual(
composition[3:, number_of_zones-1].sum(), 0.00 | units.none
)
self.assertAlmostEqual(
composition.sum(axis=0), [1.0]*number_of_zones | units.none
)
self.assertAlmostEqual(
composition[:1, 0].sum(), 0.00 | units.none
)
self.assertAlmostEqual(
composition[1:3, 0].sum(), 1.00 | units.none
)
self.assertAlmostEqual(
composition[3:, 0].sum(), 0.00 | units.none
)
instance.stop()
def xtest9(self):
print("Test for changing the stellar structure model")
##################################################################
# Changing the density or radius in this manner is not supported #
##################################################################
# star = Particles(1)
# star.mass = 1.0 | units.MSun
# instance = self.new_instance_of_an_optional_code(MESA)
# if instance is None:
# print("MESA was not built. Skipping test.")
# return
# 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 (3830) does not match the "
# "number of mesh zones of the star (3832)."
# )
# )
# 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. * numpy.pi * delta_radius_cubed
# * instance.particles[0].get_density_profile()
# ).sum()
# self.assertAlmostRelativeEqual(
# integrated_mass, star.mass*mass_factor, places=3
# )
# instance.stop()
def test10(self):
print("Test for changing the stellar composition")
star = Particles(1)
star.mass = 1.0 | units.MSun
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(star)
instance.commit_particles()
instance.evolve_model(0.3 | units.Myr)
composition = instance.particles[0].get_chemical_abundance_profiles()
k_surface = -1 # index to the outer mesh cell (surface)
self.assertAlmostEqual(composition[:1, k_surface].sum(), 0.7)
self.assertAlmostEqual(
composition[1:3, k_surface].sum(),
(0.3) - instance.parameters.metallicity)
self.assertAlmostEqual(
composition[3:, k_surface].sum(),
instance.parameters.metallicity)
he4_start = composition[2, k_surface]
h1_start = composition[0, k_surface]
h1_profile = composition[0] * 1
he4_profile = composition[2] * 1
instance.particles[0].set_control('okay_to_remesh', False) # Turn of remeshing
# Gradually and consistently increase helium and decrease hydrogen
# abundances until reversed
for alpha in numpy.arange(0.1, 1.1, 0.1):
composition[0] = alpha * he4_profile + (1-alpha) * h1_profile
composition[2] = (1-alpha) * he4_profile + alpha * h1_profile
instance.particles[0].set_chemical_abundance_profiles(composition)
instance.particles[0].evolve_for(1 | units.julianyr)
composition = (
instance.particles[0].get_chemical_abundance_profiles()
)
self.assertAlmostEqual(
composition[2, k_surface], h1_start, 3)
self.assertAlmostEqual(composition[0, k_surface], he4_start, 3)
self.assertAlmostEqual(
composition[3:, k_surface].sum(),
0.020, 3)
self.assertAlmostEqual(composition.sum(axis=0), 1.0)
self.assertRaises(
AmuseException,
instance.particles[0].set_chemical_abundance_profiles,
composition[:7],
expected_message=(
"The length of the supplied vector (7) does not match "
"the number of chemical species of the star (8)."
)
)
instance.stop()
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 = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertAlmostEqual(
instance.particles.age, [0.0, 0.0, 0.0] | units.yr)
print(
"evolve_model without arguments: use shared timestep = "
"0.99*min(particles.time_step)"
)
instance.evolve_model()
self.assertAlmostEqual(
instance.particles.age.in_(units.yr),
[6350.98860534, 6350.98860534, 6350.98860534] | units.yr, 3
)
self.assertAlmostEqual(
instance.model_time, 0.99 * 6415.0029 | units.julianyr, 3
)
print(
"evolve_model with end_time: take timesteps, until end_time "
"is reached exactly"
)
instance.evolve_model(15000 | units.yr)
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.model_time, 15000.0 | units.yr, 3)
instance.stop()
def test12(self):
print("Test for importing new stellar models")
star = Particles(1)
star.mass = 1.0 | units.MSun
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(star)
instance.commit_particles()
instance.evolve_model(1 | units.Myr)
number_of_zones = instance.particles[0].get_number_of_zones()
composition = instance.particles[0].get_chemical_abundance_profiles(
number_of_zones=number_of_zones)
instance.new_particle_from_model(dict(
mass=instance.particles[0].get_cumulative_mass_profile(
number_of_zones=number_of_zones) * instance.particles[0].mass,
radius=instance.particles[0].get_radius_profile(
number_of_zones=number_of_zones),
rho=instance.particles[0].get_density_profile(
number_of_zones=number_of_zones),
temperature=instance.particles[0].get_temperature_profile(
number_of_zones=number_of_zones),
luminosity=instance.particles[0].get_luminosity_profile(
number_of_zones=number_of_zones),
X_H=composition[0],
X_He=composition[1] + composition[2],
X_C=composition[3],
X_N=composition[4],
X_O=composition[5],
X_Ne=composition[6],
X_Mg=composition[7],
X_Si=composition[7]*0.0,
X_Fe=composition[7]*0.0), 10.0 | units.Myr)
self.assertEqual(len(instance.particles), 2)
self.assertEqual(len(instance.imported_stars), 1)
self.assertIsOfOrder(
instance.imported_stars[0].get_radius_profile()[-1],
1.0 | units.RSun)
self.assertIsOfOrder(
instance.imported_stars[0].get_temperature_profile()[0],
1.0e7 | units.K)
self.assertIsOfOrder(
instance.imported_stars[0].get_pressure_profile()[0],
1.0e17 | units.barye)
self.assertAlmostEqual(
instance.imported_stars[0].get_mass_profile()[-1],
instance.native_stars[0].get_mass_profile()[-1])
print(instance.particles)
instance.evolve_model(keep_synchronous=False)
print(instance.particles)
instance.stop()
def slowtest13(self):
print("Testing MESA wind parameters...")
stars = Particles(9)
stars.mass = 10.0 | units.MSun
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
instance.initialize_code()
winds = {
'': 0.0,
'Reimers': 0.5,
'Blocker': 0.1,
'de Jager': 0.8,
'Dutch': 0.8,
}
instance.commit_parameters()
for i, (wind_scheme, scale) in enumerate(winds):
instance.recommit_parameters()
instance.particles.add_particle(stars[i])
stars[i].RGB_wind_scheme = wind_scheme
stars[i].set_RGB_wind_efficiency(scale)
winds[wind_scheme] = stars[i].get_RGB_wind_efficiency() * 2
for i, (wind_scheme, scale) in enumerate(winds):
instance.recommit_parameters()
instance.particles.add_particle(stars[i+4])
stars[i+4].RGB_wind_scheme = wind_scheme
instance.commit_particles()
instance.evolve_model(keep_synchronous=False)
from_code_to_model = instance.particles.new_channel_to(stars)
from_code_to_model.copy()
self.assertAlmostEqual(stars[0].wind, 0.0 | units.MSun / units.yr)
self.assertAlmostRelativeEqual(
stars[1:5].wind,
[
4.59318475897e-10, 5.20742729636e-11, 1.05565558121e-09,
3.62519254311e-09
] | units.MSun / units.yr, places=7)
self.assertAlmostRelativeEqual(
stars[5:].wind, 2.0 * stars[1:5].wind, places=7)
instance.stop()
def test14(self):
print("Testing MESA wind parameters... (short version of slowtest13)")
stars = Particles(3)
stars.mass = 10.0 | units.MSun
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
instance.initialize_code()
instance.commit_parameters()
for i, wind_efficiency in enumerate([0.0, 0.5, 1.0]):
instance.particles.add_particle(stars[i])
stars[i].RGB_wind_scheme = 'Reimers'
stars[i].reimers_wind_efficiency = wind_efficiency
instance.commit_particles()
instance.evolve_model(keep_synchronous=False)
from_code_to_model = instance.particles.new_channel_to(stars)
from_code_to_model.copy()
self.assertAlmostEqual(stars[0].mass_change, 0.0 | units.MSun / units.yr)
self.assertAlmostRelativeEqual(
stars[1].mass_change, 4.59318475897e-10 | units.MSun / units.yr, places=1)
self.assertAlmostRelativeEqual(
stars[2].mass_change, 2.0 * stars[1].mass_change, places=7)
instance.stop()
def xtest15(self):
print("Testing MESA states")
stars = Particles(2)
stars.mass = 1.0 | units.MSun
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
print("First do everything manually:", end=' ')
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
# FIXME: ??
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particle(stars[0])
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("ok")
print(
"initialize_code(), commit_parameters(), (re)commit_particles(), "
"and cleanup_code() should be called automatically:", end=' ')
instance = MESA()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
set_mesa_paths_instance(instance)
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particle(stars[0])
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.particles.add_particle(stars[1])
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
print("ok")
def test16(self):
print("Testing basic operations: evolve_one_step and evolve_for")
stars = Particles(2)
stars.mass = 1.0 | units.MSun
instance = self.new_instance_of_an_optional_code(MESA)
if instance is None:
print("MESA was not built. Skipping test.")
return
set_mesa_paths_instance(instance)
se_stars = instance.particles.add_particles(stars)
for i in range(3):
se_stars[0].evolve_one_step()
self.assertAlmostEqual(se_stars.age, [364000.0, 0] | units.julianyr)
se_stars[1].evolve_for(se_stars[0].age)
self.assertAlmostRelativeEqual(se_stars[0].age, se_stars[1].age)
self.assertAlmostRelativeEqual(
se_stars[0].luminosity, se_stars[1].luminosity, 2)
self.assertAlmostRelativeEqual(
se_stars[0].radius, se_stars[1].radius, 2)
self.assertAlmostRelativeEqual(
se_stars[0].temperature, se_stars[1].temperature, 2)
instance.stop()
def test18(self):
print("Testing MESA mass_change (User-specified wind/accretion)")
instance = self.new_instance_of_an_optional_code(MESA)
set_mesa_paths_instance(instance)
star = instance.particles.add_particle(Particle(mass=1 | units.MSun))
star.mass_change = 1.0e-8 | units.MSun / units.julianyr # positive -> accretion
star.evolve_for(1.0e5 | units.julianyr)
self.assertAlmostRelativeEqual(
star.mass_change, 1.0e-8 | units.MSun / units.julianyr)
self.assertAlmostRelativeEqual(
star.wind, 1.0e-8 | units.MSun / units.julianyr, 3)
self.assertAlmostRelativeEqual(star.age, 1.0e5 | units.julianyr)
self.assertAlmostRelativeEqual(star.mass, 1.0010 | units.MSun)
star.mass_change = -1.0e-8 | units.MSun / units.julianyr # negative -> wind
star.evolve_for(1 | units.s)
self.assertAlmostRelativeEqual(
star.mass_change, -1.0e-8 | units.MSun / units.julianyr)
self.assertAlmostRelativeEqual(
star.wind, -1.0e-8 | units.MSun / units.julianyr, 3)
star.evolve_for(1.0e5 | units.julianyr)
self.assertAlmostRelativeEqual(star.age, 2.e5 | units.julianyr, 3)
self.assertAlmostRelativeEqual(star.mass, 1.00 | units.MSun, 3)
print(star.as_set())
instance.stop()
def slowtest19a(self):
print("Testing MESA core mass")
instance = self.new_instance_of_an_optional_code(MESA)
set_mesa_paths_instance(instance)
star = instance.particles.add_particle(
Particle(mass=3 | units.MSun))
star.evolve_for(330 | units.Myr)
for i in range(10):
star.evolve_for(10 | units.Myr)
index = numpy.searchsorted(
star.get_chemical_abundance_profiles(number_of_species=1)[0],
1.0e-4
)
h_poor_mass = EnclosedMassInterpolator(
radii=star.get_radius_profile(),
densities=star.get_density_profile()
).enclosed_mass[index].as_quantity_in(units.MSun)
print(h_poor_mass, star.core_mass)
self.assertAlmostEqual(star.core_mass, h_poor_mass, 2)
instance.stop()
def test19b(self):
print("Testing MESA core mass (short version of slowtest19a)")
instance = self.new_instance_of_an_optional_code(MESA)
set_mesa_paths_instance(instance)
star = instance.particles.add_particle(Particle(mass=3 | units.MSun))
star.evolve_one_step()
index = numpy.searchsorted(
star.get_chemical_abundance_profiles(
number_of_species=1)[0], 1.0e-4
)
h_poor_mass = EnclosedMassInterpolator(
radii=star.get_radius_profile(),
densities=star.get_density_profile()
).enclosed_mass[index].as_quantity_in(units.MSun)
self.assertAlmostEqual(star.core_mass, h_poor_mass, 2)
instance.stop()
def test20(self):
# FIXME seems to fail on yr/julianyr error
print("Testing MESA pre-main-sequence star")
instance = self.new_instance_of_an_optional_code(MESA)
set_mesa_paths_instance(instance)
star = instance.pre_ms_stars.add_particle(
Particle(mass=1.0 | units.MSun))
self.assertAlmostEqual(
star.time_step.in_(units.julianyr), 1.0e-5 | units.julianyr)
star.evolve_one_step()
self.assertAlmostEqual(
star.age.in_(units.julianyr), 1.0e-5 | units.julianyr)
instance.evolve_model(1.0 | units.julianyr)
self.assertEqual(star.stellar_type, 17 | units.stellar_type)
self.assertEqual(str(star.stellar_type), "Pre-main-sequence Star")
self.assertTrue(star.age >= 1.0 | units.julianyr)
# 4408.57819467 K
self.assertTrue(star.temperature < 4500 | units.K)
# 1.33431386707 LSun
# FIXME self.assertTrue(star.luminosity > 10 | units.LSun)
# 1.98009060937 RSun
# FIXME self.assertTrue(star.radius > 2 | units.RSun)
instance.stop()
def slowtest21(self):
print("Testing MESA calculate_core_mass")
instance = self.new_instance_of_an_optional_code(MESA)
set_mesa_paths_instance(instance)
star = instance.particles.add_particle(Particle(mass=40 | units.MSun))
instance.evolve_model(4.56 | units.Myr)
total_core_mass = star.calculate_core_mass()
self.assertAlmostRelativeEqual(star.core_mass, total_core_mass, 2)
self.assertTrue(
star.calculate_core_mass(core_H_abundance_limit=1.0e-2)
> total_core_mass
)
self.assertEqual(
star.calculate_core_mass(core_H_abundance_limit=1.0e-4),
total_core_mass)
self.assertTrue(
star.calculate_core_mass(core_H_abundance_limit=1.0e-6)
< total_core_mass)
self.assertAlmostRelativeEqual(
star.calculate_core_mass(core_H_abundance_limit=0.8), star.mass, 2)
h1_core_mass = star.calculate_core_mass(species=["h1"])
he3_core_mass = star.calculate_core_mass(species=["he3"])
he4_core_mass = star.calculate_core_mass(species=["he4"])
c12_core_mass = star.calculate_core_mass(species=["c12"])
n14_core_mass = star.calculate_core_mass(species=["n14"])
o16_core_mass = star.calculate_core_mass(species=["o16"])
ne20_core_mass = star.calculate_core_mass(species=["ne20"])
mg24_core_mass = star.calculate_core_mass(species=["mg24"])
metal_core_mass = star.calculate_core_mass(
species=["c12", "n14", "o16", "ne20", "mg24"])
print(
h1_core_mass, he3_core_mass, he4_core_mass, c12_core_mass,
n14_core_mass, o16_core_mass
)
print(ne20_core_mass, mg24_core_mass, metal_core_mass)
self.assertAlmostRelativeEqual(star.core_mass, total_core_mass, 2)
instance.stop()
self.assertAlmostRelativeEqual(total_core_mass, he4_core_mass, 1)
self.assertAlmostRelativeEqual(
total_core_mass, he4_core_mass + metal_core_mass, 4)
self.assertAlmostRelativeEqual(
total_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
), 7)
self.assertAlmostEqual(he3_core_mass, 0 | units.MSun)
def test22(self):
print("Testing MESA calculate_core_mass (short version of slowtest21)")
instance = self.new_instance_of_an_optional_code(MESA)
set_mesa_paths_instance(instance)
star = instance.particles.add_particle(Particle(mass=1 | units.MSun))
instance.evolve_model(0.2 | units.Gyr) # VERY short, for test speed up
central_hydrogen_abundance = star.get_chemical_abundance_profiles(
)[0][0]
print(central_hydrogen_abundance)
self.assertTrue(
central_hydrogen_abundance < 0.69) # some hydrogen is burned
self.assertTrue(
central_hydrogen_abundance > 0.68) # ... but not that much yet
self.assertEqual(
star.calculate_core_mass(core_H_abundance_limit=0.67),
0 | units.MSun)
# FIXME the test below should give a "core mass" nearly equal to the
# stellar mass, but it is a bit too small, maybe missing one layer/zone?
# self.assertAlmostEqual(
# star.calculate_core_mass(core_H_abundance_limit=0.7),
# 1 | units.MSun,
# 3
# )
# For test speed up, we use a weird core_H_abundance_limit to define
# the "hydrogen exhausted core"
# FIXME updated values in the rest of the test
limit = 0.69
expected_core_mass = 0.0288211177139 | units.MSun
self.assertAlmostEqual(
star.calculate_core_mass(core_H_abundance_limit=limit),
expected_core_mass, 3)
h1_core_mass = star.calculate_core_mass(
species=["h1"], core_H_abundance_limit=limit)
he3_core_mass = star.calculate_core_mass(
species=["he3"], 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)
metal_core_mass = star.calculate_core_mass(
species=["c12", "n14", "o16", "ne20", "mg24"],
core_H_abundance_limit=limit)
instance.stop()
self.assertAlmostRelativeEqual(
h1_core_mass, expected_core_mass*0.685, 2)
self.assertAlmostRelativeEqual(
he4_core_mass, expected_core_mass*0.29, 2)
self.assertAlmostRelativeEqual(
metal_core_mass, expected_core_mass*0.02, 1)
self.assertAlmostRelativeEqual(
expected_core_mass,
he4_core_mass + he3_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
), 7)
self.assertAlmostEqual(he3_core_mass, 5.91e-6 | units.MSun, 5)
def test23(self):
print("Testing MESA central_temperature and central_density")
instance = self.new_instance_of_an_optional_code(MESA)
set_mesa_paths_instance(instance)
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()
def test24(self):
print("Testing MESA calculate_helium_exhausted_core_mass")
instance = self.new_instance_of_an_optional_code(MESA)
set_mesa_paths_instance(instance)
star = instance.particles.add_particle(Particle(mass=2 | units.MSun))
composition = star.get_chemical_abundance_profiles()
# Mimic hydrogen exhausted core:
composition[2, :100] = composition[2, :100] + composition[0, :100]
composition[0, :100] = 0
# Mimic helium exhausted core:
carbon_oxygen = composition[:6, :50].sum(axis=0)
composition[3, :50] = carbon_oxygen * 0.6
composition[5, :50] = carbon_oxygen * 0.4
composition[1:3, :50] = 0
composition[4, :50] = 0
star.set_chemical_abundance_profiles(composition)
self.assertAlmostRelativeEqual(
star.calculate_core_mass(),
star.mass * star.get_cumulative_mass_profile()[100], 1)
self.assertAlmostRelativeEqual(
star.calculate_helium_exhausted_core_mass(),
star.mass * star.get_cumulative_mass_profile()[50], 1)
core_mass = star.calculate_helium_exhausted_core_mass(
split_species=False)
core_mass_by_species = star.calculate_helium_exhausted_core_mass(
split_species=True)
carbon_mass_in_core, oxygen_mass_in_core = \
star.calculate_helium_exhausted_core_mass(
split_species=True, species=["c12", "o16"])
self.assertEqual(
len(core_mass_by_species), len(star.get_names_of_species())
)
instance.stop()
self.assertAlmostRelativeEqual(core_mass, core_mass_by_species.sum())
self.assertEqual(core_mass_by_species[0:3].sum(), 0 | units.MSun)
self.assertEqual(core_mass_by_species[4], 0 | units.MSun)
self.assertEqual(core_mass_by_species[3], carbon_mass_in_core)
self.assertEqual(core_mass_by_species[5], oxygen_mass_in_core)
def test25(self):
print("Testing MESA accretion")
instance = self.new_instance_of_an_optional_code(MESA)
set_mesa_paths_instance(instance)
star = instance.particles.add_particle(Particle(mass=2 | units.MSun))
self.assertEqual(star.get_accrete_same_as_surface(), True)
star.set_accrete_same_as_surface(False)
self.assertEqual(star.get_accrete_same_as_surface(), False)
self.assertEqual(
star.get_accrete_composition_non_metals(), {'h1': 0.0, 'h2': 0.0, 'he3': 0.0, 'he4': 0.0}
)
self.assertEqual(star.get_accrete_composition_metals_identifier(), -1)
self.assertEqual(star.get_accrete_composition_metals(), {'li': 0.0,
'be': 0.0,
'b': 0.0,
'c': 0.0,
'n': 0.0,
'o': 0.0,
'f': 0.0,
'ne': 0.0,
'na': 0.0,
'mg': 0.0,
'al': 0.0,
'si': 0.0,
'p': 0.0,
's': 0.0,
'cl': 0.0,
'ar': 0.0,
'k': 0.0,
'ca': 0.0,
'sc': 0.0,
'ti': 0.0,
'v': 0.0,
'cr': 0.0,
'mn': 0.0,
'fe': 0.0,
'co': 0.0,
'ni': 0.0,
'cu': 0.0,
'zn': 0.0})
print("Accreting 75% deuterium", end=' ')
print("and 25% iron")
star.set_accrete_composition_non_metals(h2=0.75)
star.set_accrete_composition_metals_identifier(0) # i.e. specified below:
star.set_accrete_composition_metals(fe=1.0) # These must add to 1.0
self.assertEqual(
star.get_accrete_composition_non_metals()['h2'], 0.75)
self.assertEqual(star.get_accrete_composition_metals_identifier(), 0)
self.assertEqual(
star.get_accrete_composition_metals()['fe'], 1.0) # Metals must now sum to 1.0
# Z is set by the 1 - sum(non_metals)
star.mass_change = 1.0e-8 | units.MSun / units.yr
star.time_step = 0.1 | units.yr
instance.evolve_model(1 | units.yr)
composition = star.get_chemical_abundance_profiles()
species = star.get_names_of_species()
print("Both deuterium and iron are not in the current net,")
print(
f"so have been added to {species[0]} and {species[-1]}"
)
self.assertAlmostEqual(composition[:, -1], [0.75, 0, 0, 0, 0, 0, 0, 0.25])
instance.stop()
| 57,659
| 40.782609
| 101
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_phigrape.py
|
import os
import sys
import time
from amuse.community.phigrape.interface import PhiGRAPEInterface, PhiGRAPE
from amuse.test.amusetest import TestWithMPI
import numpy
from amuse.units import nbody_system
from amuse.units import units
from amuse import datamodel
from amuse.ic.plummer import new_plummer_model
try:
import matplotlib
matplotlib.use("Agg")
from matplotlib import pyplot
HAS_MATPLOTLIB = True
except ImportError:
HAS_MATPLOTLIB = False
default_test_options = dict()
# ~default_test_options = dict(mode='gpu')
class TestMPIInterface(TestWithMPI):
def test0(self):
instance = PhiGRAPEInterface(**default_test_options)
self.assertTrue("Harfst, S., Gualandris, A., Merritt, D., Spurzem, R., Portegies Zwart, S., & Berczik, P."
in instance.all_literature_references_string())
instance.stop()
def test1(self):
instance = PhiGRAPEInterface(**default_test_options)
instance.initialize_code()
instance.new_particle(11.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0)
retrieved_state = instance.get_state(1)
self.assertEqual(11.0, retrieved_state['mass'])
self.assertEqual(2.0, retrieved_state['radius'])
self.assertEqual(instance.get_number_of_particles()['number_of_particles'], 1)
instance.cleanup_code()
instance.stop()
def test2(self):
instance = PhiGRAPEInterface(**default_test_options)
for x in [0.101, 4.0]:
error = instance.set_eps2(x)
self.assertEqual(error, 0)
value, error = instance.get_eps2()
self.assertEqual(error, 0)
self.assertEqual(x, value)
instance.cleanup_code()
instance.stop()
def test3(self):
instance = PhiGRAPEInterface(**default_test_options)
instance.initialize_code()
instance.new_particle([11.0, 12.0, 13.0, 14.0], [2.1, 3.1, 4.1, 5.1], [2.2, 3.2, 4.2, 5.2], [2.3, 3.3, 4.3, 5.3], [2.4, 3.4, 4.4, 5.4], [2.5, 3.5, 4.5, 5.5], [2.6, 3.6, 4.6, 5.6], [2.0, 3.0, 4.0, 5.0])
retrieved_state = instance.get_state(1)
self.assertEqual(11.0, retrieved_state['mass'])
retrieved_state = instance.get_state([2, 3, 4])
self.assertEqual(12.0, retrieved_state['mass'][0])
self.assertEqual(instance.get_number_of_particles()['number_of_particles'], 4)
instance.cleanup_code()
instance.stop()
def test5(self):
instance = PhiGRAPEInterface(**default_test_options)
instance.initialize_code()
n = 4000
ids = [i for i in range(1, n)]
values = [1.0 * i for i in range(1, n)]
instance.new_particle(
values, values, values, values, values, values, values)
retrieved_state = instance.get_state(3999)
self.assertEqual(3999.0, retrieved_state['mass'])
instance.cleanup_code()
instance.stop()
def test6(self):
instance = PhiGRAPEInterface(**default_test_options)
instance.initialize_code()
n = 4000
ids = [i for i in range(1, n)]
values = [1.0 * i for i in range(1, n)]
for i in range(n-1):
instance.new_particle(
values[i], values[i], values[i], values[i], values[i], values[i], values[i])
retrieved_state = instance.get_state(1)
self.assertEqual(1.0, retrieved_state['mass'])
instance.cleanup_code()
instance.stop()
def test7(self):
instance = PhiGRAPEInterface(**default_test_options) # (debugger="xterm")
instance.initialize_code()
instance.set_eps2(0.0**2)
instance.set_eta(0.01, 0.02)
instance.commit_parameters()
instance.new_particle(
[1.0, 1.0, 1.0],
[1.0, 0.0, -1.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0])
instance.recommit_particles()
Ep = instance.get_potential_energy()['potential_energy']
Ek = instance.get_kinetic_energy()['kinetic_energy']
self.assertEqual(Ek, 0.5)
self.assertEqual(Ep, -2.5)
instance.delete_particle(2)
instance.recommit_particles()
n = instance.get_number_of_particles()['number_of_particles']
Ep = instance.get_potential_energy()['potential_energy']
Ek = instance.get_kinetic_energy()['kinetic_energy']
self.assertEqual(n, 2)
self.assertEqual(Ek, 0.)
self.assertEqual(Ep, -0.5)
instance.cleanup_code()
instance.stop()
def xtest8(self):
instance = PhiGRAPEInterface(**default_test_options)
instance.initialize_code()
instance.set_eps2(0.0**2)
instance.set_eta(0.01, 0.02)
instance.new_particle(
[0.01, 0.01],
[10., -10.],
[0.0, 0.0],
[0.0, 0.0],
[-5.0, 5.0],
[0.0, 0.0],
[0.0, 0.0],
[0.1, 0.1])
instance.commit_particles()
# HAS NO RESULT...
result = instance.evolve_model(3.14159)
tnow = instance.get_time()['time']
print("after evolve(pi), tnow = %f" % (tnow))
# self.assertEqual( id1, 1)
"""
instance.evolve(instance.get_time(),1)
id2=instance.find_colliding_secondary(id1)
self.assertEqual( id2, 2)
self.assertAlmostEqual( tnow, 2.,2)
state1 = instance.get_state(id1)
state2 = instance.get_state(id2)
self.assertTrue( abs(state1['x'] - state2['x'])<0.2)
"""
instance.cleanup_code()
instance.stop()
def test8(self):
instance = PhiGRAPEInterface(**default_test_options)
instance.initialize_code()
instance.set_eps2(0.1**2)
instance.commit_parameters()
id1, errorcode = instance.new_particle(mass=10.0, radius=1.0,
x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
id2, errorcode = instance.new_particle(mass=10.0, radius=1.0,
x=2.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
instance.commit_particles()
potential, errorcode = instance.get_potential(id1)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -10.0 / numpy.sqrt(2.0**2 + 0.1**2), 6)
total_potential, errorcode = instance.get_potential_energy()
self.assertEqual(errorcode, 0)
potentials, errorcode = instance.get_potential([id1, id2])
instance.cleanup_code()
instance.stop()
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(total_potential, numpy.sum(potentials * [10.0, 10.0]) / 2.0)
def test9(self):
instance = PhiGRAPEInterface(**default_test_options)
instance.initialize_code()
instance.set_eps2(0)
instance.commit_parameters()
id1, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
id2, errorcode = instance.new_particle(mass=1.0, radius=1.0, x=2.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
instance.commit_particles()
potential, errorcode = instance.get_potential(id1)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -1.0 / numpy.sqrt(2.0**2), 8)
total_potential, errorcode = instance.get_potential_energy()
potentials, errorcode = instance.get_potential([id1, id2])
instance.cleanup_code()
instance.stop()
self.assertAlmostRelativeEquals(total_potential, numpy.sum(potentials * [10.0, 1.0]) / 2.0)
class TestPhigrape(TestWithMPI):
def new_system_of_sun_and_earth(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
return stars
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = PhiGRAPE(convert_nbody, **default_test_options) # , debugger="xterm")
instance.initialize_code()
instance.parameters.set_defaults()
instance.parameters.initial_timestep_parameter = 0.001
instance.parameters.timestep_parameter = 0.001
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
instance.commit_particles()
position_at_start = earth.position.value_in(units.AU)[0]
instance.evolve_model(365 | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(position_at_start, position_after_full_rotation, 2)
instance.evolve_model(365.0 + (365.0 / 2) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 2)
instance.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 3)
instance.cleanup_code()
instance.stop()
def test2(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = PhiGRAPE(convert_nbody, **default_test_options)
instance.initialize_code()
instance.parameters.set_defaults()
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
instance.commit_particles()
for x in range(1, 365, 30):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
if HAS_MATPLOTLIB:
figure = pyplot.figure()
plot = figure.add_subplot(1, 1, 1)
x_points = earth.get_timeline_of_attribute("x")
y_points = earth.get_timeline_of_attribute("y")
x_points_in_AU = [t_x[1].value_in(units.AU) for t_x in x_points]
y_points_in_AU = [t_x1[1].value_in(units.AU) for t_x1 in y_points]
plot.scatter(x_points_in_AU, y_points_in_AU, color="b", marker='o')
plot.set_xlim(-1.5, 1.5)
plot.set_ylim(-1.5, 1.5)
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "phiGRAPE-earth-sun2.svg")
figure.savefig(output_file)
instance.cleanup_code()
instance.stop()
def test4(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = PhiGRAPE(convert_nbody, **default_test_options)
instance.initialize_code()
instance.parameters.set_defaults()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
instance.particles.mass = [17.0, 33.0] | units.kg
self.assertEqual(instance.get_mass(1), 17.0 | units.kg)
self.assertEqual(instance.get_mass(2), 33.0 | units.kg)
instance.stop()
def test5(self):
instance = PhiGRAPE(**default_test_options)
instance.initialize_code()
instance.parameters.set_defaults()
particles = datamodel.Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
instance.commit_particles()
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, 1.0 | nbody_system.length, zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration, 3)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fx0, -1.0 * fx1, 5)
fx = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0, 2)
self.assertAlmostEqual(potential0, potential1, 5)
instance.stop()
def test6(self):
instance = PhiGRAPE(**default_test_options)
instance.initialize_code()
instance.parameters.set_defaults()
particles = datamodel.Particles(6)
particles.mass = nbody_system.mass.new_quantity(range(1, 7))
particles.radius = 0.00001 | nbody_system.length
particles.position = [[-1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, -1.0], [0.0, 0.0, 1.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
instance.commit_particles()
copyof = instance.particles.copy()
self.assertEqual(2 | nbody_system.mass, copyof[1].mass)
instance.stop()
def test7(self):
instance = PhiGRAPE(**default_test_options)
instance.initialize_code()
instance.parameters.set_defaults()
particles = datamodel.Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
instance.commit_particles()
zero = [0.0, 0.0, 0.0] | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, [0.5, 1.0, 1.5] | nbody_system.length, zero, zero)
self.assertAlmostRelativeEqual(fx[0], -3.55555555556 | nbody_system.acceleration, 5)
self.assertAlmostRelativeEqual(fy[0], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostRelativeEqual(fz[0], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostRelativeEqual(fx[1], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostRelativeEqual(fy[1], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostRelativeEqual(fz[1], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostRelativeEqual(fx[2], 3.55555555556 | nbody_system.acceleration, 5)
self.assertAlmostRelativeEqual(fy[2], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostRelativeEqual(fz[2], 0.0 | nbody_system.acceleration, 3)
n = 512
x = nbody_system.length.new_quantity(numpy.linspace(0.1, 1.9, n))
zero = nbody_system.length.new_quantity(numpy.zeros(n))
fx, fy, fz = instance.get_gravity_at_point(zero, x, zero, zero)
for i in range(n//2):
self.assertAlmostRelativeEqual(fx[i], - fx[n - 1 - i], 5)
instance.stop()
def test8(self):
particles = datamodel.Particles(6)
particles.mass = nbody_system.mass.new_quantity(range(1, 7))
particles.radius = 0.00001 | nbody_system.length
particles.position = [[-1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, -1.0], [0.0, 0.0, 1.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
for current_mode in ['g6lib', 'gpu', 'grape']:
try:
instance = PhiGRAPE(mode=current_mode)
except:
print("Running PhiGRAPE with mode=" + current_mode, "was unsuccessful.")
else:
print("Running PhiGRAPE with mode=" + current_mode + "...", end=' ')
instance.initialize_code()
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.1 | nbody_system.time)
instance.cleanup_code()
instance.stop()
print("ok")
def test9(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = PhiGRAPE(convert_nbody, **default_test_options) # , debugger="xterm")
instance.initialize_code()
instance.parameters.set_defaults()
instance.parameters.initialize_gpu_once = 1
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
instance.commit_particles()
instance.evolve_model(365 | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_at_start = earth.position.value_in(units.AU)[0]
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(position_at_start, position_after_full_rotation, 6)
instance.evolve_model(365.0 + (365.0 / 2) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 2)
instance.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[1]
# self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 3)
instance.cleanup_code()
instance.stop()
def test10(self):
instance = PhiGRAPE(**default_test_options)
instance.initialize_code()
instance.parameters.set_defaults()
stars = new_plummer_model(100)
stars.radius = 0 | nbody_system.length
instance.particles.add_particles(stars)
channel = stars.new_channel_to(instance.particles)
instance.evolve_model(0.001 | nbody_system.time)
e0 = instance.kinetic_energy + instance.potential_energy
stars.mass *= 0.9
channel.copy()
instance.synchronize_model()
e1 = instance.kinetic_energy + instance.potential_energy
delta_e = e1 - e0
self.assertTrue(e1 != e0)
instance.stop()
def test11(self):
print("Testing PhiGRAPE collision_detection")
particles = datamodel.Particles(7)
particles.mass = 0.001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = PhiGRAPE(redirection='none', **default_test_options)
instance.initialize_code()
instance.parameters.set_defaults()
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 3)
self.assertEqual(len(collisions.particles(1)), 3)
self.assertEqual(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = datamodel.Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print(instance.model_time)
print(instance.particles)
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print()
print(instance.model_time)
print(instance.particles)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test13(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
instance = PhiGRAPE(**default_test_options)
instance.initialize_code()
instance.parameters.stopping_conditions_number_of_steps = 2
self.assertEqual(instance.parameters.stopping_conditions_number_of_steps, 2)
instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2
instance.particles.add_particles(particles)
instance.stopping_conditions.number_of_steps_detection.enable()
instance.evolve_model(10 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
self.assertTrue(instance.model_time < 10 | nbody_system.time)
instance.stop()
def test14(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
very_short_time_to_evolve = 1 | units.s
very_long_time_to_evolve = 1e9 | nbody_system.time
instance = PhiGRAPE(**default_test_options)
instance.initialize_code()
instance.parameters.stopping_conditions_timeout = very_short_time_to_evolve
self.assertEqual(instance.parameters.stopping_conditions_timeout, very_short_time_to_evolve)
instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2
instance.particles.add_particles(particles)
instance.stopping_conditions.timeout_detection.enable()
start = time.time()
instance.evolve_model(very_long_time_to_evolve)
end = time.time()
self.assertTrue(instance.stopping_conditions.timeout_detection.is_set())
self.assertTrue((end-start) < very_short_time_to_evolve.value_in(units.s) + 2) # 2 = some overhead compensation
instance.stop()
def test15(self):
instance = PhiGRAPE(number_of_workers=2, **default_test_options) # , redirection = "none")
instance.initialize_code()
instance.parameters.set_defaults()
print(1)
particles = datamodel.Particles(2)
particles.x = [-1.0, 1.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.01 | nbody_system.time)
instance.particles.copy_values_of_all_attributes_to(particles)
print(instance.particles.position.x)
self.assertEqual(instance.particles[0].position.x, -instance.particles[1].position.x)
self.assertAlmostRelativeEquals(instance.particles[1].position.x, 0.999969482111 | nbody_system.length, 6)
instance.evolve_model(0.10 | nbody_system.time)
instance.particles.copy_values_of_all_attributes_to(particles)
print(instance.particles.position.x)
self.assertEqual(instance.particles[0].position.x, -instance.particles[1].position.x)
self.assertAlmostRelativeEquals(instance.particles[1].position.x, 0.99804560161 | nbody_system.length, 6)
instance.evolve_model(0.50 | nbody_system.time)
instance.particles.copy_values_of_all_attributes_to(particles)
print(instance.particles.position.x)
self.assertEqual(instance.particles[0].position.x, -instance.particles[1].position.x)
self.assertAlmostRelativeEquals(instance.particles[1].position.x, 0.968416814302 | nbody_system.length, 6)
instance.cleanup_code()
instance.stop()
def test16(self):
instance = PhiGRAPE(number_of_workers=2, **default_test_options)
instance.initialize_code()
instance.parameters.set_defaults()
print(1)
particles = datamodel.Particles(2)
particles.x = [-1.0, 1.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = [1.0, 0.5] | nbody_system.mass
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.01 | nbody_system.time)
instance.particles.copy_values_of_all_attributes_to(particles)
print(instance.particles.position.x)
self.assertAlmostRelativeEquals(instance.particles[0].position.x, -0.999984741095 | nbody_system.length, 8)
self.assertAlmostRelativeEquals(instance.particles[1].position.x, 0.999969482189 | nbody_system.length, 8)
instance.evolve_model(0.10 | nbody_system.time)
instance.particles.copy_values_of_all_attributes_to(particles)
print(instance.particles.position.x)
self.assertAlmostRelativeEquals(instance.particles[0].position.x, -0.999022960148 | nbody_system.length, 8)
self.assertAlmostRelativeEquals(instance.particles[1].position.x, 0.998045920305 | nbody_system.length, 8)
instance.evolve_model(0.50 | nbody_system.time)
instance.particles.copy_values_of_all_attributes_to(particles)
print(instance.particles.position.x)
self.assertAlmostRelativeEquals(instance.particles[0].position.x, -0.984250788742 | nbody_system.length, 8)
self.assertAlmostRelativeEquals(instance.particles[1].position.x, 0.968501583383 | nbody_system.length, 8)
instance.cleanup_code()
instance.stop()
def test17(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = PhiGRAPE(convert_nbody, **default_test_options)
instance.initialize_code()
instance.parameters.set_defaults()
instance.parameters.initial_timestep_parameter = 0.001
instance.parameters.timestep_parameter = 0.001
instance.parameters.epsilon_squared = 0.0 | units.AU**2
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
instance.commit_particles()
position_at_start = earth.position.value_in(units.AU)[0]
print(instance.particles[0].position.as_quantity_in(units.AU))
print(instance.particles[1].position.as_quantity_in(units.AU))
instance.evolve_model(365 | units.day)
print(instance.particles[0].position.as_quantity_in(units.AU))
print(instance.particles[1].position.as_quantity_in(units.AU))
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(position_at_start, position_after_full_rotation, 3)
print(instance.particles[0].position.as_quantity_in(units.AU))
instance.evolve_model(365.0 + (365.0 / 2) | units.day)
print(instance.particles[0].position.as_quantity_in(units.AU))
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 2)
instance.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[1]
# self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 3)
instance.cleanup_code()
instance.stop()
def test18(self):
print("Testing PhiGRAPE delete_particle")
number_of_particles = 15
delete_order = [6, 9, 3, 1, 0, 2, 5]
number_of_initial_deletes = 3
particles = datamodel.Particles(number_of_particles)
particles.mass = range(1, number_of_particles + 1) | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = range(number_of_particles) | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.vx = range(number_of_particles) | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
instance = PhiGRAPE(**default_test_options)
instance.initialize_code()
instance.parameters.set_defaults()
initial_number_of_particles = number_of_particles - len(delete_order) + number_of_initial_deletes
instance.particles.add_particles(particles[:initial_number_of_particles])
index_new_particle = initial_number_of_particles
self.assertEqual(len(instance.particles), initial_number_of_particles)
instance.evolve_model(0.01 | nbody_system.time)
instance.particles.remove_particles(particles[delete_order[:number_of_initial_deletes]])
number_of_deletes = number_of_initial_deletes
self.assertEqual(len(instance.particles), initial_number_of_particles - number_of_deletes)
for i, particle_index in enumerate(delete_order[number_of_initial_deletes:]):
instance.evolve_model((i+1) / 10.0 | nbody_system.time)
instance.particles.remove_particle(particles[particle_index])
number_of_deletes += 1
instance.particles.add_particle(particles[index_new_particle])
index_new_particle += 1
self.assertEqual(len(instance.particles), initial_number_of_particles - number_of_deletes + i + 1)
self.assertAlmostEqual(particles[:index_new_particle].total_mass() - instance.particles.total_mass(),
(delete_order[:number_of_deletes] | nbody_system.mass).sum() + (number_of_deletes | nbody_system.mass))
instance.stop()
def test19(self):
converter = nbody_system.nbody_to_si(1 | units.MSun, 1 | units.parsec)
particles = datamodel.Particles(2)
particles.mass = 100 | units.MSun
particles.radius = 200 | units.RSun
particles[0].position = [0, 0, 0] | units.parsec
particles[1].position = [1, 0, 0] | units.parsec
particles.velocity = [0, 0, 0] | units.km / units.s
code = PhiGRAPE(
converter,
PhiGRAPEInterface.MODE_G6LIB,
number_of_workers=2
)
code.initialize_code()
stop_cond = code.stopping_conditions.collision_detection
stop_cond.enable()
code.particles.add_particles(particles)
code.evolve_model(0.08 | nbody_system.time)
self.assertTrue(stop_cond.is_set())
| 34,411
| 41.483951
| 209
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_smalln.py
|
from amuse.test.amusetest import TestWithMPI
import os
import sys
import numpy
import math
from amuse.community.smalln.interface import SmallNInterface, SmallN
from amuse.units import nbody_system
from amuse.units import units
from amuse import datamodel
from amuse import io
from amuse.datamodel import trees
from amuse.ic import plummer
try:
from matplotlib import pyplot
HAS_MATPLOTLIB = True
except ImportError:
HAS_MATPLOTLIB = False
class TestSmallNInterface(TestWithMPI):
def test0(self):
instance = SmallNInterface()
instance.stop()
def test1(self):
instance = SmallNInterface()
instance.initialize_code()
res1 = instance.new_particle(mass=11.0, radius=2.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
res2 = instance.new_particle(mass=21.0, radius=5.0, x=10.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
self.assertEqual(1, res1['index_of_the_particle'])
self.assertEqual(2, res2['index_of_the_particle'])
retrieved_state1 = instance.get_state(1)
retrieved_state2 = instance.get_state(2)
self.assertEqual(11.0, retrieved_state1['mass'])
self.assertEqual(21.0, retrieved_state2['mass'])
self.assertEqual(0.0, retrieved_state1['x'])
self.assertEqual(10.0, retrieved_state2['x'])
self.assertEqual(2.0, retrieved_state1['radius'])
self.assertEqual(5.0, retrieved_state2['radius'])
instance.cleanup_code()
instance.stop()
def test2(self):
instance = SmallNInterface()
instance.initialize_code()
self.skip("index of the next particle not implemented correctly yet")
for i in [0, 1, 2]:
temp_particle = instance.new_particle(mass=i, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
self.assertEqual(i+1, temp_particle['index_of_the_particle'])
instance.delete_particle(2)
self.assertEqual(2, instance.get_number_of_particles()['number_of_particles'])
self.assertEqual(1, instance.get_index_of_first_particle()['index_of_the_particle'])
self.assertEqual(2, instance.get_index_of_next_particle(1)['index_of_the_next_particle'])
self.assertEqual(0, instance.get_index_of_next_particle(1)['__result'])
self.assertEqual(-1, instance.get_index_of_next_particle(3)['__result'])
self.assertEqual(1, instance.get_index_of_next_particle(2)['__result'])
instance.cleanup_code()
instance.stop()
def test5(self):
smalln = SmallNInterface()
smalln.initialize_code()
smalln.new_particle([10, 20], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1])
retrieved_state = smalln.get_state(1)
self.assertEqual(10.0, retrieved_state['mass'])
self.assertEqual(1, retrieved_state['radius'])
retrieved_state = smalln.get_state([1, 2])
self.assertEqual(20.0, retrieved_state['mass'][1])
self.assertEqual(smalln.get_number_of_particles()['number_of_particles'], 2)
smalln.cleanup_code()
smalln.stop()
def test6(self):
smalln = SmallNInterface()
smalln.initialize_code()
smalln.new_particle([10, 10], [-1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1])
retrieved_state = smalln.get_state(1)
self.assertFalse(hasattr(smalln, 'get_potential_at_point'))
# retr = smalln.get_potential_at_point(0.01, 0, 0, 0)
# self.assertEqual(retr['__result'], -1)
smalln.cleanup_code()
smalln.stop()
def xtest7(self):
instance = SmallNInterface()
instance.initialize_code()
instance.set_eps2(0.1 * 0.1)
instance.commit_parameters()
id1, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
id2, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=2.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
instance.commit_particles()
potential, errorcode = instance.get_potential(id1)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -10.0 / numpy.sqrt(2.0**2 + 0.1**2), 8)
potential, errorcode = instance.get_potential(id2)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -10.0 / numpy.sqrt(2.0**2 + 0.1**2), 8)
total_potential, errorcode = instance.get_potential_energy()
potentials, errorcode = instance.get_potential([id1, id2])
instance.cleanup_code()
instance.stop()
self.assertAlmostRelativeEquals(total_potential, numpy.sum(potentials * [10.0, 10.0]) / 2.0)
def xtest8(self):
instance = SmallNInterface()
instance.initialize_code()
instance.commit_parameters()
id1, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
id2, errorcode = instance.new_particle(mass=1.0, radius=1.0, x=2.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
instance.commit_particles()
potential, errorcode = instance.get_potential(id1)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -1.0 / numpy.sqrt(2.0**2), 8)
total_potential, errorcode = instance.get_potential_energy()
potentials, errorcode = instance.get_potential([id1, id2])
instance.cleanup_code()
instance.stop()
self.assertAlmostRelativeEquals(total_potential, numpy.sum(potentials * [10.0, 1.0]) / 2.0)
def test9(self):
print("Test SmallNInterface evolve_model")
instance = SmallNInterface()
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_eta(0.001))
self.assertEqual(0, instance.commit_parameters())
# Set up an equal-mass binary on a circular orbit:
self.assertEqual([1, 0], list(instance.new_particle(0.5, 0.5, 0, 0, 0, 0.5, 0, 0.01).values()))
self.assertEqual([2, 0], list(instance.new_particle(0.5, -0.5, 0, 0, 0, -0.5, 0, 0.01).values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(math.pi))
for result, expected in zip(instance.get_position(1).values(), [-0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
for result, expected in zip(instance.get_position(2).values(), [0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
self.assertEqual(0, instance.evolve_model(2 * math.pi))
# print instance.get_time()
# print instance.get_position(1), instance.get_velocity(1)
# print instance.get_position(2)
# for result, expected in zip(instance.get_position(1).values(), [0.5, 0.0, 0.0, 0]):
# self.assertAlmostEquals(result, expected, 3)
# for result, expected in zip(instance.get_position(2).values(), [-0.5, 0.0, 0.0, 0]):
# self.assertAlmostEquals(result, expected, 3)
self.assertEqual(0, instance.cleanup_code())
instance.cleanup_code()
instance.stop()
class TestSmallN(TestWithMPI):
def new_system_of_sun_and_earth(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
return stars
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
smalln = SmallN(convert_nbody)
smalln.initialize_code()
smalln.dt_dia = 5000
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
smalln.particles.add_particles(stars)
smalln.evolve_model(365.0 | units.day)
smalln.particles.copy_values_of_all_attributes_to(stars)
position_at_start = earth.position.value_in(units.AU)[0]
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(position_at_start, position_after_full_rotation, 6)
smalln.evolve_model(365.0 + (365.0 / 2) | units.day)
smalln.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 2)
smalln.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
smalln.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 3)
smalln.cleanup_code()
smalln.stop()
def test2(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = SmallN(convert_nbody)
instance.initialize_code()
instance.dt_dia = 5000
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
for x in range(1, 2000, 10):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
if HAS_MATPLOTLIB:
figure = pyplot.figure()
plot = figure.add_subplot(1, 1, 1)
x_points = earth.get_timeline_of_attribute("x")
y_points = earth.get_timeline_of_attribute("y")
x_points_in_AU = [t_x[1].value_in(units.AU) for t_x in x_points]
y_points_in_AU = [t_x1[1].value_in(units.AU) for t_x1 in y_points]
plot.scatter(x_points_in_AU, y_points_in_AU, color="b", marker='o')
plot.set_xlim(-1.5, 1.5)
plot.set_ylim(-1.5, 1.5)
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "smalln-earth-sun2.svg")
figure.savefig(output_file)
instance.cleanup_code()
instance.stop()
def test3(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = SmallN(convert_nbody)
instance.initialize_code()
instance.dt_dia = 5000
stars = datamodel.Stars(2)
star1 = stars[0]
star2 = stars[1]
star1.mass = units.MSun(1.0)
star1.position = units.AU(numpy.array((-1.0, 0.0, 0.0)))
star1.velocity = units.AUd(numpy.array((0.0, 0.0, 0.0)))
star1.radius = units.RSun(1.0)
star2.mass = units.MSun(1.0)
star2.position = units.AU(numpy.array((1.0, 0.0, 0.0)))
star2.velocity = units.AUd(numpy.array((0.0, 0.0, 0.0)))
star2.radius = units.RSun(100.0)
instance.particles.add_particles(stars)
for x in range(1, 2000, 10):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
instance.stop()
def test4(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = SmallN(convert_nbody)
instance.initialize_code()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
instance.particles.mass = [17.0, 33.0] | units.kg
self.assertEqual(instance.get_mass(1), 17.0 | units.kg)
self.assertEqual(instance.get_mass(2), 33.0 | units.kg)
instance.stop()
def test5(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = SmallN(convert_nbody)
instance.initialize_code()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
instance.set_state(1, 16 | units.kg,
20.0 | units.m, 40.0 | units.m, 60.0 | units.m,
1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms,
20.0 | units.m)
curr_state = instance.get_state(1)
for expected, actual in zip([16 | units.kg,
20.0 | units.m, 40.0 | units.m, 60.0 | units.m,
1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms,
20.0 | units.m], curr_state):
self.assertAlmostRelativeEquals(expected, actual)
instance.stop()
self.assertEqual(curr_state[0], 16 | units.kg, 8)
def test6(self):
print("Test6: Testing SmallN parameters")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.yr, 1.0 | units.AU)
instance = SmallN(convert_nbody)
instance.initialize_code()
value = instance.get_eta()
self.assertEqual(0.14, value)
self.assertAlmostEqual(0.14, instance.parameters.timestep_parameter)
for x in [0.001, 0.01, 0.1]:
instance.parameters.timestep_parameter = x
self.assertAlmostEqual(x, instance.parameters.timestep_parameter)
value = instance.get_time()
self.assertEqual(0 | units.yr, value)
value = instance.get_gamma()
self.assertEqual(1e-6, value)
self.assertAlmostEqual(1e-6, instance.parameters.unperturbed_threshold)
for x in [0.001, 0.01, 0.1]:
instance.parameters.unperturbed_threshold = x
self.assertAlmostEqual(x, instance.parameters.unperturbed_threshold)
instance.stop()
def test15(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0.0 | nbody_system.length
particles.z = 0.0 | nbody_system.length
particles.vx = 0.0 | nbody_system.speed
particles.vy = 0.0 | nbody_system.speed
particles.vz = 0.0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
instance = SmallN()
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(instance.particles[0].radius, 0.0 | nbody_system.length)
p = datamodel.Particle(
x=1.0 | nbody_system.length,
y=2.0 | nbody_system.length,
z=3.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=2.0 | nbody_system.speed,
vz=3.0 | nbody_system.speed,
mass=1.0 | nbody_system.mass,
radius=4.0 | nbody_system.length,
)
instance.particles.add_particle(p)
self.assertEqual(instance.particles[0].radius, 0.0 | nbody_system.length)
self.assertEqual(instance.particles[1].radius, 0.0 | nbody_system.length)
self.assertEqual(instance.particles[2].radius, 4.0 | nbody_system.length)
instance.stop()
def assertEarthAndMoonWasDetectedAsBinary(self, set, stars):
alltrees = trees.BinaryTreesOnAParticleSet(set, 'child1', 'child2')
roots = list(alltrees.iter_roots())
self.assertEqual(len(roots), 1)
root = roots[0].particle
earth_and_moon = None
if not root.child1.child1 is None:
earth_and_moon = root.child1
else:
earth_and_moon = root.child2
self.assertAlmostRelativeEquals(earth_and_moon.mass, stars[1].mass + stars[2].mass)
def test16(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
smalln = SmallN(convert_nbody)
smalln.initialize_code()
smalln.dt_dia = 5000
stars = self.new_system_of_sun_and_earth()
moon = datamodel.Particle()
moon.mass = units.kg(7.3477e22)
moon.radius = units.km(1737.10)
moon.position = units.km(numpy.array((149.5e6 + 384.399, 0.0, 0.0)))
moon.velocity = units.ms(numpy.array((0.0, 29800 + 1022, 0.0)))
stars.add_particle(moon)
earth = stars[1]
smalln.particles.add_particles(stars)
smalln.evolve_model(365.0 | units.day)
smalln.update_particle_tree()
smalln.update_particle_set()
self.assertEqual(len(smalln.particles), 5)
self.assertEarthAndMoonWasDetectedAsBinary(smalln.particles, stars)
inmemory = smalln.particles.copy()
self.assertEarthAndMoonWasDetectedAsBinary(inmemory, stars)
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "newsmalln-test16.hdf5")
if os.path.exists(output_file):
os.remove(output_file)
io.write_set_to_file(smalln.particles, output_file, "hdf5")
fromfile = io.read_set_from_file(output_file, "hdf5")
self.assertEarthAndMoonWasDetectedAsBinary(fromfile, stars)
smalln.stop()
def test17(self):
particles = datamodel.Particles(keys=[1, 2, 3, 4, 5, 6, 7])
particles.mass = 0.001 | nbody_system.mass
particles.radius = 0.1 | nbody_system.length
particles.x = [
-100.5, -99.5,
-0.5, 0.5,
99.5, 100.5,
120.0
] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [
[2, 0, 0], [-2, 0, 0],
[2, 0, 0], [-2, 0, 0],
[2, 0, 0], [-2, 0, 0],
[-4, 0, 0]
] | nbody_system.speed
instance = SmallN()
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 3)
self.assertEqual(len(collisions.particles(1)), 3)
self.assertEqual(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <=
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
instance.stop()
def test18(self):
particles = datamodel.Particles(keys=[1, 2])
particles.mass = 1 | nbody_system.mass
particles.radius = 0.1 | nbody_system.length
particles.x = [1, -1] | nbody_system.length
particles.y = [1, -1] | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[-1, 0, 0], [1, 0, 0]] | nbody_system.speed
instance = SmallN()
instance.particles.add_particles(particles)
stopping_condition = instance.stopping_conditions.interaction_over_detection
stopping_condition.enable()
instance.evolve_model(10.0 | nbody_system.time)
self.assertTrue(stopping_condition.is_set())
self.assertTrue(instance.model_time < 11.0 | nbody_system.time)
instance.stop()
def test19(self):
particles = datamodel.Particles(keys=[1, 2, 3])
particles.mass = 1 | nbody_system.mass
particles.radius = 0.1 | nbody_system.length
particles.x = [1, -1, 0] | nbody_system.length
particles.y = [1, -1, 0] | nbody_system.length
particles.z = [0, 0, 1] | nbody_system.length
particles.velocity = [[-1, 0, 0], [1, 0, 0], [0, 0, -10]] | nbody_system.speed
instance = SmallN()
instance.particles.add_particles(particles)
stopping_condition = instance.stopping_conditions.interaction_over_detection
stopping_condition.enable()
instance.evolve_model(10.0 | nbody_system.time)
self.assertTrue(stopping_condition.is_set())
self.assertTrue(instance.model_time < 10.0 | nbody_system.time)
instance.stop()
def test20(self):
p = datamodel.Particles(3)
p[0].mass = 6.667e-01 | nbody_system.mass
p[0].radius = 4.000e-03 | nbody_system.length
p[0].x = -1.309e+01 | nbody_system.length
p[0].y = 1.940e+01 | nbody_system.length
p[0].z = -1.163e+01 | nbody_system.length
p[0].vx = 2.366e-01 | nbody_system.speed
p[0].vy = -3.813e-01 | nbody_system.speed
p[0].vz = 2.486e-01 | nbody_system.speed
p[1].mass = 3.333e-01 | nbody_system.mass
p[1].radius = 1.000e-03 | nbody_system.length
p[1].x = -1.506e+01 | nbody_system.length
p[1].y = 1.937e+01 | nbody_system.length
p[1].z = -1.163e+01 | nbody_system.length
p[1].vx = 3.483e-01 | nbody_system.speed
p[1].vy = -4.513e-01 | nbody_system.speed
p[1].vz = 2.486e-01 | nbody_system.speed
p[2].mass = 5.000e-01 | nbody_system.mass
p[2].radius = 2.000e-03 | nbody_system.length
p[2].x = 2.749e+01 | nbody_system.length
p[2].y = -3.877e+01 | nbody_system.length
p[2].z = 2.325e+01 | nbody_system.length
p[2].vx = -5.476e-01 | nbody_system.speed
p[2].vy = 8.092e-01 | nbody_system.speed
p[2].vz = -4.972e-01 | nbody_system.speed
instance = SmallN()
instance.initialize_code()
instance.parameters.set_defaults
N = 3
t_begin = 0.0 | nbody_system.time
t_end = 100.0 | nbody_system.time
particles = p
instance.particles.add_particles(particles)
instance.commit_particles()
sc = instance.stopping_conditions.collision_detection
sc.enable()
isCollision = False
instance.evolve_model(t_end)
isCollision = sc.is_set()
instance.stop()
self.assertTrue(isCollision, "no collision detected")
| 22,713
| 37.368243
| 115
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_bridge.py
|
import numpy
from amuse.test.amusetest import TestWithMPI
from amuse.community.fi.interface import Fi
from amuse.community.hermite.interface import Hermite
from amuse.community.phigrape.interface import PhiGRAPE
from amuse.community.bhtree.interface import BHTree
from amuse.ext.bridge import bridge
from amuse.units import nbody_system
from amuse.units import units
from amuse.ic.kingmodel import new_king_model
def sys_from_parts(base_class, parts, converter, eps=None):
interface = base_class(converter)
interface.initialize_code()
if eps is not None:
interface.parameters.epsilon_squared = eps**2
interface.particles.add_particles(parts)
return interface
class TestBridge(TestWithMPI):
def test1(self):
convert = nbody_system.nbody_to_si(1.e5 | units.MSun, 1.0 | units.parsec)
eps = 2.e-4 | nbody_system.length
test_class = PhiGRAPE
number_of_particles = 50
stars = new_king_model(number_of_particles, W0=7, convert_nbody=convert)
stars.radius = 0.0 | units.RSun
cluster = test_class(convert)
cluster.parameters.epsilon_squared = eps**2
cluster.particles.add_particles(stars)
cluster.synchronize_model()
Ep1 = convert.to_nbody(cluster.potential_energy).number
Ek1 = convert.to_nbody(cluster.kinetic_energy).number
parts = cluster.particles.copy()
parts1 = parts.select_array(lambda x: (x > 0 | units.m), ['x'])
parts2 = parts.select_array(lambda x: (x < 0 | units.m), ['x'])
cluster1 = sys_from_parts(test_class, parts1, convert, eps)
cluster2 = sys_from_parts(test_class, parts2, convert, eps)
cluster1.synchronize_model()
cluster2.synchronize_model()
bridgesys = bridge()
bridgesys.add_system(cluster1, (cluster2,))
bridgesys.add_system(cluster2, (cluster1,))
Ep2 = convert.to_nbody(bridgesys.potential_energy).number
Ek2 = convert.to_nbody(bridgesys.kinetic_energy).number
self.assertAlmostEqual(Ek1, Ek2, 12)
self.assertAlmostEqual(Ep1, Ep2, 12)
| 2,107
| 34.728814
| 81
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/legacy_support.py
| 0
| 0
| 0
|
py
|
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_hacs64.py
|
from amuse.test.amusetest import TestWithMPI
import os
import sys
import numpy
import math
from amuse.community.hacs64.interface import Hacs64Interface, Hacs64
from amuse.units import nbody_system
from amuse.units import units
from amuse import datamodel
from amuse.ic import plummer
try:
from matplotlib import pyplot
HAS_MATPLOTLIB = True
except ImportError:
HAS_MATPLOTLIB = False
default_options = dict()
class TestHacs64Interface(TestWithMPI):
def test0(self):
instance = self.new_instance_of_an_optional_code(
Hacs64Interface, **default_options)
instance.stop()
def test1(self):
instance = self.new_instance_of_an_optional_code(
Hacs64Interface, **default_options)
instance.initialize_code()
instance.commit_parameters()
res1 = instance.new_particle(mass=11.0, radius=2.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
res2 = instance.new_particle(mass=21.0, radius=5.0, x=10.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
self.assertEqual(0, res1['index_of_the_particle'])
self.assertEqual(1, res2['index_of_the_particle'])
error = instance.commit_particles()
self.assertEqual(0, error)
retrieved_state1 = instance.get_state(0)
retrieved_state2 = instance.get_state(1)
self.assertEqual(0, retrieved_state1['__result'])
self.assertEqual(0, retrieved_state2['__result'])
self.assertEqual(11.0, retrieved_state1['mass'])
self.assertEqual(21.0, retrieved_state2['mass'])
self.assertEqual(0.0, retrieved_state1['x'])
self.assertEqual(10.0, retrieved_state2['x'])
self.assertEqual(5.0, retrieved_state2['radius'])
instance.cleanup_code()
instance.stop()
def test2(self):
instance = self.new_instance_of_an_optional_code(
Hacs64Interface, **default_options)
instance.initialize_code()
instance.commit_parameters()
for i in [1, 2, 3]:
temp_particle = instance.new_particle(mass=i, radius=1.0, x=i * 1.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
self.assertEqual(i-1, temp_particle['index_of_the_particle'])
error = instance.commit_particles()
self.assertEqual(0, error)
error = instance.delete_particle(1)
self.assertEqual(0, error)
error = instance.recommit_particles()
self.assertEqual(0, error)
self.assertEqual(2, instance.get_number_of_particles()['number_of_particles'])
self.assertEqual(0, instance.get_index_of_first_particle()['index_of_the_particle'])
self.assertEqual(2, instance.get_index_of_next_particle(0)['index_of_the_next_particle'])
self.assertEqual(0, instance.get_index_of_next_particle(0)['__result'])
self.assertEqual(-1, instance.get_index_of_next_particle(1)['__result'])
self.assertEqual(1, instance.get_index_of_next_particle(2)['__result'])
instance.stop()
def test3(self):
instance = self.new_instance_of_an_optional_code(
Hacs64Interface, **default_options)
instance.initialize_code()
self.assertEqual(0, instance.set_nmax(10))
self.assertEqual((10, 0), tuple(instance.get_nmax()))
self.assertEqual(0, instance.set_dtmax(4))
self.assertEqual((4, 0), tuple(instance.get_dtmax()))
self.assertEqual(0, instance.set_eps2(2))
self.assertEqual((2, 0), tuple(instance.get_eps2()))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(-1, instance.set_nmax(11))
self.assertEqual((10, 0), tuple(instance.get_nmax()))
self.assertEqual(-1, instance.set_dtmax(6))
self.assertEqual((4, 0), tuple(instance.get_dtmax()))
instance.cleanup_code()
instance.stop()
def test4(self):
instance = self.new_instance_of_an_optional_code(
Hacs64Interface, **default_options)
instance.initialize_code()
self.assertEqual(0, instance.set_h2max(0.1))
self.assertEqual((0.1, 0), tuple(instance.get_h2max()))
self.assertEqual((0.14, 0), tuple(instance.get_eta_reg()))
self.assertEqual(0, instance.set_eta_reg(0.4))
self.assertEqual((0.4, 0), tuple(instance.get_eta_reg()))
self.assertEqual((0.8, 0), tuple(instance.get_eta_irr()))
self.assertEqual(0, instance.set_eta_irr(0.6))
self.assertEqual((0.6, 0), tuple(instance.get_eta_irr()))
self.assertEqual(0, instance.commit_parameters())
instance.cleanup_code()
instance.stop()
def test5(self):
instance = self.new_instance_of_an_optional_code(
Hacs64Interface, **default_options)
instance.initialize_code()
instance.commit_parameters()
instance.new_particle([10, 20], [0, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1])
instance.commit_particles()
retrieved_state = instance.get_state(0)
self.assertEqual(10.0, retrieved_state['mass'])
self.assertEqual(1, retrieved_state['radius'])
retrieved_state = instance.get_state([0, 1])
self.assertEqual(20.0, retrieved_state['mass'][1])
self.assertEqual(instance.get_number_of_particles()['number_of_particles'], 2)
instance.cleanup_code()
instance.stop()
def test6(self):
instance = self.new_instance_of_an_optional_code(
Hacs64Interface, **default_options)
instance.initialize_code()
instance.commit_parameters()
instance.new_particle([10, 10], [-1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1])
instance.commit_particles()
self.assertFalse(hasattr(instance, "get_potential_at_point"))
# retr, error = instance.get_potential_at_point(0.01, 0,0,0)
# @print retr
# self.assertEqual(error, -1) # TODO: Not IMPLEMENTED yet
# self.assertEqual(retr['phi'], -20.0)
instance.cleanup_code()
instance.stop()
def test7(self):
instance = self.new_instance_of_an_optional_code(
Hacs64Interface, **default_options)
instance.initialize_code()
instance.set_eps2(0.1 * 0.1)
instance.commit_parameters()
id1, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
id2, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=2.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
instance.commit_particles()
potential, errorcode = instance.get_potential(id1)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -10.0 / numpy.sqrt(2.0**2 + 0.1**2), 8)
potential, errorcode = instance.get_potential(id2)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -10.0 / numpy.sqrt(2.0**2 + 0.1**2), 8)
total_potential, errorcode = instance.get_potential_energy()
potentials, errorcode = instance.get_potential([id1, id2])
instance.stop()
self.assertAlmostRelativeEquals(total_potential, numpy.sum(potentials * [10.0, 10.0]) / 2.0)
def test8(self):
instance = self.new_instance_of_an_optional_code(
Hacs64Interface, **default_options)
instance.initialize_code()
instance.set_eps2(0)
instance.commit_parameters()
id1, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
id2, errorcode = instance.new_particle(mass=1.0, radius=1.0, x=2.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
instance.commit_particles()
potential, errorcode = instance.get_potential(id1)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -1.0 / numpy.sqrt(2.0**2), 8)
total_potential, errorcode = instance.get_potential_energy()
potentials, errorcode = instance.get_potential([id1, id2])
instance.stop()
self.assertAlmostRelativeEquals(total_potential, numpy.sum(potentials * [10.0, 1.0]) / 2.0)
def test9(self):
print("Test Hacs64Interface evolve_model")
instance = self.new_instance_of_an_optional_code(
Hacs64Interface, **default_options)
self.assertEqual(0, instance.initialize_code())
# self.assertEquals(0, instance.set_eta_irr(0.14))
# self.assertEquals(0, instance.set_eta_reg(0.001))
self.assertEqual(0, instance.commit_parameters())
# Set up an equal-mass binary on a circular orbit:
self.assertEqual([0, 0], list(instance.new_particle(0.5, 0.5, 0, 0, 0, 0.5, 0, 0.01).values()))
self.assertEqual([1, 0], list(instance.new_particle(0.5, -0.5, 0, 0, 0, -0.5, 0, 0.01).values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(math.pi))
for result, expected in zip(list(instance.get_position(0).values()), [-0.5, -0.007, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
for result, expected in zip(list(instance.get_position(1).values()), [0.5, 0.007, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
self.assertEqual(0, instance.evolve_model(2 * math.pi))
for result, expected in zip(list(instance.get_position(0).values()), [0.5, 0.0147, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
for result, expected in zip(list(instance.get_position(1).values()), [-0.5, -0.0147, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
class _TestHacs64(TestWithMPI):
def new_system_of_sun_and_earth(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
return stars
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = self.new_instance_of_an_optional_code(
Hacs64, convert_nbody, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | units.AU**2
instance.dt_dia = 5000
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
instance.evolve_model(365.0 | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_at_start = earth.position.value_in(units.AU)[0]
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(position_at_start, position_after_full_rotation, 6)
instance.evolve_model(365.0 + (365.0 / 2) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 2)
instance.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 3)
instance.cleanup_code()
instance.stop()
def test2(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = self.new_instance_of_an_optional_code(
Hacs64, convert_nbody, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | units.AU**2
instance.dt_dia = 5000
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
for x in range(1, 2000, 10):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
if HAS_MATPLOTLIB:
figure = pyplot.figure()
plot = figure.add_subplot(1, 1, 1)
x_points = earth.get_timeline_of_attribute("x")
y_points = earth.get_timeline_of_attribute("y")
x_points_in_AU = [t_x[1].value_in(units.AU) for t_x in x_points]
y_points_in_AU = [t_x1[1].value_in(units.AU) for t_x1 in y_points]
plot.scatter(x_points_in_AU, y_points_in_AU, color="b", marker='o')
plot.set_xlim(-1.5, 1.5)
plot.set_ylim(-1.5, 1.5)
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "instance-earth-sun2.svg")
figure.savefig(output_file)
instance.cleanup_code()
instance.stop()
def test3(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = self.new_instance_of_an_optional_code(
Hacs64, convert_nbody, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00001 | units.AU**2
instance.dt_dia = 5000
stars = datamodel.Stars(2)
star1 = stars[0]
star2 = stars[1]
star1.mass = units.MSun(1.0)
star1.position = units.AU(numpy.array((-1.0, 0.0, 0.0)))
star1.velocity = units.AUd(numpy.array((0.0, 0.0, 0.0)))
star1.radius = units.RSun(1.0)
star2.mass = units.MSun(1.0)
star2.position = units.AU(numpy.array((1.0, 0.0, 0.0)))
star2.velocity = units.AUd(numpy.array((0.0, 0.0, 0.0)))
star2.radius = units.RSun(100.0)
instance.particles.add_particles(stars)
for x in range(1, 2000, 10):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
instance.stop()
def test4(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = self.new_instance_of_an_optional_code(
Hacs64, convert_nbody, **default_options)
instance.initialize_code()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
instance.particles.mass = [17.0, 33.0] | units.kg
self.assertEqual(instance.get_mass(0), 17.0 | units.kg)
self.assertEqual(instance.get_mass(1), 33.0 | units.kg)
instance.stop()
def test5(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = self.new_instance_of_an_optional_code(
Hacs64, convert_nbody, **default_options)
instance.initialize_code()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
instance.set_state(1, 16 | units.kg, 20.0 | units.m,
20.0 | units.m, 40.0 | units.m, 60.0 | units.m,
1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms)
curr_state = instance.get_state(1)
instance.stop()
self.assertEqual(curr_state[0], 16 | units.kg, 8)
def test6(self):
print("Test6: Testing Hacs64 parameters")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.yr, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(
Hacs64, convert_nbody, **default_options)
value = instance.get_eps2()
self.assertEqual(0.0 | units.AU**2, value)
self.assertAlmostEqual(0.0 | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2)
for x in [0.01, 0.1, 0.2]:
instance.parameters.epsilon_squared = x | units.AU**2
self.assertAlmostEqual(x | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2)
value = instance.get_dt_param()
self.assertEqual(0.03, value)
self.assertAlmostEqual(0.03, instance.parameters.dt_param, in_units=units.none)
for x in [0.001, 0.01, 0.1]:
instance.parameters.dt_param = x
self.assertAlmostEqual(x, instance.parameters.dt_param, in_units=units.none)
value = instance.get_dt_dia()
self.assertAlmostEqual(1.0 | units.yr, value)
self.assertAlmostEqual(1.0 | units.yr, instance.parameters.dt_dia, in_units=units.yr)
for x in [0.1, 10.0, 100.0]:
instance.parameters.dt_dia = x | units.yr
self.assertAlmostEqual(x | units.yr, instance.parameters.dt_dia, in_units=units.yr)
value = instance.get_time()
self.assertEqual(0.0 | units.yr, value)
self.assertAlmostEqual(0.0 | units.yr, instance.parameters.time, in_units=units.yr)
for x in [1.0, 10.0, 100.0]:
instance.parameters.time = x | units.yr
self.assertAlmostEqual(x | units.yr, instance.parameters.time, in_units=units.yr)
instance.stop()
def test7(self):
print("Test7: Testing effect of Hacs64 parameter epsilon_squared")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
particles = datamodel.Particles(2)
sun = particles[0]
sun.mass = 1.0 | units.MSun
sun.position = [0.0, 0.0, 0.0] | units.AU
sun.velocity = [0.0, 0.0, 0.0] | units.AU / units.yr
sun.radius = 1.0 | units.RSun
earth = particles[1]
earth.mass = 5.9736e24 | units.kg
earth.radius = 6371.0 | units.km
earth.position = [0.0, 1.0, 0.0] | units.AU
earth.velocity = [2.0*numpy.pi, -0.0001, 0.0] | units.AU / units.yr
initial_direction = math.atan((earth.velocity[0]/earth.velocity[1]))
final_direction = []
for log_eps2 in range(-9, 10, 2):
instance = self.new_instance_of_an_optional_code(
Hacs64, convert_nbody, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU ** 2
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.25 | units.yr)
final_direction.append(math.atan((instance.particles[1].velocity[0] /
instance.particles[1].velocity[1])))
instance.stop()
# Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees
self.assertAlmostEqual(abs(final_direction[0]), abs(initial_direction+math.pi/2.0), 2)
# Large values of epsilon_squared should result in ~ no interaction
self.assertAlmostEqual(final_direction[-1], initial_direction, 2)
# Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2
delta = [abs(final_direction[i+1]-final_direction[i]) for i in range(len(final_direction)-1)]
self.assertEqual(delta[len(final_direction)/2 - 1], max(delta))
def test8(self):
print("Testing Hacs64 collision_detection")
particles = datamodel.Particles(7)
particles.mass = 0.001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = self.new_instance_of_an_optional_code(
Hacs64, **default_options)
instance.initialize_code()
instance.parameters.set_defaults()
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 3)
self.assertEqual(len(collisions.particles(1)), 3)
self.assertEqual(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = datamodel.Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print(instance.model_time)
print(instance.particles)
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print()
print(instance.model_time)
print(instance.particles)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test9(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = self.new_instance_of_an_optional_code(
Hacs64, convert_nbody, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | units.AU**2
instance.parameters.pair_factor = 1e14
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
instance.stopping_conditions.pair_detection.enable()
instance.evolve_model(365.0 | units.day)
self.assertTrue(instance.stopping_conditions.pair_detection.is_set())
instance.particles.copy_values_of_all_attributes_to(stars)
position_at_start = earth.position.value_in(units.AU)[0]
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(position_at_start, position_after_full_rotation, 6)
print(instance.model_time)
print(instance.stopping_conditions.pair_detection.particles(0).key)
print(instance.stopping_conditions.pair_detection.particles(1).key)
instance.cleanup_code()
instance.stop()
def test10(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = self.new_instance_of_an_optional_code(
Hacs64, convert_nbody, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | units.AU**2
instance.parameters.stopping_conditions_number_of_steps = 10
self.assertEqual(instance.parameters.stopping_conditions_number_of_steps, 10)
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
instance.stopping_conditions.number_of_steps_detection.enable()
instance.evolve_model(365.0 | units.day)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
instance.particles.copy_values_of_all_attributes_to(stars)
instance.cleanup_code()
instance.stop()
def test11(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
instance = self.new_instance_of_an_optional_code(
Hacs64, **default_options)
instance.initialize_code()
instance.parameters.stopping_conditions_number_of_steps = 2
self.assertEqual(instance.parameters.stopping_conditions_number_of_steps, 2)
instance.particles.add_particles(particles)
instance.stopping_conditions.number_of_steps_detection.enable()
instance.evolve_model(10 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
self.assertTrue(instance.model_time < 10 | nbody_system.time)
instance.stop()
def test12(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 1.00] | nbody_system.length
particles.y = [0.0, 0.0] | nbody_system.length
particles.z = [0.0, 0.0] | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = [5.1, 0.0] | nbody_system.speed
particles.vy = [0.0, 0.0] | nbody_system.speed
particles.vz = [0.0, 0.0] | nbody_system.speed
particles.mass = [0.1, 0.1] | nbody_system.mass
instance = self.new_instance_of_an_optional_code(
Hacs64, **default_options)
instance.initialize_code()
instance.parameters.stopping_conditions_out_of_box_size = .5 | nbody_system.length
self.assertEqual(instance.parameters.stopping_conditions_out_of_box_size, .5 | nbody_system.length)
instance.particles.add_particles(particles)
instance.stopping_conditions.out_of_box_detection.enable()
instance.evolve_model(0.1 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.out_of_box_detection.is_set())
self.assertAlmostEqual(instance.stopping_conditions.out_of_box_detection.particles(0).x, 1.0 | nbody_system.length, 3)
instance.stop()
def test13(self):
particles = plummer.new_plummer_model(31)
instance = self.new_instance_of_an_optional_code(
Hacs64, number_of_workers=1, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length ** 2
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
expected_positions = instance.particles.position
instance.stop()
positions_per_workers = []
for n in [2, 3, 4, 5]:
instance = self.new_instance_of_an_optional_code(
Hacs64, number_of_workers=n, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length ** 2
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
positions_per_workers.append(instance.particles.position)
instance.stop()
for index, n in enumerate([2, 3, 4, 5]):
self.assertAlmostEqual(expected_positions, positions_per_workers[index], 15)
def test14(self):
instance = self.new_instance_of_an_optional_code(
Hacs64, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00001 | nbody_system.length**2
particles = datamodel.Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, 1.0 | nbody_system.length, zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration, 6)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fx0, -1.0 * fx1, 5)
fx = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0, 2)
self.assertAlmostEqual(potential0, potential1, 5)
instance.stop()
| 30,640
| 42.648148
| 126
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_mmams.py
|
import os.path
import itertools
import pickle
import numpy
from math import pi
from amuse.test.amusetest import get_path_to_results, TestWithMPI
from amuse.support.exceptions import AmuseException, CodeException
from amuse.community.mesa.interface import MESA
from amuse.community.evtwin.interface import EVtwin
from amuse.community.mmams.interface import MMAMSInterface, MMAMS
from amuse.couple.collision_handler import CollisionHandler
from amuse.units import units, constants
from amuse.datamodel import Particles, Particle, ParticlesSubset
# Change the default for some MMAMS(-Interface) keyword arguments:
# default_options = dict(redirection="none")
default_options = dict()
class TestMMAMSInterface(TestWithMPI):
def test1(self):
print("Test 1: initialization of the interface")
instance = MMAMSInterface(**default_options)
error = instance.initialize_code()
self.assertEqual(error, 0)
error = instance.commit_parameters()
self.assertEqual(error, 0)
instance.stop()
def test2(self):
print("Test 2: define a new particle")
instance = MMAMSInterface(**default_options)
self.assertEqual(instance.initialize_code(), 0)
self.assertEqual(instance.commit_parameters(), 0)
id, error = instance.new_particle(1.0)
self.assertEqual(error, 0)
self.assertEqual(id, 0)
id, error = instance.new_particle([2.0, 3.0, 4.0])
self.assertEqual(error, [0, 0, 0])
self.assertEqual(id, [1, 2, 3])
n_particles, error = instance.get_number_of_particles()
self.assertEqual(error, 0)
self.assertEqual(n_particles, 4)
error = instance.add_shell([1, 1, 1, 1], [1.0, 2.0, 3.0, 3.0],
[2.0, 4.0, 6.0, 6.0], [3.0, 6.0, 9.0, 9.0], [4.0, 8.0, 12.0, 12.0],
[5.0, 10.0, 15.0, 15.0], [6.0, 12.0, 18.0, 18.0],
[-6.0, -12.0, -18.0, -18.0], [7.0, 14.0, 21.0, 21.0],
[0.4, 0.2, 0.4, 0.4], [0.2, 0.4, 0.2, 0.2], [0.15, 0.1, 0.1, 0.1],
[0.1, 0.15, 0.15, 0.15], [0.05, 0.01, 0.01, 0.01],
[0.04, 0.02, 0.02, 0.02], [0.03, 0.03, 0.03, 0.03],
[0.02, 0.04, 0.04, 0.04], [0.01, 0.05, 0.05, 0.05])
self.assertEqual(error, [0, 0, 0, 0])
number_of_shells, error = instance.get_number_of_zones(1)
self.assertEqual(error, 0)
self.assertEqual(number_of_shells, 3)
d_mass, mass, radius, density, pressure, entropy, temperature, luminosity, \
molecular_weight, H1, He4, C12, N14, O16, Ne20, Mg24, Si28, Fe56, \
error = instance.get_stellar_model_element([0, 1, 2], [1, 1, 1])
self.assertEqual(error, [0, 0, 0])
self.assertEqual(d_mass, [1.0, 2.0, 3.0])
self.assertEqual(mass, [2.0, 4.0, 6.0])
self.assertEqual(radius, [3.0, 6.0, 9.0])
self.assertEqual(density, [4.0, 8.0, 12.0])
self.assertEqual(pressure, [5.0, 10.0, 15.0])
self.assertEqual(temperature, [6.0, 12.0, 18.0])
self.assertEqual(luminosity, [-6.0, -12.0, -18.0])
self.assertEqual(molecular_weight, [7.0, 14.0, 21.0])
self.assertEqual(H1, [0.4, 0.2, 0.4])
self.assertEqual(He4, [0.2, 0.4, 0.2])
self.assertEqual(C12, [0.15, 0.1, 0.1])
self.assertEqual(N14, [0.1, 0.15, 0.15])
self.assertEqual(O16, [0.05, 0.01, 0.01])
self.assertEqual(Ne20, [0.04, 0.02, 0.02])
self.assertEqual(Mg24, [0.03, 0.03, 0.03])
self.assertEqual(Si28, [0.02, 0.04, 0.04])
self.assertEqual(Fe56, [0.01, 0.05, 0.05])
instance.stop()
def test3(self):
print("Test 3: read a new particle from a usm file")
instance = MMAMSInterface(**default_options)
self.assertEqual(instance.initialize_code(), 0)
self.assertEqual(instance.commit_parameters(), 0)
usm_file = os.path.join(instance.data_directory, 'primary.usm')
id, error = instance.read_usm(usm_file)
self.assertEqual(error, 0)
self.assertEqual(id, 0)
id, error = instance.new_particle([2.0, 3.0])
self.assertEqual(error, [0, 0])
self.assertEqual(id, [1, 2])
n_particles, error = instance.get_number_of_particles()
self.assertEqual(error, 0)
self.assertEqual(n_particles, 3)
number_of_shells, error = instance.get_number_of_zones([0, 1, 2])
self.assertEqual(error, [0, 0, 0])
self.assertEqual(number_of_shells, [187, 0, 0])
d_mass, mass, radius, density, pressure, entropy, temperature, luminosity, \
molecular_weight, H1, He4, C12, N14, O16, Ne20, Mg24, Si28, Fe56, \
error = instance.get_stellar_model_element([0, 186, 0, 0], [0, 0, 1, 3])
self.assertEqual(error, [0, 0, -2, -3])
self.assertAlmostEqual(mass[0], 0.0, 3)
self.assertAlmostEqual(mass[1], 20.0, 0)
self.assertAlmostEqual(radius[0], 0.0, 1)
self.assertAlmostEqual(radius[1], 16.8, 1)
self.assertAlmostEqual(temperature[0], 47318040.0, 0)
self.assertAlmostEqual(temperature[1], 81542.0, 0)
self.assertAlmostEqual(H1[0], 0.0121, 4)
self.assertAlmostEqual(H1[1], 0.7, 4)
instance.stop()
def slowtest4(self):
print("Test 4: merge particles (from usm files)")
instance = MMAMSInterface(**default_options)
self.assertEqual(instance.initialize_code(), 0)
self.assertEqual(instance.set_dump_mixed_flag(0), 0)
self.assertEqual(instance.commit_parameters(), 0)
usm_file = os.path.join(instance.data_directory, 'primary.usm')
id, error = instance.read_usm(usm_file)
self.assertEqual(error, 0)
self.assertEqual(id, 0)
usm_file = os.path.join(instance.data_directory, 'secondary.usm')
id, error = instance.read_usm(usm_file)
self.assertEqual(error, 0)
self.assertEqual(id, 1)
id, error = instance.merge_two_stars(0, 1)
self.assertEqual(error, 0)
self.assertEqual(id, 2)
n_particles, error = instance.get_number_of_particles()
self.assertEqual(error, 0)
self.assertEqual(n_particles, 3)
number_of_shells, error = instance.get_number_of_zones([0, 1, 2])
self.assertEqual(error, [0, 0, 0])
self.assertEqual(number_of_shells[:2], [187, 181])
self.assertIsOfOrder(number_of_shells[2], 10000)
d_mass, mass, radius, density, pressure, entropy, temperature, luminosity, \
molecular_weight, H1, He4, C12, N14, O16, Ne20, Mg24, Si28, Fe56, \
error = instance.get_stellar_model_element([0, 10000, 12288], [2, 2, 2])
self.assertEqual(error, [0, 0, 0])
self.assertAlmostEqual(mass, [0.0, 24.5169, 25.6762], 3)
self.assertAlmostEqual(radius, [0.0, 10.3786, 19.3713], 3)
self.assertAlmostEqual(temperature, [38998355.9, 3478242.6, 49264.9], 0)
self.assertAlmostEqual(H1, [0.61562, 0.69999, 0.70000], 4)
instance.stop()
def test5(self):
print("Test 5: parameters")
instance = MMAMSInterface(**default_options)
self.assertEqual(instance.initialize_code(), 0)
self.assertEqual(instance.commit_parameters(), 0)
dump_mixed_flag, error = instance.get_dump_mixed_flag()
self.assertEqual(error, 0)
self.assertEqual(dump_mixed_flag, 1)
self.assertEqual(instance.set_dump_mixed_flag(0), 0)
dump_mixed_flag, error = instance.get_dump_mixed_flag()
self.assertEqual(error, 0)
self.assertEqual(dump_mixed_flag, 0)
target_n_shells_mixing, error = instance.get_target_n_shells_mixing()
self.assertEqual(error, 0)
self.assertEqual(target_n_shells_mixing, 200)
self.assertEqual(instance.set_target_n_shells_mixing(300), 0)
target_n_shells_mixing, error = instance.get_target_n_shells_mixing()
self.assertEqual(error, 0)
self.assertEqual(target_n_shells_mixing, 300)
target_n_shells, error = instance.get_target_n_shells()
self.assertEqual(error, 0)
self.assertEqual(target_n_shells, 10000)
self.assertEqual(instance.set_target_n_shells(5000), 0)
target_n_shells, error = instance.get_target_n_shells()
self.assertEqual(error, 0)
self.assertEqual(target_n_shells, 5000)
do_shock_heating_flag, error = instance.get_do_shock_heating_flag()
self.assertEqual(error, 0)
self.assertEqual(do_shock_heating_flag, 1)
self.assertEqual(instance.set_do_shock_heating_flag(0), 0)
do_shock_heating_flag, error = instance.get_do_shock_heating_flag()
self.assertEqual(error, 0)
self.assertEqual(do_shock_heating_flag, 0)
instance.stop()
class TestMMAMS(TestWithMPI):
def test1(self):
print("Test 1: initialization of the interface")
instance = MMAMS(**default_options)
instance.initialize_code()
instance.commit_parameters()
instance.recommit_parameters()
instance.cleanup_code()
instance.stop()
def test2(self):
print("Test 2: define a new particle")
stars = Particles(4)
stars.mass = [1.0, 2.0, 3.0, 4.0] | units.MSun
instance = MMAMS(**default_options)
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particle(stars[0])
instance.particles.add_particles(stars[1:])
self.assertEqual(instance.number_of_particles, 4)
instance.particles[1].add_shell([1.0, 2.0] | units.MSun, [2.0, 4.0] | units.MSun, [3.0, 6.0] | units.RSun,
[4.0, 8.0] | units.g / units.cm**3, [5.0, 10.0] | units.barye,
[6.0, 12.0] | units.K, [-6.0, -12.0] | units.LSun, [7.0, 14.0] | units.amu, [0.4, 0.2],
[0.2, 0.4], [0.15, 0.1], [0.1, 0.15],
[0.05, 0.01], [0.04, 0.02], [0.03, 0.03],
[0.02, 0.04], [0.01, 0.05])
self.assertEqual(instance.particles[1].number_of_zones, 2)
stellar_model = instance.particles[1].get_internal_structure()
self.assertTrue(set(['d_mass', 'mass', 'radius', 'rho', 'pressure', 'entropy',
'temperature', 'luminosity', 'molecular_weight', 'X_H', 'X_He', 'X_C',
'X_N', 'X_O', 'X_Ne', 'X_Mg', 'X_Si', 'X_Fe']).issubset(
stellar_model.all_attributes()
)
)
self.assertEqual(stellar_model.d_mass, [1.0, 2.0] | units.MSun)
self.assertEqual(stellar_model.mass, [2.0, 4.0] | units.MSun)
self.assertEqual(stellar_model.radius, [3.0, 6.0] | units.RSun)
self.assertEqual(stellar_model.rho, [4.0, 8.0] | units.g / units.cm**3)
self.assertEqual(stellar_model.pressure, [5.0, 10.0] | units.barye)
self.assertAlmostEqual(stellar_model.entropy, [407038297.689, 256418059.686], 2)
self.assertEqual(stellar_model.temperature, [6.0, 12.0] | units.K)
self.assertEqual(stellar_model.luminosity, [-6.0, -12.0] | units.LSun)
self.assertEqual(stellar_model.molecular_weight, [7.0, 14.0] | units.amu)
self.assertEqual(stellar_model.X_H, [0.4, 0.2])
self.assertEqual(stellar_model.X_He, [0.2, 0.4])
self.assertEqual(stellar_model.X_C, [0.15, 0.1])
self.assertEqual(stellar_model.X_N, [0.1, 0.15])
self.assertEqual(stellar_model.X_O, [0.05, 0.01])
self.assertEqual(stellar_model.X_Ne, [0.04, 0.02])
self.assertEqual(stellar_model.X_Mg, [0.03, 0.03])
self.assertEqual(stellar_model.X_Si, [0.02, 0.04])
self.assertEqual(stellar_model.X_Fe, [0.01, 0.05])
instance.stop()
def test3(self):
print("Test 3: read a new particle from a usm file")
instance = MMAMS(**default_options)
instance.initialize_code()
instance.commit_parameters()
stars = Particles(4)
stars.usm_file = [os.path.join(instance.data_directory, filename) for
filename in ['primary.usm', 'secondary.usm', '', '']]
stars[2:].mass = [3.0, 4.0] | units.MSun
instance.imported_stars.add_particles(stars[:2])
instance.particles.add_particles(stars[2:])
self.assertEqual(instance.number_of_particles, 4)
self.assertEqual(instance.native_stars.number_of_zones, [0, 0])
self.assertEqual(instance.imported_stars.number_of_zones, [187, 181])
self.assertEqual(instance.particles.number_of_zones, [0, 0, 187, 181])
stellar_model = instance.imported_stars[0].get_internal_structure()
self.assertAlmostEqual(stellar_model.mass[0], 0.0 | units.MSun, 3)
self.assertAlmostEqual(stellar_model.mass[-1], 20.0 | units.MSun, 0)
self.assertAlmostEqual(stellar_model.radius[0], 0.0 | units.RSun, 1)
self.assertAlmostEqual(stellar_model.radius[-1], 16.8 | units.RSun, 1)
self.assertAlmostEqual(stellar_model.temperature[0], 47318040.0 | units.K, 0)
self.assertAlmostEqual(stellar_model.temperature[-1], 81542.0 | units.K, 0)
self.assertAlmostEqual(stellar_model.X_H[0], 0.0121, 4)
self.assertAlmostEqual(stellar_model.X_H[-1], 0.7, 4)
self.assertAlmostRelativeEqual(instance.particles.mass, [3.0, 4.0, 20.0, 8.0] | units.MSun, 2)
instance.stop()
def slowtest4(self):
print("Test 4: merge particles (from usm files)")
# instance = MMAMS(debugger = 'gdb', **default_options)
instance = MMAMS(**default_options)
instance.initialize_code()
instance.parameters.dump_mixed_flag = False
instance.commit_parameters()
stars = Particles(2)
stars.usm_file = [os.path.join(instance.data_directory, filename) for
filename in ['primary.usm', 'secondary.usm']]
instance.imported_stars.add_particles(stars)
merge_product = Particle()
merge_product.primary = instance.imported_stars[0]
merge_product.secondary = instance.imported_stars[1]
instance.merge_products.add_particle(merge_product)
self.assertEqual(instance.number_of_particles, 3)
self.assertEqual(instance.particles.number_of_zones, [187, 181, 12289])
stellar_model = instance.merge_products[0].get_internal_structure()
self.assertAlmostEqual(stellar_model.mass[[0, 10000, 12288]], [0.0, 24.5169, 25.6762] | units.MSun, 3)
self.assertAlmostEqual(stellar_model.radius[[0, 10000, 12288]], [0.0, 10.3786, 19.3713] | units.RSun, 3)
self.assertAlmostEqual(stellar_model.temperature[[0, 10000, 12288]], [38998355.9, 3478242.6, 49264.9] | units.K, 0)
self.assertAlmostEqual(stellar_model.X_H[[0, 10000, 12288]], [0.61562, 0.69999, 0.70000] | units.none, 4)
instance.stop()
def test5(self):
print("Test 5: parameters")
instance = MMAMS(**default_options)
instance.initialize_code()
for par, value in [('dump_mixed_flag', True), ('do_shock_heating_flag', True),
('create_new_key', True)]:
print("1", instance.parameters)
self.assertTrue(value is getattr(instance.parameters, par))
setattr(instance.parameters, par, not value)
print("2", instance.parameters)
self.assertFalse(value is getattr(instance.parameters, par))
for par, value in [('target_n_shells_mixing', 200), ('target_n_shells', 10000)]:
self.assertEqual(value, getattr(instance.parameters, par))
setattr(instance.parameters, par, 1)
self.assertEqual(1, getattr(instance.parameters, par))
instance.stop()
def slowtest6(self):
print("Test 6: MMAMS with MESA particles - match composition only")
stars = Particles(2)
stars.mass = [20.0, 8.0] | units.MSun
instance = MMAMS(**default_options)
instance.initialize_code()
instance.parameters.dump_mixed_flag = False
instance.commit_parameters()
instance.particles.add_particles(stars)
self.assertEqual(instance.number_of_particles, 2)
stellar_evolution = self.new_instance(MESA)
if stellar_evolution is None:
print("MESA was not built. Skipping test.")
return
stellar_evolution.initialize_code()
stellar_evolution.commit_parameters()
stellar_evolution.particles.add_particles(stars)
stellar_evolution.commit_particles()
stellar_evolution.evolve_model(2 | units.Myr)
stellar_model = [None, None]
for i in [0, 1]:
number_of_zones = stellar_evolution.particles[i].get_number_of_zones()
mass_profile = stellar_evolution.particles[i].get_mass_profile(
number_of_zones=number_of_zones) * stellar_evolution.particles[i].mass
cumul_mass_profile = stellar_evolution.particles[i].get_cumulative_mass_profile(
number_of_zones=number_of_zones) * stellar_evolution.particles[i].mass
density_profile = stellar_evolution.particles[i].get_density_profile(number_of_zones=number_of_zones)
radius_profile = stellar_evolution.particles[i].get_radius_profile(number_of_zones=number_of_zones)
temperature_profile = stellar_evolution.particles[i].get_temperature_profile(number_of_zones=number_of_zones)
pressure_profile = stellar_evolution.particles[i].get_pressure_profile(number_of_zones=number_of_zones)
luminosity_profile = stellar_evolution.particles[i].get_luminosity_profile(number_of_zones=number_of_zones)
mu_profile = stellar_evolution.particles[i].get_mu_profile(number_of_zones=number_of_zones)
composition_profile = stellar_evolution.particles[i].get_chemical_abundance_profiles(number_of_zones=number_of_zones)
species_names = stellar_evolution.particles[i].get_names_of_species()
self.assertEqual(species_names, ['h1', 'he3', 'he4', 'c12', 'n14', 'o16', 'ne20', 'mg24'])
instance.particles[i].add_shell(mass_profile, cumul_mass_profile, radius_profile, density_profile,
pressure_profile, temperature_profile, luminosity_profile, mu_profile, composition_profile[0],
composition_profile[1]+composition_profile[2], composition_profile[3],
composition_profile[4], composition_profile[5], composition_profile[6],
composition_profile[7], composition_profile[7]*0.0, composition_profile[7]*0.0)
self.assertEqual(instance.particles[i].number_of_zones, number_of_zones)
stellar_model[i] = instance.particles[i].get_internal_structure()
self.assertTrue(set(['d_mass', 'mass', 'radius', 'rho', 'pressure',
'entropy', 'temperature', 'luminosity', 'molecular_weight', 'X_H', 'X_He', 'X_C',
'X_N', 'X_O', 'X_Ne', 'X_Mg', 'X_Si', 'X_Fe']).issubset(
stellar_model[i].all_attributes()
)
)
self.assertAlmostEqual(stellar_model[0].mass[0], 0.0 | units.MSun, 3)
self.assertAlmostEqual(stellar_model[0].mass[-1], 20.0 | units.MSun, 0)
self.assertAlmostEqual(stellar_model[0].radius[0], 0.0 | units.RSun, 1)
self.assertAlmostEqual(stellar_model[0].radius[-1], 6.67 | units.RSun, 1)
self.assertAlmostRelativeEqual(stellar_model[0].temperature[0], 35408447.7 | units.K, 2)
self.assertAlmostRelativeEqual(stellar_model[0].temperature[-1], 33533.7 | units.K, 2)
self.assertAlmostEqual(stellar_model[0].X_H[0], 0.58642 | units.none, 2)
self.assertAlmostEqual(stellar_model[0].X_H[-1], 0.7 | units.none, 2)
self.assertEqual(instance.number_of_particles, 2)
merge_product = Particle()
merge_product.primary = instance.particles[0]
merge_product.secondary = instance.particles[1]
instance.merge_products.add_particle(merge_product)
self.assertEqual(instance.number_of_particles, 3)
self.assertIsOfOrder(instance.parameters.target_n_shells, instance.merge_products[0].number_of_zones)
stellar_model = instance.merge_products[0].get_internal_structure()
self.assertAlmostEqual(stellar_model.mass[[0, -1]], [0.0, 25.7] | units.MSun, 1)
self.assertAlmostEqual(stellar_model.radius[[0, -1]], [0.0, 8.4] | units.RSun, 1)
merged = Particle()
merged.mass = stellar_model.mass[-1]
merged_in_code = stellar_evolution.native_stars.add_particle(merged)
stellar_evolution.evolve_model(keep_synchronous=False)
mass_profile = merged_in_code.get_cumulative_mass_profile()*merged.mass
new_composition = instance.match_composition_to_mass_profile(stellar_model, mass_profile)
cumulative_mass = [0.0] | units.MSun
cumulative_mass.extend(stellar_model.mass)
original_hydrogen_mass = (stellar_model.X_H * (cumulative_mass[1:] - cumulative_mass[:-1])).sum()
instance.stop()
cumulative_mass = [0.0] | units.MSun
cumulative_mass.extend(mass_profile)
new_hydrogen_mass = (new_composition[0] * (cumulative_mass[1:] - cumulative_mass[:-1])).sum()
self.assertEqual(len(new_composition), 8) # MESA species: H, He3, He4, C, N, O, Ne, Mg
self.assertEqual(len(new_composition[0]), len(mass_profile))
self.assertAlmostEqual(new_composition.sum(axis=0), 1.0)
self.assertAlmostEqual(new_hydrogen_mass, original_hydrogen_mass)
merged_in_code.set_chemical_abundance_profiles(new_composition)
for i in range(4):
stellar_evolution.evolve_model(keep_synchronous=False)
print(stellar_evolution.particles)
stellar_evolution.stop()
def slowtest7(self):
print("Test 7: MMAMS with MESA particles - import product into MESA")
stars = Particles(2)
stars.mass = [20.0, 8.0] | units.MSun
stellar_evolution = self.new_instance(MESA)
if stellar_evolution is None:
print("MESA was not built. Skipping test.")
return
stellar_evolution.initialize_code()
stellar_evolution.commit_parameters()
stellar_evolution.particles.add_particles(stars)
stellar_evolution.commit_particles()
stellar_evolution.evolve_model(2 | units.Myr)
if os.path.exists(os.path.join(get_path_to_results(), "test_mmams_7.pkl")):
# Remove the next line to speed-up, and only test MESA loading the merger product
os.remove(os.path.join(get_path_to_results(), "test_mmams_7.pkl"))
print("", end=' ')
if os.path.exists(os.path.join(get_path_to_results(), "test_mmams_7.pkl")):
with open(os.path.join(get_path_to_results(), "test_mmams_7.pkl"), 'r') as in_file:
stellar_model = pickle.load(in_file)
else:
instance = MMAMS(**default_options)
instance.initialize_code()
instance.parameters.target_n_shells_mixing = 1000
instance.parameters.dump_mixed_flag = True
instance.commit_parameters()
instance.particles.add_particles(stars)
self.assertEqual(instance.number_of_particles, 2)
stellar_model = [None, None]
for i in [0, 1]:
number_of_zones = stellar_evolution.particles[i].get_number_of_zones()
mass_profile = stellar_evolution.particles[i].get_mass_profile(
number_of_zones=number_of_zones) * stellar_evolution.particles[i].mass
cumul_mass_profile = stellar_evolution.particles[i].get_cumulative_mass_profile(
number_of_zones=number_of_zones) * stellar_evolution.particles[i].mass
density_profile = stellar_evolution.particles[i].get_density_profile(number_of_zones=number_of_zones)
radius_profile = stellar_evolution.particles[i].get_radius_profile(number_of_zones=number_of_zones)
temperature_profile = stellar_evolution.particles[i].get_temperature_profile(number_of_zones=number_of_zones)
pressure_profile = stellar_evolution.particles[i].get_pressure_profile(number_of_zones=number_of_zones)
luminosity_profile = stellar_evolution.particles[i].get_luminosity_profile(number_of_zones=number_of_zones)
mu_profile = stellar_evolution.particles[i].get_mu_profile(number_of_zones=number_of_zones)
composition_profile = stellar_evolution.particles[i].get_chemical_abundance_profiles(number_of_zones=number_of_zones)
species_names = stellar_evolution.particles[i].get_names_of_species()
self.assertEqual(species_names, ['h1', 'he3', 'he4', 'c12', 'n14', 'o16', 'ne20', 'mg24'])
instance.particles[i].add_shell(mass_profile, cumul_mass_profile, radius_profile, density_profile,
pressure_profile, temperature_profile, luminosity_profile, mu_profile, composition_profile[0],
composition_profile[1]+composition_profile[2], composition_profile[3],
composition_profile[4], composition_profile[5], composition_profile[6],
composition_profile[7], composition_profile[7]*0.0, composition_profile[7]*0.0)
self.assertEqual(instance.particles[i].number_of_zones, number_of_zones)
stellar_model[i] = instance.particles[i].get_internal_structure()
self.assertTrue(set(['d_mass', 'mass', 'radius', 'rho', 'pressure',
'entropy', 'temperature', 'luminosity', 'molecular_weight', 'X_H', 'X_He', 'X_C',
'X_N', 'X_O', 'X_Ne', 'X_Mg', 'X_Si', 'X_Fe']).issubset(
stellar_model[i].all_attributes()
)
)
self.assertAlmostEqual(stellar_model[0].mass[0], 0.0 | units.MSun, 3)
self.assertAlmostEqual(stellar_model[0].mass[-1], 20.0 | units.MSun, 0)
self.assertAlmostEqual(stellar_model[0].radius[0], 0.0 | units.RSun, 1)
self.assertAlmostEqual(stellar_model[0].radius[-1], 6.67 | units.RSun, 1)
self.assertAlmostRelativeEqual(stellar_model[0].temperature[0], 35408447.7 | units.K, 2)
self.assertAlmostRelativeEqual(stellar_model[0].temperature[-1], 33533.7 | units.K, 2)
self.assertAlmostEqual(stellar_model[0].X_H[0], 0.58642 | units.none, 2)
self.assertAlmostEqual(stellar_model[0].X_H[-1], 0.7 | units.none, 4)
self.assertEqual(instance.number_of_particles, 2)
merge_product = Particle()
merge_product.primary = instance.particles[0]
merge_product.secondary = instance.particles[1]
instance.merge_products.add_particle(merge_product)
self.assertEqual(instance.number_of_particles, 3)
self.assertIsOfOrder(instance.parameters.target_n_shells_mixing, instance.merge_products[0].number_of_zones)
mmams_merged_model = instance.merge_products[0].get_internal_structure()
stellar_model = dict(
mass=mmams_merged_model.mass,
radius=mmams_merged_model.radius,
rho=mmams_merged_model.rho,
temperature=mmams_merged_model.temperature,
luminosity=mmams_merged_model.luminosity,
X_H=mmams_merged_model.X_H,
X_He=mmams_merged_model.X_He,
X_C=mmams_merged_model.X_C,
X_N=mmams_merged_model.X_N,
X_O=mmams_merged_model.X_O,
X_Ne=mmams_merged_model.X_Ne,
X_Mg=mmams_merged_model.X_Mg,
X_Si=mmams_merged_model.X_Si,
X_Fe=mmams_merged_model.X_Fe
)
instance.stop()
with open(os.path.join(get_path_to_results(), "test_mmams_7.pkl"), 'w') as out_file:
pickle.dump(stellar_model, out_file)
print(stellar_model['mass'][[0, -1]])
print(stellar_model['radius'][[0, -1]])
print(stellar_model['X_H'][[0, -1]])
self.assertAlmostEqual(stellar_model['mass'][[0, -1]], [0.0263, 25.705] | units.MSun, 1)
self.assertAlmostEqual(stellar_model['radius'][[0, -1]], [0.0328, 7.674] | units.RSun, 1)
self.assertAlmostEqual(stellar_model['X_H'][[0, -1]], [0.6733, 0.6999] | units.none, 2)
stellar_evolution.new_particle_from_model(stellar_model, 10.0 | units.Myr)
print(stellar_evolution.particles)
for i in range(10):
stellar_evolution.evolve_model(keep_synchronous=False)
print(stellar_evolution.particles)
stellar_evolution.stop()
def slowtest8(self):
print("Test 8: MMAMS with MESA particles - multiple mergers")
number_of_stars = 4
stars = Particles(number_of_stars)
stars.mass = range(20, 20+number_of_stars) | units.MSun
stellar_evolution = self.new_instance(MESA)
if stellar_evolution is None:
print("MESA was not built. Skipping test.")
return
stellar_evolution.initialize_code()
stellar_evolution.commit_parameters()
stellar_evolution.particles.add_particles(stars)
stellar_evolution.commit_particles()
stellar_evolution.evolve_model(0.1 | units.Myr)
instance = MMAMS(**default_options)
instance.initialize_code()
instance.commit_parameters()
while len(stellar_evolution.particles) > 1:
to_be_merged = [stellar_evolution.particles[len(stellar_evolution.particles)-1], stellar_evolution.particles[len(stellar_evolution.particles)-2]]
print("Merging particles with mass", to_be_merged[0].mass, "and", to_be_merged[1].mass)
merge_product = Particle()
for i in [0, 1]:
number_of_zones = to_be_merged[i].get_number_of_zones()
mass_profile = to_be_merged[i].get_mass_profile() * to_be_merged[i].mass
cumul_mass_profile = to_be_merged[i].get_cumulative_mass_profile() * to_be_merged[i].mass
density_profile = to_be_merged[i].get_density_profile(number_of_zones=number_of_zones)
radius_profile = to_be_merged[i].get_radius_profile(number_of_zones=number_of_zones)
temperature_profile = to_be_merged[i].get_temperature_profile(number_of_zones=number_of_zones)
pressure_profile = to_be_merged[i].get_pressure_profile(number_of_zones=number_of_zones)
luminosity_profile = to_be_merged[i].get_luminosity_profile(number_of_zones=number_of_zones)
mu_profile = to_be_merged[i].get_mu_profile(number_of_zones=number_of_zones)
composition_profile = to_be_merged[i].get_chemical_abundance_profiles(number_of_zones=number_of_zones)
species_names = to_be_merged[i].get_names_of_species()
new_mmams_particle = instance.native_stars.add_particle(to_be_merged[i])
stellar_evolution.particles.remove_particle(to_be_merged[i])
new_mmams_particle.add_shell(mass_profile, cumul_mass_profile, radius_profile, density_profile,
pressure_profile, temperature_profile, luminosity_profile, mu_profile, composition_profile[0],
composition_profile[1]+composition_profile[2], composition_profile[3],
composition_profile[4], composition_profile[5], composition_profile[6],
composition_profile[7], composition_profile[7]*0.0, composition_profile[7]*0.0)
self.assertEqual(new_mmams_particle.number_of_zones, number_of_zones)
if i == 0:
merge_product.primary = new_mmams_particle
else:
merge_product.secondary = new_mmams_particle
self.assertEqual(len(instance.merge_products)+len(stellar_evolution.particles), number_of_stars-2)
new_merge_product = instance.merge_products.add_particle(merge_product)
print("Successfully merged particles. number_of_zones:", new_merge_product.number_of_zones)
self.assertEqual(len(instance.merge_products)+len(stellar_evolution.particles), number_of_stars-1)
new_merge_product_model = new_merge_product.get_internal_structure()
stellar_evolution.new_particle_from_model(new_merge_product_model, 0 | units.yr)
print(stellar_evolution.particles)
self.assertEqual(len(instance.merge_products)+len(stellar_evolution.particles), number_of_stars)
for i in range(10):
stellar_evolution.evolve_model(keep_synchronous=False)
print(stellar_evolution.particles)
stellar_evolution.stop()
instance.stop()
def slowtest9(self):
print("Test 9: MMAMS with MESA particles - evolved stars")
stars = Particles(2)
stars.mass = [20.0, 8.0] | units.MSun
stellar_evolution = self.new_instance(MESA)
if stellar_evolution is None:
print("MESA was not built. Skipping test.")
return
stellar_evolution.initialize_code()
stellar_evolution.parameters.min_timestep_stop_condition = 1 | units.yr
stellar_evolution.commit_parameters()
stellar_evolution.particles.add_particles(stars)
stellar_evolution.commit_particles()
try:
stellar_evolution.particles[0].evolve_for(1.0 | units.Gyr)
except AmuseException:
stellar_evolution.particles[1].evolve_for(stellar_evolution.particles[0].age)
print("Evolved stars to", stellar_evolution.particles.age)
print("Radius:", stellar_evolution.particles.radius)
instance = MMAMS(**default_options)
instance.initialize_code()
instance.parameters.dump_mixed_flag = True
instance.commit_parameters()
instance.particles.add_particles(stars)
self.assertEqual(instance.number_of_particles, 2)
stellar_model = [None, None]
for i in [0, 1]:
number_of_zones = stellar_evolution.particles[i].get_number_of_zones()
mass_profile = stellar_evolution.particles[i].get_mass_profile(
number_of_zones=number_of_zones) * stellar_evolution.particles[i].mass
cumul_mass_profile = stellar_evolution.particles[i].get_cumulative_mass_profile(
number_of_zones=number_of_zones) * stellar_evolution.particles[i].mass
density_profile = stellar_evolution.particles[i].get_density_profile(number_of_zones=number_of_zones)
radius_profile = stellar_evolution.particles[i].get_radius_profile(number_of_zones=number_of_zones)
temperature_profile = stellar_evolution.particles[i].get_temperature_profile(number_of_zones=number_of_zones)
luminosity_profile = stellar_evolution.particles[i].get_luminosity_profile(number_of_zones=number_of_zones)
mu_profile = stellar_evolution.particles[i].get_mu_profile(number_of_zones=number_of_zones)
pressure_profile = stellar_evolution.particles[i].get_pressure_profile(number_of_zones=number_of_zones)
composition_profile = stellar_evolution.particles[i].get_chemical_abundance_profiles(number_of_zones=number_of_zones)
species_names = stellar_evolution.particles[i].get_names_of_species()
self.assertEqual(species_names, ['h1', 'he3', 'he4', 'c12', 'n14', 'o16', 'ne20', 'mg24', 'si28', 's32', ''][:-(1+2*i)])
instance.particles[i].add_shell(mass_profile, cumul_mass_profile, radius_profile, density_profile,
pressure_profile, temperature_profile, luminosity_profile, mu_profile, composition_profile[0],
composition_profile[1]+composition_profile[2], composition_profile[3],
composition_profile[4], composition_profile[5], composition_profile[6],
composition_profile[7], composition_profile[7]*0.0, composition_profile[7]*0.0)
self.assertEqual(instance.particles[i].number_of_zones, number_of_zones)
stellar_model[i] = instance.particles[i].get_internal_structure()
self.assertTrue(set(['d_mass', 'mass', 'radius', 'rho', 'pressure',
'entropy', 'temperature', 'luminosity', 'molecular_weight', 'X_H', 'X_He', 'X_C',
'X_N', 'X_O', 'X_Ne', 'X_Mg', 'X_Si', 'X_Fe']).issubset(
stellar_model[i].all_attributes()
)
)
print(stellar_model[0].mass[[0, -1]])
print(stellar_model[0].radius[[0, -1]])
print(stellar_model[0].X_H[[0, -1]])
self.assertEqual(instance.number_of_particles, 2)
merge_product = Particle()
merge_product.primary = instance.particles[0]
merge_product.secondary = instance.particles[1]
instance.merge_products.add_particle(merge_product)
self.assertEqual(instance.number_of_particles, 3)
mmams_merged_model = instance.merge_products[0].get_internal_structure()
print(mmams_merged_model.mass[[0, -1]])
print(mmams_merged_model.radius[[0, -1]])
print(mmams_merged_model.X_H[[0, -1]])
stellar_model = dict(
mass=mmams_merged_model.mass,
radius=mmams_merged_model.radius,
rho=mmams_merged_model.rho,
temperature=mmams_merged_model.temperature,
luminosity=mmams_merged_model.luminosity,
X_H=mmams_merged_model.X_H,
X_He=mmams_merged_model.X_He,
X_C=mmams_merged_model.X_C,
X_N=mmams_merged_model.X_N,
X_O=mmams_merged_model.X_O,
X_Ne=mmams_merged_model.X_Ne,
X_Mg=mmams_merged_model.X_Mg,
X_Si=mmams_merged_model.X_Si,
X_Fe=mmams_merged_model.X_Fe
)
instance.stop()
stellar_evolution.parameters.min_timestep_stop_condition = 1.0e-6 | units.s
merged_in_code = stellar_evolution.new_particle_from_model(stellar_model, 0.0 | units.Myr)
stellar_evolution.particles.remove_particles(stars)
print(stellar_evolution.particles)
for i in range(10):
stellar_evolution.evolve_model()
print(stellar_evolution.particles)
stellar_evolution.stop()
def xtest10(self):
print("Test 10: MMAMS with EVtwin particles - import product into EVtwin (WIP)")
stars = Particles(2)
stars.mass = [20.0, 8.0] | units.MSun
instance = MMAMS(**default_options)
instance.initialize_code()
instance.parameters.dump_mixed_flag = True
instance.commit_parameters()
instance.particles.add_particles(stars)
self.assertEqual(instance.number_of_particles, 2)
stellar_evolution = EVtwin(redirection="none")
stellar_evolution.initialize_code()
stellar_evolution.commit_parameters()
stellar_evolution.particles.add_particles(stars)
stellar_evolution.commit_particles()
stellar_evolution.evolve_model(2 | units.Myr)
print(stellar_evolution.particles)
for i in [0, 1]:
stellar_model = stellar_evolution.particles[i].get_internal_structure()
instance.particles[i].add_shell(
stellar_model.d_mass, stellar_model.mass, stellar_model.radius,
stellar_model.rho, stellar_model.pressure, stellar_model.temperature,
stellar_model.luminosity, stellar_model.molecular_weight, stellar_model.X_H,
stellar_model.X_He, stellar_model.X_C, stellar_model.X_N, stellar_model.X_O,
stellar_model.X_Ne, stellar_model.X_Mg, stellar_model.X_Si, stellar_model.X_Fe
)
self.assertEqual(instance.particles[i].number_of_zones, len(stellar_model))
self.assertEqual(instance.number_of_particles, 2)
merge_product = Particle()
merge_product.primary = instance.particles[0]
merge_product.secondary = instance.particles[1]
instance.merge_products.add_particle(merge_product)
self.assertEqual(instance.number_of_particles, 3)
self.assertEqual(instance.native_stars.number_of_zones, [199, 199])
self.assertIsOfOrder(instance.merge_products[0].number_of_zones, instance.parameters.target_n_shells_mixing)
stellar_model = instance.merge_products[0].get_internal_structure()
print(stellar_model.mass[[0, -1]])
print(stellar_model.radius[[0, -1]])
print(stellar_model.X_H[[0, -1]])
stellar_evolution.new_particle_from_model(stellar_model, 10.0 | units.Myr)
instance.stop()
print(stellar_evolution.particles)
for i in range(10):
stellar_evolution.evolve_model(keep_synchronous=False)
print(stellar_evolution.particles)
stellar_evolution.stop()
def slowtest11(self):
print("Test 11: MMAMS with MESA particles of various masses/ages")
masses = [1.0, 5.0, 20.0, 42.0, 80.0, 200.0] | units.MSun
number_of_stars = len(masses)
stars = Particles(number_of_stars)
stars.mass = masses
stellar_evolution = self.new_instance(MESA)
if stellar_evolution is None:
print("MESA was not built. Skipping test.")
return
stellar_evolution.parameters.metallicity = 0.0
mesa_particles = stellar_evolution.particles.add_particles(stars)
stellar_evolution.evolve_model(1.5 | units.Myr)
mesa_models = []
for i in range(number_of_stars):
number_of_zones = mesa_particles[i].get_number_of_zones()
mass_profile = mesa_particles[i].get_mass_profile(
number_of_zones=number_of_zones) * mesa_particles[i].mass
cumul_mass_profile = mesa_particles[i].get_cumulative_mass_profile(
number_of_zones=number_of_zones) * mesa_particles[i].mass
density_profile = mesa_particles[i].get_density_profile(number_of_zones=number_of_zones)
radius_profile = mesa_particles[i].get_radius_profile(number_of_zones=number_of_zones)
temperature_profile = mesa_particles[i].get_temperature_profile(number_of_zones=number_of_zones)
pressure_profile = mesa_particles[i].get_pressure_profile(number_of_zones=number_of_zones)
luminosity_profile = mesa_particles[i].get_luminosity_profile(number_of_zones=number_of_zones)
mu_profile = mesa_particles[i].get_mu_profile(number_of_zones=number_of_zones)
composition_profile = mesa_particles[i].get_chemical_abundance_profiles(number_of_zones=number_of_zones)
mesa_models.append((mass_profile, cumul_mass_profile, radius_profile, density_profile,
pressure_profile, temperature_profile, luminosity_profile, mu_profile, composition_profile[0],
composition_profile[1]+composition_profile[2], composition_profile[3],
composition_profile[4], composition_profile[5], composition_profile[6],
composition_profile[7], composition_profile[7]*0.0, composition_profile[7]*0.0))
stellar_evolution.stop()
instance = MMAMS(**default_options) # debugger = "gdb", **default_options)
instance.initialize_code()
instance.parameters.dump_mixed_flag = True
instance.commit_parameters()
stellar_models = []
crashed = False
for (index_1, index_2) in itertools.combinations(range(number_of_stars), 2):
print()
print(masses[index_1], masses[index_2])
print()
self.assertEqual(instance.number_of_particles, len(stellar_models))
colliding = instance.particles.add_particles(stars[[index_1, index_2]])
colliding[0].add_shell(*(mesa_models[index_1]))
colliding[1].add_shell(*(mesa_models[index_2]))
self.assertEqual(instance.number_of_particles, 2 + len(stellar_models))
merge_product = Particle()
merge_product.primary = colliding[0]
merge_product.secondary = colliding[1]
try:
instance.merge_products.add_particle(merge_product)
self.assertEqual(instance.number_of_particles, 3 + len(stellar_models))
instance.particles.remove_particles(stars[[index_1, index_2]])
self.assertEqual(instance.number_of_particles, 1 + len(stellar_models))
stellar_models.append(instance.particles[len(stellar_models)].get_internal_structure().copy())
except CodeException as ex:
print(ex)
crashed = True
break
if not crashed:
instance.stop()
for stellar_model in stellar_models:
print("mass:", stellar_model.mass[-1])
print("radius:", stellar_model.radius[-1])
print("X_H:", stellar_model.X_H[[0, -1]])
print("Storing the merger products in", os.path.join(get_path_to_results(), "test_mmams_11.pkl"))
mmams_merged_models = []
for mmams_merged_model in stellar_models:
mmams_merged_models.append(dict(
mass=mmams_merged_model.mass,
radius=mmams_merged_model.radius,
rho=mmams_merged_model.rho,
temperature=mmams_merged_model.temperature,
luminosity=mmams_merged_model.luminosity,
X_H=mmams_merged_model.X_H,
X_He=mmams_merged_model.X_He,
X_C=mmams_merged_model.X_C,
X_N=mmams_merged_model.X_N,
X_O=mmams_merged_model.X_O,
X_Ne=mmams_merged_model.X_Ne,
X_Mg=mmams_merged_model.X_Mg,
X_Si=mmams_merged_model.X_Si,
X_Fe=mmams_merged_model.X_Fe
))
with open(os.path.join(get_path_to_results(), "test_mmams_11.pkl"), 'w') as out_file:
pickle.dump(mmams_merged_models, out_file)
def slowtest11b(self):
print("Test 11b: Continue the stellar evolution of the products from test 11 with MESA")
if os.path.exists(os.path.join(get_path_to_results(), "test_mmams_11.pkl")):
with open(os.path.join(get_path_to_results(), "test_mmams_11.pkl"), 'r') as in_file:
stellar_models = pickle.load(in_file)
else:
return
print(len(stellar_models))
stellar_evolution = self.new_instance(MESA)
if stellar_evolution is None:
print("MESA was not built. Skipping test.")
return
stellar_evolution.initialize_code()
stellar_evolution.parameters.metallicity = 0.0
stellar_evolution.commit_parameters()
for i, stellar_model in enumerate(stellar_models):
stellar_evolution.model_time = 0 | units.yr
print("\n\n\n***", i, "***", stellar_model['mass'][-1])
stellar_evolution.particles.remove_particles(stellar_evolution.particles)
merged_in_code = stellar_evolution.new_particle_from_model(stellar_model, 0.0 | units.Myr)
print(stellar_evolution.particles)
stellar_evolution.evolve_model(1000 | units.yr)
print(stellar_evolution.particles)
stellar_evolution.stop()
def test12(self):
print("Test 12: merge particles, as fast/crude as possible")
stars = Particles(2)
stars.mass = [1.0, 2.0] | units.MSun
instance = MMAMS(**default_options)
instance.initialize_code()
instance.parameters.target_n_shells = 100
instance.parameters.dump_mixed_flag = False
instance.parameters.do_shock_heating_flag = False
instance.commit_parameters()
instance.particles.add_particles(stars)
self.assertEqual(instance.number_of_particles, 2)
d_mass = [0.25]*4 | units.MSun
cumul_mass = d_mass.accumulate()
radius = ([0.0]+[0.25]*4 | units.RSun).accumulate()
d_volume = 4.0/3.0 * pi * (radius[1:]**3 - radius[:-1]**3)
density = d_mass / d_volume
pressure = (constants.G * cumul_mass * density * (radius[1:] - radius[:-1]) / radius[1:]**2)[::-1].accumulate()[::-1]
mu = constants.proton_mass * (16.0/27.0)
temperature = pressure * mu / (constants.kB * density)
luminosity = [0]*4 | units.LSun
X = [0.75]*4
Y = [0.25]*4
Z = [0.00]*4
instance.particles[0].add_shell(d_mass, cumul_mass, radius[1:], density,
pressure, temperature, luminosity, mu, X, Y, Z, Z, Z, Z, Z, Z, Z)
instance.particles[1].add_shell(d_mass*2, cumul_mass*2, radius[1:], density*2,
pressure*4, temperature*2, luminosity, mu, X, Y, Z, Z, Z, Z, Z, Z, Z)
self.assertEqual(instance.particles[1].number_of_zones, 4)
stellar_model = instance.particles[1].get_internal_structure()
self.assertTrue(set(['d_mass', 'mass', 'radius', 'rho', 'pressure', 'entropy',
'temperature', 'luminosity', 'molecular_weight', 'X_H', 'X_He', 'X_C',
'X_N', 'X_O', 'X_Ne', 'X_Mg', 'X_Si', 'X_Fe']).issubset(
stellar_model.all_attributes()
)
)
merge_product = Particle()
merge_product.primary = instance.particles[0]
merge_product.secondary = instance.particles[1]
instance.merge_products.add_particle(merge_product)
self.assertEqual(instance.number_of_particles, 3)
self.assertEqual(instance.particles[0].number_of_zones, 4)
self.assertEqual(instance.particles[1].number_of_zones, 4)
self.assertTrue(instance.particles[2].number_of_zones > 100)
self.assertAlmostEqual(instance.particles[2].mass, 2.7324 | units.MSun, 2)
instance.stop()
class ParticlesForTesting(list):
def has_key_in_store(self, key):
return key in [x.key for x in self]
def _subset(self, selected, indices=None):
return ParticlesForTesting([x for x in self if x.key in selected])
def remove_particles(self, particles):
particles_in_self = self._subset(particles.key)
for particle in particles_in_self:
self.remove(particle)
class StarParticleWithStructureWithoutGetMassProfile(Particle):
def __init__(self, mass, **keyword_arguments):
Particle.__init__(self, **keyword_arguments)
self.mass = mass
def get_number_of_zones(self):
return 4
def _mass_profile(self, number_of_zones=None):
return numpy.asarray([0.25]*4)
def _cumulative_mass_profile(self, number_of_zones=None):
return numpy.add.accumulate(self._mass_profile(number_of_zones))
def _radii(self):
return ([0.0]+[0.25]*4 | units.RSun).accumulate()
def get_radius_profile(self, number_of_zones=None):
return self._radii()[1:]
def get_density_profile(self, number_of_zones=None):
return self._mass_profile() * self.mass / (4.0/3.0 * constants.pi * (self._radii()[1:]**3 - self._radii()[:-1]**3))
def get_pressure_profile(self, number_of_zones=None):
return (constants.G * self._cumulative_mass_profile() * self.mass * self.get_density_profile() *
(self._radii()[1:] - self._radii()[:-1]) / self._radii()[1:]**2)[::-1].accumulate()[::-1]
def get_temperature_profile(self, number_of_zones=None):
return self.get_pressure_profile() * self.get_mu_profile() / (constants.kB * self.get_density_profile())
def get_luminosity_profile(self, number_of_zones=None):
return [0]*4 | units.LSun
def get_mu_profile(self, number_of_zones=None):
return (constants.proton_mass * (16.0/27.0)).as_vector_with_length(4)
def get_chemical_abundance_profiles(self, number_of_zones=None, number_of_species=None):
return numpy.asarray([[0.75]*4, [0.25]*4, [0]*4, [0]*4, [0]*4, [0]*4, [0]*4, [0]*4])
class StarParticleWithStructure(StarParticleWithStructureWithoutGetMassProfile):
def __init__(self, mass, **keyword_arguments):
Particle.__init__(self, **keyword_arguments)
self.mass = mass
def get_mass_profile(self, number_of_zones=None):
return numpy.asarray([0.25]*4)
def get_cumulative_mass_profile(self, number_of_zones=None):
return numpy.add.accumulate(self.get_mass_profile(number_of_zones))
class StellarEvolutionCodeWithInternalStructureForTesting(object):
def __init__(self, has_get_mass_profile=True):
if has_get_mass_profile:
self.particles = ParticlesForTesting([
StarParticleWithStructure(mass=1.0 | units.MSun),
StarParticleWithStructure(mass=2.0 | units.MSun)
])
else:
self.particles = ParticlesForTesting([
StarParticleWithStructureWithoutGetMassProfile(mass=1.0 | units.MSun),
StarParticleWithStructureWithoutGetMassProfile(mass=2.0 | units.MSun)
])
def new_particle_from_model(self, internal_structure, current_age, key=None):
tmp_star = Particle(key=key)
tmp_star.mass = internal_structure.mass[-1]
tmp_star.radius = internal_structure.radius[-1]
self.particles.append(StarParticleWithStructure(mass=tmp_star.mass, key=tmp_star.key))
return tmp_star
class TestMMAMSWithCollisionHandler(TestWithMPI):
def test1(self):
print("Test 1: MMAMS in CollisionHandler")
self.assertRaises(AmuseException, CollisionHandler, MMAMS, expected_message="MMAMS requires a stellar evolution code: CollisionHandler(..., stellar_evolution_code=x)")
handler = CollisionHandler(
MMAMS,
stellar_evolution_code=StellarEvolutionCodeWithInternalStructureForTesting(),
verbose=True
)
def test2(self):
print("Test 2: merge particles with CollisionHandler and MMAMS class, as fast/crude as possible")
stellar_evolution = StellarEvolutionCodeWithInternalStructureForTesting()
self.assertEqual(len(stellar_evolution.particles), 2)
handler = CollisionHandler(
MMAMS,
collision_code_parameters=dict(
target_n_shells=100,
target_n_shells_mixing=100,
do_shock_heating_flag=False
),
stellar_evolution_code=stellar_evolution,
verbose=True
)
merged = handler.handle_collision(stellar_evolution.particles[0], stellar_evolution.particles[1])
self.assertTrue(isinstance(merged, Particles))
self.assertTrue(merged.number_of_zones > 50)
self.assertEqual(merged[0].key, stellar_evolution.particles[0].key)
self.assertEqual(len(stellar_evolution.particles), 1)
self.assertAlmostEqual(stellar_evolution.particles[0].mass, 2.73 | units.MSun, 1)
self.assertEqual(handler.collision_code, MMAMS)
def test3(self):
print("Test 3: merge particles with CollisionHandler and MMAMS instance, as fast/crude as possible")
stellar_evolution = StellarEvolutionCodeWithInternalStructureForTesting()
self.assertEqual(len(stellar_evolution.particles), 2)
collision = MMAMS()
collision.parameters.target_n_shells = 100
collision.parameters.dump_mixed_flag = False
collision.parameters.do_shock_heating_flag = False
collision.commit_parameters()
handler = CollisionHandler(
collision,
stellar_evolution_code=stellar_evolution,
verbose=True
)
merged = handler.handle_collision(stellar_evolution.particles[0], stellar_evolution.particles[1])
self.assertTrue(isinstance(merged, ParticlesSubset))
self.assertTrue(merged.number_of_zones > 100)
self.assertEqual(merged[0].key, stellar_evolution.particles[0].key)
self.assertEqual(len(stellar_evolution.particles), 1)
self.assertAlmostRelativeEqual(stellar_evolution.particles[0].mass, 2.73 | units.MSun, 2)
self.assertEqual(handler.collision_code.__class__, MMAMS)
self.assertEqual(handler.collision_code.get_name_of_current_state(), 'INITIALIZED')
collision.stop()
self.assertEqual(handler.collision_code.get_name_of_current_state(), 'STOPPED')
def test4(self):
print("Test 4: merge particles without get_mass_profile, as fast/crude as possible")
stellar_evolution = StellarEvolutionCodeWithInternalStructureForTesting(
has_get_mass_profile=False
)
self.assertEqual(len(stellar_evolution.particles), 2)
handler = CollisionHandler(
MMAMS,
collision_code_parameters=dict(
target_n_shells=100,
dump_mixed_flag=False,
do_shock_heating_flag=False
),
stellar_evolution_code=stellar_evolution,
verbose=True
)
merged = handler.handle_collision(stellar_evolution.particles[0], stellar_evolution.particles[1])
self.assertTrue(isinstance(merged, Particles))
self.assertTrue(merged.number_of_zones > 100)
self.assertEqual(merged[0].key, stellar_evolution.particles[0].key)
self.assertEqual(len(stellar_evolution.particles), 1)
self.assertAlmostRelativeEqual(stellar_evolution.particles[0].mass, 2.73 | units.MSun, 2)
self.assertEqual(handler.collision_code, MMAMS)
def slowtest5(self):
print("Test 5: merge MESA particles with CollisionHandler and MMAMS class")
stellar_evolution = self.new_instance(MESA)
stellar_evolution.particles.add_particles(Particles(2, mass=[20.0, 8.0] | units.MSun))
stellar_evolution.evolve_model(2 | units.Myr)
self.assertEqual(len(stellar_evolution.particles), 2)
handler = CollisionHandler(
MMAMS,
stellar_evolution_code=stellar_evolution,
verbose=True
)
merged = handler.handle_collision(stellar_evolution.particles[0], stellar_evolution.particles[1])
self.assertTrue(isinstance(merged, Particles))
self.assertTrue(merged.number_of_zones > 100)
self.assertEqual(merged[0].key, stellar_evolution.particles[0].key)
self.assertEqual(len(stellar_evolution.particles), 1)
self.assertAlmostEqual(stellar_evolution.particles[0].mass, 25.705 | units.MSun, 1)
self.assertEqual(handler.collision_code, MMAMS)
print(stellar_evolution.particles)
for i in range(10):
stellar_evolution.evolve_model(keep_synchronous=False)
print(stellar_evolution.particles)
stellar_evolution.stop()
def slowtest6(self):
print("Test 6: merge EVtwin particles with CollisionHandler and MMAMS class")
stellar_evolution = EVtwin(redirection="none")
stellar_evolution.particles.add_particles(Particles(2, mass=[20.0, 8.0] | units.MSun))
stellar_evolution.evolve_model(2 | units.Myr)
self.assertEqual(len(stellar_evolution.particles), 2)
stellar_evolution.new_particle_from_model = stub
handler = CollisionHandler(
MMAMS,
stellar_evolution_code=stellar_evolution,
verbose=True
)
merged = handler.handle_collision(stellar_evolution.particles[0], stellar_evolution.particles[1])
self.assertTrue(isinstance(merged, Particles))
self.assertTrue(merged.number_of_zones > 100)
self.assertEqual(merged[0].key, stellar_evolution.particles[0].key)
self.assertEqual(len(stellar_evolution.particles), 1)
self.assertAlmostEqual(stellar_evolution.particles[0].mass, 25.705 | units.MSun, 1)
self.assertEqual(handler.collision_code, MMAMS)
print(stellar_evolution.particles)
for i in range(10):
stellar_evolution.evolve_model(keep_synchronous=False)
print(stellar_evolution.particles)
stellar_evolution.stop()
def stub(instance, internal_structure, current_age, key=None):
tmp_star = Particle(key=key)
tmp_star.mass = internal_structure.mass[-1]
return instance.native_stars.add_particle(tmp_star)
| 60,154
| 50.022053
| 175
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_bonsai.py
|
from amuse.community import *
from amuse.test.amusetest import TestWithMPI
from amuse.community.bonsai.interface import BonsaiInterface, Bonsai
import os
import sys
import numpy
from amuse.units import nbody_system
from amuse.units import units
from amuse import datamodel
from amuse.rfi import channel
from amuse.ic.plummer import new_plummer_model
from amuse.support.exceptions import AmuseException
default_options = dict()
# default_options = dict(redirection="none")
# default_options = dict(redirection="none", debugger="gdb")
class TestBonsaiInterface(TestWithMPI):
def test1(self):
plummer_size = 500
plummer = new_plummer_model(plummer_size)
mass = plummer.mass.number
radius = plummer.radius.number
x = plummer.x.number
y = plummer.y.number
z = plummer.z.number
vx = plummer.vx.number
vy = plummer.vy.number
vz = plummer.vz.number
instance = self.new_instance_of_an_optional_code(BonsaiInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual([0, 0], list(instance.get_number_of_particles().values()))
ids, errors = instance.new_particle(mass, x, y, z, vx, vy, vz, radius)
self.assertEqual(0, errors)
self.assertEqual(list(range(plummer_size)), ids)
self.assertEqual(0, instance.commit_particles())
self.assertEqual([500, 0], list(instance.get_number_of_particles().values()))
masses, errors = instance.get_mass(range(500))
self.assertEqual(0, errors)
self.assertAlmostEqual(0.002, masses)
masses, xs, ys, zs, vxs, vys, vzs, radii, errors = instance.get_state(range(500))
self.assertEqual(0, errors)
self.assertAlmostRelativeEquals(xs, x, 6)
self.assertEqual(0, instance.evolve_model(0.00001))
energy_total_init = instance.get_potential_energy()["potential_energy"] + instance.get_kinetic_energy()["kinetic_energy"]
self.assertEqual(0, instance.evolve_model(1))
energy_total_final = instance.get_potential_energy()["potential_energy"] + instance.get_kinetic_energy()["kinetic_energy"]
self.assertAlmostRelativeEqual(energy_total_init, energy_total_final, 2)
instance.stop()
class TestBonsai(TestWithMPI):
def test1(self):
print("Testing Bonsai initialization")
instance = self.new_instance_of_an_optional_code(Bonsai, **default_options)
instance.initialize_code()
print("cleaning the code")
instance.cleanup_code()
print("done")
instance.stop()
def test2(self):
print("Testing Bonsai parameters")
instance = self.new_instance_of_an_optional_code(Bonsai, **default_options)
instance.initialize_code()
self.assertAlmostEqual(instance.parameters.epsilon_squared, 0.0025 | nbody_system.length**2)
self.assertAlmostEqual(instance.parameters.timestep, 1.0 / 64 | nbody_system.time)
instance.parameters.epsilon_squared = 0.01 | nbody_system.length**2
instance.parameters.timestep = 0.001 | nbody_system.time
instance.commit_parameters()
self.assertAlmostEqual(instance.parameters.epsilon_squared, 0.01 | nbody_system.length**2)
self.assertAlmostEqual(instance.parameters.timestep, 0.001 | nbody_system.time)
instance.stop()
def test3(self):
print("Testing Bonsai, N-body units")
instance = self.new_instance_of_an_optional_code(Bonsai, **default_options)
instance.initialize_code()
plummer = new_plummer_model(500)
instance.particles.add_particles(plummer)
self.assertAlmostEqual(instance.particles.mass, 0.002 | nbody_system.mass)
instance.evolve_model(1.0 | nbody_system.time)
self.assertAlmostEqual(instance.model_time, 1.0 | nbody_system.time)
instance.stop()
def test4(self):
print("Testing Bonsai, SI units")
convert_nbody = nbody_system.nbody_to_si(100.0 | units.MSun, 1.0 | units.parsec)
instance = self.new_instance_of_an_optional_code(Bonsai, convert_nbody, **default_options)
instance.initialize_code()
plummer = new_plummer_model(500, convert_nbody=convert_nbody)
instance.particles.add_particles(plummer)
instance.commit_particles()
instance.evolve_model(1 | nbody_system.time)
instance.stop()
def test5(self):
print("Testing Bonsai remove_particle")
convert_nbody = nbody_system.nbody_to_si(100.0 | units.MSun, 1.0 | units.parsec)
instance = self.new_instance_of_an_optional_code(Bonsai, convert_nbody, **default_options)
instance.initialize_code()
plummer = new_plummer_model(500, convert_nbody=convert_nbody)
instance.particles.add_particles(plummer)
instance.commit_particles()
instance.particles.remove_particle(plummer[0])
# self.assertRaises(AmuseException, instance.particles.remove_particle, plummer[0],
# expected_message = "Error when calling 'delete_particle' of a 'Bonsai', errorcode is -2")
print(instance.particles[0].mass)
instance.stop()
def test6(self):
print("Testing Bonsai states")
plummer = new_plummer_model(500)
print("First do everything manually:")
instance = self.new_instance_of_an_optional_code(Bonsai, **default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particles(plummer)
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
mass = instance.particles[0].mass
instance.evolve_model(0.1 | nbody_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print(("initialize_code(), commit_parameters(), commit_particles(), and cleanup_code() should be called " +
"automatically before editing parameters, new_particle(), get_xx(), and stop():"))
instance = self.new_instance_of_an_optional_code(Bonsai, **default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
timestep = instance.parameters.timestep
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(plummer)
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.1 | nbody_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
def test7(self):
print("Testing Bonsai properties")
numpy.random.seed(12345)
plummer = new_plummer_model(500)
instance = self.new_instance_of_an_optional_code(Bonsai, **default_options)
instance.particles.add_particles(plummer)
self.assertEqual(instance.model_time, 0.0 | nbody_system.time)
instance.evolve_model(0.0001 | nbody_system.time)
print(instance.model_time)
self.assertTrue(instance.model_time >= 0.0001 | nbody_system.time)
self.assertEqual(instance.model_time, 1.0 * instance.parameters.timestep)
self.assertAlmostEqual(instance.potential_energy, -0.486261308193 | nbody_system.energy)
self.assertAlmostEqual(instance.kinetic_energy, 0.244612112641 | nbody_system.energy)
self.assertAlmostEqual(instance.total_mass, 1.0 | nbody_system.mass)
E0 = instance.kinetic_energy + instance.potential_energy
self.assertRaises(AmuseException, getattr, instance, "total_radius", expected_message="Error when calling 'get_total_radius' of a 'Bonsai', errorcode is -2, "
"error is 'Called function is not implemented.'")
self.assertRaises(AmuseException, getattr, instance, "center_of_mass_position", expected_message="Error when calling 'get_center_of_mass_position' of a 'Bonsai', "
"errorcode is -2, error is 'Called function is not implemented.'")
self.assertRaises(AmuseException, getattr, instance, "center_of_mass_velocity", expected_message="Error when calling 'get_center_of_mass_velocity' of a 'Bonsai', "
"errorcode is -2, error is 'Called function is not implemented.'")
instance.evolve_model(1.0 | nbody_system.time)
self.assertAlmostEqual(instance.model_time, 1.0 | nbody_system.time)
self.assertAlmostEqual(instance.potential_energy, -0.4915 | nbody_system.energy, 4)
self.assertAlmostEqual(instance.kinetic_energy, 0.2499 | nbody_system.energy, 4)
self.assertAlmostEqual(
instance.kinetic_energy + instance.potential_energy,
E0, 4)
instance.particles.remove_particle(plummer[2])
instance.evolve_model(2.0 | nbody_system.time)
instance.particles.remove_particle(plummer[20])
instance.particles.remove_particle(plummer[30])
instance.evolve_model(3.0 | nbody_system.time)
instance.particles.remove_particle(plummer[35])
instance.stop()
def test8(self):
print("Testing Bonsai collision_detection")
particles = datamodel.Particles(7)
particles.mass = 0.001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = self.new_instance_of_an_optional_code(Bonsai)
instance.initialize_code()
instance.parameters.set_defaults()
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 3)
self.assertEqual(len(collisions.particles(1)), 3)
self.assertEqual(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = datamodel.Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print(instance.model_time)
print(instance.particles)
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print()
print(instance.model_time)
print(instance.particles)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test9(self):
print("Testing Bonsai tree build exception")
plummer = new_plummer_model(50)
instance = self.new_instance_of_an_optional_code(Bonsai, **default_options)
instance.particles.add_particles(plummer)
instance.particles[0].position -= [1e9, 0, 0] | nbody_system.length
self.assertRaises(AmuseException, instance.evolve_model, 1.0 | nbody_system.time, expected_message="Error when calling 'evolve_model' of a 'Bonsai', errorcode is -4, error is "
"'The tree has become too deep, consider the removal of far away particles to prevent a too large box.'")
instance.particles.remove_particle(instance.particles[0])
instance.evolve_model(0.1 | nbody_system.time)
instance.stop()
| 13,098
| 48.806084
| 184
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_mi6.py
|
import numpy
import math
from amuse.test.amusetest import TestWithMPI
from amuse.units import nbody_system, units, constants
from amuse.datamodel import Particles
from amuse.community.mi6.interface import MI6Interface, MI6
from amuse.ic.plummer import new_plummer_model
default_options = dict()
class TestMI6Interface(TestWithMPI):
def test1(self):
print("Test MI6Interface initialization")
instance = MI6Interface(**default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test2(self):
print("Test MI6Interface new_particle / get_state")
instance = MI6Interface(**default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
id, error = instance.new_particle(mass=11.0, radius=2.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
self.assertEqual(0, error)
self.assertEqual(1, id)
id, error = instance.new_particle(mass=21.0, radius=5.0, x=10.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
self.assertEqual(0, error)
self.assertEqual(2, id)
self.assertEqual(0, instance.commit_particles())
retrieved_state1 = instance.get_state(1)
retrieved_state2 = instance.get_state(2)
self.assertEqual(0, retrieved_state1['__result'])
self.assertEqual(0, retrieved_state2['__result'])
self.assertEqual(11.0, retrieved_state1['mass'])
self.assertEqual(21.0, retrieved_state2['mass'])
self.assertEqual(0.0, retrieved_state1['x'])
self.assertEqual(10.0, retrieved_state2['x'])
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def xtest3(self):
print("Test MI6Interface get_index_of_first_particle, get_index_of_next_particle")
instance = MI6Interface(**default_options)
instance.initialize_code()
instance.commit_parameters()
for i in [1, 2, 3]:
result = instance.new_particle(mass=i, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
self.assertEqual(i, result['index_of_the_particle'])
instance.commit_particles()
self.assertEqual(1, instance.get_index_of_first_particle()['index_of_the_particle'])
self.assertEqual(2, instance.get_index_of_next_particle(1)['index_of_the_next_particle'])
self.assertEqual(3, instance.get_index_of_next_particle(2)['index_of_the_next_particle'])
instance.delete_particle(1)
self.assertEqual(2, instance.get_number_of_particles()['number_of_particles'])
# the deletion does a swap, so 3 is copied to 1, (overwriting old 1 and treesize -> treesize-1
self.assertEqual(3, instance.get_index_of_first_particle()['index_of_the_particle'])
self.assertEqual(1, instance.get_index_of_next_particle(2)['__result'])
instance.cleanup_code()
instance.stop()
def test4(self):
print("Test MI6Interface particle property getters/setters")
instance = MI6Interface(**default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([1, 0], list(instance.new_particle(0.01, 1, 0, 0, 0, 1, 0, 0.1).values()))
self.assertEqual([2, 0], list(instance.new_particle(0.02, -1, 0, 0, 0, -1, 0, 0.1).values()))
self.assertEqual(-3, instance.get_mass(1)['__result']) # Have to commit first
self.assertEqual(0, instance.commit_particles())
# getters
mass, result = instance.get_mass(1)
self.assertAlmostEqual(0.01, mass)
self.assertEqual(0, result)
radius, result = instance.get_radius(2)
self.assertAlmostEqual(0.1, radius)
self.assertEqual(0, result)
self.assertEqual(-3, instance.get_mass(3)['__result']) # Particle not found
self.assertEqual([1, 0, 0, 0], list(instance.get_position(1).values()))
self.assertEqual([-1, 0, 0, 0], list(instance.get_position(2).values()))
self.assertEqual([0, 1, 0, 0], list(instance.get_velocity(1).values()))
self.assertEqual([0, -1, 0, 0], list(instance.get_velocity(2).values()))
# setters
self.assertEqual(0, instance.set_state(1, 0.01, 1, 2, 3, 4, 5, 6, 0.1))
self.assertEqual([0.01, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.1, 0], list(instance.get_state(1).values()))
self.assertEqual(0, instance.set_mass(1, 0.02))
self.assertEqual([0.02, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.1, 0], list(instance.get_state(1).values()))
self.assertEqual(0, instance.set_radius(1, 0.2))
self.assertEqual([0.02, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.2, 0], list(instance.get_state(1).values()))
self.assertEqual(0, instance.set_position(1, 10, 20, 30))
self.assertEqual([0.02, 10.0, 20.0, 30.0, 4.0, 5.0, 6.0, 0.2, 0], list(instance.get_state(1).values()))
self.assertEqual(0, instance.set_velocity(1, 40, 50, 60))
self.assertEqual([0.02, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 0.2, 0], list(instance.get_state(1).values()))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test5(self):
print("Test MI6Interface parameters")
instance = MI6Interface(**default_options)
self.assertEqual(0, instance.initialize_code())
# MI6 has separate epsilon_squared parameters for different interactions!
self.assertEqual([0, 0], list(instance.get_eps2_fs_fs().values()))
self.assertEqual([0, 0], list(instance.get_eps2_fs_bh().values()))
self.assertEqual([0, 0], list(instance.get_eps2_bh_bh().values()))
self.assertEqual(-2, instance.get_eps2()['__result']) # Not implemented (would be ambiguous)
self.assertEqual(0, instance.set_eps2_fs_fs(0.2))
self.assertEqual([0.2, 0], list(instance.get_eps2_fs_fs().values()))
self.assertEqual(0, instance.set_eps2_fs_bh(0.3))
self.assertEqual([0.3, 0], list(instance.get_eps2_fs_bh().values()))
self.assertEqual(0, instance.set_eps2_bh_bh(0.4))
self.assertEqual([0.4, 0], list(instance.get_eps2_bh_bh().values()))
self.assertEqual(-2, instance.set_eps2(0.1)) # Not implemented (would be ambiguous)
self.assertEqual([1.0e-4, 0], list(instance.get_eta_s().values()))
self.assertEqual([0.1, 0], list(instance.get_eta_fs().values()))
self.assertEqual([0.4, 0], list(instance.get_eta_smbh().values()))
self.assertEqual([0.4, 0], list(instance.get_eta_imbh().values()))
self.assertEqual(0, instance.set_eta_s(0.01))
self.assertEqual([0.01, 0], list(instance.get_eta_s().values()))
self.assertEqual(0, instance.set_eta_fs(0.02))
self.assertEqual([0.02, 0], list(instance.get_eta_fs().values()))
self.assertEqual(0, instance.set_eta_smbh(0.03))
self.assertEqual([0.03, 0], list(instance.get_eta_smbh().values()))
self.assertEqual(0, instance.set_eta_imbh(0.04))
self.assertEqual([0.04, 0], list(instance.get_eta_imbh().values()))
self.assertEqual(0, instance.set_max_relative_energy_error(1.0e-6))
self.assertEqual([1.0e-6, 0], list(instance.get_max_relative_energy_error().values()))
self.assertEqual(0, instance.set_maximum_timestep(1.0e-6))
self.assertEqual([1.0e-6, 0], list(instance.get_maximum_timestep().values()))
self.assertEqual(0, instance.set_smbh_mass(0.1))
self.assertEqual([0.1, 0], list(instance.get_smbh_mass().values()))
self.assertEqual([0, 0], list(instance.get_include_smbh_flag().values()))
self.assertEqual(0, instance.set_include_smbh_flag(1))
self.assertEqual([1, 0], list(instance.get_include_smbh_flag().values()))
self.assertEqual([1, 0], list(instance.get_calculate_postnewtonian().values()))
self.assertEqual(0, instance.set_calculate_postnewtonian(0))
self.assertEqual([0, 0], list(instance.get_calculate_postnewtonian().values()))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test6(self):
print("Test MI6Interface evolve_model, single particle (+SMBH)")
instance = MI6Interface(**default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_include_smbh_flag(1))
self.assertEqual(0, instance.set_calculate_postnewtonian(0))
self.assertEqual(0, instance.commit_parameters())
# Set up a light particle on a circular orbit around the SMBH:
self.assertEqual([1, 0], list(instance.new_particle(1.0e-4, 1.0, 0, 0, 0, 1.0, 0, 0.001).values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(math.pi)) # half an orbit
for result, expected in zip(instance.get_position(1).values(), [-1.0, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 4)
self.assertEqual(0, instance.evolve_model(2 * math.pi)) # full orbit
for result, expected in zip(instance.get_position(1).values(), [1.0, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 4)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test7(self):
print("Test MI6Interface evolve_model, 2 particles orbiting the SMBH")
instance = MI6Interface(**default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_include_smbh_flag(1))
self.assertEqual(0, instance.set_calculate_postnewtonian(0))
self.assertEqual(0, instance.commit_parameters())
# Set up a light binary on circular orbits around the SMBH:
mass = 1.0e-4
dv = 0.5 * (math.sqrt(1.0 + 0.5*mass) - 1.0)
self.assertEqual([1, 0], list(instance.new_particle(mass, 1.0, 0, 0, 0, 1.0+dv, 0, 0.001).values()))
self.assertEqual([2, 0], list(instance.new_particle(mass, -1.0, 0, 0, 0, -1.0-dv, 0, 0.001).values()))
self.assertEqual(0, instance.commit_particles())
P = 2 * math.pi / (1 + dv)
self.assertEqual(0, instance.evolve_model(P / 2)) # half an orbit
for result, expected in zip(instance.get_position(1).values(), [-1.0, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 4)
self.assertEqual(0, instance.evolve_model(P)) # full orbit
for result, expected in zip(instance.get_position(1).values(), [1.0, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 4)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test8(self):
print("Test MI6Interface evolve_model, binary (+SMBH) --> accretion!?")
instance = MI6Interface(**default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_include_smbh_flag(1))
self.assertEqual(0, instance.set_calculate_postnewtonian(0))
self.assertEqual(0, instance.commit_parameters())
# Set up a light binary on circular orbits around the SMBH:
mass = 1.0e-6
self.assertEqual([1, 0], list(instance.new_particle(mass, 1.0, 0, 0, 0, 1.0, 0, 0.001).values()))
self.assertEqual([2, 0], list(instance.new_particle(mass, -1.0, 0, 0, 0, -1.0, 0, 0.001).values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(0.00001))
result1 = list(instance.get_position(1).values())
result2 = list(instance.get_position(2).values())
print(result1)
print(result2)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
class TestMI6(TestWithMPI):
default_converter = nbody_system.nbody_to_si(1.0e4 | units.MSun, 1.0 | units.AU)
def new_sun_earth_system(self):
particles = Particles(2)
particles.mass = [1.0, 3.0037e-6] | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * particles.total_mass() / (1.0 | units.AU)).sqrt()
return particles
def test1(self):
print("Testing MI6 initialization")
instance = MI6(self.default_converter, **default_options)
instance.initialize_code()
instance.commit_parameters()
instance.cleanup_code()
instance.stop()
def test2(self):
print("Testing MI6 parameters")
instance = MI6(self.default_converter, **default_options)
instance.initialize_code()
self.assertEqual(instance.parameters.epsilon_squared,
instance.unit_converter.to_si(0.0 | nbody_system.length**2))
self.assertEqual(instance.parameters.timestep_parameter, 0.1)
for par, value in [('epsilon_squared_star_star', 0.0 | nbody_system.length**2),
('epsilon_squared_star_blackhole', 0.0 | nbody_system.length**2),
('epsilon_squared_blackhole_blackhole', 0.0 | nbody_system.length**2),
('initial_timestep_parameter', 1.0e-4),
('timestep_parameter_stars', 0.1),
('timestep_parameter_supermassive_black_holes', 0.4),
('timestep_parameter_intermediate_mass_black_holes', 0.4),
('max_relative_energy_error', 5.0e-5),
('maximum_timestep', 1.0/1024.0 | nbody_system.time),
('smbh_mass', 1.0 | nbody_system.mass),
('lightspeed', 1.0 | nbody_system.speed)]:
self.assertEqual(instance.unit_converter.to_si(value),
getattr(instance.parameters, par))
if hasattr(value, 'unit'):
new_value = 3.0 | value.unit
else:
new_value = 3.0
setattr(instance.parameters, par, new_value)
self.assertEqual(instance.unit_converter.to_si(new_value),
getattr(instance.parameters, par))
# epsilon_squared is an alias for epsilon_squared_star_star, so epsilon_squared also has become 3:
self.assertEqual(instance.parameters.epsilon_squared,
instance.unit_converter.to_si(3.0 | nbody_system.length**2))
instance.parameters.epsilon_squared = 0.1 | nbody_system.length**2
self.assertEqual(instance.parameters.epsilon_squared,
instance.unit_converter.to_si(0.1 | nbody_system.length**2))
# timestep_parameter is an alias for timestep_parameter_stars, so timestep_parameter also has become 3:
self.assertEqual(instance.parameters.timestep_parameter, 3.0)
instance.parameters.timestep_parameter = 0.01
self.assertEqual(instance.parameters.timestep_parameter, 0.01)
self.assertEqual(instance.parameters.include_smbh, False)
instance.parameters.include_smbh = True
self.assertEqual(instance.parameters.include_smbh, True)
self.assertEqual(instance.parameters.calculate_postnewtonian, True)
instance.parameters.calculate_postnewtonian = False
self.assertEqual(instance.parameters.calculate_postnewtonian, False)
self.assertEqual(instance.parameters.drink, "Vodka martini. Shaken, not stirred.")
instance.stop()
def test3(self):
print("Testing MI6 particles")
instance = MI6(self.default_converter, **default_options)
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(self.new_sun_earth_system())
instance.commit_particles()
self.assertAlmostEqual(instance.particles.mass, [1.0, 3.0037e-6] | units.MSun)
self.assertAlmostEqual(instance.particles.radius, 1.0 | units.RSun)
self.assertAlmostEqual(instance.particles.position,
[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU)
self.assertAlmostEqual(instance.particles.velocity,
[[0.0, 0.0, 0.0], [0.0, 29.7885, 0.0]] | units.km / units.s, 3)
instance.cleanup_code()
instance.stop()
def test4(self):
print("Testing MI6 evolve_model, 2 particles orbiting the SMBH")
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = ((constants.G * (10001.0 | units.MSun) / (1.0 | units.AU)).sqrt() +
(constants.G * (10000.0 | units.MSun) / (1.0 | units.AU)).sqrt())
particles.move_to_center()
print(particles)
instance = MI6(self.default_converter, **default_options)
instance.initialize_code()
instance.parameters.include_smbh = True
instance.parameters.lightspeed = constants.c
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
P_corrected = (P) * (2.0 / (1.0 + math.sqrt(1.0001)))
position_at_start = primary.position.x
instance.evolve_model(P_corrected / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3)
instance.evolve_model(P_corrected / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3)
instance.evolve_model(P_corrected)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3)
instance.cleanup_code()
instance.stop()
def test5(self):
print("Testing MI6 evolve_model, 2 particles, no SMBH")
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * (2.0 | units.MSun) / (2.0 | units.AU)).sqrt()
particles.move_to_center()
print(particles)
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = MI6(converter, **default_options)
instance.initialize_code()
instance.parameters.smbh_mass = 0.0 | units.MSun
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3)
instance.cleanup_code()
instance.stop()
def test6(self):
print("Testing MI6 evolve_model, earth-sun system, no SMBH")
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = MI6(converter, **default_options)
instance.initialize_code()
instance.parameters.smbh_mass = 0.0 | units.MSun
instance.commit_parameters()
instance.particles.add_particles(self.new_sun_earth_system())
instance.commit_particles()
earth = instance.particles[1]
position_at_start = earth.position.x
instance.evolve_model(0.25 | units.yr)
self.assertAlmostRelativeEqual(position_at_start, earth.position.y, 3)
instance.evolve_model(0.5 | units.yr)
self.assertAlmostRelativeEqual(position_at_start, -earth.position.x, 3)
instance.evolve_model(1.0 | units.yr)
self.assertAlmostRelativeEqual(position_at_start, earth.position.x, 3)
instance.cleanup_code()
instance.stop()
def test7(self):
print("Testing effect of MI6 parameter epsilon_squared")
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
particles = self.new_sun_earth_system()
particles.rotate(0.0, 0.0, -math.pi/4)
particles.move_to_center()
tan_initial_direction = particles[1].vy/particles[1].vx
self.assertAlmostEqual(tan_initial_direction, math.tan(math.pi/4))
tan_final_direction = []
for log_eps2 in range(-9, 10, 2):
instance = MI6(converter, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU ** 2
instance.parameters.smbh_mass = 0.0 | units.MSun
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.25 | units.yr)
tan_final_direction.append(instance.particles[1].velocity[1] /
instance.particles[1].velocity[0])
instance.cleanup_code()
instance.stop()
# Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees
self.assertAlmostEqual(tan_final_direction[0], math.tan(3 * math.pi / 4.0), 2)
# Large values of epsilon_squared should result in ~ no interaction
self.assertAlmostEqual(tan_final_direction[-1], tan_initial_direction, 2)
# Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2
delta = [abs(tan_final_direction[i+1]-tan_final_direction[i]) for i in range(len(tan_final_direction)-1)]
self.assertEqual(delta[len(tan_final_direction)//2 - 1], max(delta))
def test8(self):
print("Testing MI6 get_gravity_at_point and get_potential_at_point")
instance = MI6(**default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
instance.parameters.smbh_mass = 0.0 | nbody_system.mass
particles = Particles(2)
particles.mass = 1.0 | nbody_system.mass
particles.radius = 0.0 | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, 1.0 | nbody_system.length, zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fx0, -1.0 * fx1)
fx = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0)
self.assertAlmostEqual(potential0, potential1)
instance.stop()
def test9(self):
print("Testing MI6 evolve_model and getters energy, plummer sphere, no SMBH")
converter = nbody_system.nbody_to_si(1.0e2 | units.MSun, 1.0 | units.parsec)
instance = MI6(converter, **default_options)
instance.initialize_code()
instance.parameters.smbh_mass = 0.0 | units.MSun
instance.commit_parameters()
numpy.random.seed(987654321)
instance.particles.add_particles(new_plummer_model(100, convert_nbody=converter))
instance.commit_particles()
kinetic_energy = instance.kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy, 2.12292810174e+37 | units.J, 10)
self.assertAlmostRelativeEqual(potential_energy, -4.33511391248e+37 | units.J, 10)
initial_total_energy = kinetic_energy + potential_energy
instance.evolve_model(0.1 | nbody_system.time)
kinetic_energy = instance.kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy, 2.13633848369e+37 | units.J, 5)
self.assertAlmostRelativeEqual(potential_energy, -4.34851806763e+37 | units.J, 5)
self.assertAlmostRelativeEqual(potential_energy + kinetic_energy, initial_total_energy, 5)
instance.cleanup_code()
instance.stop()
def test10(self):
print("Testing MI6 collision_detection")
particles = Particles(7)
particles.mass = 0.00000001 | nbody_system.mass
particles.radius = 0.0001 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = MI6(**default_options)
instance.initialize_code()
instance.parameters.set_defaults()
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertAlmostEqual(instance.model_time, -(particles[0].x-particles[1].x)/(particles[0].vx-particles[1].vx), 3)
self.assertEqual(len(collisions.particles(0)), 3)
self.assertEqual(len(collisions.particles(1)), 3)
self.assertEqual(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print(instance.model_time)
print(instance.particles)
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print()
print(instance.model_time)
print(instance.particles)
self.assertTrue(collisions.is_set())
self.assertAlmostEqual(instance.model_time, -(particles[6].x-0.5*(particles[4].x+particles[5].x))/particles[6].vx, 3)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test11(self):
print("Testing MI6 properties")
numpy.random.seed(12345)
particles = new_plummer_model(100, do_scale=True)
particles.position += [1, 2, 3] | nbody_system.length
cluster_velocity = [4, 5, 6] | nbody_system.speed
particles.velocity += cluster_velocity
external_kinetic_energy = (0.5 | nbody_system.mass) * cluster_velocity.length_squared()
instance = MI6(**default_options)
instance.particles.add_particles(particles)
kinetic_energy = instance.kinetic_energy - external_kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy, 0.25 | nbody_system.energy, 10)
self.assertAlmostRelativeEqual(potential_energy, -0.5 | nbody_system.energy, 10)
self.assertAlmostRelativeEqual(instance.total_mass, 1.0 | nbody_system.mass, 10)
self.assertAlmostRelativeEqual(instance.center_of_mass_position,
[1, 2, 3] | nbody_system.length, 10)
self.assertAlmostRelativeEqual(instance.center_of_mass_velocity,
[4, 5, 6] | nbody_system.speed, 10)
initial_total_energy = kinetic_energy + potential_energy
instance.evolve_model(0.1 | nbody_system.time)
self.assertAlmostRelativeEqual(instance.model_time, 0.1 | nbody_system.time)
kinetic_energy = instance.kinetic_energy - external_kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy+potential_energy, -0.25 | nbody_system.energy, 3)
self.assertAlmostRelativeEqual(instance.total_mass, 1.0 | nbody_system.mass, 3)
self.assertAlmostRelativeEqual(instance.center_of_mass_position,
[1.4, 2.5, 3.6] | nbody_system.length, 3)
self.assertAlmostRelativeEqual(instance.center_of_mass_velocity,
[4, 5, 6] | nbody_system.speed, 3)
instance.cleanup_code()
instance.stop()
| 30,287
| 48.168831
| 125
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_parallel.py
|
from amuse.test.amusetest import TestWithMPI
import os
import sys
from amuse.community.hermite.interface import Hermite
from amuse.community.bhtree.interface import BHTree
import numpy
import threading
from amuse.units import nbody_system
from amuse.units import units
from amuse.datamodel import Particles
try:
from matplotlib import pyplot
HAS_MATPLOTLIB = True
except ImportError:
HAS_MATPLOTLIB = False
class TestAmuseInterface(TestWithMPI):
def new_system_sun_and_earth(self):
result = Particles(2)
sun = result[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = result[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
return result
def evolve_model_unit_day(self, instance, particles, day):
delta_days = 5
for x in range(1, day + delta_days, delta_days):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(particles)
particles.savepoint()
def test1(self):
from amuse.rfi import channel
channel.MpiChannel.ensure_mpi_initialized()
is_threaded = channel.MpiChannel.is_threaded()
is_multithreading_supported = channel.MpiChannel.is_multithreading_supported()
self.assertEqual(is_threaded, is_multithreading_supported)
def test2(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
bhtree = BHTree(convert_nbody)
bhtree.initialize_code()
bhtree.eps2_for_gravity = 0.001
bhtree_particles = self.new_system_sun_and_earth()
bhtree.particles.add_particles(bhtree_particles)
if bhtree.legacy_interface.channel_type == 'mpi':
from mpi4py import MPI
if not MPI.Query_thread() == MPI.THREAD_MULTIPLE:
bhtree.stop()
self.skip("can only test parallel with multiple thread support in mpi implementation")
hermite = Hermite(convert_nbody)
hermite.dt_dia = 5000
hermite.commit_parameters()
hermite_particles = self.new_system_sun_and_earth()
hermite.particles.add_particles(hermite_particles)
thread1 = threading.Thread(target=self.evolve_model_unit_day, args=(bhtree, bhtree_particles, 10))
thread2 = threading.Thread(target=self.evolve_model_unit_day, args=(hermite, hermite_particles, 10))
thread1.start()
thread2.start()
thread1.join()
thread2.join()
if HAS_MATPLOTLIB:
figure = pyplot.figure()
plot = figure.add_subplot(1, 1, 1)
earth = bhtree_particles[1]
x_points = earth.get_timeline_of_attribute("x")
y_points = earth.get_timeline_of_attribute("y")
x_points_in_AU = [t_x[1].value_in(units.AU) for t_x in x_points]
y_points_in_AU = [t_x1[1].value_in(units.AU) for t_x1 in y_points]
plot.scatter(x_points_in_AU, y_points_in_AU, color="b", marker='o')
earth = hermite_particles[1]
x_points = earth.get_timeline_of_attribute("x")
y_points = earth.get_timeline_of_attribute("y")
x_points_in_AU = [t_x2[1].value_in(units.AU) for t_x2 in x_points]
y_points_in_AU = [t_x3[1].value_in(units.AU) for t_x3 in y_points]
plot.scatter(x_points_in_AU, y_points_in_AU, color="g", marker='o')
plot.set_xlim(-1.5, 1.5)
plot.set_ylim(-1.5, 1.5)
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "parallel-earth-sun.svg")
figure.savefig(output_file)
bhtree.stop()
hermite.stop()
bhtree.stop()
| 4,044
| 34.79646
| 108
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_aarsethzare.py
|
from amuse.test.amusetest import TestWithMPI
import os
import sys
import numpy
import math
from amuse.community.aarsethzare.interface import AarsethZareInterface, AarsethZare
from amuse.units import nbody_system
from amuse.units import units
from amuse import datamodel
from amuse.ic import plummer
try:
from matplotlib import pyplot
HAS_MATPLOTLIB = True
except ImportError:
HAS_MATPLOTLIB = False
class TestAarsethZareInterface(TestWithMPI):
def test0(self):
instance = AarsethZareInterface()
instance.stop()
def test1(self):
instance = AarsethZareInterface()
time, x, y, z, vx, vy, vz, error = instance.evolve_triple(
[0, 0, 0],
[1, 1, 1],
[-10, 0, 10],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[1.0, 1.0, 1.0]
)
print(time, x, y, z, vx, vy, vz, error)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(y, [0, 0, 0])
self.assertAlmostRelativeEquals(z, [0, 0, 0])
self.assertAlmostRelativeEquals(x[-1], -x[0], 10)
self.assertAlmostRelativeEquals(x[1], 0, 10)
self.assertAlmostRelativeEquals(vx[-1], -vx[0], 10)
self.assertAlmostRelativeEquals(vx[1], 0, 10)
self.assertAlmostRelativeEquals(vy, [0, 0, 0])
self.assertAlmostRelativeEquals(vz, [0, 0, 0])
def test2(self):
instance = AarsethZareInterface()
time, x, y, z, vx, vy, vz, error = instance.evolve_triple(
[0, 0],
[1, 1],
[-10, 0],
[0, 0],
[0, 0],
[0, 0],
[0, 0],
[0, 0],
[1.0]
)
self.assertEqual(error, -1)
class TestAarsethZare(TestWithMPI):
def new_system_of_sun_and_earth_and_moon(self):
stars = datamodel.Stars(3)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
moon = stars[2]
moon.mass = units.kg(7.3477e22)
moon.radius = units.km(1737.10)
moon.position = units.km(numpy.array((149.5e6 + 384399.0, 0.0, 0.0)))
moon.velocity = ([0.0, 1.022, 0] | units.km/units.s) + earth.velocity
return stars
def test0(self):
instance = AarsethZare()
instance.stop()
def test1(self):
instance = AarsethZare()
time, x, y, z, vx, vy, vz = instance.evolve_triple(
[0, 0, 0] | nbody_system.time,
[1, 1, 1] | nbody_system.mass,
[-10, 0, 10] | nbody_system.length,
[0, 0, 0] | nbody_system.length,
[0, 0, 0] | nbody_system.length,
[0, 0, 0] | nbody_system.speed,
[0, 0, 0] | nbody_system.speed,
[0, 0, 0] | nbody_system.speed,
[1.0, 1.0, 1.0] | nbody_system.time
)
self.assertAlmostRelativeEquals(y, [0, 0, 0] | nbody_system.length)
self.assertAlmostRelativeEquals(z, [0, 0, 0] | nbody_system.length)
self.assertAlmostRelativeEquals(x[-1], -x[0], 10)
self.assertAlmostRelativeEquals(x[1], 0 | nbody_system.length, 10)
self.assertAlmostRelativeEquals(vx[-1], -vx[0], 10)
self.assertAlmostRelativeEquals(vx[1], 0 | nbody_system.speed, 10)
self.assertAlmostRelativeEquals(vy, [0, 0, 0] | nbody_system.speed)
self.assertAlmostRelativeEquals(vz, [0, 0, 0] | nbody_system.speed)
def test2(self):
instance = AarsethZare()
particles = datamodel.Particles(3)
particles.mass = 1.0 | nbody_system.mass
particles.position = [
[-10.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[10.0, 0.0, 0.0],
] | nbody_system.length
particles.velocity = [0.0, 0.0, 0.0] | nbody_system.speed
instance.particles.add_particles(particles)
instance.evolve_model(1.0 | nbody_system.time)
self.assertAlmostRelativeEquals(instance.particles.y, [0, 0, 0] | nbody_system.length)
self.assertAlmostRelativeEquals(instance.particles.z, [0, 0, 0] | nbody_system.length)
self.assertAlmostRelativeEquals(instance.particles.x[-1], -instance.particles.x[0], 10)
self.assertAlmostRelativeEquals(instance.particles.x[1], 0 | nbody_system.length, 10)
self.assertAlmostRelativeEquals(instance.particles.vx[-1], -instance.particles.vx[0], 10)
self.assertAlmostRelativeEquals(instance.particles.vx[1], 0 | nbody_system.speed, 10)
self.assertAlmostRelativeEquals(instance.particles.vy, [0, 0, 0] | nbody_system.speed)
self.assertAlmostRelativeEquals(instance.particles.vz, [0, 0, 0] | nbody_system.speed)
def test3(self):
instance = AarsethZare(nbody_system.nbody_to_si(1.0 | units.yr, 1.0 | units.MSun))
particles = self.new_system_of_sun_and_earth_and_moon()
instance.particles.add_particles(particles)
earth = instance.particles[1]
position_at_start = earth.position[0]
instance.evolve_model(365.0 | units.day)
position_after_full_rotation = earth.position[0]
self.assertAlmostRelativeEquals(position_at_start, position_after_full_rotation, 4)
instance.evolve_model(1.5 | units.yr)
position_after_half_a_rotation = earth.position[0]
self.assertAlmostRelativeEquals(-position_at_start, position_after_half_a_rotation, 2)
instance.evolve_model(1.75 | units.yr)
position_after_quarter_a_rotation = earth.position[1]
self.assertAlmostRelativeEquals(position_at_start, position_after_quarter_a_rotation, 2)
instance.stop()
| 6,044
| 34.145349
| 97
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_krome.py
|
import os.path
import numpy
from amuse.test.amusetest import TestWithMPI
from amuse.community.krome.interface import KromeInterface, Krome, solar_abundances
from amuse.units import units
from amuse.datamodel import Particles
from amuse.io import read_set_from_file
# default_options={}
default_options = dict(redirection="none")
# default_options=dict(debugger="gdb")
class TestKromeInterface(TestWithMPI):
def test1(self):
print("Test 1: initialization")
instance = self.new_instance_of_an_optional_code(KromeInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test2(self):
print("Test 1: add particle, get state")
instance = self.new_instance_of_an_optional_code(KromeInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
dens = 1.e5
t = 500.
ion = 1.e-11
id, err = instance.new_particle(dens, t, ion)
self.assertEqual(err, 0)
self.assertEqual(instance.commit_particles(), 0)
dens_, t_, ion_, err = instance.get_state(id)
self.assertEqual(err, 0)
self.assertEqual(dens_, dens)
self.assertEqual(t_, t)
self.assertEqual(ion_, ion)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test3(self):
print("Test 1: add 2 particles, get state")
instance = self.new_instance_of_an_optional_code(KromeInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
dens = [1.e5, 2.e5]
t = [500., 550]
ion = [1.e-11, 2.e-11]
id, err = instance.new_particle(dens, t, ion)
self.assertEqual(err, 0)
self.assertEqual(instance.commit_particles(), 0)
for i in range(2):
dens_, t_, ion_, err = instance.get_state(id[i])
self.assertEqual(err, 0)
self.assertEqual(dens_, dens[i])
self.assertEqual(t_, t[i])
self.assertEqual(ion_, ion[i])
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test4(self):
print("Test 1: add 100 particles, get state")
instance = self.new_instance_of_an_optional_code(KromeInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
dens = 1.e5*numpy.random.random(100)
t = 500.*numpy.random.random(100)
ion = 1.e-11*numpy.random.random(100)
id, err = instance.new_particle(dens, t, ion)
self.assertEqual(err, 0)
self.assertEqual(instance.commit_particles(), 0)
for i in range(100):
dens_, t_, ion_, err = instance.get_state(id[i])
self.assertEqual(err, 0)
self.assertEqual(dens_, dens[i])
self.assertEqual(t_, t[i])
self.assertEqual(ion_, ion[i])
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test5(self):
print("Test 5: can we get species?")
instance = self.new_instance_of_an_optional_code(KromeInterface, **default_options)
first, last, err = instance.get_firstlast_abundance()
self.assertEqual(err, 0)
self.assertTrue(last-first > 0)
for i in range(first, last+1):
name, err = instance.get_name_of_species(i)
print(name)
self.assertEqual(err, 0)
index, err = instance.get_index_of_species(name)
self.assertEqual(i, index)
instance.stop()
def test6(self):
print("Test 6: add 100 particles, remove particles")
instance = self.new_instance_of_an_optional_code(KromeInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
dens = 1.e5*numpy.random.random(100)
t = 500.*numpy.random.random(100)
ion = 1.e-11*numpy.random.random(100)
ids, err = instance.new_particle(dens, t, ion)
self.assertEqual(err, 0)
self.assertEqual(instance.commit_particles(), 0)
for i in ids[:10]:
instance.delete_particle(i)
instance.recommit_particles()
for i in range(10, 100):
dens_, t_, ion_, err = instance.get_state(ids[i])
self.assertEqual(err, 0)
self.assertEqual(dens_, dens[i])
self.assertEqual(t_, t[i])
self.assertEqual(ion_, ion[i])
dens_, t_, ion_, err = instance.get_state(ids[0])
self.assertEqual(err, -1)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test7(self):
print("Test 1: add particle, set abundances")
instance = self.new_instance_of_an_optional_code(KromeInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
dens = 1.e5
t = 500.
ion = 1.e-11
id, err = instance.new_particle(dens, t, ion)
instance.commit_particles()
first, last, err = instance.get_firstlast_abundance()
for i in range(first, last+1):
x, err = instance.get_abundance(id, i)
self.assertTrue((x >= 0.) & (x <= 1.))
self.assertEqual(err, 0)
x, err = instance.get_abundance(id, last+1)
self.assertEqual(err, -1)
for s in ["H", "HE", "C", "SI", "O"]:
x = solar_abundances[s]
aid, err = instance.get_index_of_species(s)
instance.set_abundance(id, aid, x)
for s in ["H", "HE", "C", "SI", "O"]:
x = solar_abundances[s]
aid, err = instance.get_index_of_species(s)
xx, err = instance.get_abundance(id, aid)
self.assertEqual(x, xx)
self.assertEqual(err, 0)
def test8(self):
print("evolve test")
instance = self.new_instance_of_an_optional_code(KromeInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
dens = 1.e2
t = 100.
ion = 2.e-17
id, err = instance.new_particle(dens, t, ion)
first, last, err = instance.get_firstlast_abundance()
for i in range(first, last+1):
err = instance.set_abundance(id, i, 1.e-40)
for s in ["H", "HE", "C", "SI", "O"]:
x = solar_abundances[s]
aid, err = instance.get_index_of_species(s)
instance.set_abundance(id, aid, x)
instance.commit_particles()
yr = 365*24*3600.
err = instance.evolve_model(10000.*yr)
self.assertEqual(err, 0)
time, err = instance.get_time()
self.assertEqual(err, 0)
self.assertEqual(time, 10000.*yr)
first, last, err = instance.get_firstlast_abundance()
for i in range(first, last+1):
x, err = instance.get_abundance(id, i)
self.assertEqual(err, 0)
name, err = instance.get_name_of_species(i)
print(i, name, x)
def test9(self):
print("evolve test 2")
instance = self.new_instance_of_an_optional_code(KromeInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
dens = 1.e2
t = 100.
ion = 2.e-17
id, err = instance.new_particle(dens, t, ion)
first, last, err = instance.get_firstlast_abundance()
for i in range(first, last+1):
err = instance.set_abundance(id, i, 1.e-40)
for s in ["H", "HE", "C", "SI", "O"]:
x = solar_abundances[s]
aid, err = instance.get_index_of_species(s)
instance.set_abundance(id, aid, x)
aid, err = instance.get_index_of_species("C")
instance.set_abundance(id, aid, 1.e-40)
aid, err = instance.get_index_of_species("C+")
instance.set_abundance(id, aid, solar_abundances["C"])
aid, err = instance.get_index_of_species("H2")
instance.set_abundance(id, aid, 1.e-6)
aid, err = instance.get_index_of_species("H+")
instance.set_abundance(id, aid, 1.e-4)
instance.commit_particles()
yr = 365*24*3600.
err = instance.evolve_model(10000.*yr)
self.assertEqual(err, 0)
time, err = instance.get_time()
self.assertEqual(err, 0)
self.assertEqual(time, 10000.*yr)
first, last, err = instance.get_firstlast_abundance()
for i in range(first, last+1):
x, err = instance.get_abundance(id, i)
self.assertEqual(err, 0)
name, err = instance.get_name_of_species(i)
print(i, name, x)
def test10(self):
print("check initialization of abundances")
instance = self.new_instance_of_an_optional_code(KromeInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
dens = 1.e2
t = 100.
ion = 2.e-17
id, err = instance.new_particle(dens, t, ion)
abundances = {"E": 0.000369180975425,
"H+": 0.0001, "HE": 0.0775,
"C+": 0.000269180975425, "SI": 3.2362683404e-05,
"O": 0.000489828841345}
first, last, err = instance.get_firstlast_abundance()
for i in range(first, last+1):
x, err = instance.get_abundance(id, i)
self.assertEqual(err, 0)
name, err = instance.get_name_of_species(i)
if name in abundances:
self.assertAlmostEqual(x, abundances[name], 12)
def test11(self):
print("evolve test, comparison")
instance = self.new_instance_of_an_optional_code(KromeInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
dens = 1.e2
t = 100.
ion = 2.e-17
id, err = instance.new_particle(dens, t, ion)
instance.evolve_model(1.e10)
result1 = {}
first, last, err = instance.get_firstlast_abundance()
for i in range(first, last+1):
x, err = instance.get_abundance(id, i)
self.assertEqual(err, 0)
name, err = instance.get_name_of_species(i)
result1[name] = x
instance = self.new_instance_of_an_optional_code(KromeInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
dens = 1.e2
t = 100.
ion = 2.e-17
id, err = instance.new_particle(dens, t, ion)
instance.evolve_model(1.e9)
instance.evolve_model(5.e9)
instance.evolve_model(1.e10)
result2 = {}
first, last, err = instance.get_firstlast_abundance()
for i in range(first, last+1):
x, err = instance.get_abundance(id, i)
self.assertEqual(err, 0)
name, err = instance.get_name_of_species(i)
result2[name] = x
for x in result1:
self.assertAlmostEqual(result1[x], result2[x])
class TestKrome(TestWithMPI):
def makeparts(self, N):
parts = Particles(N)
numpy.random.seed(1234567)
parts.number_density = (numpy.random.random(N)*1.e5+1.e5) | units.cm**-3
parts.temperature = (numpy.random.random(N)*500+100) | units.K
parts.ionrate = (numpy.random.random(N)*1.e-11+1.e-17) | units.s**-1
return parts
def test0(self):
print("test1: basic startup and flow")
instance = self.new_instance_of_an_optional_code(Krome)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
instance.stop()
def test1(self):
print("test1: adding particles")
instance = self.new_instance_of_an_optional_code(Krome)
parts = self.makeparts(5)
self.assertEqual(len(instance.particles), 0)
instance.particles.add_particles(parts)
self.assertEqual(len(instance.particles), len(parts))
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
part2 = instance.particles.copy()
self.assertAlmostRelativeEquals(parts.number_density, part2.number_density, 12)
self.assertAlmostRelativeEquals(parts.temperature, part2.temperature, 12)
self.assertAlmostRelativeEquals(parts.ionrate, part2.ionrate, 12)
for p in part2:
i = instance.species["E"]
self.assertAlmostEqual(p.abundances[i], 0.000369180975425)
i = instance.species["H+"]
self.assertAlmostEqual(p.abundances[i], 0.0001)
i = instance.species["HE"]
self.assertAlmostEqual(p.abundances[i], 0.0775)
i = instance.species["C+"]
self.assertAlmostEqual(p.abundances[i], 0.000269180975425)
i = instance.species["SI"]
self.assertAlmostEqual(p.abundances[i], 3.2362683404e-05)
i = instance.species["O"]
self.assertAlmostEqual(p.abundances[i], 0.000489828841345)
instance.cleanup_code()
instance.stop()
def test2(self):
print("test2: adding particles w abund.")
instance = self.new_instance_of_an_optional_code(Krome)
parts = self.makeparts(5)
N = len(instance.species)
parts.abundances = numpy.zeros((5, N))
for i in range(5):
parts[i].abundances = (numpy.array(range(N))+1)/(N+1.)
instance.particles.add_particles(parts)
channel = parts.new_channel_to(instance.particles)
channel.copy()
part2 = instance.particles.copy()
self.assertAlmostRelativeEquals(parts.number_density, part2.number_density, 12)
self.assertAlmostRelativeEquals(parts.temperature, part2.temperature, 12)
self.assertAlmostRelativeEquals(parts.ionrate, part2.ionrate, 12)
for i in range(5):
self.assertAlmostRelativeEquals(part2[i].abundances, parts[i].abundances, 12)
instance.cleanup_code()
instance.stop()
def test3(self):
print("test3: evolve test")
instance = self.new_instance_of_an_optional_code(Krome, **default_options)
parts = Particles(1)
parts.number_density = 1.e5 | units.cm**-3
parts.temperature = 50 | units.K
parts.ionrate = 2.e-17 | units.s**-1
Ns = len(instance.species)
parts.abundances = numpy.zeros((1, Ns))
instance.particles.add_particles(parts)
instance.evolve_model(1. | units.Myr)
print(instance.particles.abundances)
f = 2*instance.particles[0].abundances[instance.species["H2"]]
self.assertTrue(f > 0.95) # not much of a test..
# ~ for x,i in instance.species.items():
# ~ print x, instance.particles[0].abundances[i]
instance.cleanup_code()
instance.stop()
def test4(self):
print("test4: evolve test (10 part)")
instance = self.new_instance_of_an_optional_code(Krome, **default_options)
parts = Particles(10)
parts.number_density = 1.e5 | units.cm**-3
parts.temperature = 50 | units.K
parts.ionrate = 2.e-17 | units.s**-1
Ns = len(instance.species)
parts.abundances = numpy.zeros((10, Ns))
instance.particles.add_particles(parts)
instance.evolve_model(1. | units.Myr)
f = 2*instance.particles[0].abundances[instance.species["H2"]]
self.assertTrue(f > 0.95) # not much of a test..
# ~ for x,i in instance.species.items():
# ~ print x, instance.particles[0].abundances[i]
instance.cleanup_code()
instance.stop()
| 16,525
| 31.986028
| 91
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_nbody6xx.py
|
from amuse.community import *
from amuse.test.amusetest import TestWithMPI
from amuse.community.nbody6xx.interface import Nbody6xxInterface
from amuse.community.nbody6xx.interface import Nbody6xx
import math
class Nbody6xxInterfaceTests(TestWithMPI):
def test1(self):
instance = Nbody6xxInterface()
instance.initialize_code()
res1 = instance.new_particle(mass=11.0, radius=2.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
res2 = instance.new_particle(mass=21.0, radius=5.0, x=10.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
self.assertEqual(1, res1['index_of_the_particle'])
self.assertEqual(2, res2['index_of_the_particle'])
retrieved_state1 = instance.get_state(1)
retrieved_state2 = instance.get_state(2)
self.assertEqual(11.0, retrieved_state1['mass'])
self.assertEqual(21.0, retrieved_state2['mass'])
self.assertEqual(0.0, retrieved_state1['x'])
self.assertEqual(10.0, retrieved_state2['x'])
# self.assertEquals(2.0, retrieved_state1['radius'])
# self.assertEquals(5.0, retrieved_state2['radius'])
instance.cleanup_code()
instance.stop()
def test2(self):
instance = Nbody6xxInterface()
instance.initialize_code()
instance.new_particle([10, 20], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1])
retrieved_state = instance.get_state(1)
self.assertEqual(10.0, retrieved_state['mass'])
# self.assertEquals(1, retrieved_state['radius'])
retrieved_state = instance.get_state([1, 2])
self.assertEqual(20.0, retrieved_state['mass'][1])
self.assertEqual(instance.get_number_of_particles()['number_of_particles'], 2)
instance.cleanup_code()
instance.stop()
def xtest3(self):
instance = Nbody6xxInterface(redirection="none") # ,debugger="ddd")
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
# Set up an equal-mass binary on a circular orbit:
self.assertEqual([1, 0], list(instance.new_particle(0.5, 0.5, 0, 0, 0, 0.5, 0, 0.01).values()))
self.assertEqual([2, 0], list(instance.new_particle(0.5, -0.5, 0, 0, 0, -0.5, 0, 0.01).values()))
self.assertEqual([3, 0], list(instance.new_particle(100.5, -0.5, 0, 0, 0, -0.5, 0, 0.01).values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(math.pi))
for result, expected in zip(instance.get_position(1).values(), [-0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
for result, expected in zip(instance.get_position(2).values(), [0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
self.assertEqual(0, instance.evolve_model(2 * math.pi))
for result, expected in zip(instance.get_position(1).values(), [0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
for result, expected in zip(instance.get_position(2).values(), [-0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
| 3,256
| 41.855263
| 109
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_petar.py
|
from amuse.test.amusetest import TestWithMPI
import numpy
from amuse.community.petar.interface import PetarInterface, Petar
from amuse.units import nbody_system
from amuse import datamodel
from amuse.ic import plummer
from amuse.ic.plummer import new_plummer_model
from .gd_tests import _TestGravitationalDynamicsInterface
class TestPetarInterface(_TestGravitationalDynamicsInterface, TestWithMPI):
PRECISION = 6
def gravity_code_interface(self):
return PetarInterface
def reference_includes(self):
return "Wang"
def starting_particle_index(self):
return 1
def check_for_energy(self, *args, **kwargs):
return self.assertAlmostEqual(*args, **kwargs, places=self.PRECISION)
def test_reversed_time_allowed(self):
self.skip("not supported")
class TestPetar(TestWithMPI):
def test_small_plummer_model(self):
particles = plummer.new_plummer_model(31)
instance = Petar(number_of_workers=1) # , debugger="xterm")
instance.initialize_code()
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
expected_positions = instance.particles.position
instance.stop()
positions_per_workers = []
for n in [2, 3, 4, 5]:
instance = Petar(number_of_workers=n)
instance.initialize_code()
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
positions_per_workers.append(instance.particles.position)
instance.stop()
for index, n in enumerate([2, 3, 4, 5]):
self.assertAlmostEqual(
expected_positions, positions_per_workers[index], 15)
def test_reset_code(self):
particles = new_plummer_model(50)
particles.scale_to_standard()
instance = Petar()
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 50)
instance.reset()
self.assertEqual(len(instance.particles), 0)
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 50)
instance.stop()
def test_adding_particles(self):
petar = Petar()
particles = datamodel.Particles(10)
particles.position = ([0, 0, 0]) | nbody_system.length
particles.velocity = ([1, 0, 0]) | nbody_system.speed
particles.radius = 0 | nbody_system.length
particles.mass = 0.1 | nbody_system.mass
particles.x = numpy.linspace(1, 10, 10) | nbody_system.length
particles.vx = numpy.linspace(1, 5, 10) | nbody_system.speed
petar.particles.add_particles(particles)
request = petar.particles.get_values_in_store_async(None, ["x"])
request.wait()
print(request.result())
self.assertEqual(request.result()[0], particles.x)
request = petar.particles.get_values_in_store_async(None, [
"x", "vx"])
request.wait()
print(request.result())
self.assertEqual(request.result()[0], particles.x)
self.assertEqual(request.result()[1], particles.vx)
p = particles.copy()
channel = petar.particles.new_channel_to(p)
p.x = 0 | nbody_system.length
p.vx = 0 | nbody_system.speed
request = channel.copy_attributes_async(("x", "vx",), async_get=True)
request.wait()
self.assertEqual(p.x, particles.x)
self.assertEqual(p.vx, particles.vx)
p.x = 0 | nbody_system.length
p.vx = 0 | nbody_system.speed
channel = p.new_channel_to(petar.particles)
request = channel.copy_attributes_async(
("x", "y", "z", "vx", "vy", "vz"), async_get=False, async_set=True)
request.wait()
self.assertEqual(p.x, petar.particles.x)
self.assertEqual(p.vx, petar.particles.vx)
channel = p.new_channel_to(particles)
request = channel.copy_attributes_async(
("x", "y", "z", "vx", "vy", "vz"), async_get=False, async_set=True)
request.wait()
self.assertEqual(p.x, particles.x)
self.assertEqual(p.vx, particles.vx)
request = channel.copy_attributes_async(
("x", "y", "z", "vx", "vy", "vz"), async_get=True, async_set=False)
request.wait()
self.assertEqual(p.x, particles.x)
self.assertEqual(p.vx, particles.vx)
| 4,562
| 35.798387
| 79
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_multiples.py
|
from amuse.test.amusetest import TestWithMPI
import tempfile
import numpy
from amuse.community.hermite.interface import Hermite
from amuse.community.kepler.interface import Kepler
from amuse.community.smalln.interface import SmallN
from amuse.units import nbody_system
from amuse.units import units
from amuse.units import constants
from amuse import datamodel
from amuse.ic import plummer
from amuse.couple import multiples
from amuse.couple import encounters
from amuse import io
class TestSimpleMultiples(TestWithMPI):
previous = None
def new_smalln(self):
if not self.previous is None:
self.previous.stop()
result = SmallN()
result.parameters.timestep_parameter = 0.1
result.parameters.cm_index = 2001
self.previous = result
return result
def new_kepler_si(self):
unit_converter = nbody_system.nbody_to_si(
1.0 | units.MSun,
1.0 | units.AU
)
kepler = Kepler(unit_converter)
kepler.initialize_code()
return kepler
def new_kepler(self):
kepler = Kepler()
kepler.initialize_code()
return kepler
def new_smalln_si(self):
if not self.previous is None:
self.previous.stop()
converter = nbody_system.nbody_to_si(units.MSun, units.parsec)
result = SmallN(converter)
result.parameters.timestep_parameter = 0.1
result.parameters.cm_index = 2001
return result
def new_binary(self, mass1, mass2, semi_major_axis,
eccentricity=0, keyoffset=-1):
total_mass = mass1 + mass2
mass_fraction_particle_1 = mass1 / (total_mass)
if keyoffset >= 0:
binary = datamodel.Particles(keys=range(keyoffset, keyoffset+2))
else:
binary = datamodel.Particles(2)
binary[0].mass = mass1
binary[1].mass = mass2
mu = nbody_system.G * total_mass
velocity_perihelion = numpy.sqrt(mu / semi_major_axis * ((1.0 + eccentricity)/(1.0 - eccentricity)))
radius_perihelion = semi_major_axis * (1.0 - eccentricity)
binary[0].position = ((1.0 - mass_fraction_particle_1) * radius_perihelion * [1.0, 0.0, 0.0])
binary[1].position = -(mass_fraction_particle_1 * radius_perihelion * [1.0, 0.0, 0.0])
binary[0].velocity = ((1.0 - mass_fraction_particle_1) * velocity_perihelion * [0.0, 1.0, 0.0])
binary[1].velocity = -(mass_fraction_particle_1 * velocity_perihelion * [0.0, 1.0, 0.0])
return binary
def create_binaries(self, center_of_mass_particles, mass1, mass2, semi_major_axis,
eccentricity=0):
singles_in_binaries = datamodel.Particles()
for binary in center_of_mass_particles:
particles_in_binary = self.new_binary(
mass1,
mass2,
semi_major_axis
)
particles_in_binary.radius = semi_major_axis
binary.child1 = particles_in_binary[0]
binary.child2 = particles_in_binary[1]
binary.mass = mass1 + mass2
particles_in_binary.position += binary.position
particles_in_binary.velocity += binary.velocity
singles_in_binaries.add_particles(particles_in_binary)
return center_of_mass_particles, singles_in_binaries
def test0(self):
code = Hermite()
stars = datamodel.Particles(2)
stars.mass = 1 | nbody_system.mass
stars.position = [
[0.0, 0, 0],
[1.2, 0, 0]
] | nbody_system.length
stars.velocity = [
[0.0, 0, 0],
[0, 0.1, 0]
] | nbody_system.speed
stars.radius = 0.5 | nbody_system.length
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
interaction_over_code=None
)
encounter_code.parameters.hard_binary_factor = 1
encounter_code.small_scale_factor = 1
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.particles.add_particles(stars)
multiples_code.commit_particles()
multiples_code.evolve_model(0.6 | nbody_system.time)
self.assertEqual(len(multiples_code.multiples), 1)
self.assertEqual(len(multiples_code.binaries), 1)
def test1(self):
code = Hermite()
stars = datamodel.Particles(keys=(1, 2, 3, 4))
stars.mass = 1 | nbody_system.mass
stars.position = [
[0.0, 0, 0],
[0.5, 0, 0],
[2.0, 0, 0],
[-10.0, 0, 0],
] | nbody_system.length
stars.velocity = [
[0.0, 0, 0],
[0, 0.1, 0],
[0, -0.1, 0],
[0, 0.2, 0],
] | nbody_system.speed
stars.radius = 0.5 | nbody_system.length
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
interaction_over_code=None
)
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.particles.add_particles(stars)
multiples_code.commit_particles()
multiples_code.evolve_model(0.6 | nbody_system.time)
self.assertEqual(len(multiples_code.multiples), 1)
self.assertEqual(len(multiples_code.binaries), 1)
self.assertAlmostRelativeEquals(multiples_code.particles[:-1].radius, 0.5 | nbody_system.length)
self.assertAlmostRelativeEquals(multiples_code.particles[-1].radius, 0.4446 | nbody_system.length, 3)
multiples_code.evolve_model(2 | nbody_system.time)
self.assertEqual(len(multiples_code.multiples), 1)
self.assertEqual(len(multiples_code.binaries), 1)
multiples_code.evolve_model(3 | nbody_system.time)
self.assertEqual(len(multiples_code.multiples), 1)
self.assertEqual(len(multiples_code.particles), 2)
self.assertEqual(len(multiples_code.binaries), 1)
def test2(self):
code = Hermite()
stars = datamodel.Particles(keys=(1, 2, 3, 4))
stars.mass = 1 | nbody_system.mass
stars.position = [
[0.0, 0, 0],
[0.5, 0, 0],
[3, 0, 0],
[-10, 0, 0],
] | nbody_system.length
stars.velocity = [
[0.0, 0, 0],
[0, 0.1, 0],
[0.0, -0.5, 0],
[0, 0.2, 0],
] | nbody_system.speed
stars.radius = 0.5 | nbody_system.length
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
interaction_over_code=None
)
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.particles.add_particles(stars)
multiples_code.commit_particles()
multiples_code.evolve_model(3 | nbody_system.time)
self.assertEqual(len(multiples_code.multiples), 1)
print(multiples_code.multiples[0].components)
self.assertEqual(len(multiples_code.multiples[0].components), 2)
self.assertEqual(len(multiples_code.particles), 3)
self.assertEqual(len(multiples_code.binaries), 1)
self.assertEqual(len(multiples_code.singles), 2)
def test3(self):
code = Hermite()
particles_in_binary = self.new_binary(
0.1 | nbody_system.mass,
0.1 | nbody_system.mass,
0.01 | nbody_system.length,
keyoffset=1
)
particles_in_binary.radius = 0.001 | nbody_system.length
binary = datamodel.Particle(key=3)
binary.child1 = particles_in_binary[0]
binary.child2 = particles_in_binary[1]
binary.radius = 0.5 | nbody_system.length
binary.mass = 0.2 | nbody_system.mass
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
interaction_over_code=None
)
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.singles_in_binaries.add_particles(particles_in_binary)
multiples_code.binaries.add_particle(binary)
self.assertEqual(len(multiples_code.singles_in_binaries), 2)
self.assertEqual(id(multiples_code.binaries[0].child1.particles_set), id(multiples_code.singles_in_binaries))
multiples_code.commit_particles()
self.assertEqual(len(multiples_code.multiples), 1)
self.assertEqual(len(multiples_code.components_of_multiples), 2)
def test4(self):
code = Hermite()
stars = datamodel.Particles(keys=(1, 2, 3, 4))
stars.mass = 1 | nbody_system.mass
stars.position = [
[0.0, 0, 0],
[0.5, 0, 0],
[2, 0, 0],
[-10, 0, 0],
] | nbody_system.length
stars.velocity = [
[0, 0, 0],
[0, 0.2, 0],
[0, -0.2, 0],
[0, 0.3, 0],
] | nbody_system.speed
stars.radius = 0.5 | nbody_system.length
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
interaction_over_code=None
)
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.particles.add_particles(stars)
multiples_code.commit_particles()
stopping_condition = multiples_code.stopping_conditions.multiples_change_detection
stopping_condition.enable()
multiples_code.evolve_model(3 | nbody_system.time)
self.assertTrue(stopping_condition.is_set())
self.assertAlmostRelativeEquals(multiples_code.model_time, 0.0075 | nbody_system.time, 4)
self.assertEqual(len(stopping_condition.particles(0)), 1)
self.assertEqual(len(stopping_condition.particles(1)), 0)
self.assertEqual(len(multiples_code.multiples), 1)
self.assertEqual(len(multiples_code.multiples[0].components), 2)
self.assertEqual(len(multiples_code.particles), 3) # 1 multiples with 2 singles, plus 2 singles free
self.assertEqual(len(multiples_code.binaries), 1)
self.assertEqual(len(multiples_code.singles), 2)
multiples_code.evolve_model(3 | nbody_system.time)
self.assertTrue(stopping_condition.is_set())
self.assertAlmostRelativeEquals(multiples_code.model_time, 1.2195 | nbody_system.time, 4)
self.assertEqual(len(stopping_condition.particles(0)), 1) # 1 new multiple
self.assertEqual(len(stopping_condition.particles(1)), 1) # 1 dissolved multiple
self.assertEqual(len(multiples_code.multiples[0].components), 3)
self.assertEqual(len(multiples_code.particles), 2) # 1 multiple, plus 1 single free
self.assertEqual(len(multiples_code.binaries), 1)
self.assertEqual(len(multiples_code.singles), 1)
def test5(self):
converter = nbody_system.nbody_to_si(units.MSun, units.parsec)
code = Hermite(converter)
stars = datamodel.Particles(keys=(1, 2))
stars.mass = converter.to_si(1 | nbody_system.mass)
stars.position = converter.to_si([
[0, 0, 0],
[1.2, 0, 0]
] | nbody_system.length)
stars.velocity = converter.to_si([
[0, 0, 0],
[0, 0.1, 0]
] | nbody_system.speed)
stars.radius = converter.to_si(0.5 | nbody_system.length)
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler_si(),
resolve_collision_code=self.new_smalln_si(),
interaction_over_code=None,
G=constants.G
)
encounter_code.parameters.hard_binary_factor = 1
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code,
G=constants.G
)
end_time = converter.to_si(1.0 | nbody_system.time)
multiples_code.particles.add_particles(stars)
multiples_code.commit_particles()
multiples_code.evolve_model(end_time)
self.assertEqual(len(multiples_code.particles), 1) # 1 multiples with 2 singles
self.assertEqual(len(multiples_code.multiples), 1)
self.assertEqual(len(multiples_code.multiples[0].components), 2)
self.assertEqual(len(multiples_code.binaries), 1)
self.assertEqual(len(multiples_code.singles), 0)
def test6(self):
converter = nbody_system.nbody_to_si(units.MSun, units.parsec)
code = Hermite(converter)
stars = datamodel.Particles(keys=(1, 2, 3, 4))
stars.mass = converter.to_si(1 | nbody_system.mass)
stars.position = converter.to_si([
[0, 0, 0],
[1.2, 0, 0],
[100, 0, 0],
[100, 1.2, 0]
] | nbody_system.length)
stars.velocity = converter.to_si([
[0, 0, 0],
[0, 0.1, 0],
[0, 0, 0],
[0, 0, 0.1],
] | nbody_system.speed)
stars.radius = converter.to_si(0.5 | nbody_system.length)
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler_si(),
resolve_collision_code=self.new_smalln_si(),
interaction_over_code=None,
G=constants.G
)
encounter_code.small_scale_factor = 1.0
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code,
G=constants.G
)
multiples_code.must_handle_one_encounter_per_stopping_condition = False
multiples_code.particles.add_particles(stars)
multiples_code.commit_particles()
stopping_condition = multiples_code.stopping_conditions.multiples_change_detection
stopping_condition.enable()
end_time = converter.to_si(3.0 | nbody_system.time)
print(end_time.as_quantity_in(units.Myr))
multiples_code.evolve_model(end_time)
self.assertTrue(stopping_condition.is_set())
print(multiples_code.model_time.as_quantity_in(units.Myr))
self.assertAlmostRelativeEquals(multiples_code.model_time, 7.99844 | units.Myr, 4)
self.assertEqual(len(stopping_condition.particles(0)), 2)
self.assertEqual(len(stopping_condition.particles(1)), 0)
self.assertEqual(len(multiples_code.particles), 2) # 1 multiples with 2 singles
self.assertEqual(len(multiples_code.multiples), 2)
self.assertEqual(len(multiples_code.binaries), 2)
self.assertEqual(len(multiples_code.multiples[0].components), 2)
self.assertEqual(len(multiples_code.multiples[1].components), 2)
self.assertEqual(len(multiples_code.singles), 0)
self.assertEqual(len(multiples_code.all_singles), 4)
def test7(self):
converter = nbody_system.nbody_to_si(units.MSun, units.parsec)
code = Hermite(converter)
stars = datamodel.Particles(keys=(1, 2))
stars.mass = converter.to_si(1 | nbody_system.mass)
stars.position = converter.to_si([
[0, 0, 0],
[1.1, 0, 0],
] | nbody_system.length)
stars.velocity = converter.to_si([
[0, 0, 0],
[-0.5, 1.5, 0],
] | nbody_system.speed)
stars.radius = converter.to_si(0.55 | nbody_system.length)
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler_si(),
resolve_collision_code=self.new_smalln_si(),
interaction_over_code=None,
G=constants.G
)
encounter_code.small_scale_factor = 1.0
encounter_code.parameters.hard_binary_factor = 1
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code,
G=constants.G
)
multiples_code.must_handle_one_encounter_per_stopping_condition = False
multiples_code.singles.add_particles(stars)
multiples_code.commit_particles()
stopping_condition = multiples_code.stopping_conditions.encounter_detection
stopping_condition.enable()
end_time = converter.to_si(3.0 | nbody_system.time)
print(end_time.as_quantity_in(units.Myr))
multiples_code.evolve_model(end_time)
self.assertTrue(stopping_condition.is_set())
print(multiples_code.model_time.as_quantity_in(units.Myr))
# self.assertAlmostRelativeEquals(multiples_code.model_time , 5.96955 | units.Myr, 4)
self.assertEqual(len(stopping_condition.particles(0)), 1)
model = stopping_condition.particles(0)[0]
self.assertEqual(len(model.particles_before_encounter), 2)
self.assertEqual(len(model.particles_after_encounter), 2)
before = model.particles_before_encounter
after = model.particles_after_encounter
self.assertAlmostRelativeEquals(before.center_of_mass(), after.center_of_mass(), 7)
self.assertAlmostRelativeEquals(before.center_of_mass_velocity(), after.center_of_mass_velocity(), 7)
total_energy_before = before.kinetic_energy() + before.potential_energy(G=constants.G)
total_energy_after = after.kinetic_energy() + after.potential_energy(G=constants.G)
self.assertAlmostRelativeEquals(total_energy_before, total_energy_after, 7)
def test8(self):
code = Hermite()
particles_in_binary = self.new_binary(
0.1 | nbody_system.mass,
0.1 | nbody_system.mass,
0.01 | nbody_system.length,
keyoffset=1
)
particles_in_binary.radius = 0.001 | nbody_system.length
binary = datamodel.Particle(key=3)
binary.child1 = particles_in_binary[0]
binary.child2 = particles_in_binary[1]
binary.radius = 0.5 | nbody_system.length
binary.mass = 0.2 | nbody_system.mass
binary.position = [0.0, 0.0, 0.0] | nbody_system.length
binary.velocity = [0.0, 0.0, 0.0] | nbody_system.speed
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
interaction_over_code=None
)
encounter_code.parameters.hard_binary_factor = 1
encounter_code.small_scale_factor = 1
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.singles_in_binaries.add_particles(particles_in_binary)
multiples_code.binaries.add_particle(binary)
multiples_code.must_handle_one_encounter_per_stopping_condition = False
field_particle = datamodel.Particle(key=4)
field_particle.mass = 0.5 | nbody_system.mass
field_particle.radius = 0.1 | nbody_system.length
field_particle.position = [0.0, 0.2, 0.0] | nbody_system.length
field_particle.velocity = [0.0, 0.0, 0.0] | nbody_system.speed
multiples_code.singles.add_particle(field_particle)
self.assertEqual(len(multiples_code.singles_in_binaries), 2)
self.assertEqual(id(multiples_code.binaries[0].child1.particles_set), id(multiples_code.singles_in_binaries))
multiples_code.commit_particles()
multiples_code.multiples.radius = 0.5 | nbody_system.length
initial_energy = multiples_code.get_total_energy()
self.assertEqual(len(multiples_code.multiples), 1)
self.assertEqual(len(multiples_code.components_of_multiples), 2)
self.assertEqual(len(multiples_code.particles), 2)
stopping_condition = multiples_code.stopping_conditions.encounter_detection
stopping_condition.enable()
singles = datamodel.Particles()
singles.add_particles(particles_in_binary)
singles.add_particle(field_particle)
singles_energy = singles.kinetic_energy() + singles.potential_energy(G=nbody_system.G)
self.assertAlmostRelativeEquals(initial_energy, singles_energy, 3)
multiples_code.evolve_model(2 | nbody_system.time)
final_energy = multiples_code.get_total_energy()
self.assertTrue(stopping_condition.is_set())
self.assertAlmostRelativeEquals(initial_energy, final_energy, 7)
def test9(self):
code = Hermite()
particles_in_binary = self.new_binary(
0.1 | nbody_system.mass,
0.1 | nbody_system.mass,
0.01 | nbody_system.length,
keyoffset=1
)
particles_in_binary.radius = 0.001 | nbody_system.length
binary = datamodel.Particle(key=3)
binary.child1 = particles_in_binary[0]
binary.child2 = particles_in_binary[1]
binary.radius = 0.5 | nbody_system.length
binary.mass = 0.2 | nbody_system.mass
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
)
others = datamodel.Particles(key=[4, 5, 6])
for i in range(3):
others[i].position = [i, 0, 0] | nbody_system.length
others[i].velocity = [0, 0, i] | nbody_system.speed
others[i].mass = 1 | nbody_system.mass
others[i].radius = 0 | nbody_system.length
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.singles_in_binaries.add_particles(particles_in_binary)
multiples_code.binaries.add_particle(binary)
multiples_code.singles.add_particles(others)
multiples_code.commit_particles()
self.assertEqual(len(multiples_code.multiples), 1)
self.assertEqual(len(multiples_code.components_of_multiples), 2)
self.assertEqual(len(multiples_code.singles), 3)
self.assertEqual(len(multiples_code.particles), 4)
self.assertEqual(len(code.particles), 4)
self.assertAlmostRelativeEquals(multiples_code.particles[-1].mass, 0.2 | nbody_system.mass)
self.assertAlmostRelativeEquals(code.particles[-1].mass, 0.2 | nbody_system.mass)
self.assertAlmostRelativeEquals(code.particles[-1].position, [0, 0, 0] | nbody_system.length, 6)
self.assertAlmostRelativeEquals(code.particles[-1].velocity, [0, 0, 0] | nbody_system.speed, 6)
multiples_code.update_model()
self.assertAlmostRelativeEquals(multiples_code.particles[-1].mass, 0.2 | nbody_system.mass)
self.assertAlmostRelativeEquals(code.particles[-1].mass, 0.2 | nbody_system.mass)
self.assertAlmostRelativeEquals(code.particles[-1].position, [0, 0, 0] | nbody_system.length, 6)
self.assertAlmostRelativeEquals(code.particles[-1].velocity, [0, 0, 0] | nbody_system.speed, 6)
multiples_code.singles_in_binaries[0].mass = 0.2 | nbody_system.mass
multiples_code.update_model()
print(code.particles.mass)
self.assertAlmostRelativeEquals(multiples_code.particles[-1].mass, 0.3 | nbody_system.mass)
self.assertAlmostRelativeEquals(code.particles[-1].mass, 0.3 | nbody_system.mass)
print(code.particles[-1].position)
print(code.particles[-1].velocity)
self.assertAlmostRelativeEquals(code.particles[-1].position, [0.00166666666667, 0, 0] | nbody_system.length, 6)
self.assertAlmostRelativeEquals(code.particles[-1].velocity, [0, 0.7453559925, 0] | nbody_system.speed, 6)
def test10(self):
code = Hermite()
particles_in_binary = self.new_binary(
0.1 | nbody_system.mass,
0.1 | nbody_system.mass,
0.01 | nbody_system.length,
keyoffset=1
)
particles_in_binary.radius = 0.001 | nbody_system.length
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
)
encounter_code.parameters.hard_binary_factor = 1
encounter_code.small_scale_factor = 1
others = datamodel.Particles(key=[4, 5, 6])
for i in range(3):
others[i].position = [i, 0, 0] | nbody_system.length
others[i].velocity = [0, 0, i] | nbody_system.speed
others[i].mass = 1 | nbody_system.mass
others[i].radius = 0.05 | nbody_system.length
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.must_handle_one_encounter_per_stopping_condition = False
multiples_code.singles.add_particles(particles_in_binary)
multiples_code.singles.add_particles(others)
multiples_code.commit_particles()
multiples_code.evolve_model(1 | nbody_system.time)
self.assertEqual(len(multiples_code.multiples), 1)
self.assertEqual(len(multiples_code.components_of_multiples), 2)
self.assertEqual(len(multiples_code.singles), 3)
self.assertEqual(len(multiples_code.particles), 4)
self.assertEqual(len(code.particles), 4)
self.assertEqual(id(multiples_code.singles_in_binaries), id(multiples_code.binaries[0].child1.particles_set))
self.assertEqual(id(multiples_code.components_of_multiples), id(multiples_code.multiples[0].components[0].particles_set))
# multiples_code.singles_in_binaries[0].mass = 0.2 | nbody_system.mass
print(multiples_code.particles.mass)
self.assertAlmostRelativeEquals(multiples_code.particles[-1].mass, 1.1 | nbody_system.mass)
self.assertAlmostRelativeEquals(multiples_code.particles.mass.sum(), 0.1 + 0.1 + 3.0 | nbody_system.mass)
multiples_code.update_model()
self.assertAlmostRelativeEquals(multiples_code.particles[-1].mass, 1.1 | nbody_system.mass)
index = -1
if not code.particles[index].mass > 1.0 | nbody_system.mass:
index = -2
self.assertAlmostRelativeEquals(code.particles[index].mass, 1.1 | nbody_system.mass)
multiples_code.singles_in_binaries[0].mass += 0.2 | nbody_system.mass
multiples_code.update_model()
self.assertAlmostRelativeEquals(multiples_code.particles[-1].mass, 1.3 | nbody_system.mass)
self.assertAlmostRelativeEquals(code.particles[index].mass, 1.3 | nbody_system.mass)
def test11(self):
code = Hermite()
particles_in_binary = self.new_binary(
1.0 | nbody_system.mass,
1.0 | nbody_system.mass,
0.001 | nbody_system.length,
keyoffset=1
)
particles_in_binary.radius = 0.01 | nbody_system.length
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
)
others = datamodel.Particles(keys=[4, 5, 6])
for i in range(3):
others[i].position = [i, 0, 0] | nbody_system.length
others[i].velocity = [0, 0, 0] | nbody_system.speed
others[i].mass = 0.2 | nbody_system.mass
others[i].radius = 0.05 | nbody_system.length
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.singles.add_particles(particles_in_binary)
multiples_code.singles.add_particles(others)
stopping_condition = multiples_code.stopping_conditions.binaries_change_detection
stopping_condition.enable()
multiples_code.commit_particles()
multiples_code.evolve_model(1 | nbody_system.time)
self.assertEqual(len(multiples_code.multiples), 1)
self.assertEqual(len(multiples_code.binaries), 1)
self.assertEqual(len(multiples_code.components_of_multiples), 2)
self.assertEqual(len(multiples_code.singles), 3)
self.assertEqual(len(multiples_code.particles), 4)
self.assertEqual(len(code.particles), 4)
self.assertTrue(stopping_condition.is_set())
multiples_code.particles[-1].velocity = [0, 0, 0] | nbody_system.speed
multiples_code.update_model()
print(multiples_code.particles.key)
self.assertEqual(len(stopping_condition.particles(0)), 1)
self.assertEqual(len(stopping_condition.particles(1)), 0)
self.assertEqual(len(stopping_condition.particles(2)), 0)
self.assertAlmostRelativeEquals(multiples_code.multiples[0].mass, 2.0 | nbody_system.mass)
self.assertAlmostRelativeEquals(multiples_code.particles.mass.sum(), 2.6 | nbody_system.mass)
print(multiples_code.particles.velocity)
multiples_code.evolve_model(2 | nbody_system.time)
self.assertTrue(stopping_condition.is_set())
self.assertEqual(len(stopping_condition.particles(0)), 0)
self.assertEqual(len(stopping_condition.particles(1)), 0)
self.assertEqual(len(stopping_condition.particles(2)), 1)
self.assertAlmostRelativeEquals(multiples_code.multiples[0].mass, 2.0 | nbody_system.mass)
self.assertAlmostRelativeEquals(multiples_code.particles.mass.sum(), 2.6 | nbody_system.mass)
def test12(self):
code = Hermite()
particles_in_binary = self.new_binary(
1.0 | nbody_system.mass,
1.0 | nbody_system.mass,
0.001 | nbody_system.length,
keyoffset=10
)
particles_in_binary.radius = 0.01 | nbody_system.length
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
)
binary = datamodel.Particle(key=20)
binary.child1 = particles_in_binary[0]
binary.child2 = particles_in_binary[1]
binary.position = [1, 0, 1] | nbody_system.length
particles_in_binary.position += [1, 0, 1] | nbody_system.length
others = datamodel.Particles(keys=[4, 5, 6])
for i in range(3):
others[i].position = [i*10, 0, 0] | nbody_system.length
others[i].velocity = [0, 0, 0] | nbody_system.speed
others[i].mass = 0.2 | nbody_system.mass
others[i].radius = 0.05 | nbody_system.length
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.particles.add_particles(others)
multiples_code.singles_in_binaries.add_particles(particles_in_binary)
multiples_code.binaries.add_particle(binary)
multiples_code.commit_particles()
print(multiples_code.particles)
self.assertEqual(len(multiples_code.particles), 4)
self.assertAlmostRelativeEquals(multiples_code.particles[-1].position, [1, 0, 1] | nbody_system.length)
def test13(self):
code = Hermite()
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
)
center_of_mass_particles = datamodel.Particles(5)
center_of_mass_particles.position = (numpy.asarray(range(5))).reshape(5, 1) * ([1.0, 0.0, 0.0] | nbody_system.length)
center_of_mass_particles.velocity = [0.0, 0.0, 0.0] | nbody_system.speed
center_of_mass_particles.radius = 0.05 | nbody_system.length
binaries, singles_in_binaries = self.create_binaries(
center_of_mass_particles,
1 | nbody_system.mass,
0.01 | nbody_system.mass,
0.0001 | nbody_system.length
)
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.singles_in_binaries.add_particles(singles_in_binaries)
multiples_code.binaries.add_particles(binaries)
multiples_code.commit_particles()
# stopping_condition = multiples_code.stopping_conditions.encounter_detection
# stopping_condition.enable()
stopping_condition = multiples_code.stopping_conditions.binaries_change_detection
stopping_condition.enable()
for x in multiples_code.binaries:
print(x.key, x.child1.key, x.child2.key)
multiples_code.evolve_model(1 | nbody_system.time)
self.assertTrue(stopping_condition.is_set())
for x in multiples_code.binaries:
print(x.key, x.child1.key, x.child2.key)
for x in stopping_condition.particles(0):
print("NEW:", x.key, x.child1.key, x.child2.key)
for x in stopping_condition.particles(1):
print("REMOVED:", x.key, x.child1.key, x.child2.key)
for x in stopping_condition.particles(2):
print("UPDATED:", x.key, x.child1.key, x.child2.key)
for x in multiples_code.singles:
print(x.key, x.mass)
self.assertEqual(len(multiples_code.singles_in_binaries) + len(multiples_code.singles), 2*len(center_of_mass_particles))
self.assertEqual(len(multiples_code.binaries) - len(stopping_condition.particles(0)) + len(stopping_condition.particles(1)), len(center_of_mass_particles))
def test14(self):
code = Hermite()
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
)
center_of_mass_particles = datamodel.Particles(5)
center_of_mass_particles.position = (numpy.asarray(range(5))).reshape(5, 1) * ([1.0, 0.0, 0.0] | nbody_system.length)
center_of_mass_particles.velocity = [0.0, 0.0, 0.0] | nbody_system.speed
center_of_mass_particles.radius = 0.05 | nbody_system.length
binaries, singles_in_binaries = self.create_binaries(
center_of_mass_particles,
1 | nbody_system.mass,
0.1 | nbody_system.mass,
0.00000001 | nbody_system.length
)
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.singles_in_binaries.add_particles(singles_in_binaries)
multiples_code.binaries.add_particles(binaries)
multiples_code.commit_particles()
# stopping_condition = multiples_code.stopping_conditions.encounter_detection
# stopping_condition.enable()
stopping_condition = multiples_code.stopping_conditions.binaries_change_detection
stopping_condition.enable()
for x in multiples_code.binaries:
print(x.key, x.child1.key, x.child2.key)
multiples_code.evolve_model(2 | nbody_system.time)
self.assertTrue(stopping_condition.is_set())
for x in multiples_code.binaries:
print(x.key, x.child1.key, x.child2.key)
for x in stopping_condition.particles(0):
print("NEW:", x.key, x.child1.key, x.child2.key)
for x in stopping_condition.particles(1):
print("REMOVED:", x.key, x.child1.key, x.child2.key)
for x in stopping_condition.particles(2):
print("UPDATED:", x.key, x.child1.key, x.child2.key)
for x in multiples_code.singles:
print(x.key, x.mass)
self.assertEqual(len(multiples_code.singles_in_binaries) + len(multiples_code.singles), 2*len(center_of_mass_particles))
self.assertEqual(len(multiples_code.binaries) - len(stopping_condition.particles(0)) + len(stopping_condition.particles(1)), len(center_of_mass_particles))
def test15(self):
code = Hermite()
encounter_code = encounters.HandleEncounter(
kepler_code=self.new_kepler(),
resolve_collision_code=self.new_smalln(),
)
n = 10
center_of_mass_particles = plummer.new_plummer_model(n, random=numpy.random.mtrand.RandomState(1))
center_of_mass_particles.radius = 0.5 | nbody_system.length
center_of_mass_particles.velocity *= 0
binaries, singles_in_binaries = self.create_binaries(
center_of_mass_particles,
0.999 * ((1.0 | nbody_system.mass) / n),
0.001 * ((1.0 | nbody_system.mass) / n),
0.00001 | nbody_system.length
)
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounter_code
)
multiples_code.singles_in_binaries.add_particles(singles_in_binaries)
multiples_code.binaries.add_particles(binaries)
multiples_code.commit_particles()
# stopping_condition = multiples_code.stopping_conditions.encounter_detection
# stopping_condition.enable()
stopping_condition = multiples_code.stopping_conditions.binaries_change_detection
stopping_condition.enable()
for x in multiples_code.binaries:
print(x.key, x.child1.key, x.child2.key)
multiples_code.evolve_model(2 | nbody_system.time)
self.assertTrue(stopping_condition.is_set())
for x in multiples_code.binaries:
print(x.key, x.child1.key, x.child2.key)
for x in stopping_condition.particles(0):
print("NEW:", x.key, x.child1.key, x.child2.key)
for x in stopping_condition.particles(1):
print("REMOVED:", x.key, x.child1.key, x.child2.key)
for x in stopping_condition.particles(2):
print("UPDATED:", x.key, x.child1.key, x.child2.key)
for x in multiples_code.singles:
print(x.key, x.mass)
self.assertEqual(len(multiples_code.binaries) - len(stopping_condition.particles(0)) + len(stopping_condition.particles(1)), len(center_of_mass_particles))
def test16(self):
code = Hermite()
n = 10
singles = datamodel.Particles(keys=range(1, n+1))
singles.mass = 1 | nbody_system.mass
for x in range(n):
singles[x].position = [x*x, 0, 0] | nbody_system.length
singles.velocity = [0, 0, 0] | nbody_system.speed
singles.radius = 0.5 | nbody_system.length
multiples_code = encounters.Multiples(
gravity_code=code,
handle_encounter_code=encounters.StickyHandleEncounter()
)
multiples_code.singles.add_particles(singles)
multiples_code.commit_particles()
multiples_code.evolve_model(1 | nbody_system.time)
print(len(multiples_code.multiples))
self.assertEqual(len(multiples_code.multiples), 1)
self.assertEqual(len(multiples_code.particles), 9)
self.assertEqual(len(multiples_code.singles), 8)
self.assertEqual(len(multiples_code.binaries), 1)
self.assertEqual(len(multiples_code.singles_in_binaries), 2)
self.assertEqual(id(multiples_code.components_of_multiples), id(multiples_code.multiples[0].components[0].particles_set))
print(multiples_code.multiples[0].components)
with tempfile.NamedTemporaryFile() as temp:
io.write_set_to_file(
(
multiples_code.singles,
multiples_code.singles_in_binaries,
multiples_code.binaries,
multiples_code.components_of_multiples,
multiples_code.multiples
),
temp.name,
# "multiples.hdf5",
"hdf5",
overwrite_file=True,
version="2.0",
names=(
"singles",
"singles_in_binaries",
"binaries",
"components_of_multiples",
"multiples"
)
)
multiples_code_loaded = encounters.Multiples(
gravity_code=Hermite(),
handle_encounter_code=encounters.StickyHandleEncounter()
)
(
singles,
singles_in_binaries,
binaries,
components_of_multiples,
multiples
) = io.read_set_from_file(
temp.name,
# "multiples.hdf5",
"hdf5",
version="2.0",
names=(
"singles",
"singles_in_binaries",
"binaries",
"components_of_multiples",
"multiples"
)
)
self.assertEqual(len(multiples), 1)
self.assertEqual(len(singles), 8)
self.assertEqual(len(binaries), 1)
self.assertEqual(len(singles_in_binaries), 2)
# self.assertEquals(id(components_of_multiples), id(multiples[0].components[0].particles_set))
multiples_code_loaded.singles.add_particles(singles)
multiples_code_loaded.singles_in_binaries.add_particles(singles_in_binaries)
multiples_code_loaded.binaries.add_particles(binaries)
multiples_code_loaded.components_of_multiples.add_particles(components_of_multiples)
multiples_code_loaded.multiples.add_particles(multiples)
multiples_code_loaded.commit_particles()
self.assertEqual(len(multiples_code_loaded.multiples), 1)
self.assertEqual(len(multiples_code_loaded.particles), 9)
self.assertEqual(len(multiples_code_loaded.singles), 8)
self.assertEqual(len(multiples_code_loaded.binaries), 1)
self.assertEqual(len(multiples_code_loaded.singles_in_binaries), 2)
# self.assertEquals(id(multiples_code_loaded.components_of_multiples), id(multiples_code_loaded.multiples[0].components[0].particles_set))
multiples_code.evolve_model(4 | nbody_system.time)
# need to use 3 here as the model_time is reset when doing a restart and we dit not set it after creating Hermite
multiples_code_loaded.evolve_model(3.0 | nbody_system.time)
print(len(multiples_code.multiples), multiples_code.particles)
print(multiples_code.particles.position - multiples_code_loaded.particles.position)
self.assertAlmostRelativeEquals(multiples_code.particles.position - multiples_code_loaded.particles.position, [0, 0, 0] | nbody_system.length)
for code in [multiples_code, multiples_code_loaded]:
self.assertEqual(len(code.multiples), 1)
self.assertEqual(len(code.particles), 8)
self.assertEqual(len(code.singles), 7)
self.assertEqual(len(code.binaries), 1)
self.assertEqual(len(code.singles_in_binaries), 2)
self.assertEqual(len(code.components_of_multiples), 3)
self.assertEqual(id(code.components_of_multiples), id(code.multiples[0].components[0].particles_set))
| 43,150
| 41.5133
| 164
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_secularmultiple.py
|
from amuse.test.amusetest import TestWithMPI
import os
import sys
import numpy
import math
from amuse.community.secularmultiple.interface import SecularMultipleInterface, SecularMultiple
from amuse.units import units, quantities, constants
from amuse.datamodel import Particles
HAS_MATPLOTLIB = False # disable plotting in the test script
def parse_arguments():
from amuse.units.optparse import OptionParser
parser = OptionParser()
parser.add_option("--test",
dest="test", type="int", default=1,
help="")
options, args = parser.parse_args()
return options.__dict__
class TestSecularMultipleInterface(TestWithMPI):
def test0(self):
instance = SecularMultipleInterface()
instance.stop()
def create_binary(m1, m2, a, e, i, g, h):
particles = Particles(3)
for index in range(2):
particle = particles[index]
particle.is_binary = False
if index == 0:
particle.mass = m1
else:
particle.mass = m2
particle.child1 = None
particle.child2 = None
particles[2].is_binary = True
particles[2].semimajor_axis = a
particles[2].eccentricity = e
particles[2].inclination = i
particles[2].argument_of_pericenter = g
particles[2].longitude_of_ascending_node = h
particles[2].child1 = particles[0]
particles[2].child2 = particles[1]
return particles
def create_triple(m1, m2, m3, a_in, a_out, e_in, e_out, i_in, i_out, g_in, g_out, h_in, h_out):
N_bodies = 3
N_binaries = 2
m_list = [m1, m2, m3]
a_list = [a_in, a_out]
e_list = [e_in, e_out]
i_list = [i_in, i_out]
g_list = [g_in, g_out]
h_list = [h_in, h_out]
particles = Particles(N_bodies + N_binaries)
for index in range(N_bodies):
particle = particles[index]
particle.is_binary = False
particle.mass = m_list[index]
particle.child1 = None
particle.child2 = None
for index in range(N_binaries):
particles[index+N_bodies].is_binary = True
particles[index+N_bodies].semimajor_axis = a_list[index]
particles[index+N_bodies].eccentricity = e_list[index]
particles[index+N_bodies].inclination = i_list[index]
particles[index+N_bodies].argument_of_pericenter = g_list[index]
particles[index+N_bodies].longitude_of_ascending_node = h_list[index]
if index == 0:
particles[index+N_bodies].child1 = particles[0]
particles[index+N_bodies].child2 = particles[1]
elif index == 1:
particles[index+N_bodies].child1 = particles[2]
particles[index+N_bodies].child2 = particles[3]
return particles
def create_quadruple_triple_single(m1, m2, m3, m4, a_A, a_B, a_C, e_A, e_B, e_C, i_A, i_B, i_C, g_A, g_B, g_C, h_A, h_B, h_C):
N_bodies = 4
N_binaries = 3
m_list = [m1, m2, m3, m4]
a_list = [a_A, a_B, a_C]
e_list = [e_A, e_B, e_C]
i_list = [i_A, i_B, i_C]
g_list = [g_A, g_B, g_C]
h_list = [h_A, h_B, h_C]
particles = Particles(N_bodies + N_binaries)
for index in range(N_bodies):
particle = particles[index]
particle.is_binary = False
particle.mass = m_list[index]
particle.child1 = None
particle.child2 = None
for index in range(N_binaries):
particle = particles[index+N_bodies]
particle.is_binary = True
particle.semimajor_axis = a_list[index]
particle.eccentricity = e_list[index]
particle.inclination = i_list[index]
particle.argument_of_pericenter = g_list[index]
particle.longitude_of_ascending_node = h_list[index]
if index == 0:
particle.child1 = particles[1]
particle.child2 = particles[0]
elif index == 1:
particle.child1 = particles[2]
particle.child2 = particles[4]
elif index == 2:
particle.child1 = particles[5]
particle.child2 = particles[3]
return particles
def create_nested_multiple(N, masses, semimajor_axes, eccentricities, inclinations, arguments_of_pericentre, longitudes_of_ascending_node):
"""
N is number of bodies
masses should be N-sized array
the other arguments should be (N-1)-sized arrays
"""
N_bodies = N
N_binaries = N-1
particles = Particles(N_bodies + N_binaries)
for index in range(N_bodies):
particle = particles[index]
particle.is_binary = False
particle.mass = masses[index]
particle.child1 = None
particle.child2 = None
previous_binary = particles
for index in range(N_binaries):
particle = particles[index+N_bodies]
particle.is_binary = True
particle.semimajor_axis = semimajor_axes[index]
particle.eccentricity = eccentricities[index]
particle.inclination = inclinations[index]
particle.argument_of_pericenter = arguments_of_pericentre[index]
particle.longitude_of_ascending_node = longitudes_of_ascending_node[index]
if index == 0:
particle.child1 = particles[0]
particle.child2 = particles[1]
else:
particle.child1 = previous_binary
particle.child2 = particles[index+1]
previous_binary = particle
return particles
class TestSecularMultiple(TestWithMPI):
def test0(self):
instance = SecularMultiple()
print(instance.parameters)
def test1(self):
"""
test reference system of Naoz et al. (2009)
"""
particles = create_nested_multiple(3, [1.0 | units.MSun, 1.0 | units.MJupiter, 40.0 | units.MJupiter], [6.0 | units.AU, 100.0 | units.AU], [0.001, 0.6], [0.0001, 65.0*numpy.pi/180.0], [45.0*numpy.pi/180.0, 0.0001], [0.01, 0.01])
binaries = particles[particles.is_binary]
binaries.include_pairwise_1PN_terms = False
code = SecularMultiple(redirection='none')
code.particles.add_particles(particles)
channel_to_code = particles.new_channel_to(code.particles)
channel_from_code = code.particles.new_channel_to(particles)
channel_to_code.copy()
self.assertEqual(0.6, code.particles[particles.is_binary][1].eccentricity)
t = 0.0 | units.Myr
dt = 1.0e-2 | units.Myr
tend = 3.0e0 | units.Myr
t_print_array = quantities.AdaptingVectorQuantity()
a_print_array = quantities.AdaptingVectorQuantity()
e_print_array = quantities.AdaptingVectorQuantity()
INCL_print_array = quantities.AdaptingVectorQuantity()
AP_print_array = quantities.AdaptingVectorQuantity()
N = 0
while (t < tend):
t += dt
N += 1
code.evolve_model(t)
print('t/Myr = ', code.model_time.value_in(units.Myr))
channel_from_code.copy()
t_print_array.append(t)
a_print_array.append(binaries[0].semimajor_axis)
e_print_array.append(binaries[0].eccentricity | units.none)
INCL_print_array.append(binaries[0].inclination_relative_to_parent | units.none)
AP_print_array.append(binaries[0].argument_of_pericenter | units.none)
def test2(self):
"""
test 1PN precession in 2-body system
"""
particles = create_nested_multiple(2, [1.0 | units.MSun, 1.0 | units.MJupiter], [1.0 | units.AU], [0.99], [0.01], [0.01], [0.01])
binaries = particles[particles.is_binary]
binaries.include_pairwise_1PN_terms = True
code = SecularMultiple(redirection='none')
code.particles.add_particles(particles)
channel_to_code = particles.new_channel_to(code.particles)
channel_from_code = code.particles.new_channel_to(particles)
channel_to_code.copy()
t = 0.0 | units.Myr
dt = 1.0e-1 | units.Myr
tend = 1.0e0 | units.Myr
t_print_array = quantities.AdaptingVectorQuantity()
a_print_array = quantities.AdaptingVectorQuantity()
e_print_array = quantities.AdaptingVectorQuantity()
AP_print_array = quantities.AdaptingVectorQuantity()
N = 0
while (t < tend):
t += dt
N += 1
code.evolve_model(t)
channel_from_code.copy()
print('t/Myr', t.value_in(units.Myr), 'omega', binaries[0].argument_of_pericenter | units.none)
t_print_array.append(t)
a_print_array.append(binaries[0].semimajor_axis)
e_print_array.append(binaries[0].eccentricity | units.none)
AP_print_array.append(binaries[0].argument_of_pericenter | units.none)
a = binaries[0].semimajor_axis
e = binaries[0].eccentricity
M = binaries[0].mass
rg = constants.G*M/(constants.c**2)
P = 2.0*numpy.pi*numpy.sqrt(a**3/(constants.G*M))
t_1PN = (1.0/3.0)*P*(1.0-e**2)*(a/rg)
def test3(self):
"""
test GW emission in 2-body system + collision detection
"""
particles = create_nested_multiple(2, [1.0 | units.MSun, 1.0 | units.MJupiter], [0.1 | units.AU], [0.994], [0.01], [0.01], [0.01])
binaries = particles[particles.is_binary]
stars = particles - binaries
stars.radius = 0.0001 | units.AU
binaries.check_for_physical_collision_or_orbit_crossing = True
binaries.include_pairwise_25PN_terms = True
code = SecularMultiple(redirection='none')
code.particles.add_particles(particles)
channel_to_code = particles.new_channel_to(code.particles)
channel_from_code = code.particles.new_channel_to(particles)
channel_to_code.copy()
t_print_array = quantities.AdaptingVectorQuantity()
a_print_array = quantities.AdaptingVectorQuantity()
e_print_array = quantities.AdaptingVectorQuantity()
AP_print_array = quantities.AdaptingVectorQuantity()
tend = 1.0 | units.Gyr
N = 0
t = 0.0 | units.Myr
dt = 100.0 | units.Myr
while (t < tend):
t += dt
N += 1
code.evolve_model(t)
flag = code.flag
if flag == 2:
print('root found')
break
channel_from_code.copy()
t_print_array.append(t)
a_print_array.append(binaries[0].semimajor_axis)
e_print_array.append(binaries[0].eccentricity | units.none)
AP_print_array.append(binaries[0].argument_of_pericenter | units.none)
print('e', binaries.eccentricity, 'a/AU', binaries.semimajor_axis.value_in(units.AU), 'rp/AU', (binaries.semimajor_axis*(1.0-binaries.eccentricity)).value_in(units.AU))
def test4(self):
"""
test tidal friction in 2-body system
"""
M = 1.0 | units.MJupiter
R = 40.0 | units.RJupiter
m_per = 1.0 | units.MSun
m = m_per
mu = m*M/(m+M)
a0 = 0.1 | units.AU
e0 = 0.3
P0 = 2.0*numpy.pi*numpy.sqrt(a0**3/(constants.G*(M+m_per)))
n0 = 2.0*numpy.pi/P0
aF = a0*(1.0-e0**2)
nF = numpy.sqrt(constants.G*(M+m_per)/(aF**3))
particles = create_nested_multiple(2, [m_per, M], [a0], [e0], [0.01], [0.01], [0.01])
binaries = particles[particles.is_binary]
particles[0].radius = 1.0 | units.RSun
particles[1].radius = R
particles[1].spin_vec_x = 0.0 | 1.0/units.day
particles[1].spin_vec_y = 0.0 | 1.0/units.day
particles[1].spin_vec_z = 4.0e-2 | 1.0/units.day
k_L = 0.38
k_AM = k_L/2.0
rg = 0.25
tau = 0.66 | units.s
I = rg*M*R**2
alpha = I/(mu*a0**2)
T = R**3/(constants.G*M*tau)
t_V = 3.0*(1.0 + 1.0/k_L)*T
particles[1].tides_method = 2
particles[1].include_tidal_friction_terms = True
particles[1].include_tidal_bulges_precession_terms = False
particles[1].include_rotation_precession_terms = False
particles[1].minimum_eccentricity_for_tidal_precession = 1.0e-8
particles[1].tides_apsidal_motion_constant = k_AM
particles[1].tides_viscous_time_scale = t_V
particles[1].tides_gyration_radius = rg
tD = M*aF**8/(3.0*k_L*tau*constants.G*m_per*(M+m_per)*R**5)
particles[2].check_for_physical_collision_or_orbit_crossing = True
code = SecularMultiple(redirection='none')
code.particles.add_particles(particles)
code.parameters.relative_tolerance = 1.0e-14
channel_to_code = particles.new_channel_to(code.particles)
channel_from_code = code.particles.new_channel_to(particles)
channel_to_code.copy()
t = 0.0 | units.Myr
dt = 1.0e-5 | units.Myr
tend = 1.0e-4 | units.Myr
t_print_array = quantities.AdaptingVectorQuantity()
a_print_array = quantities.AdaptingVectorQuantity()
n_print_array = quantities.AdaptingVectorQuantity()
e_print_array = quantities.AdaptingVectorQuantity()
AP_print_array = quantities.AdaptingVectorQuantity()
spin_print_array = quantities.AdaptingVectorQuantity()
while (t < tend):
t += dt
code.evolve_model(t)
print('flag', code.flag, t, 'a/AU', binaries[0].semimajor_axis, 'e', binaries[0].eccentricity)
channel_from_code.copy()
t_print_array.append(t)
a_print_array.append(binaries[0].semimajor_axis)
n_print_array.append(numpy.sqrt(constants.G*(M+m)/(binaries[0].semimajor_axis**3)))
e_print_array.append(binaries[0].eccentricity | units.none)
AP_print_array.append(binaries[0].argument_of_pericenter | units.none)
spin_print_array.append(numpy.sqrt(particles[1].spin_vec_x**2 + particles[1].spin_vec_y**2 + particles[1].spin_vec_z**2))
binaries = particles[particles.is_binary]
bodies = particles - binaries
print('S_x', bodies.spin_vec_x.value_in(1.0/units.day))
print('S_y', bodies.spin_vec_y.value_in(1.0/units.day))
print('S_z', bodies.spin_vec_z.value_in(1.0/units.day))
print('='*50)
def test5(self):
"""
test precession due to tidal bulges
"""
M = 1.0 | units.MJupiter
R = 1.0 | units.RJupiter
m_per = 1.0 | units.MSun
a0 = 30.0 | units.AU
e0 = 0.999
P0 = 2.0*numpy.pi*numpy.sqrt(a0**3/(constants.G*(M+m_per)))
n0 = 2.0*numpy.pi/P0
particles = create_nested_multiple(2, [m_per, M], [a0], [e0], [0.01], [0.01], [0.01])
binaries = particles[particles.is_binary]
particles[0].radius = 1.0 | units.RSun
particles[1].radius = R
k_L = 0.41
k_AM = k_L/2.0
particles[1].tides_method = 0
particles[1].include_tidal_friction_terms = False
particles[1].include_tidal_bulges_precession_terms = True
particles[1].include_rotation_precession_terms = False
particles[1].minimum_eccentricity_for_tidal_precession = 1.0e-5
particles[1].tides_apsidal_motion_constant = k_AM
particles[1].tides_gyration_radius = 0.25
code = SecularMultiple(redirection='none')
code.particles.add_particles(particles)
channel_to_code = particles.new_channel_to(code.particles)
channel_from_code = code.particles.new_channel_to(particles)
channel_to_code.copy()
t = 0.0 | units.Myr
dt = 1.0e1 | units.Myr
tend = 1.0e2 | units.Myr
t_print_array = quantities.AdaptingVectorQuantity()
a_print_array = quantities.AdaptingVectorQuantity()
e_print_array = quantities.AdaptingVectorQuantity()
AP_print_array = quantities.AdaptingVectorQuantity()
g_dot_TB = (15.0/8.0)*n0*(8.0+12.0*e0**2+e0**4)*(m_per/M)*k_AM*pow(R/a0, 5.0)/pow(1.0-e0**2, 5.0)
t_TB = 2.0*numpy.pi/g_dot_TB
N = 0
while (t < tend):
t += dt
code.evolve_model(t)
print('flag', code.flag, t, binaries[0].semimajor_axis, binaries[0].eccentricity)
channel_from_code.copy()
t_print_array.append(t)
a_print_array.append(binaries[0].semimajor_axis)
e_print_array.append(binaries[0].eccentricity | units.none)
AP_print_array.append(binaries[0].argument_of_pericenter | units.none)
N += 1
def test6(self):
"""
test precession due to rotation
"""
M = 1.0 | units.MJupiter
R = 1.5 | units.RJupiter
m_per = 1.0 | units.MSun
a0 = 30.0 | units.AU
e0 = 0.999
P0 = 2.0*numpy.pi*numpy.sqrt(a0**3/(constants.G*(M+m_per)))
n0 = 2.0*numpy.pi/P0
aF = a0*(1.0-e0**2)
nF = numpy.sqrt(constants.G*(M+m_per)/(aF**3))
particles = create_nested_multiple(2, [m_per, M], [a0], [e0], [1.0e-5], [1.0e-5], [1.0e-5])
binaries = particles[particles.is_binary]
particles[0].radius = 1.0 | units.RSun
particles[1].radius = R
particles[1].spin_vec_x = 0.0 | 1.0/units.day
particles[1].spin_vec_y = 0.0 | 1.0/units.day
Omega_PS0 = n0*(33.0/10.0)*pow(a0/aF, 3.0/2.0)
particles[1].spin_vec_z = Omega_PS0
k_L = 0.51
k_AM = k_L/2.0
rg = 0.25
particles[1].tides_method = 1
particles[1].include_tidal_friction_terms = False
particles[1].include_tidal_bulges_precession_terms = False
particles[1].include_rotation_precession_terms = True
particles[1].minimum_eccentricity_for_tidal_precession = 1.0e-5
particles[1].tides_apsidal_motion_constant = k_AM
particles[1].tides_gyration_radius = rg
code = SecularMultiple(redirection='none')
code.particles.add_particles(particles)
channel_to_code = particles.new_channel_to(code.particles)
channel_from_code = code.particles.new_channel_to(particles)
channel_to_code.copy()
t = 0.0 | units.Myr
dt = 1.0e1 | units.Myr
tend = 1.0e2 | units.Myr
t_print_array = quantities.AdaptingVectorQuantity()
a_print_array = quantities.AdaptingVectorQuantity()
e_print_array = quantities.AdaptingVectorQuantity()
AP_print_array = quantities.AdaptingVectorQuantity()
Omega_vec = [particles[1].spin_vec_x, particles[1].spin_vec_y, particles[1].spin_vec_z]
Omega = numpy.sqrt(Omega_vec[0]**2 + Omega_vec[1]**2 + Omega_vec[2]**2)
print('Omega/n', Omega/n0)
g_dot_rot = n0*(1.0 + m_per/M)*k_AM*pow(R/a0, 5.0)*(Omega/n0)**2/((1.0-e0**2)**2)
t_rot = 2.0*numpy.pi/g_dot_rot
print('t_rot/Myr', t_rot.value_in(units.Myr))
N = 0
while (t < tend):
t += dt
code.evolve_model(t)
print('flag', code.flag, t, binaries[0].semimajor_axis, binaries[0].eccentricity)
channel_from_code.copy()
t_print_array.append(t)
a_print_array.append(binaries[0].semimajor_axis)
e_print_array.append(binaries[0].eccentricity | units.none)
AP_print_array.append(binaries[0].argument_of_pericenter | units.none)
N += 1
def test7(self):
"""
test collision detection in 3-body system
"""
particles = create_nested_multiple(3, [1.0 | units.MSun, 1.2 | units.MSun, 0.9 | units.MSun], [1.0 | units.AU, 100.0 | units.AU], [0.1, 0.5], [0.01, 80.0*numpy.pi/180.0], [0.01, 0.01], [0.01, 0.01])
binaries = particles[particles.is_binary]
stars = particles - binaries
binaries.check_for_physical_collision_or_orbit_crossing = True
stars.radius = 0.03 | units.AU
code = SecularMultiple(redirection='none')
code.particles.add_particles(particles)
channel_to_code = particles.new_channel_to(code.particles)
channel_from_code = code.particles.new_channel_to(particles)
channel_to_code.copy()
t = 0.0 | units.Myr
dt = 1.0e-2 | units.Myr
tend = 1.0e-1 | units.Myr
t_print_array = quantities.AdaptingVectorQuantity()
a_print_array = quantities.AdaptingVectorQuantity()
e_print_array = quantities.AdaptingVectorQuantity()
while (t < tend):
t += dt
code.evolve_model(t)
flag = code.flag
channel_from_code.copy()
print('secular_breakdown_has_occurred', binaries.secular_breakdown_has_occurred)
print('dynamical_instability_has_occurred', binaries.dynamical_instability_has_occurred)
print('physical_collision_or_orbit_crossing_has_occurred', binaries.physical_collision_or_orbit_crossing_has_occurred)
print('minimum_periapse_distance_has_occurred', binaries.minimum_periapse_distance_has_occurred)
print('RLOF_at_pericentre_has_occurred', binaries.RLOF_at_pericentre_has_occurred)
if flag == 2:
print('root found')
break
print('t_end', code.model_time.value_in(units.Myr))
t_print_array.append(t)
a_print_array.append(binaries[0].semimajor_axis)
e_print_array.append(binaries[0].eccentricity | units.none)
def test8(self):
"""
test minimum periapse occurrence
"""
particles = create_nested_multiple(3, [1.0 | units.MSun, 1.2 | units.MSun, 0.9 | units.MSun], [1.0 | units.AU, 100.0 | units.AU], [0.1, 0.5], [0.01, 80.0*numpy.pi/180.0], [0.01, 0.01], [0.01, 0.01])
binaries = particles[particles.is_binary]
stars = particles - binaries
binaries.check_for_minimum_periapse_distance = True
rp_min = 0.1 | units.AU
binaries.check_for_minimum_periapse_distance_value = rp_min
code = SecularMultiple(redirection='none')
code.particles.add_particles(particles)
channel_to_code = particles.new_channel_to(code.particles)
channel_from_code = code.particles.new_channel_to(particles)
channel_to_code.copy()
t = 0.0 | units.Myr
dt = 5.0e-3 | units.Myr
tend = 1.0e-1 | units.Myr
t_print_array = quantities.AdaptingVectorQuantity()
a_print_array = quantities.AdaptingVectorQuantity()
e_print_array = quantities.AdaptingVectorQuantity()
while (t < tend):
t += dt
code.evolve_model(t)
flag = code.flag
channel_from_code.copy()
print('secular_breakdown_has_occurred', binaries.secular_breakdown_has_occurred)
print('dynamical_instability_has_occurred', binaries.dynamical_instability_has_occurred)
print('physical_collision_or_orbit_crossing_has_occurred', binaries.physical_collision_or_orbit_crossing_has_occurred)
print('minimum_periapse_distance_has_occurred', binaries.minimum_periapse_distance_has_occurred)
print('RLOF_at_pericentre_has_occurred', binaries.RLOF_at_pericentre_has_occurred)
if flag == 2:
print('root found')
break
print('t_end', code.model_time.value_in(units.Myr))
t_print_array.append(t)
a_print_array.append(binaries[0].semimajor_axis)
e_print_array.append(binaries[0].eccentricity | units.none)
if __name__ in ('__main__', '__plot__'):
testSecularMultiple = TestSecularMultiple()
cmd_options = parse_arguments()
if cmd_options["test"] == 1:
testSecularMultiple.test1()
if cmd_options["test"] == 2:
testSecularMultiple.test2()
if cmd_options["test"] == 3:
testSecularMultiple.test3()
if cmd_options["test"] == 4:
testSecularMultiple.test4()
if cmd_options["test"] == 5:
testSecularMultiple.test5()
if cmd_options["test"] == 6:
testSecularMultiple.test6()
if cmd_options["test"] == 7:
testSecularMultiple.test7()
if cmd_options["test"] == 8:
testSecularMultiple.test8()
| 24,111
| 34.880952
| 236
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_mercury.py
|
import os
import sys
import numpy as np
from amuse.test.amusetest import TestWithMPI
from amuse.community.mercury.interface import MercuryInterface, MercuryWayWard, Mercury
from amuse.ext.solarsystem import new_solar_system_for_mercury, new_solar_system
from amuse.units import nbody_system
from amuse.units import units, constants
from amuse import datamodel
from amuse.ic import plummer
DUMMYID = 0
try:
from matplotlib import pyplot
HAS_MATPLOTLIB = True
except ImportError:
HAS_MATPLOTLIB = False
class TestMercuryInterface(TestWithMPI):
def setUp(self):
super(TestWithMPI, self).setUp()
def test1(self):
instance = MercuryInterface()
instance.stop()
def test2(self):
instance = MercuryInterface()
instance.initialize_code()
instance.stop()
def test3(self):
instance = MercuryInterface()
instance.initialize_code()
instance.cleanup_code()
instance.stop()
def test4(self):
instance = MercuryInterface()
instance.initialize_code()
mass, err = instance.get_central_mass(DUMMYID)
self.assertEqual(mass, 1.0)
radius, err = instance.get_central_radius(DUMMYID)
self.assertEqual(radius, .005)
j2, j4, j6, err = instance.get_central_oblateness(DUMMYID)
self.assertEqual(j2, 0.0)
self.assertEqual(j4, 0.0)
self.assertEqual(j6, 0.0)
lx, ly, lz, err = instance.get_central_spin(DUMMYID)
self.assertEqual(lx, 0.0)
self.assertEqual(ly, 0.0)
self.assertEqual(lz, 0.0)
instance.stop()
def test5(self):
instance = MercuryInterface()
instance.initialize_code()
instance.set_central_mass(DUMMYID, 2.0)
instance.set_central_radius(DUMMYID, 0.0625)
instance.set_central_oblateness(DUMMYID, 0.001, 0.002, 0.003)
instance.set_central_spin(DUMMYID, -0.1, -0.2, -0.3)
mass, err = instance.get_central_mass(DUMMYID)
self.assertEqual(mass, 2.0)
radius, err = instance.get_central_radius(DUMMYID)
self.assertEqual(radius, .0625)
j2, j4, j6, err = instance.get_central_oblateness(DUMMYID)
self.assertEqual(j2, 0.001)
self.assertEqual(j4, 0.002)
self.assertEqual(j6, 0.003)
lx, ly, lz, err = instance.get_central_spin(DUMMYID)
self.assertEqual(lx, -0.1)
self.assertEqual(ly, -0.2)
self.assertEqual(lz, -0.3)
instance.stop()
def test6(self):
instance = MercuryInterface()
instance.initialize_code()
instance.commit_particles()
instance.cleanup_code()
instance.stop()
def test7(self):
instance = MercuryInterface()
instance.initialize_code()
time, err = instance.get_time()
self.assertEqual(time, 0.0)
instance.stop()
def test8(self):
instance = MercuryInterface()
instance.initialize_code()
n, err = instance.get_number_of_orbiters()
self.assertEqual(n, 0)
instance.stop()
def test9(self):
instance = MercuryInterface()
instance.initialize_code()
pid, err = instance.new_orbiter(0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.)
n, err = instance.get_number_of_orbiters()
self.assertEqual(n, 1)
instance.stop()
def test10(self):
instance = MercuryInterface()
instance.initialize_code()
pid, err = instance.new_orbiter(0.5, 1., 2., 3., 4., 5., 6., 7., 1., 2., 3., 8.)
mass, dens, x, y, z, vx, vy, vz, sx, sy, sz, celimit, err = instance.get_orbiter_state(pid)
self.assertEqual(mass, 0.5)
self.assertEqual(dens, 1.)
self.assertEqual(x, 2.)
self.assertEqual(y, 3.)
self.assertEqual(z, 4.)
self.assertEqual(vx, 5.)
self.assertEqual(vy, 6.)
self.assertEqual(vz, 7.)
self.assertEqual(sx, 1.)
self.assertEqual(sy, 2.)
self.assertEqual(sz, 3.)
self.assertEqual(celimit, 8.)
instance.stop()
def test11(self):
instance = MercuryInterface()
instance.initialize_code()
mass = 3.04043264264672381E-06
dens = 5.52
x = 2.42093942183383037E-01
y = -9.87467766698604366E-01
z = -4.54276292555233496E-06
vx = 1.64294055023289365E-02
vy = 4.03200725816140870E-03
vz = 1.13609607260006795E-08
sx = sy = sz = 0.
celimit = 20.
pid, err = instance.new_orbiter(mass, dens, x, y, z, vx, vy, vz, sx, sy, sz, celimit)
instance.commit_particles()
de, err = instance.get_energy_deviation()
self.assertEqual(de, 0.0)
etot, err = instance.get_total_energy()
ep, err = instance.get_potential_energy()
ek, err = instance.get_kinetic_energy()
self.assertAlmostEqual(etot, ep+ek, 15)
instance.stop()
def test12(self):
instance = MercuryInterface()
instance.initialize_code()
mass = 3.04043264264672381E-06
dens = 5.52
x = 2.42093942183383037E-01
y = -9.87467766698604366E-01
z = -4.54276292555233496E-06
vx = 1.64294055023289365E-02
vy = 4.03200725816140870E-03
vz = 1.13609607260006795E-08
sx = sy = sz = 0.
celimit = 20.
pid, err = instance.new_orbiter(mass, dens, x, y, z, vx, vy, vz, sx, sy, sz, celimit)
instance.commit_particles()
etot1, err = instance.get_total_energy()
err = instance.evolve_model(8*100000.)
etot2, err = instance.get_total_energy()
self.assertAlmostEqual(etot1, etot2, 7)
instance.stop()
def test13(self):
instance = MercuryInterface()
instance.initialize_code()
mass = 3.04043264264672381E-06
dens = 5.52
x = 2.42093942183383037E-01
y = -9.87467766698604366E-01
z = -4.54276292555233496E-06
vx = 1.64294055023289365E-02
vy = 4.03200725816140870E-03
vz = 1.13609607260006795E-08
sx = sy = sz = 0.
celimit = 20.
pid, err = instance.new_orbiter(mass, dens, x, y, z, vx, vy, vz, sx, sy, sz, celimit)
instance.commit_particles()
instance.enable_stopping_condition(3)
instance.set_stopping_condition_timeout_parameter(0.01)
etot1, err = instance.get_total_energy()
err = instance.evolve_model(8*1e100)
self.assertTrue(instance.is_stopping_condition_set(3)['result'] == 1)
etot2, err = instance.get_total_energy()
self.assertAlmostEqual(etot1, etot2, 7)
instance.stop()
def test14(self):
instance = MercuryInterface(redirection='none')
instance.initialize_code()
instance.set_central_particle_state(DUMMYID, 1., 2., 3., 4., 5., 6., 7., 8.)
mass, radius, j2, j4, j6, lx, ly, lz, err = instance.get_central_particle_state(DUMMYID)
self.assertEqual(mass, 1.0)
self.assertEqual(radius, 2.0)
self.assertEqual(j2, 3.0)
self.assertEqual(j4, 4.0)
self.assertEqual(j6, 5.0)
self.assertEqual(lx, 6.0)
self.assertEqual(ly, 7.0)
self.assertEqual(lz, 8.0)
instance.stop()
def test15(self):
instance = MercuryInterface(redirection='none')
instance.initialize_code()
i, err = instance.get_integrator()
self.assertEqual(i, 10)
err = instance.set_integrator(2)
self.assertEqual(err, 0)
i, err = instance.get_integrator()
self.assertEqual(i, 2)
err = instance.set_integrator(22)
self.assertEqual(err, -1)
instance.stop()
def test16(self):
instance = MercuryInterface()
instance.initialize_code()
err = instance.set_integrator(2)
mass = 3.04043264264672381E-06
dens = 5.52
x = 2.42093942183383037E-01
y = -9.87467766698604366E-01
z = -4.54276292555233496E-06
vx = 1.64294055023289365E-02
vy = 4.03200725816140870E-03
vz = 1.13609607260006795E-08
sx = sy = sz = 0.
celimit = 20.
pid, err = instance.new_orbiter(mass, dens, x, y, z, vx, vy, vz, sx, sy, sz, celimit)
instance.commit_particles()
instance.enable_stopping_condition(3)
instance.set_stopping_condition_timeout_parameter(0.01)
etot1, err = instance.get_total_energy()
err = instance.evolve_model(8*1e100)
self.assertTrue(instance.is_stopping_condition_set(3)['result'] == 1)
etot2, err = instance.get_total_energy()
self.assertAlmostEqual(etot1, etot2, 7)
instance.stop()
class TestMercury(TestWithMPI):
def setUp(self):
super(TestWithMPI, self).setUp()
def sun_and_earth(self):
orbiter = datamodel.Particles(1)
orbiter.mass = 5.97e24 | units.kg
orbiter.density = 1.0 | units.g/units.cm**3
orbiter.position = [1.0, 0.0, 0.0] | units.AU
orbiter.velocity = [0.0, 2.0*3.1415926535*1.0/365, 0.0] | units.AUd
orbiter.angular_momentum = [1.0, 0, 0] | units.MSun * units.AU**2/units.day
orbiter.celimit = 0.0 | units.none
centre = datamodel.Particles(1)
centre.mass = 1.0 | units.MSun
centre.radius = .0000001 | units.AU
centre.j2 = .0001 | units.AU**2
centre.j4 = .0 | units.AU**4
centre.j6 = .0 | units.AU**6
centre.angular_momentum = [0.0, 0.0, 0.0] | units.MSun * units.AU**2/units.day
return centre, orbiter
def test0(self):
centre, orbiter = self.sun_and_earth()
mercury = MercuryWayWard() # ,debugger='xterm')
mercury.initialize_code()
mercury.central_particle.add_particles(centre)
mercury.orbiters.add_particles(orbiter)
mercury.commit_particles()
self.assertAlmostEqual(mercury.central_particle.j4, .0 | units.AU**4)
self.assertAlmostEqual(mercury.central_particle.mass, 1.98892e+30 | units.kg, 3)
self.assertAlmostEqual(mercury.central_particle.mass, 1.0 | units.MSun, 3)
self.assertEqual(mercury.get_number_of_orbiters(), 1)
self.assertEqual(mercury.orbiters.position, [[1, 0, 0]] | units.AU)
self.assertEqual(mercury.orbiters.density, 1.0 | units.g/units.cm**3)
self.assertEqual(mercury.orbiters.angular_momentum, [[1.0, 0.0, 0.0]] | units.MSun*units.AU**2/units.day)
mercury.evolve_model(365.24 | units.day)
self.assertAlmostEqual(mercury.orbiters.position, [[1.0, 0.0, 0.0]] | units.AU, 1)
self.assertAlmostEqual(mercury.kinetic_energy+mercury.potential_energy, mercury.total_energy, 3)
mercury.stop()
def test1(self):
centre, orbiters = new_solar_system_for_mercury()
mercury = MercuryWayWard()
mercury.initialize_code()
mercury.central_particle.add_particles(centre)
mercury.orbiters.add_particles(orbiters)
mercury.commit_particles()
start_pos = mercury.orbiters[2].position
mercury.evolve_model(365.14 | units.day)
self.assertAlmostEqual(mercury.orbiters[2].position, start_pos, 1)
mercury.stop()
def test2(self):
centre, orbiters = new_solar_system_for_mercury()
mercury = MercuryWayWard()
mercury.initialize_code()
mercury.central_particle.add_particles(centre)
mercury.orbiters.add_particles(orbiters)
mercury.commit_particles()
start_pos = mercury.orbiters[2].position
mercury.evolve_model(16. | units.day)
self.assertEqual(mercury.get_time(), 16. | units.day)
mercury.stop()
def test3(self):
solsys = new_solar_system()
mercury = Mercury()
mercury.initialize_code()
mercury.particles.add_particles(solsys)
mercury.commit_particles()
start_pos = mercury.orbiters[2].position
mercury.evolve_model(365.14 | units.day)
self.assertAlmostEqual(mercury.orbiters[2].position, start_pos, 1)
mercury.stop()
def test4(self):
solsys = new_solar_system()
mercury = Mercury()
mercury.initialize_code()
self.assertEqual(mercury.parameters.timestep, 8 | units.day)
mercury.set_initial_timestep(1 | units.day)
mercury.parameters.timestep = 1 | units.day
mercury.particles.add_particles(solsys)
mercury.commit_particles()
start_pos = mercury.orbiters[2].position
mercury.evolve_model(365.14 | units.day)
self.assertAlmostEqual(mercury.orbiters[2].position, start_pos, 1)
mercury.stop()
def test5(self):
centre, orbiters = new_solar_system_for_mercury()
mercury = MercuryWayWard()
self.assertEqual(mercury.get_name_of_current_state(), 'UNINITIALIZED')
mercury.initialize_code()
self.assertEqual(mercury.get_name_of_current_state(), 'INITIALIZED')
mercury.commit_parameters()
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.central_particle.add_particles(centre)
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.orbiters.add_particles(orbiters)
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.commit_particles()
self.assertEqual(mercury.get_name_of_current_state(), 'RUN')
start_pos = mercury.orbiters[2].position
mercury.evolve_model(365.14 | units.day)
self.assertEqual(mercury.get_name_of_current_state(), 'EVOLVED')
self.assertAlmostEqual(mercury.orbiters[2].position, start_pos, 1)
mercury.cleanup_code()
self.assertEqual(mercury.get_name_of_current_state(), 'END')
mercury.stop()
def test6(self):
centre, orbiters = new_solar_system_for_mercury()
mercury = MercuryWayWard()
self.assertEqual(mercury.get_name_of_current_state(), 'UNINITIALIZED')
mercury.initialize_code()
self.assertEqual(mercury.get_name_of_current_state(), 'INITIALIZED')
mercury.commit_parameters()
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.central_particle.add_particles(centre)
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.orbiters.add_particles(orbiters[4:5])
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.commit_particles()
self.assertEqual(mercury.get_name_of_current_state(), 'RUN')
start_pos = mercury.orbiters[0].position
mercury.evolve_model(11.8618 | units.yr)
self.assertEqual(mercury.get_name_of_current_state(), 'EVOLVED')
self.assertAlmostEqual(mercury.orbiters[0].position, start_pos, 1)
mercury.orbiters.add_particles(orbiters[0:1])
self.assertEqual(mercury.get_name_of_current_state(), 'UPDATE')
mercury.recommit_particles()
self.assertAlmostEqual(mercury.orbiters[0].position, start_pos, 1)
start_pos = mercury.orbiters[0].position
mercury.evolve_model(2*11.8618 | units.yr)
self.assertEqual(mercury.get_name_of_current_state(), 'EVOLVED')
self.assertAlmostEqual(mercury.orbiters[0].position, start_pos, 1)
mercury.cleanup_code()
self.assertEqual(mercury.get_name_of_current_state(), 'END')
mercury.stop()
def test7(self):
centre, orbiters = new_solar_system_for_mercury()
mercury = MercuryWayWard() # debugger="gdb")
self.assertEqual(mercury.get_name_of_current_state(), 'UNINITIALIZED')
mercury.initialize_code()
self.assertEqual(mercury.get_name_of_current_state(), 'INITIALIZED')
mercury.commit_parameters()
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.central_particle.add_particles(centre)
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.orbiters.add_particles(orbiters[0:5])
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.commit_particles()
self.assertEqual(mercury.get_name_of_current_state(), 'RUN')
start_pos = mercury.orbiters[4].position
mercury.evolve_model(11.8618 | units.yr)
self.assertEqual(mercury.get_name_of_current_state(), 'EVOLVED')
self.assertAlmostEqual(mercury.orbiters[4].position, start_pos, 1)
mercury.orbiters.remove_particles(orbiters[0:1])
self.assertEqual(mercury.get_name_of_current_state(), 'UPDATE')
mercury.recommit_particles()
self.assertAlmostEqual(mercury.orbiters[3].position, start_pos, 1)
start_pos = mercury.orbiters[3].position
mercury.evolve_model(2*11.8618 | units.yr)
self.assertEqual(mercury.get_name_of_current_state(), 'EVOLVED')
self.assertAlmostEqual(mercury.orbiters[3].position, start_pos, 1)
mercury.cleanup_code()
self.assertEqual(mercury.get_name_of_current_state(), 'END')
mercury.stop()
def test8(self):
centre, orbiters = new_solar_system_for_mercury()
mercury = MercuryWayWard() # debugger="gdb")
self.assertEqual(mercury.get_name_of_current_state(), 'UNINITIALIZED')
mercury.initialize_code()
self.assertEqual(mercury.get_name_of_current_state(), 'INITIALIZED')
mercury.commit_parameters()
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.central_particle.add_particles(centre)
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.orbiters.add_particles(orbiters[0:5])
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.commit_particles()
self.assertEqual(mercury.get_name_of_current_state(), 'RUN')
start_pos = mercury.orbiters[4].position
mercury.evolve_model(11.8618 | units.yr)
self.assertEqual(mercury.get_name_of_current_state(), 'EVOLVED')
self.assertAlmostEqual(mercury.orbiters[4].position, start_pos, 1)
mercury.orbiters.remove_particles(orbiters[0:4])
self.assertEqual(mercury.get_name_of_current_state(), 'UPDATE')
mercury.recommit_particles()
self.assertAlmostEqual(mercury.orbiters[0].position, start_pos, 1)
start_pos = mercury.orbiters[0].position
mercury.evolve_model(2*11.8618 | units.yr)
self.assertEqual(mercury.get_name_of_current_state(), 'EVOLVED')
self.assertAlmostEqual(mercury.orbiters[0].position, start_pos, 1)
mercury.cleanup_code()
self.assertEqual(mercury.get_name_of_current_state(), 'END')
mercury.stop()
def test9(self):
centre, orbiters = new_solar_system_for_mercury()
mercury = MercuryWayWard() # debugger="gdb")
self.assertEqual(mercury.get_name_of_current_state(), 'UNINITIALIZED')
mercury.central_particle.add_particles(centre)
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.orbiters.add_particles(orbiters[0:5])
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
start_pos = mercury.orbiters[4].position
mercury.evolve_model(11.8618 | units.yr)
self.assertEqual(mercury.get_name_of_current_state(), 'EVOLVED')
self.assertAlmostEqual(mercury.orbiters[4].position, start_pos, 1)
mercury.orbiters.remove_particles(orbiters[0:4])
self.assertEqual(mercury.get_name_of_current_state(), 'UPDATE')
self.assertAlmostEqual(mercury.orbiters[0].position, start_pos, 1)
start_pos = mercury.orbiters[0].position
mercury.evolve_model(2*11.8618 | units.yr)
self.assertEqual(mercury.get_name_of_current_state(), 'EVOLVED')
self.assertAlmostEqual(mercury.orbiters[0].position, start_pos, 1)
def test10(self):
centre, orbiters = new_solar_system_for_mercury()
mercury = MercuryWayWard()
mercury.central_particle.add_particles(centre)
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
mercury.orbiters.add_particles(orbiters[4:5])
self.assertEqual(mercury.get_name_of_current_state(), 'EDIT')
start_pos = mercury.orbiters[0].position
mercury.evolve_model(11.8618 | units.yr)
self.assertEqual(mercury.get_name_of_current_state(), 'EVOLVED')
self.assertAlmostEqual(mercury.orbiters[0].position, start_pos, 1)
mercury.orbiters.add_particles(orbiters[0:4])
self.assertEqual(mercury.get_name_of_current_state(), 'UPDATE')
self.assertAlmostEqual(mercury.orbiters[0].position, start_pos, 1)
start_pos = mercury.orbiters[0].position
mercury.evolve_model(2*11.8618 | units.yr)
self.assertEqual(mercury.get_name_of_current_state(), 'EVOLVED')
self.assertAlmostEqual(mercury.orbiters[0].position, start_pos, 1)
def test11(self):
solsys = new_solar_system()
mercury = Mercury()
self.assertEqual(mercury.parameters.timestep, 8 | units.day)
mercury.parameters.timestep = 1 | units.day
self.assertEqual(mercury.parameters.timestep, 1 | units.day)
mercury.particles.add_particles(solsys)
start_pos = mercury.particles[5].position
mercury.evolve_model(11.8618 | units.yr)
self.assertAlmostEqual(mercury.particles[5].position, start_pos, 1)
mercury.stop()
def test12(self):
solsys = new_solar_system()
mercury = Mercury()
mercury.parameters.timestep = 1. | units.day
mercury.particles.add_particles(solsys)
start_pos = mercury.particles[5].position
mercury.evolve_model(11.8618 | units.yr)
self.assertAlmostEqual(mercury.particles[5].position, start_pos, 1)
mercury.particles.remove_particles(mercury.particles[1:5])
self.assertAlmostEqual(mercury.particles[1].position, start_pos, 1)
start_pos = mercury.particles[1].position
mercury.evolve_model(2*11.8618 | units.yr)
self.assertAlmostEqual(mercury.particles[1].position, start_pos, 1)
mercury.stop()
def test13(self):
solsys = new_solar_system()
mercury = Mercury()
mercury.particles.add_particles(solsys)
idpos1 = [(p.position - q.position) for p in mercury.particles[1:10] for q in mercury.particles[1:10]]
mercury.evolve_model(11.8618 | units.yr)
edpos1 = [(p.position - q.position) for p in mercury.particles[1:10] for q in mercury.particles[1:10]]
mercury.stop()
centre, orbiters = new_solar_system_for_mercury()
mercury = MercuryWayWard()
mercury.central_particle.add_particles(centre)
mercury.orbiters.add_particles(orbiters)
idpos2 = [(p.position - q.position) for p in mercury.orbiters[0:9] for q in mercury.orbiters[0:9]]
mercury.evolve_model(11.8618 | units.yr)
edpos2 = [(p.position - q.position) for p in mercury.orbiters[0:9] for q in mercury.orbiters[0:9]]
mercury.stop()
for d1, d2 in zip(idpos1, idpos2):
self.assertAlmostEqual(d1, d2, 7)
for d1, d2 in zip(edpos1, edpos2):
self.assertAlmostEqual(d1, d2, 7)
def test14(self):
centre, orbiters = new_solar_system_for_mercury()
oneyear = 365.14 | units.day
halfyear = oneyear / 2.0
mercury = MercuryWayWard()
mercury.initialize_code()
mercury.commit_parameters()
mercury.central_particle.add_particles(centre)
mercury.orbiters.add_particles(orbiters)
start_pos = mercury.orbiters[2].position
mercury.evolve_model(halfyear)
central_particles = mercury.central_particle.copy()
orbiters = mercury.orbiters.copy()
mercury.stop()
mercury = MercuryWayWard()
mercury.initialize_code()
mercury.parameters.begin_time = halfyear
mercury.commit_parameters()
mercury.central_particle.add_particles(centre)
mercury.orbiters.add_particles(orbiters)
mercury.evolve_model(oneyear)
self.assertAlmostEqual(mercury.orbiters[2].position, start_pos, 1)
mercury.stop()
def test15(self):
solsys = new_solar_system()
solsys.x -= 1. | units.AU
p = datamodel.Particles(3)
p.mass = [1, 2, 3] | units.MSun
p.x = [1, 10, 100] | units.AU
p.y = [0, 0, -10] | units.AU
p.z = [0, 0, 10] | units.AU
pe = p.potential_energy_in_field(solsys)
mercury = Mercury()
mercury.particles.add_particles(solsys)
pot = mercury.get_potential_at_point(p.x*0., p.x, p.y, p.z)
self.assertAlmostRelativeEqual((pot*p.mass).sum(), pe, 12)
def test16(self):
solsys = new_solar_system()
solsys.x -= 1. | units.AU
p = datamodel.Particles(3)
p.mass = [1, 2, 3] | units.MSun
p.x = [1, 10, 100] | units.AU
p.y = [0, 0, -10] | units.AU
p.z = [0, 0, 10] | units.AU
from amuse.community.huayno.interface import Huayno
from amuse.units import nbody_system
conv = nbody_system.nbody_to_si(1. | units.AU, 1. | units.MSun)
h = Huayno(conv)
h.particles.add_particles(solsys)
ax1, ay1, az1 = h.get_gravity_at_point(p.x*0., p.x, p.y, p.z)
mercury = Mercury()
mercury.particles.add_particles(solsys)
ax2, ay2, az2 = mercury.get_gravity_at_point(p.x*0., p.x, p.y, p.z)
self.assertAlmostRelativeEqual(ax1, ax2, 12)
self.assertAlmostRelativeEqual(ay1, ay2, 12)
self.assertAlmostRelativeEqual(az1, az2, 12)
def test17(self):
solsys = new_solar_system()
mercury = Mercury()
mercury.particles.add_particles(solsys)
mercury.evolve_model(5. | units.yr)
mercury.evolve_model(10. | units.yr)
dpos1 = mercury.particles[0].position-mercury.particles[5].position
mercury.stop()
mercury = Mercury()
mercury.particles.add_particles(solsys)
mercury.evolve_model(5. | units.yr)
mercury.particles.x += 1 | units.AU
mercury.particles.y += 2 | units.AU
mercury.particles.z += 3 | units.AU
mercury.particles.vx += 10. | units.kms
mercury.particles.vy += 20. | units.kms
mercury.particles.vz += 30. | units.kms
mercury.evolve_model(10. | units.yr)
dpos2 = mercury.particles[0].position-mercury.particles[5].position
mercury.stop()
self.assertAlmostEqual(dpos1, dpos2, 12)
def test18(self):
solsys = new_solar_system()
mercury = Mercury()
mercury.initialize_code()
self.assertEqual(mercury.parameters.integrator, 10)
mercury.parameters.integrator = 2
self.assertEqual(mercury.parameters.integrator, 2)
mercury.stop()
def test19(self):
solsys = new_solar_system()
mercury = Mercury()
mercury.initialize_code()
mercury.parameters.integrator = 1
mercury.particles.add_particles(solsys)
mercury.commit_particles()
start_pos = mercury.orbiters[2].position
mercury.evolve_model(365.14 | units.day)
self.assertAlmostEqual(mercury.orbiters[2].position, start_pos, 1)
mercury.stop()
def test20(self):
solsys = new_solar_system()
mercury = Mercury() # debugger="gdb")
mercury.initialize_code()
mercury.parameters.integrator = 2
mercury.particles.add_particles(solsys)
mercury.commit_particles()
start_pos = mercury.orbiters[2].position
mercury.evolve_model(365.14 | units.day)
self.assertAlmostEqual(mercury.orbiters[2].position, start_pos, 1)
mercury.stop()
def test21(self):
solsys = new_solar_system()
mercury = Mercury()
mercury.initialize_code()
names = ["elements_file", "close_encounters_file", "info_file",
"bigbody_file", "smallbody_file", "integration_parameters_file", "restart_file"]
for name in names:
self.assertEqual(getattr(mercury.parameters, name), "/dev/null")
for name in names:
setattr(mercury.parameters, name, os.path.join(mercury.output_directory, name))
for name in names:
self.assertEqual(getattr(mercury.parameters, name), os.path.join(mercury.output_directory, name))
mercury.stop()
def xtest22(self):
""" collision test hangs or fails if internal collision detection is enabled """
def collision():
M = 1. | units.MSun
m = 1. | units.MJupiter
r = 5. | units.AU
vcirc = (constants.G*(M+m)/r)**0.5
sys = datamodel.Particles(4)
sys[0].mass = M
sys[0].radius = 1. | units.RSun
sys[0].x = 0 | units.AU
sys[0].y = 0 | units.AU
sys[0].z = 0 | units.AU
sys[0].vx = 0 | units.kms
sys[0].vy = 0 | units.kms
sys[0].vz = 0 | units.kms
sys[1].mass = m
sys[1].radius = 0.01 | units.RSun
sys[1].x = r
sys[1].y = 0 | units.AU
sys[1].z = 0 | units.AU
sys[1].vx = 0 | units.kms
sys[1].vy = vcirc
sys[1].vz = 0 | units.kms
sys[2].mass = m
sys[2].radius = 0.01 | units.RSun
sys[2].x = -r
sys[2].y = 0 | units.AU
sys[2].z = 0 | units.AU
sys[2].vx = 0 | units.kms
sys[2].vy = vcirc
sys[2].vz = 0 | units.kms
sys[3].mass = m
sys[3].radius = 0.01 | units.RSun
sys[3].x = 0 | units.AU
sys[3].y = r
sys[3].z = 0 | units.AU
sys[3].vx = 0 | units.kms
sys[3].vy = 0 | units.kms
sys[3].vz = 0 | units.kms
return sys
code = Mercury()
sys = collision()
code.particles.add_particles(sys)
tend = 3.5 | units.yr
dt = 100. | units.day
tnow = code.model_time
while tnow < tend:
code.evolve_model(tnow+dt)
tnow = code.model_time
print(tnow.in_(units.yr))
code.stop()
| 30,338
| 35.730024
| 113
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_evtwin.py
|
from amuse.test.amusetest import TestWithMPI, get_path_to_results
import sys
import os.path
from numpy import pi, arange
import numpy.random
from amuse.community.evtwin.interface import EVtwin, EVtwinInterface
from amuse.support.exceptions import AmuseException
from amuse.units import nbody_system, units
from amuse.units.quantities import new_quantity
from amuse.datamodel import Particle, Particles
from amuse.rfi import channel
class TestEVtwinInterface(TestWithMPI):
def test1(self):
instance = EVtwinInterface()
error = instance.initialize_code()
self.assertEqual(0, error)
error = instance.cleanup_code()
self.assertEqual(0, error)
instance.stop()
def test2(self):
instance = EVtwinInterface()
error = instance.initialize_code()
self.assertEqual(0, error)
error = instance.set_ev_path(instance.get_data_directory())
self.assertEqual(0, error)
error = instance.cleanup_code()
self.assertEqual(0, error)
instance.stop()
def test3(self):
print("Testing get/set for metallicity...")
instance = EVtwinInterface()
error = instance.initialize_code()
self.assertEqual(0, error)
error = instance.set_ev_path(instance.get_data_directory())
self.assertEqual(0, error)
(metallicity, error) = instance.get_metallicity()
self.assertEqual(0, error)
self.assertEqual(0.02, metallicity)
# Z > 0.04 is not allowed
error = instance.set_metallicity(0.0401)
self.assertEqual(0, error)
error = instance.commit_parameters()
self.assertEqual(-2, error)
# 0.0 <= Z <= 0.04 is allowed
any_allowed_Z = numpy.random.random() * 0.04
error = instance.set_metallicity(any_allowed_Z)
self.assertEqual(0, error)
(metallicity, error) = instance.get_metallicity()
self.assertEqual(0, error)
self.assertEqual(any_allowed_Z, metallicity)
error = instance.commit_parameters()
self.assertEqual(0, error)
error = instance.cleanup_code()
self.assertEqual(0, error)
instance.stop()
def test4(self):
print("Testing get/set for maximum number of stars...")
instance = EVtwinInterface()
error = instance.initialize_code()
self.assertEqual(0, error)
error = instance.set_ev_path(instance.get_data_directory())
self.assertEqual(0, error)
(value, error) = instance.get_maximum_number_of_stars()
self.assertEqual(0, error)
self.assertEqual(10, value)
error = instance.set_maximum_number_of_stars(10000)
self.assertEqual(0, error)
(value, error) = instance.get_maximum_number_of_stars()
self.assertEqual(0, error)
self.assertEqual(10000, value)
error = instance.commit_parameters()
self.assertEqual(0, error)
error = instance.cleanup_code()
self.assertEqual(0, error)
instance.stop()
def test5(self):
print("Testing basic operations (new_particle_method, evolve_one_step etc.)...")
instance = EVtwinInterface()
error = instance.initialize_code()
self.assertEqual(0, error)
error = instance.set_ev_path(instance.get_data_directory())
self.assertEqual(0, error)
error = instance.commit_parameters()
self.assertEqual(0, error)
(index_of_the_star, error) = instance.new_particle_method(1.05)
self.assertEqual(0, error)
self.assertTrue(index_of_the_star >= 0)
error = instance.commit_particles()
self.assertEqual(0, error)
error = instance.set_wind_multiplier(index_of_the_star, 1.0)
self.assertEqual(0, error)
(mass, error) = instance.get_mass(index_of_the_star)
self.assertEqual(0, error)
self.assertEqual(1.05, mass)
for i in range(3):
error = instance.evolve_one_step(index_of_the_star)
self.assertEqual(0, error)
(mass, error) = instance.get_mass(index_of_the_star)
self.assertEqual(0, error)
self.assertTrue(mass <= 1.05)
(age, error) = instance.get_age(index_of_the_star)
self.assertEqual(0, error)
self.assertTrue(age > 0)
(x, error) = instance.get_wind_mass_loss_rate(index_of_the_star)
self.assertEqual(0, error)
self.assertTrue(x < 1e-13, "mass loss should be less than 1e-13, it is {0}".format(x))
self.assertTrue(x > 0, "mass loss rate should be more than 0, it is {0}".format(x))
error = instance.cleanup_code()
self.assertEqual(0, error)
instance.stop()
def test6(self):
print("Testing EVtwin stop conditions...")
instance = EVtwinInterface()
error = instance.initialize_code()
self.assertEqual(0, error)
error = instance.set_ev_path(instance.get_data_directory())
self.assertEqual(0, error)
(value, error) = instance.get_max_age_stop_condition()
self.assertEqual(0, error)
self.assertEqual(2.0e12, value)
for x in range(10, 14):
error = instance.set_max_age_stop_condition(10 ** x)
self.assertEqual(0, error)
(value, error) = instance.get_max_age_stop_condition()
self.assertEqual(0, error)
self.assertEqual(10 ** x, value)
(value, error) = instance.get_min_timestep_stop_condition()
self.assertEqual(0, error)
self.assertAlmostEqual(1.0e6, value, 5)
for x in range(-3, 2):
error = instance.set_min_timestep_stop_condition(10 ** x)
self.assertEqual(0, error)
(value, error) = instance.get_min_timestep_stop_condition()
self.assertEqual(0, error)
self.assertEqual(10 ** x, value)
instance.stop()
def test7(self):
print("Testing EVtwin parameters...")
instance = EVtwinInterface()
error = instance.initialize_code()
self.assertEqual(0, error)
error = instance.set_ev_path(instance.get_data_directory())
self.assertEqual(0, error)
error = instance.commit_parameters()
self.assertEqual(0, error)
(value, error) = instance.get_number_of_ionization_elements()
self.assertEqual(0, error)
self.assertEqual(5, value)
for x in range(1, 10):
error = instance.set_number_of_ionization_elements(x)
self.assertEqual(0, error)
(value, error) = instance.get_number_of_ionization_elements()
self.assertEqual(0, error)
self.assertEqual(x, value)
(value, error) = instance.get_convective_overshoot_parameter()
self.assertEqual(0, error)
self.assertEqual(0.12, value)
for x in [0.0, 0.1, 0.12, 0.15]:
error = instance.set_convective_overshoot_parameter(x)
self.assertEqual(0, error)
(value, error) = instance.get_convective_overshoot_parameter()
self.assertEqual(0, error)
self.assertEqual(x, value)
(value, error) = instance.get_mixing_length_ratio()
self.assertEqual(0, error)
self.assertEqual(2.0, value)
for x in [0.1, 1.0, 3.0]:
error = instance.set_mixing_length_ratio(x)
self.assertEqual(0, error)
(value, error) = instance.get_mixing_length_ratio()
self.assertEqual(0, error)
self.assertEqual(x, value)
(value, error) = instance.get_semi_convection_efficiency()
self.assertEqual(0, error)
self.assertEqual(0.04, value)
for x in [0.0, 0.1]:
error = instance.set_semi_convection_efficiency(x)
self.assertEqual(0, error)
(value, error) = instance.get_semi_convection_efficiency()
self.assertEqual(0, error)
self.assertEqual(x, value)
(value, error) = instance.get_thermohaline_efficiency()
self.assertEqual(0, error)
self.assertEqual(1.0, value)
for x in [0.0, 0.5, 1.5]:
error = instance.set_thermohaline_efficiency(x)
self.assertEqual(0, error)
(value, error) = instance.get_thermohaline_efficiency()
self.assertEqual(0, error)
self.assertEqual(x, value)
instance.stop()
def test9(self):
print("Testing adding and removing particles from stellar evolution code...")
instance = EVtwinInterface()
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_ev_path(instance.get_data_directory()))
self.assertEqual(0, instance.commit_parameters())
(indices, errors) = instance.new_particle_method([1.0, 1.0])
self.assertEqual(errors, [0, 0])
self.assertEqual(indices, [1, 2])
self.assertEqual(0, instance.commit_particles())
for index in indices:
self.assertEqual(0, instance.evolve_one_step(index))
(age_after_evolve, error) = instance.get_age(index)
self.assertEqual(0, error)
self.assertAlmostEqual(age_after_evolve, 3000000.0, 5)
self.assertEqual(0, instance.delete_star(1))
self.assertEqual(instance.get_number_of_particles()['number_of_particles'], 1)
(age, error) = instance.get_age(1)
self.assertEqual(error, -1)
(indices, errors) = instance.new_particle_method([1.0, 1.0])
self.assertEqual(errors, [0, 0])
self.assertEqual(indices, [1, 3])
self.assertEqual(instance.get_number_of_particles()['number_of_particles'], 3)
for index in indices:
(age, error) = instance.get_age(index)
self.assertEqual(0, error)
print(age, age_after_evolve)
self.assertTrue(age < age_after_evolve)
self.assertEqual(0, instance.evolve_one_step(index))
(age, error) = instance.get_age(index)
self.assertEqual(0, error)
self.assertAlmostEqual(age, age_after_evolve)
instance.stop()
class TestEVtwin(TestWithMPI):
def test0(self):
instance = EVtwin()
instance.initialize_code()
instance.cleanup_code()
instance.stop()
def test1(self):
print("Testing assigned default parameter values...")
instance = EVtwin()
instance.initialize_code()
instance.parameters.set_defaults()
self.assertEqual(10, instance.parameters.maximum_number_of_stars)
instance.parameters.maximum_number_of_stars = 12
self.assertEqual(12, instance.parameters.maximum_number_of_stars)
instance.stop()
def test2(self):
print("Testing basic operations")
instance = EVtwin()
instance.initialize_code()
instance.commit_parameters()
stars = Particles(1)
stars.mass = 10 | units.MSun
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertEqual(instance.particles.mass, 10 | units.MSun)
self.assertAlmostEqual(instance.particles.luminosity, 5695.19757302 | units.LSun, 6)
self.assertAlmostEqual(instance.particles.radius, 4.07378590 | units.RSun, 6)
instance.stop()
def test3(self):
print("Testing sun recreation")
instance = EVtwin()
instance.initialize_code()
instance.commit_parameters()
stars = Particles(1)
stars.mass = 1 | units.MSun
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertEqual(instance.particles.mass, 1 | units.MSun)
self.assertAlmostEqual(instance.particles.luminosity, 0.7098065 | units.LSun, 6)
self.assertAlmostEqual(instance.particles.radius, 0.8892833 | units.RSun, 6)
instance.evolve_model(4.8 | units.Gyr)
self.assertAlmostEqual(instance.particles.mass, 0.999921335 | units.MSun, 6)
self.assertAlmostEqual(instance.particles.luminosity, 1.04448714 | units.LSun, 6)
self.assertAlmostEqual(instance.particles.radius, 1.02061451 | units.RSun, 6)
instance.stop()
def xtest3(self):
instance = EVtwin()
instance.initialize_code()
instance.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 5.0 | units.MSun
star.radius = 0.0 | units.RSun
instance.particles.add_particles(stars)
instance.commit_particles()
from_code_to_model = instance.particles.new_channel_to(stars)
from_code_to_model.copy()
previous_type = star.stellar_type
results = []
t0 = 0 | units.Myr
current_time = t0
while current_time < (115 | units.Myr):
instance.evolve_model()
from_code_to_model.copy()
current_time = star.age
print((star.age, star.mass, star.stellar_type))
if not star.stellar_type == previous_type:
results.append((star.age, star.mass, star.stellar_type))
previous_type = star.stellar_type
print(results)
self.assertEqual(len(results), 6)
times = (
104.0 | units.Myr,
104.4 | units.Myr,
104.7 | units.Myr,
120.1 | units.Myr,
120.9 | units.Myr,
121.5 | units.Myr
)
for result, expected in zip(results, times):
self.assertAlmostEqual(result[0].value_in(units.Myr), expected.value_in(units.Myr), 1)
masses = (
5.000 | units.MSun,
5.000 | units.MSun,
4.998 | units.MSun,
4.932 | units.MSun,
4.895 | units.MSun,
0.997 | units.MSun
)
for result, expected in zip(results, masses):
self.assertAlmostEqual(result[1].value_in(units.MSun), expected.value_in(units.MSun), 3)
types = (
"Hertzsprung Gap",
"First Giant Branch",
"Core Helium Burning",
"First Asymptotic Giant Branch",
"Second Asymptotic Giant Branch",
"Carbon/Oxygen White Dwarf",
)
for result, expected in zip(results, types):
self.assertEqual(str(result[2]), expected)
instance.stop()
def test4(self):
print("Testing max age stop condition...")
# masses = [.5, 1.0, 1.5] | units.MSun # Test with fewer particles for speed-up.
masses = [.5] | units.MSun
max_age = 9.0 | units.Myr
number_of_stars = len(masses)
stars = Particles(number_of_stars)
for i, star in enumerate(stars):
star.mass = masses[i]
star.radius = 0.0 | units.RSun
# Initialize stellar evolution code
instance = EVtwin()
instance.initialize_code()
instance.parameters.verbosity = True
if instance.parameters.maximum_number_of_stars < number_of_stars:
instance.parameters.maximum_number_of_stars = number_of_stars
self.assertEqual(instance.parameters.max_age_stop_condition, 2e6 | units.Myr)
instance.parameters.max_age_stop_condition = max_age
self.assertEqual(instance.parameters.max_age_stop_condition, max_age)
instance.commit_parameters()
instance.particles.add_particles(stars)
# Let the code perform initialization actions after all particles have been created.
instance.commit_particles()
from_code_to_model = instance.particles.new_channel_to(stars)
instance.evolve_model(end_time=8.0 | units.Myr)
from_code_to_model.copy()
for i in range(number_of_stars):
print(stars[i].age.as_quantity_in(units.Myr))
self.assertTrue(stars[i].age >= 8.0 | units.Myr)
self.assertTrue(stars[i].age <= max_age)
self.assertTrue(stars[i].mass <= masses[i])
self.assertTrue(stars[i].time_step <= max_age)
self.assertRaises(
AmuseException,
instance.evolve_model,
end_time=2*max_age,
expected_message=(
"Error when calling 'evolve_for' of a "
"'<class 'amuse.community.evtwin.interface.EVtwin'>', "
"errorcode is 5, error is 'Age greater than maximum "
"age limit.'"
)
)
instance.stop()
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.assertEqual(len(stars), 0) # before creation
stars.add_particles(particles[:-1])
instance.commit_particles()
instance.evolve_model(1.0 | units.Myr)
self.assertEqual(len(stars), 2) # before remove
self.assertAlmostEqual(stars.age, 1.0 | units.Myr)
stars.remove_particle(particles[0])
self.assertEqual(len(stars), 1)
self.assertEqual(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.assertEqual(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()
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.assertEqual(instance.particles.get_number_of_zones(), [199, 199])
self.assertEqual(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.assertEqual(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.assertAlmostEqual(instance.particles[0].get_mu_profile()[:100], [0.62]*100 | units.amu, places=1)
instance.stop()
def test7(self):
print("Test for obtaining the stellar composition structure")
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()
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.assertEqual(number_of_zones, 199)
self.assertEqual(number_of_species, 9)
self.assertEqual(len(species_names), number_of_species)
self.assertEqual(len(composition), number_of_species)
self.assertEqual(len(composition[0]), number_of_zones)
self.assertEqual(species_names, ['h1', 'he4', 'c12', 'n14', 'o16', 'ne20', 'mg24', 'si28', 'fe56'])
self.assertAlmostEqual(composition[0, -1], 0.7, 3)
self.assertAlmostEqual(composition[1, -1], 0.3 - instance.parameters.metallicity, 3)
self.assertAlmostEqual(composition[2:, -1].sum(), instance.parameters.metallicity, 3)
self.assertAlmostEqual(composition.sum(axis=0), [1.0]*number_of_zones)
instance.stop()
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.assertEqual(number_of_zones, 199)
self.assertEqual(number_of_species, 9)
self.assertEqual(len(species_names), number_of_species)
self.assertEqual(len(composition), number_of_species)
self.assertEqual(len(composition[0]), number_of_zones)
self.assertEqual(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.assertAlmostEqual(composition.sum(axis=0), [1.0]*number_of_zones | units.none)
self.assertAlmostEqual(composition[0, 0], 0.00 | units.none)
self.assertAlmostEqual(composition[1, 0], 1.00 - instance.parameters.metallicity, 3)
self.assertAlmostEqual(composition[2:, 0].sum(), instance.parameters.metallicity, 3)
instance.stop()
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)
import warnings
warnings.warn("this test's precision has been temporarily (2017) decreased")
# the reason for this is that the deviation is compiler dependend (and does only happen
# on some machine/compiler/OS combinations)
# it may have something to do with initialization of variables in evtwin
# ~ self.assertAlmostRelativeEquals(instance.particles.temperature, [3644, 4783, 3644, 4783] | units.K, 3)
self.assertAlmostRelativeEquals(instance.particles.temperature, [3644, 4783, 3644, 4783] | units.K, 2)
instance.stop()
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
def xtest10(self):
print("Test for changing the stellar composition (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()
composition = instance.particles[0].get_chemical_abundance_profiles()
h1_profile = composition[0] * 1
he4_profile = composition[1] * 1
k_surface = -1 # index to the outer mesh cell (surface)
self.assertAlmostEqual(composition[0, k_surface], 0.7 | units.none, 4)
self.assertAlmostEqual(composition[1, k_surface], (0.3 | units.none) - instance.parameters.metallicity, 4)
self.assertAlmostEqual(composition[2:, k_surface].sum(), instance.parameters.metallicity, 4)
composition[0] = he4_profile
composition[1] = h1_profile
instance.particles[0].set_chemical_abundance_profiles(composition)
instance.evolve_model()
composition = instance.particles[0].get_chemical_abundance_profiles()
self.assertAlmostEqual(composition[0, k_surface], (0.3 | units.none) - instance.parameters.metallicity, 4)
self.assertAlmostEqual(composition[1, k_surface], 0.7 | units.none, 4)
self.assertAlmostEqual(composition[2:, k_surface].sum(), instance.parameters.metallicity, 4)
self.assertAlmostEqual(composition.sum(axis=0), 1.0 | units.none)
self.assertRaises(AmuseException, instance.particles[0].set_chemical_abundance_profiles, composition[:7],
expected_message="The length of the supplied vector (7) does not match the number of "
"chemical species of the star (8).")
instance.stop()
del instance
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()
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)
# plot_tracks(t1, l1, t2, l2)
def xslowtest11(self):
print("Test 11: Continue the stellar evolution of a 'merger product' - WIP")
instance = EVtwin()
instance.initialize_code()
instance.commit_parameters()
instance.parameters.min_timestep_stop_condition = 1.0 | units.s
stars = Particles(3)
stars.mass = [1.0, 2.0, 1.0] | units.MSun
instance.particles.add_particles(stars)
instance.commit_particles()
instance.evolve_model(1.0 | units.Myr)
stellar_models = instance.native_stars.get_internal_structure()
self.assertEqual(len(stellar_models), 3)
self.assertEqual(len(stellar_models[0]), 199)
self.assertEqual(len(stellar_models[1]), 199)
self.assertAlmostEqual(stellar_models[0].mass[198], 1.0 | units.MSun, 2)
self.assertAlmostEqual(stellar_models[1].mass[198], 2.0 | units.MSun, 2)
self.assertAlmostEqual(stellar_models[0].mass[0], 0.0 | units.MSun, 2)
instance.new_particle_from_model(stellar_models[0], instance.particles[0].age)
self.assertEqual(len(instance.particles), 4)
self.assertEqual(len(instance.imported_stars), 1)
imported_stellar_model = instance.imported_stars[0].get_internal_structure()
self.assertEqual(len(imported_stellar_model), 199)
self.assertAlmostEqual(imported_stellar_model.mass[198], 1.0 | units.MSun, 2)
self.assertAlmostEqual(imported_stellar_model.mass[0], 0.0 | units.MSun, 2)
self.assertAlmostRelativeEqual(imported_stellar_model.X_H, stellar_models[0].X_H, 5)
self.assertAlmostRelativeEqual(imported_stellar_model.X_He, stellar_models[0].X_He, 5)
self.assertAlmostRelativeEqual(imported_stellar_model.mass, stellar_models[0].mass, 2)
self.assertAlmostRelativeEqual(imported_stellar_model.radius[1:], stellar_models[0].radius[1:], 2)
# instance.evolve_model(2.0 | units.Myr)
print(instance.particles)
instance.stop()
del instance
def xtest12a(self):
print("Testing basic operations: evolve_one_step and evolve_for")
stars = Particles(2)
stars.mass = 1.0 | units.MSun
instance = EVtwin()
se_stars = instance.particles.add_particles(stars)
self.assertAlmostEqual(se_stars.age, [0.0, 0.0] | units.yr)
for i in range(3):
se_stars[0].evolve_one_step()
self.assertAlmostEqual(se_stars.age, [225488.337629, 0.0] | units.yr, 3)
number_of_steps = 10
step_size = se_stars[0].age / number_of_steps
for i in range(1, number_of_steps + 1):
se_stars[1].evolve_for(step_size)
self.assertAlmostEqual(se_stars.age, [number_of_steps, i] * step_size)
print(se_stars)
self.assertAlmostRelativeEqual(se_stars[0].age, se_stars[1].age)
self.assertAlmostRelativeEqual(se_stars[0].luminosity, se_stars[1].luminosity, 3)
self.assertAlmostRelativeEqual(se_stars[0].radius, se_stars[1].radius, 3)
self.assertAlmostRelativeEqual(se_stars[0].temperature, se_stars[1].temperature, 3)
instance.stop()
def xtest12b(self):
print("Testing basic operations: evolve_one_step and evolve_for (on subset, WIP: Ticket 304)")
stars = Particles(2)
stars.mass = 1.0 | units.MSun
instance = EVtwin()
se_stars = instance.particles.add_particles(stars)
self.assertAlmostEqual(se_stars.age, [0.0, 0.0] | units.yr)
for i in range(3):
se_stars[0].evolve_one_step()
self.assertAlmostEqual(se_stars.age, [225488.337629, 0.0] | units.yr, 3)
number_of_steps = 10
step_size = se_stars[0].age / number_of_steps
for i in range(1, number_of_steps + 1):
se_stars[1:].evolve_for(step_size)
self.assertAlmostEqual(se_stars.age, [number_of_steps, i] * step_size)
print(se_stars)
self.assertAlmostRelativeEqual(se_stars[0].age, se_stars[1].age)
self.assertAlmostRelativeEqual(se_stars[0].luminosity, se_stars[1].luminosity, 3)
self.assertAlmostRelativeEqual(se_stars[0].radius, se_stars[1].radius, 3)
self.assertAlmostRelativeEqual(se_stars[0].temperature, se_stars[1].temperature, 3)
instance.stop()
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()
def test14(self):
print("Testing EVtwin states")
stars = Particles(2)
stars.mass = 1.0 | units.MSun
instance = EVtwin()
print("First do everything manually:", end=' ')
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particle(stars[0])
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("ok")
print("initialize_code(), commit_parameters(), (re)commit_particles(), "
"and cleanup_code() should be called automatically:", end=' ')
instance = EVtwin()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.RGB_wind_setting = -0.5
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particle(stars[0])
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.particles.add_particle(stars[1])
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
print("ok")
def slowtest15(self):
print("test evolution of 1000 star sampled over flattish IMF")
number_of_stars = 1000
from amuse.ic.salpeter import new_salpeter_mass_distribution
import numpy
class notsorandom(object):
def random(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 = EVtwin()
instance.parameters.maximum_number_of_stars = number_of_stars
instance.parameters.min_timestep_stop_condition = .001 | units.s
instance.particles.add_particles(stars)
i = 0
for p in instance.particles:
print(i, p.mass)
p.evolve_for(0.1 | units.Myr)
i += 1
def xslowtest16(self):
print("test full evolution of 1000 star sampled over flattish IMF")
number_of_stars = 1000
from amuse.ic.salpeter import new_salpeter_mass_distribution
import numpy
class notsorandom(object):
def random(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 = EVtwin()
instance.parameters.maximum_number_of_stars = number_of_stars
instance.particles.add_particles(stars)
for p in instance.particles:
p.evolve_for(13.2 | units.Gyr)
def slowtest17(self):
"""
We add multiple particles to evtwin and evolve the stars
individualy. Evtwin crashes on some combinaties of
star masses and which star is evolved first.
"""
exceptions = []
for i, (masses, indices) in enumerate([
(
[1.21372730283, 1.22207032494, 11.21372730283] | units.MSun,
(0, 1)
),
(
[1.21372730283, 1.22207032494, 1.21372730283] | units.MSun,
(0, 1)
),
(
[1.21372730283, 1.22207032494, 1.21372730283] | units.MSun,
(1, 0)
),
(
[1.21372730283, 1.22207032494] | units.MSun,
(0, 1)
),
(
[1.21372730283, 11.22207032494, 1.21372730283] | units.MSun,
(0, 1)
),
(
[1.21372730283, 1.21372730283, 1.21372730283] | units.MSun,
(0, 1)
),
(
[1.21372730283, 1.22207032494, 1.21372730283] | units.MSun,
(0, 1)
),
(
[0.101, 1.22207032494, 1.21372730283] | units.MSun,
(0, 1)
)
]):
stars = Particles(mass=masses)
instance = EVtwin()
instance.particles.add_particles(stars)
try:
index_in_indices = 0
instance.particles[indices[index_in_indices]].evolve_for(0.1 | units.Myr)
index_in_indices = 1
instance.particles[indices[index_in_indices]].evolve_for(0.1 | units.Myr)
except AmuseException as ex:
exceptions.append([i, masses, indices, index_in_indices])
instance.stop()
if len(exceptions) > 0:
failure_message = ''
for index, masses, indices, index_in_indices in exceptions:
failure_message += '[{0}]: error in '.format(index)
failure_message += 'first' if index_in_indices == 0 else 'second'
failure_message += ' evolve_for,'
failure_message += ' index: {0},'.format(indices[index_in_indices])
failure_message += ' masses (MSun): {0}.\n'.format(masses.value_in(units.MSun))
self.fail(failure_message)
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.assertEqual(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)
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()
def test20(self):
print("Testing EVtwin manual mass transfer rate")
instance = EVtwin()
instance.parameters.verbosity = True
stars = instance.particles.add_particles(Particles(mass=[0.8, 0.8] | units.MSun))
stars[0].mass_transfer_rate = -1e-8 | units.MSun/units.yr
instance.evolve_model()
# NOTE! no mass transfer during the initial step:
self.assertEqual(stars[0].mass, stars[1].mass)
age = stars[0].age
mass = stars[0].mass
instance.evolve_model()
self.assertTrue(stars[0].mass < stars[1].mass)
# NOTE 2! actual mass transfer rate 10x lower:
self.assertAlmostRelativeEqual((stars[0].mass-mass) / (stars[0].age-age), -1.0e-9 | units.MSun/units.yr, 4)
instance.stop()
def simulate_evolution_tracks(star, end_time=1 | units.Gyr):
luminosity_at_time = [] | units.LSun
temperature_at_time = [] | units.K
while star.age < end_time:
luminosity_at_time.append(star.luminosity)
temperature_at_time.append(star.temperature)
star.evolve_one_step()
print(star.age)
return temperature_at_time, luminosity_at_time
def plot_tracks(temperature1, luminosity1, temperature2, luminosity2):
from matplotlib import pyplot
from amuse.plot import loglog, xlabel, ylabel
pyplot.figure(figsize=(8, 6))
pyplot.title('Hertzsprung-Russell diagram', fontsize=12)
loglog(temperature1, luminosity1)
loglog(temperature2, luminosity2)
xlabel('Effective Temperature')
ylabel('Luminosity')
pyplot.xlim(pyplot.xlim()[::-1])
pyplot.show()
| 47,749
| 43.212963
| 143
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_gadget2.py
|
import numpy
import os.path
from amuse.test.amusetest import TestWithMPI
from amuse.community.gadget2.interface import Gadget2Interface, Gadget2
from amuse.ext.evrard_test import MakeEvrardTest, new_evrard_gas_sphere, body_centered_grid_unit_cube
from amuse.ext.spherical_model import new_uniform_spherical_particle_distribution
from amuse.support.exceptions import AmuseException
from amuse.units import nbody_system
from amuse.units import generic_unit_converter
from amuse.units import generic_unit_system
from amuse.units import units, constants
from amuse.datamodel import Particles, Grid, ParticlesSuperset, new_regular_grid
from amuse.rfi import channel
from amuse.io import read_set_from_file, write_set_to_file
from amuse.ic.plummer import new_plummer_model
from amuse.ic.gasplummer import new_plummer_gas_model
from amuse.ext.cosmo import convert_comoving_to_physical
try:
from matplotlib import pyplot
HAS_MATPLOTLIB = True
from amuse.plot import plot, xlabel, ylabel
except ImportError:
HAS_MATPLOTLIB = False
default_options = dict(number_of_workers=1)
# default_options = dict(number_of_workers=2, redirection="none")
# ... but never use (number_of_workers>1) for tests with only a few particles:
few_particles_default_options = dict()
# few_particles_default_options = dict(redirection="none")
testing_isotherm_no_gravity = False
class TestGadget2Interface(TestWithMPI):
def test1(self):
instance = Gadget2Interface(**default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_gadget_output_directory(instance.get_output_directory()))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test2(self):
instance = Gadget2Interface(**default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_gadget_output_directory(instance.get_output_directory()))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([1.989000e43, 0], list(instance.get_unit_mass().values()))
self.assertEqual([3.085678e21, 0], list(instance.get_unit_length().values()))
self.assertEqual([3.085678e16, 0], list(instance.get_unit_time().values()))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test3(self):
instance = Gadget2Interface(**few_particles_default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_gadget_output_directory(instance.get_output_directory()))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([1, 0], list(instance.new_dm_particle(0.01, 1, 0, 0, 0, 1, 0).values()))
self.assertEqual([2, 0], list(instance.new_dm_particle(0.01, -1, 0, 0, 0, -1, 0).values()))
self.assertEqual(-1, instance.get_index_of_first_particle()['__result'])
self.assertEqual(0, instance.commit_particles())
self.assertEqual([1, 0], list(instance.get_index_of_first_particle().values()))
self.assertEqual([2, 1], list(instance.get_index_of_next_particle(1).values()))
self.assertEqual(-1, instance.get_index_of_next_particle(2)['__result'])
self.assertEqual(0, instance.evolve_model(0.01))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test3a(self):
instance = Gadget2Interface(**few_particles_default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_gadget_output_directory(instance.get_output_directory()))
# cgs
instance.set_unit_mass(0.001)
instance.set_unit_length(1.0)
instance.set_unit_time(122404.614048)
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([1, 0], list(instance.new_dm_particle(1., 1, 0, 0, 0, 0, 0).values()))
self.assertEqual([2, 0], list(instance.new_dm_particle(1., -1, 0, 0, 0, 0, 0).values()))
self.assertEqual(0, instance.commit_particles())
if testing_isotherm_no_gravity:
self.assertAlmostEqual(0.000, instance.get_potential(1)['Potential'], places=1)
else:
self.assertAlmostEqual(-0.500, instance.get_potential(1)['Potential'], places=1)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test4(self):
instance = Gadget2Interface(**few_particles_default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_gadget_output_directory(instance.get_output_directory()))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([1, 0], list(instance.new_dm_particle(0.01, 1, 0, 0, 0, 1, 0).values()))
self.assertEqual([2, 0], list(instance.new_dm_particle(0.02, -1, 0, 0, 0, -1, 0).values()))
self.assertEqual(-3, instance.get_mass(1)['__result'])
self.assertEqual(0, instance.commit_particles())
mass, result = instance.get_mass(1)
self.assertAlmostEqual(0.01, mass)
self.assertEqual(0, result)
mass, result = instance.get_mass(2)
self.assertAlmostEqual(0.02, mass)
self.assertEqual(0, result)
self.assertEqual(-3, instance.get_mass(3)['__result'])
for result, expected in zip(instance.get_position(1), [1, 0, 0, 0]):
self.assertAlmostEqual(result, expected)
for result, expected in zip(instance.get_position(2), [-1, 0, 0, 0]):
self.assertAlmostEqual(result, expected)
for result, expected in zip(instance.get_velocity(1), [0, 1, 0, 0]):
self.assertAlmostEqual(result, expected)
for result, expected in zip(instance.get_velocity(2), [0, -1, 0, 0]):
self.assertAlmostEqual(result, expected)
self.assertEqual(0, instance.set_state(1, 0.01, 1, 2, 3, 4, 5, 6))
self.assertEqual([0.01, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0], list(instance.get_state(1).values()))
self.assertEqual(0, instance.evolve_model(0.01))
mass, result = instance.get_mass(1)
self.assertAlmostEqual(0.01, mass)
self.assertEqual(0, result)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test5(self):
instance = Gadget2Interface(**default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_gadget_output_directory(instance.get_output_directory()))
self.assertEqual(0, instance.commit_parameters())
target_number_of_particles = 100
evrard = MakeEvrardTest(target_number_of_particles)
mass, x, y, z, vx, vy, vz, u = evrard.new_model()
number_of_particles = len(mass)
indices, results = instance.new_sph_particle(mass, x, y, z, vx, vy, vz, u)
self.assertEqual([0 for i in range(number_of_particles)], list(results))
self.assertEqual([i+1 for i in range(number_of_particles)], list(indices))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(0.00005))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test6(self):
instance = Gadget2Interface(**default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_gadget_output_directory(instance.get_output_directory()))
self.assertEqual(0, instance.commit_parameters())
target_number_of_particles = 100
evrard = MakeEvrardTest(target_number_of_particles)
mass, x, y, z, vx, vy, vz, u = evrard.new_model()
number_of_particles = len(mass)
first_half = number_of_particles//2
indices, results = instance.new_sph_particle(mass[:first_half], x[:first_half], y[:first_half], z[:first_half],
vx[:first_half], vy[:first_half], vz[:first_half], u[:first_half])
self.assertEqual([0 for i in range(first_half)], list(results))
self.assertEqual([i+1 for i in range(first_half)], list(indices))
self.assertEqual([number_of_particles/2+1, 0], list(instance.new_dm_particle(0.01, 1, 0, 0, 0, 1, 0).values()))
self.assertEqual([number_of_particles/2+2, 0], list(instance.new_dm_particle(0.02, -1, 0, 0, 0, -1, 0).values()))
indices, results = instance.new_sph_particle(mass[first_half:], x[first_half:], y[first_half:], z[first_half:],
vx[first_half:], vy[first_half:], vz[first_half:], u[first_half:])
self.assertEqual([0 for i in range(number_of_particles-first_half)], list(results))
self.assertEqual([first_half+i+1+2 for i in range(number_of_particles-first_half)], list(indices))
self.assertEqual(0, instance.commit_particles())
mass_list = [x for sublist in [mass[:first_half], [0.01, 0.02], mass[first_half:]] for x in sublist]
first_index, result = list(instance.get_index_of_first_particle().values())
self.assertEqual([1, 0], [first_index, result])
for i in range(first_index, number_of_particles+2):
index, result = instance.get_index_of_next_particle(i)
self.assertEqual([i+1, 0 if (i < number_of_particles+1) else 1], [index, result])
mass, result = instance.get_mass(index)
self.assertEqual(0, result)
self.assertAlmostEqual(mass_list[i], mass)
self.assertEqual(0, instance.evolve_model(0.0001))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test7(self):
instance = Gadget2Interface(**default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_gadget_output_directory(instance.get_output_directory()))
self.assertEqual(0, instance.commit_parameters())
target_number_of_particles = 100
evrard = MakeEvrardTest(target_number_of_particles)
mass, x, y, z, vx, vy, vz, u = evrard.new_model()
number_of_particles = len(mass)
indices, results = instance.new_sph_particle(mass, x, y, z, vx, vy, vz, u)
self.assertEqual([0 for i in range(number_of_particles)], list(results))
self.assertEqual([i+1 for i in range(number_of_particles)], list(indices))
self.assertEqual([number_of_particles+1, 0], list(instance.new_dm_particle(0.01, 1, 0, 0, 0, 1, 0).values()))
self.assertEqual([number_of_particles+2, 0], list(instance.new_dm_particle(0.02, -1, 0, 0, 0, -1, 0).values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(0.001))
self.assertEqual(0, instance.delete_particle(number_of_particles-1))
self.assertEqual(0, instance.delete_particle(number_of_particles+1))
self.assertEqual(-3, instance.delete_particle(number_of_particles-1))
indices, results = instance.new_sph_particle(mass, x, y, z, vx, vy, vz, u)
self.assertEqual([2*number_of_particles+3, 0], list(instance.new_dm_particle(0.02, -1, 0, 0, 0, -1, 0).values()))
self.assertEqual(0, instance.recommit_particles())
mass_list = [x for sublist in [mass[:number_of_particles-2], [mass[number_of_particles-1], 0.02],
mass, [0.02]] for x in sublist]
index_list = [x for sublist in [list(range(1, number_of_particles-1)), [number_of_particles],
list(range(number_of_particles+2, 2*number_of_particles+4))] for x in sublist]
index, result = list(instance.get_index_of_first_particle().values())
self.assertEqual([index_list[0], 0], [index, result])
for i in range(1, 2*number_of_particles+1):
index, result = instance.get_index_of_next_particle(index)
self.assertEqual([index_list[i], 0 if (i < 2*number_of_particles) else 1], [index, result])
mass, result = instance.get_mass(index)
self.assertEqual(0, result)
self.assertAlmostEqual(mass_list[i], mass)
self.assertEqual(0, instance.evolve_model(0.001))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test8(self):
instance = Gadget2Interface(**few_particles_default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_gadget_output_directory(instance.get_output_directory()))
self.assertEqual(0, instance.commit_parameters())
for i in range(1, 10):
self.assertEqual([i, 0], list(instance.new_dm_particle(i*0.01, i, -i, 0, -i*10, i*10, 0).values()))
self.assertEqual(0, instance.commit_particles())
for i in range(1, 10):
mass, result = instance.get_mass(i)
self.assertAlmostEqual(0.01*i, mass)
self.assertEqual(0, result)
x, y, z, result = instance.get_position(i)
self.assertAlmostEqual(i, x)
self.assertAlmostEqual(-i, y)
self.assertAlmostEqual(0, z)
self.assertEqual(0, result)
vx, vy, vz, result = instance.get_velocity(i)
self.assertAlmostEqual(-i*10, vx)
self.assertAlmostEqual(i*10, vy)
self.assertAlmostEqual(0, vz)
self.assertEqual(0, result)
self.assertEqual(0, instance.set_mass(i, i*0.1))
mass, result = instance.get_mass(i)
self.assertAlmostEqual(0.1*i, mass)
self.assertEqual(0, result)
self.assertEqual(0, instance.set_position(i, 2*i, -2*i, 0))
x, y, z, result = instance.get_position(i)
self.assertAlmostEqual(2*i, x)
self.assertAlmostEqual(-2*i, y)
self.assertAlmostEqual(0, z)
self.assertEqual(0, result)
self.assertEqual(0, instance.set_velocity(i, -i*20, i*20, 0))
vx, vy, vz, result = instance.get_velocity(i)
self.assertAlmostEqual(-i*20, vx)
self.assertAlmostEqual(i*20, vy)
self.assertAlmostEqual(0, vz)
self.assertEqual(0, result)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test9(self):
instance = Gadget2Interface(mode=Gadget2Interface.MODE_PERIODIC_NOGRAVITY,
**few_particles_default_options)
instance.initialize_code()
instance.set_min_size_timestep(1.0)
instance.set_gadget_output_directory(instance.get_output_directory())
instance.set_box_size(2.)
value, error = instance.get_box_size()
self.assertEqual(error, 0)
self.assertEqual(value, 2.)
self.assertEqual(instance.get_periodic_boundaries_flag()['value'], True)
self.assertEqual(instance.set_periodic_boundaries_flag(True), -2) # read-only
self.assertEqual(instance.get_nogravity()['no_gravity_flag'], True)
self.assertEqual(instance.commit_parameters(), 0)
ids, err = instance.new_particle(
[1.0, 1.0, 1.0],
[0.5, 0.0, 0.0],
[0.0, -0.5, 0.0],
[0.0, 0.0, 0.5],
[-1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, -1.0])
instance.commit_particles()
m, x, y, z, vx, vy, vz, err = instance.get_state(ids)
self.assertAlmostEqual(x, [0.5, 0., 0.], places=6)
self.assertAlmostEqual(y, [0., -0.5, 0.], places=6)
self.assertAlmostEqual(z, [0., 0., 0.5], places=6)
instance.evolve_model(0.1)
m, x, y, z, vx, vy, vz, err = instance.get_state(ids)
self.assertAlmostEqual(x, [0.4, 0., 0.], places=6)
self.assertAlmostEqual(y, [0., -0.4, 0.], places=6)
self.assertAlmostEqual(z, [0., 0., 0.4], places=6)
instance.evolve_model(1.0)
m, x, y, z, vx, vy, vz, err = instance.get_state(ids)
self.assertAlmostEqual(x, [-0.5, 0., 0.], places=6)
self.assertAlmostEqual(y, [0., 0.5, 0.], places=6)
self.assertAlmostEqual(z, [0., 0., -0.5], places=6)
instance.cleanup_code()
instance.stop()
instance = Gadget2Interface(mode=Gadget2Interface.MODE_NORMAL,
**few_particles_default_options) # MODE_NORMAL is default: non-periodic
instance.initialize_code()
instance.set_gadget_output_directory(instance.get_output_directory())
self.assertEqual(instance.get_periodic_boundaries_flag()['value'], False) # default, has to be changed for periodic runs
self.assertEqual(instance.commit_parameters(), 0)
self.assertEqual(instance.set_periodic_boundaries_flag(True), -2) # read-only
instance.stop()
def test10(self):
instance = Gadget2Interface(**few_particles_default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_gadget_output_directory(instance.get_output_directory()))
self.assertEqual(0, instance.commit_parameters())
indices_and_value = []
for i in range(10):
index, error = instance.new_sph_particle(0.1, i, 0, 0, 0, 0, 0, 0.0)
self.assertEqual(0, error)
indices_and_value.append((index, i))
instance.commit_particles()
for i, value in indices_and_value:
x, y, z, error = instance.get_position(i)
self.assertEqual(0, error)
self.assertEqual(x, value)
self.assertEqual(y, 0)
self.assertEqual(z, 0)
self.assertEqual(0, error)
for i in range(10, 20):
index, error = instance.new_sph_particle(0.1, i, 0, 0, 0, 0, 0, 0.0)
self.assertEqual(0, error)
indices_and_value.append((index, i))
error = instance.recommit_particles()
self.assertEqual(0, error)
for i, value in indices_and_value:
x, y, z, error = instance.get_position(i)
self.assertEqual(0, error)
self.assertEqual(x, value)
self.assertEqual(y, 0)
self.assertEqual(z, 0)
instance.stop()
class TestGadget2(TestWithMPI):
classname = "<class 'amuse.community.gadget2.interface.Gadget2'>"
UnitLength = 3.085678e21 | units.cm # ~ 1.0 kpc
UnitMass = 1.989e43 | units.g # 1.0e10 solar masses
UnitVelocity = 1e5 | units.cm / units.s # 1 km/sec
default_converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(UnitLength, UnitMass, UnitVelocity)
default_convert_nbody = nbody_system.nbody_to_si(UnitLength, UnitMass)
three_particles_IC = Particles(3)
three_particles_IC.position = [[0.5, 0.0, 0.0], [0.0, -0.5, 0.0], [0.0, 0.0, 0.5]] | units.kpc
three_particles_IC.velocity = [[-1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, -1.0]] | units.km / units.s
three_particles_IC.mass = 1.0e10 | units.MSun
def test1(self):
print("Testing Gadget initialization")
instance = Gadget2(self.default_converter, **default_options)
instance.initialize_code()
self.assertTrue(
os.path.join("__amuse_code_output", "gadget2")
in str(instance.parameters.gadget_output_directory)
)
instance.commit_parameters()
instance.cleanup_code()
instance.stop()
def test2(self):
print("Testing Gadget parameters")
instance = Gadget2(self.default_converter, **default_options)
instance.initialize_code()
self.assertAlmostEqual(instance.parameters.epsilon_squared, (0.01 | units.kpc)**2)
self.assertAlmostRelativeEquals(instance.parameters.code_mass_unit, self.UnitMass, 7)
self.assertAlmostRelativeEquals(instance.parameters.code_time_unit, 3.085678e16 | units.s, 7)
self.assertAlmostRelativeEquals(instance.parameters.code_length_unit, self.UnitLength, 7)
instance.parameters.epsilon_squared = 0.01 | units.kpc**2
instance.parameters.opening_angle = 0.4
instance.commit_parameters()
self.assertAlmostEqual(instance.parameters.epsilon_squared, 0.01 | units.kpc**2)
self.assertAlmostEqual(instance.parameters.opening_angle, 0.4)
self.assertAlmostRelativeEquals(instance.parameters.code_mass_unit, 1.989e43 | units.g, 7)
self.assertAlmostRelativeEquals(instance.parameters.code_time_unit, 3.085678e16 | units.s, 7)
instance.stop()
def test3(self):
print("Testing Gadget, 2 nbody particles")
# No default_options since this test fails for (number_of_workers > 1):
instance = Gadget2(self.default_converter, **few_particles_default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | units.kpc**2
dark = Particles(2)
dark.mass = [0.4, 0.4] | generic_unit_system.mass
dark.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.kpc
dark.velocity = [[100.0, 100.0, 100.0], [1.0, 1.0, 1.0]] | units.km / units.s
dark.radius = [0.0, 0.0] | units.RSun
instance.dm_particles.add_particles(dark)
instance.evolve_model(1.0 | units.Myr)
self.assertAlmostEqual(instance.model_time, 1.0 | units.Myr, 3)
instance.stop()
def test4(self):
print("Testing Gadget, 100 nbody particles")
instance = Gadget2(self.default_converter, **default_options)
instance.initialize_code()
convert_nbody = nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc)
dark = new_plummer_model(100, convert_nbody)
instance.dm_particles.add_particles(dark)
instance.evolve_model(1.0 | units.Myr)
copied = instance.dm_particles.copy()
from_copy_to_code = copied.new_channel_to(instance.dm_particles)
copied.mass *= 2
from_copy_to_code.copy_attributes(["mass", "x", "y", "z", "vx", "vy", "vz"])
instance.stop()
def test5(self):
print("Test 5: testing SPH particles")
target_number_sph_particles = 100
gas = new_evrard_gas_sphere(target_number_sph_particles, self.default_convert_nbody, seed=1234)
instance = Gadget2(self.default_converter, **default_options)
instance.initialize_code()
instance.gas_particles.add_particles(gas)
instance.evolve_model(0.0001 | generic_unit_system.time)
instance.stop()
def test6(self):
print("Test 6: testing dark matter + SPH particles")
target_number_sph_particles = 100
gas = new_evrard_gas_sphere(target_number_sph_particles, self.default_convert_nbody, seed=1234)
dark = Particles(2)
dark.mass = [0.4, 0.4] | generic_unit_system.mass
dark.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.kpc
dark.velocity = [[100.0, 100.0, 100.0], [1.0, 1.0, 1.0]] | units.km / units.s
instance = Gadget2(self.default_converter, **default_options)
instance.dm_particles.add_particles(dark)
instance.gas_particles.add_particles(gas)
instance.evolve_model(1.0 | units.Myr)
instance.stop()
def test7(self):
print("Testing more Gadget parameters")
instance = Gadget2(self.default_converter, **default_options)
instance.initialize_code()
for par, value in [('gadget_cell_opening_flag', True),
('comoving_integration_flag', False),
('interpret_kicks_as_feedback', False),
('interpret_heat_as_feedback', True)]:
self.assertTrue(value is getattr(instance.parameters, par))
setattr(instance.parameters, par, not value)
self.assertFalse(value is getattr(instance.parameters, par))
for par, value in [('time_limit_cpu', 36000 | units.s), ('min_gas_temp', 0.0 | units.K)]:
self.assertEqual(value, getattr(instance.parameters, par))
setattr(instance.parameters, par, 2 * value)
self.assertEqual(2 * value, getattr(instance.parameters, par))
for par, value in [('n_smooth_tol', 0.1), ('n_smooth', 50), ('opening_angle', 0.5),
('gadget_cell_opening_constant', 0.005), ('artificial_viscosity_alpha', 0.5),
('courant', 0.3), ('type_of_timestep_criterion', 0), ('hubble_parameter', 0.7),
('omega_zero', 0.0), ('omega_lambda', 0.0), ('omega_baryon', 0.0),
('min_gas_hsmooth_fractional', 0.0), ('timestep_accuracy_parameter', 0.025),
('tree_domain_update_frequency', 0.05), ('artificial_viscosity_beta', 1.0)]:
self.assertEqual(value, getattr(instance.parameters, par))
setattr(instance.parameters, par, 1)
self.assertEqual(1, getattr(instance.parameters, par))
for par, value in [('gas_epsilon', 0.01 | generic_unit_system.length),
('begin_time', 0.0 | generic_unit_system.time),
('time_max', 100.0 | generic_unit_system.time),
('max_size_timestep', 0.01 | generic_unit_system.time),
('min_size_timestep', 0.0 | generic_unit_system.time),
('periodic_box_size', 1.0 | generic_unit_system.length),
('time_between_statistics', 0.1 | generic_unit_system.time),
('softening_gas_max_phys', 0.0 | generic_unit_system.length),
('softening_halo_max_phys', 0.0 | generic_unit_system.length)]:
self.assertEqual(instance.unit_converter.to_si(value),
getattr(instance.parameters, par))
setattr(instance.parameters, par, 3.0 | value.unit)
self.assertEqual(instance.unit_converter.to_si(3.0 | value.unit),
getattr(instance.parameters, par))
for par, value in [('energy_file', "energy.txt"), ('info_file', "info.txt"),
('timings_file', "timings.txt"), ('cpu_file', "cpu.txt")]:
self.assertEqual(value, getattr(instance.parameters, par))
setattr(instance.parameters, par, 'test.txt')
self.assertEqual("test.txt", getattr(instance.parameters, par))
instance.stop()
def test8(self):
print("Testing read-only Gadget parameters")
def try_set_parameter(par, value, instance):
setattr(instance.parameters, par, value)
instance = Gadget2(self.default_converter, **default_options)
instance.initialize_code()
for par, value in [('no_gravity_flag', testing_isotherm_no_gravity),
('isothermal_flag', testing_isotherm_no_gravity),
('eps_is_h_flag', False),
('periodic_boundaries_flag', False),
('code_mass_unit', self.default_converter.to_si(generic_unit_system.mass)),
('code_length_unit', self.default_converter.to_si(generic_unit_system.length)),
('code_time_unit', self.default_converter.to_si(generic_unit_system.time)),
('code_velocity_unit', self.default_converter.to_si(generic_unit_system.speed)),
('polytropic_index_gamma', (1.0 if testing_isotherm_no_gravity else 5.0/3))]:
self.assertEqual(value, getattr(instance.parameters, par))
self.assertRaises(AmuseException, try_set_parameter, par, value, instance,
expected_message="Could not set value for parameter '"+par+"' of a 'Gadget2' object, "
"parameter is read-only")
instance.stop()
instance = Gadget2(self.default_converter, mode="nogravity", **default_options)
instance.initialize_code()
self.assertEqual(instance.parameters.no_gravity_flag, True)
self.assertRaises(AmuseException, try_set_parameter, 'no_gravity_flag', False, instance,
expected_message="Could not set value for parameter 'no_gravity_flag' of a 'Gadget2' object, "
"parameter is read-only")
instance.stop()
def test9(self):
print("Testing Gadget properties")
target_number_of_particles = 100
gas = new_evrard_gas_sphere(target_number_of_particles, self.default_convert_nbody, do_scale=True, seed=1234)
instance = Gadget2(self.default_converter, **default_options)
instance.gas_particles.add_particles(gas)
self.assertEqual(instance.model_time, 0.0 | units.s)
if testing_isotherm_no_gravity:
self.assertAlmostEqual(instance.potential_energy, 0.0 | 1e+50*units.J)
else:
self.assertAlmostEqual(instance.potential_energy, -4.27843220393 | 1e+50*units.J)
self.assertAlmostEqual(instance.kinetic_energy, 0.0 | 1e+49*units.J)
self.assertAlmostEqual(instance.thermal_energy, 4.27851824913 | 1e+49*units.J)
self.assertAlmostEqual(instance.total_radius, 3.96592921066 | 1e+19*units.m)
self.assertAlmostEqual(instance.center_of_mass_position, [0, 0, 0] | 1e+19*units.m)
self.assertAlmostEqual(instance.center_of_mass_velocity, [0, 0, 0] | units.m/units.s)
self.assertAlmostEqual(instance.total_mass, 1.989 | 1e+40*units.kg)
instance.stop()
def test10(self):
print("Testing Gadget states")
target_number_sph_particles = 100
gas = new_evrard_gas_sphere(target_number_sph_particles, self.default_convert_nbody, seed=1234)
dark = Particles(2)
dark.mass = [0.4, 0.4] | generic_unit_system.mass
dark.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.kpc
dark.velocity = [[100.0, 100.0, 100.0], [1.0, 1.0, 1.0]] | units.km / units.s
print("First do everything manually:")
instance = Gadget2(self.default_converter, **default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.gas_particles.add_particles(gas)
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
mass = instance.gas_particles[0].mass
instance.evolve_model(0.001 | generic_unit_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("commit_parameters(), (re)commit_particles(), and cleanup_code() should be called "
"automatically before new_xx_particle(), get_xx(), and stop():")
instance = Gadget2(self.default_converter, **default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.gas_particles.add_particles(gas)
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
mass = instance.gas_particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.dm_particles.add_particles(dark)
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
mass = instance.gas_particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.001 | generic_unit_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
def test11(self):
particles = Particles(2)
particles.x = [0.0, 10.0] | generic_unit_system.length
particles.y = 0 | generic_unit_system.length
particles.z = 0 | generic_unit_system.length
particles.radius = 0.005 | generic_unit_system.length
particles.vx = 0 | generic_unit_system.speed
particles.vy = 0 | generic_unit_system.speed
particles.vz = 0 | generic_unit_system.speed
particles.mass = 1.0 | generic_unit_system.mass
instance = Gadget2(self.default_converter, **few_particles_default_options)
instance.initialize_code()
instance.parameters.stopping_conditions_number_of_steps = 2
self.assertEqual(instance.parameters.stopping_conditions_number_of_steps, 2)
instance.parameters.epsilon_squared = (0.01 | generic_unit_system.length)**2
instance.particles.add_particles(particles)
instance.stopping_conditions.number_of_steps_detection.enable()
instance.evolve_model(1.0e15 | units.s)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
self.assertTrue(instance.model_time < 1.0e15 | units.s)
instance.stop()
def test12(self):
print("Testing Gadget get_hydro_state_at_point")
number_sph_particles = 100
gas = new_evrard_gas_sphere(number_sph_particles, self.default_convert_nbody, seed=1234)
instance = Gadget2(self.default_converter, **default_options)
instance.parameters.n_smooth = 64
instance.parameters.n_smooth_tol = 1.56250e-2
instance.gas_particles.add_particles(gas)
coords = [0.0 | units.kpc]*3
hydro_state = instance.get_hydro_state_at_point(*coords)
expected = [3.5469e-19 | units.kg * units.m**-3,
0.0 | units.kg * units.m**-2 / units.s,
0.0 | units.kg * units.m**-2 / units.s,
0.0 | units.kg * units.m**-2 / units.s,
(7.6297e-10 if testing_isotherm_no_gravity else
8.4252e-10) | units.kg * units.m**-1 * units.s**-2]
for value, expect in zip(hydro_state, expected):
self.assertAlmostRelativeEqual(value, expect, places=3)
coords = [0.1 | units.kpc]*3
hydro_state = instance.get_hydro_state_at_point(*coords)
expected = [4.1456e-19 | units.kg * units.m**-3,
0.0 | units.kg * units.m**-2 / units.s,
0.0 | units.kg * units.m**-2 / units.s,
0.0 | units.kg * units.m**-2 / units.s,
(8.9175e-10 if testing_isotherm_no_gravity else
1.0742e-09) | units.kg * units.m**-1 * units.s**-2]
for value, expect in zip(hydro_state, expected):
self.assertAlmostRelativeEqual(value, expect, places=3)
instance.stop()
def test13(self):
print("Testing Gadget get_hydro_state_at_point II: uniform sphere")
number_sph_particles = 1000
gas = new_uniform_spherical_particle_distribution(number_sph_particles, self.UnitLength, self.UnitMass)
gas.velocity = [10.0, 20.0, 30.0] | units.km / units.s
gas.u = 0.05 | generic_unit_system.specific_energy
density = (1.0e10 | units.MSun) / (4.0/3.0 * numpy.pi * (1.0 | units.kpc)**3)
instance = Gadget2(self.default_converter, **default_options)
instance.parameters.n_smooth = 64
instance.parameters.n_smooth_tol = 0.01
instance.gas_particles.add_particles(gas)
coords = [0.0 | units.kpc]*3
rho, rhovx, rhovy, rhovz, rhoe = instance.get_hydro_state_at_point(*coords)
self.assertAlmostRelativeEqual(rho, density, places=3)
self.assertAlmostRelativeEqual(rho, max(instance.gas_particles.rho), places=2)
self.assertIsOfOrder(rho, instance.gas_particles.rho)
self.assertAlmostRelativeEqual(rhovx, density*instance.gas_particles[0].vx, places=3)
self.assertAlmostRelativeEqual(rhovy, density*instance.gas_particles[0].vy, places=3)
self.assertAlmostRelativeEqual(rhovz, density*instance.gas_particles[0].vz, places=3)
self.assertAlmostRelativeEqual(rhoe, density * (instance.gas_particles[0].u +
0.5 * instance.gas_particles[0].velocity.length_squared()), places=3)
coords = [0.1 | units.kpc]*3
rho, rhovx, rhovy, rhovz, rhoe = instance.get_hydro_state_at_point(*coords)
self.assertAlmostRelativeEqual(rho, density, places=3)
self.assertAlmostRelativeEqual(rhovx, density*instance.gas_particles[0].vx, places=3)
self.assertAlmostRelativeEqual(rhovy, density*instance.gas_particles[0].vy, places=3)
self.assertAlmostRelativeEqual(rhovz, density*instance.gas_particles[0].vz, places=3)
self.assertAlmostRelativeEqual(rhoe, density * (instance.gas_particles[0].u +
0.5 * instance.gas_particles[0].velocity.length_squared()), places=3)
instance.stop()
def test14(self):
print("Testing Gadget SPH particle properties")
number_sph_particles = 1000
gas = new_evrard_gas_sphere(number_sph_particles, self.default_convert_nbody, seed=1234)
instance = Gadget2(self.default_converter, **default_options)
instance.gas_particles.add_particles(gas)
self.assertEqual(instance.gas_particles.num_neighbours >=
instance.parameters.n_smooth*(1-instance.parameters.n_smooth_tol), True)
self.assertEqual(instance.gas_particles.num_neighbours <=
instance.parameters.n_smooth*(1+instance.parameters.n_smooth_tol), True)
self.assertIsOfOrder(instance.gas_particles.h_smooth,
self.default_convert_nbody.to_si(1.0 | nbody_system.length) *
(instance.parameters.n_smooth*1.0/number_sph_particles)**(1.0/3))
self.assertAlmostRelativeEqual(instance.gas_particles.u,
self.default_convert_nbody.to_si(0.05 | nbody_system.specific_energy))
# the density of the cloud scales with 1/r:
r_sort, rho_sort = instance.gas_particles.position.lengths().sorted_with(instance.gas_particles.rho)
mean_density = self.default_convert_nbody.to_si(3.0/(4.0*numpy.pi) | nbody_system.density)
select = slice(number_sph_particles//2) # select 50% particles closest to center to avoid boundaries
self.assertIsOfOrder(rho_sort[select]/mean_density, r_sort.mean()/r_sort[select])
self.assertAlmostEqual(instance.gas_particles.u * instance.gas_particles.rho,
1.5 * instance.gas_particles.pressure)
self.assertAlmostEqual(instance.gas_particles.du_dt, 0 | units.m**2 * units.s**-3)
u_0 = instance.gas_particles.u.sum()
instance.evolve_model(0.1 | units.Myr)
if testing_isotherm_no_gravity:
self.assertAlmostEqual(instance.gas_particles.du_dt, 0 | units.m**2 * units.s**-3)
else: # Collapsing ==> heating:
self.assertTrue(instance.gas_particles.du_dt.sum() >= 0 | units.m**2 * units.s**-3)
self.assertIsOfOrder(instance.gas_particles.du_dt.sum() * (0.1 | units.Myr),
instance.gas_particles.u.sum() - u_0)
instance.stop()
def test15a(self):
print("Test Gadget2 in periodic nogravity mode")
instance = Gadget2(mode=Gadget2Interface.MODE_PERIODIC_NOGRAVITY,
**few_particles_default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
# 'False' is default, but getting parameters implicitly calls initialize_code()...
self.assertEqual(instance.parameters.periodic_boundaries_flag, True)
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
self.assertEqual(instance.parameters.no_gravity_flag, True)
instance.parameters.periodic_box_size = 2.0 | generic_unit_system.length
self.assertAlmostEqual(instance.parameters.periodic_box_size, 2.0 | units.kpc, places=6)
instance.parameters.min_size_timestep = 1.0 | generic_unit_system.time
instance.dm_particles.add_particles(self.three_particles_IC)
self.assertAlmostEqual(instance.dm_particles.x, [0.5, 0., 0.] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.y, [0., -0.5, 0.] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.z, [0., 0., 0.5] | units.kpc, places=6)
instance.evolve_model(0.1 | generic_unit_system.time)
self.assertAlmostEqual(instance.dm_particles.x, [0.4, 0., 0.] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.y, [0., -0.4, 0.] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.z, [0., 0., 0.4] | units.kpc, places=6)
instance.evolve_model(1.0 | generic_unit_system.time)
self.assertAlmostEqual(instance.dm_particles.x, [-0.5, 0., 0.] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.y, [0., 0.5, 0.] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.z, [0., 0., -0.5] | units.kpc, places=6)
instance.stop()
def test15b(self):
print("Test Gadget2 in nogravity mode")
instance = Gadget2(mode="nogravity", **few_particles_default_options)
self.assertEqual(instance.parameters.no_gravity_flag, True)
self.assertEqual(instance.parameters.periodic_boundaries_flag, False)
instance.parameters.min_size_timestep = 1.0 | generic_unit_system.time
instance.dm_particles.add_particles(self.three_particles_IC)
self.assertAlmostEqual(instance.dm_particles.x, [0.5, 0.0, 0.0] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.y, [0.0, -0.5, 0.0] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.z, [0.0, 0.0, 0.5] | units.kpc, places=6)
instance.evolve_model(0.1 | generic_unit_system.time)
self.assertAlmostEqual(instance.dm_particles.x, [0.4, 0.0, 0.0] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.y, [0.0, -0.4, 0.0] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.z, [0.0, 0.0, 0.4] | units.kpc, places=6)
instance.evolve_model(1.0 | generic_unit_system.time)
self.assertAlmostEqual(instance.dm_particles.x, [-0.5, 0.0, 0.0] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.y, [0.0, 0.5, 0.0] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.z, [0.0, 0.0, -0.5] | units.kpc, places=6)
instance.stop()
def test15c(self):
print("Test Gadget2 in periodic mode")
converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(1.0 | units.yr, 1.0 | units.MSun, 1.0 | units.AU)
instance = Gadget2(converter, mode=Gadget2Interface.MODE_PERIODIC_BOUNDARIES,
**few_particles_default_options)
self.assertEqual(instance.parameters.periodic_boundaries_flag, True)
self.assertEqual(instance.parameters.no_gravity_flag, False)
instance.parameters.periodic_box_size = 20.0 | generic_unit_system.length
self.assertAlmostEqual(instance.parameters.periodic_box_size, 20.0 | units.AU, places=6)
instance.parameters.max_size_timestep = 0.01 | units.yr
instance.parameters.epsilon_squared = 1.0e-16 | units.RSun**2
binary = Particles(2)
binary.mass = 0.5 | units.MSun
binary[1].position = [1.0, 0, 0] | units.AU
binary.velocity = [0.0, 0, 0] | units.km / units.s
binary[1].vy = (constants.G * binary.total_mass() / binary[1].x).sqrt()
binary.move_to_center()
binary.position += [7, -8, 3] | units.AU
binary.velocity += [10, -10, 10] | units.AU / units.yr
primary, secondary = instance.dm_particles.add_particles(binary)
self.assertAlmostEqual(secondary.x - primary.x, 1.0 | units.AU, places=6)
self.assertAlmostEqual(instance.dm_particles.center_of_mass(), [7, -8, 3] | units.AU, places=4)
self.assertAlmostEqual(instance.dm_particles.center_of_mass_velocity(), [10, -10, 10] | units.AU / units.yr)
instance.evolve_model(0.5 | units.yr)
self.assertAlmostEqual(secondary.x - primary.x, -1.0 | units.AU, places=2)
self.assertAlmostEqual(instance.dm_particles.center_of_mass(), [-8, 7, 8] | units.AU, places=4)
instance.evolve_model(1.0 | units.yr)
self.assertAlmostEqual(secondary.x - primary.x, 1.0 | units.AU, places=2)
self.assertAlmostEqual(instance.dm_particles.center_of_mass(), [-3, 2, -7] | units.AU, places=4)
instance.stop()
def test16(self):
instance = Gadget2(mode=Gadget2Interface.MODE_PERIODIC_BOUNDARIES,
**few_particles_default_options)
self.assertEqual(instance.parameters.periodic_boundaries_flag, True)
instance.commit_parameters() # its ok because read-only
instance.dm_particles.add_particles(self.three_particles_IC)
instance.stop()
def test17(self):
print("Testing Gadget parameters further")
target_number_of_particles = 100
gas = new_evrard_gas_sphere(target_number_of_particles, self.default_convert_nbody, seed=1234)
instance = Gadget2(self.default_converter, **default_options)
instance.parameters.time_limit_cpu = 0.001 | units.s
instance.gas_particles.add_particles(gas)
self.assertRaises(
AmuseException,
instance.evolve_model,
1.0 | generic_unit_system.time,
expected_message=(
f"Error when calling 'evolve_model' of a '{self.classname}', "
"errorcode is -5, error is 'CPU-time limit reached.'"
)
)
instance.parameters.time_limit_cpu = 10.0 | units.s
self.assertRaises(
AmuseException,
instance.evolve_model,
0.5 * instance.model_time,
expected_message=(
f"Error when calling 'evolve_model' of a '{self.classname}', "
"errorcode is -6, error is 'Can't evolve backwards in time.'"
)
)
instance.stop()
def test18(self):
print("Testing Gadget parameters further")
instance = Gadget2(mode=Gadget2Interface.MODE_PERIODIC_NOGRAVITY,
**few_particles_default_options)
instance.parameters.periodic_box_size = 2.0 | generic_unit_system.length # implicitly calls initialize_code()...
instance.parameters.begin_time = 10.04 | generic_unit_system.time
instance.parameters.time_max = 10.4 | generic_unit_system.time
instance.parameters.min_size_timestep = 0.1 | generic_unit_system.time
self.assertAlmostEqual(instance.model_time, 0.0 | units.s)
instance.dm_particles.add_particles(self.three_particles_IC)
self.assertAlmostEqual(instance.model_time, instance.parameters.begin_time)
self.assertAlmostEqual(instance.dm_particles.x, [0.5, 0., 0.] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.y, [0., -0.5, 0.] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.z, [0., 0., 0.5] | units.kpc, places=6)
instance.evolve_model(10.14 | generic_unit_system.time)
self.assertAlmostRelativeEqual(instance.model_time,
instance.parameters.begin_time + instance.parameters.min_size_timestep, 7)
self.assertAlmostEqual(instance.dm_particles.x, [0.4, 0., 0.] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.y, [0., -0.4, 0.] | units.kpc, places=6)
self.assertAlmostEqual(instance.dm_particles.z, [0., 0., 0.4] | units.kpc, places=6)
instance.stop()
def test19(self):
particles = new_plummer_model(31)
instance = Gadget2(self.default_converter, number_of_workers=1)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | generic_unit_system.length ** 2
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.001 | generic_unit_system.time)
expected_positions = instance.particles.position
instance.stop()
positions_per_workers = []
for n in [2, 3, 4, 5]:
instance = Gadget2(self.default_converter, number_of_workers=n)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | generic_unit_system.length ** 2
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.001 | generic_unit_system.time)
positions_per_workers.append(instance.particles.position)
instance.stop()
for index, n in enumerate([2, 3, 4, 5]):
self.assertAlmostRelativeEqual(expected_positions[:, 0], positions_per_workers[index][:, 0])
self.assertAlmostRelativeEqual(expected_positions[:, 1], positions_per_workers[index][:, 1])
self.assertAlmostRelativeEqual(expected_positions[:, 2], positions_per_workers[index][:, 2])
def test20(self):
print("Testing zero timestep exceptions")
number_sph_particles = 1000
gas = new_evrard_gas_sphere(number_sph_particles, self.default_convert_nbody, seed=1234)
wrong_converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
self.UnitLength,
self.UnitMass,
1.0e15 * units.yr
)
instance = Gadget2(wrong_converter, **default_options)
instance.gas_particles.add_particles(gas)
self.assertRaises(
AmuseException,
instance.evolve_model,
1.0e13 | units.yr,
expected_message=(
f"Error when calling 'evolve_model' of a '{self.classname}', "
"errorcode is -8, error is 'A particle was assigned a timestep"
" of size zero. The code_time_unit used may be too large.'"
)
)
instance.stop()
instance = Gadget2(wrong_converter, **default_options)
correct_converter = nbody_system.nbody_to_si(self.UnitLength, 1.0e15 * units.yr)
gas_compatible_with_wrong_converter = new_evrard_gas_sphere(
number_sph_particles,
correct_converter,
seed=1234
)
instance.gas_particles.add_particles(gas_compatible_with_wrong_converter)
instance.evolve_model(1.0e13 | units.yr)
instance.stop()
def test21(self):
print("Testing other evolve_model exceptions")
number_sph_particles = 1000
gas = new_evrard_gas_sphere(number_sph_particles, self.default_convert_nbody, seed=1234)
wrong_converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(self.UnitLength,
self.UnitMass, 1.0e-15 * units.yr)
instance = Gadget2(wrong_converter, **default_options)
instance.parameters.max_size_timestep = 3.0e-14 | units.yr
instance.gas_particles.add_particles(gas)
self.assertRaises(
AmuseException,
instance.evolve_model,
1.1e-13 | units.yr,
expected_message=(
f"Error when calling 'evolve_model' of a '{self.classname}', "
"errorcode is -7, error is "
"'Can't evolve further than time_max.'"
)
)
instance.evolve_model(3.0e-14 | units.yr)
self.assertRaises(
AmuseException,
instance.evolve_model,
1.0e-14 | units.yr,
expected_message=(
f"Error when calling 'evolve_model' of a '{self.classname}', "
"errorcode is -6, error is 'Can't evolve backwards in time.'"
)
)
instance.stop()
def test22(self):
print("Testing Gadget timestep limiter (Durier & Dalla Vecchia 2011)")
number_sph_particles = 1000
numpy.random.seed(345672)
gas = new_plummer_gas_model(number_sph_particles, self.default_convert_nbody, base_grid=body_centered_grid_unit_cube)
n_timescales = 0.025
t_end = (n_timescales * self.default_convert_nbody.to_si(1.0 | nbody_system.time)).as_quantity_in(units.Myr)
print("Evolving to ("+str(n_timescales), "nbody timescales): ", t_end)
n_steps = 5
times = (t_end * (range(1, n_steps+1)) / (1.0 * n_steps)).as_quantity_in(units.Myr)
instance = Gadget2(self.default_converter, **default_options)
instance.parameters.max_size_timestep = t_end
gas = instance.gas_particles.add_particles(gas)
kinetic_energies = [] | units.erg
potential_energies = [] | units.erg
thermal_energies = [] | units.erg
for time in times[:3]:
instance.evolve_model(time)
potential_energies.append(instance.potential_energy)
kinetic_energies.append(instance.kinetic_energy)
thermal_energies.append(instance.thermal_energy)
print(str(time)+": E =", potential_energies[-1] + kinetic_energies[-1] + thermal_energies[-1])
central_particle = gas.select_array(lambda x, y, z: (x**2 + y**2 + z**2) == min(x**2 + y**2 + z**2), ["x", "y", "z"])
print("Initial internal energy central particle:", central_particle[0].u.as_quantity_in(units.erg / units.g))
delta_E = abs(instance.potential_energy) - central_particle[0].u * central_particle[0].mass
central_particle.u = abs(instance.potential_energy) / central_particle.mass
print("New internal energy central particle:", central_particle[0].u.as_quantity_in(units.erg / units.g))
print("Changed total energy to:", potential_energies[-1] + kinetic_energies[-1] + thermal_energies[-1] + delta_E)
self.assertAlmostRelativeEqual(
instance.potential_energy + instance.kinetic_energy + instance.thermal_energy,
potential_energies[-1] + kinetic_energies[-1] + thermal_energies[-1] + delta_E, 7)
potential_energies[-1] = instance.potential_energy
kinetic_energies[-1] = instance.kinetic_energy
thermal_energies[-1] = instance.thermal_energy
for i_step, time in enumerate(times[3:]):
instance.evolve_model(time)
potential_energies.append(instance.potential_energy)
kinetic_energies.append(instance.kinetic_energy)
thermal_energies.append(instance.thermal_energy)
print(str(time)+": E =", potential_energies[-1] + kinetic_energies[-1] + thermal_energies[-1])
instance.stop()
total_energies = potential_energies + kinetic_energies + thermal_energies
self.assertAlmostRelativeEqual(total_energies[1], total_energies[0], 3)
self.assertAlmostRelativeEqual(total_energies[2], total_energies[1] + delta_E, 3)
self.assertIsOfOrder(total_energies[3], total_energies[2])
self.assertIsOfOrder(total_energies[4], total_energies[3])
def slowtest22b(self):
print("Testing Gadget timestep limiter (Durier & Dalla Vecchia 2011)")
number_sph_particles = 10000
numpy.random.seed(345672)
gas = new_plummer_gas_model(number_sph_particles, self.default_convert_nbody, base_grid=body_centered_grid_unit_cube)
n_pixels = 100
n_timescales = 0.5
t_end = (n_timescales * self.default_convert_nbody.to_si(1.0 | nbody_system.time)).as_quantity_in(units.Myr)
print("Evolving to ("+str(n_timescales), "nbody timescales): ", t_end)
n_steps = 100
times = (t_end * (range(1, n_steps+1)) / (1.0 * n_steps)).as_quantity_in(units.Myr)
instance = Gadget2(self.default_converter, **default_options)
instance.parameters.max_size_timestep = t_end
gas = instance.gas_particles.add_particles(gas)
kinetic_energies = [] | units.erg
potential_energies = [] | units.erg
thermal_energies = [] | units.erg
for time in times[:3]:
instance.evolve_model(time)
potential_energies.append(instance.potential_energy)
kinetic_energies.append(instance.kinetic_energy)
thermal_energies.append(instance.thermal_energy)
print(time, potential_energies[-1] + kinetic_energies[-1] + thermal_energies[-1])
view = ([-0.5, 0.5, -0.5, 0.5] * (2.0 | units.none) *
self.default_convert_nbody.to_si(1.0 | nbody_system.length)).as_quantity_in(units.kpc)
print("Physical size of window for hydro_plot:", view)
hydro_plot(
view,
instance,
(n_pixels, n_pixels),
"gadget2_slowtest22b_hydro_image{0:=03}.png".format(0)
)
central_particle = gas.select_array(lambda x, y, z: (x**2 + y**2 + z**2) == min(x**2 + y**2 + z**2), ["x", "y", "z"])
print("Position central particle:", central_particle.position.as_quantity_in(units.kpc))
print("Center of mass, virial radius of system:", gas.center_of_mass().as_quantity_in(units.kpc), gas.virial_radius().as_quantity_in(units.kpc))
print("Initial internal energy central particle:", central_particle[0].u.as_quantity_in(units.erg / units.g))
delta_E = abs(instance.potential_energy) - central_particle[0].u * central_particle[0].mass
central_particle.u = abs(instance.potential_energy) / central_particle.mass
print("New internal energy central particle:", central_particle[0].u.as_quantity_in(units.erg / units.g))
print("Changed total energy to:", potential_energies[-1] + kinetic_energies[-1] + thermal_energies[-1] + delta_E)
self.assertAlmostRelativeEqual(
instance.potential_energy + instance.kinetic_energy + instance.thermal_energy,
potential_energies[-1] + kinetic_energies[-1] + thermal_energies[-1] + delta_E, 7)
potential_energies[-1] = instance.potential_energy
kinetic_energies[-1] = instance.kinetic_energy
thermal_energies[-1] = instance.thermal_energy
print(potential_energies[-1] + kinetic_energies[-1] + thermal_energies[-1])
for i_step, time in enumerate(times[3:]):
if i_step < 20:
hydro_plot(
view,
instance,
(n_pixels, n_pixels),
"gadget2_slowtest22b_hydro_image{0:=03}.png".format(i_step+1)
)
instance.evolve_model(time)
potential_energies.append(instance.potential_energy)
kinetic_energies.append(instance.kinetic_energy)
thermal_energies.append(instance.thermal_energy)
print(time, potential_energies[-1] + kinetic_energies[-1] + thermal_energies[-1])
instance.stop()
total_energies = potential_energies + kinetic_energies + thermal_energies
self.assertAlmostRelativeEqual(total_energies[1], total_energies[0], 3)
self.assertAlmostRelativeEqual(total_energies[2], total_energies[1] + delta_E, 3)
self.assertIsOfOrder(total_energies[3], total_energies[2])
self.assertIsOfOrder(total_energies[4], total_energies[3])
for i in range(5, n_steps):
self.assertAlmostRelativeEqual(total_energies[i], total_energies[i-1], 1)
energy_evolution_plot(times, kinetic_energies, potential_energies, thermal_energies,
figname="gadget2_slowtest22b_energy.png")
def test23(self):
print("Testing Gadget2 density_limit_detection")
number_gas_particles = 1000
gas = new_evrard_gas_sphere(number_gas_particles, self.default_convert_nbody, do_scale=True, seed=12345)
instance = Gadget2(self.default_converter, **default_options)
instance.initialize_code()
instance.parameters.stopping_condition_maximum_density = 10 * self.UnitMass / self.UnitLength**3
instance.gas_particles.add_particles(gas)
stars = new_plummer_model(5, self.default_convert_nbody)
stars.x += 1000 * self.UnitLength
instance.dm_particles.add_particles(stars)
self.assertIsOfOrder(max(instance.gas_particles.density), self.UnitMass / self.UnitLength**3)
density_limit_detection = instance.stopping_conditions.density_limit_detection
density_limit_detection.enable()
instance.evolve_model(10.0 | units.Myr)
print(instance.model_time.as_quantity_in(units.Myr))
print(instance.stopping_conditions)
self.assertTrue(density_limit_detection.is_set())
self.assertTrue(instance.model_time < 10.0 | units.Myr)
self.assertEqual(len(density_limit_detection.particles()), 1)
self.assertTrue(density_limit_detection.particles().density >
10 * self.UnitMass / self.UnitLength**3)
instance.particles.remove_particles(density_limit_detection.particles())
instance.evolve_model(10.0 | units.Myr)
print(instance.model_time.as_quantity_in(units.Myr))
print(instance.stopping_conditions)
self.assertTrue(density_limit_detection.is_set())
self.assertTrue(instance.model_time < 10.0 | units.Myr)
self.assertEqual(len(density_limit_detection.particles()), 2)
self.assertEqual((density_limit_detection.particles().density >
10 * self.UnitMass / self.UnitLength**3), [True, True])
instance.stop()
def test24(self):
print("Testing Gadget2 internal_energy_limit_detection")
number_gas_particles = 1000
gas = new_evrard_gas_sphere(number_gas_particles, self.default_convert_nbody, do_scale=True, seed=12345)
initial_internal_energy = 0.05 * constants.G * self.UnitMass / self.UnitLength
instance = Gadget2(self.default_converter, **default_options)
instance.initialize_code()
instance.parameters.stopping_condition_maximum_internal_energy = 10 * initial_internal_energy
instance.gas_particles.add_particles(gas)
self.assertAlmostRelativeEquals(instance.gas_particles.u, initial_internal_energy, 8)
internal_energy_limit_detection = instance.stopping_conditions.internal_energy_limit_detection
internal_energy_limit_detection.enable()
instance.evolve_model(10.0 | units.Myr)
print(instance.model_time.as_quantity_in(units.Myr))
print(instance.stopping_conditions)
self.assertTrue(internal_energy_limit_detection.is_set())
self.assertTrue(instance.model_time < 10.0 | units.Myr)
self.assertEqual(len(internal_energy_limit_detection.particles()), 4)
self.assertEqual((internal_energy_limit_detection.particles().u >
10 * initial_internal_energy), [True, True, True, True])
instance.particles.remove_particles(internal_energy_limit_detection.particles())
instance.evolve_model(10.0 | units.Myr)
print(instance.model_time.as_quantity_in(units.Myr))
print(instance.stopping_conditions)
self.assertTrue(internal_energy_limit_detection.is_set())
self.assertTrue(instance.model_time < 10.0 | units.Myr)
self.assertEqual(len(internal_energy_limit_detection.particles()), 3)
self.assertEqual((internal_energy_limit_detection.particles().u >
10 * initial_internal_energy), [True, True, True])
instance.stop()
def test25(self):
print("Testing Gadget2 comoving_integration_flag")
particles = new_plummer_model(100, self.default_convert_nbody, do_scale=True)
instance = Gadget2(self.default_converter, **default_options)
instance.initialize_code()
instance.parameters.comoving_integration_flag = True
instance.parameters.redshift_begin = 20.0
instance.parameters.redshift_max = 0.0
instance.parameters.omega_zero = 0.3
instance.parameters.omega_lambda = 0.7
instance.parameters.omega_baryon = 0.0
instance.parameters.hubble_parameter = 0.7
instance.parameters.epsilon_squared = (1.0 | generic_unit_system.length)**2
instance.parameters.softening_halo_max_phys = 1.0 | generic_unit_system.length
instance.dm_particles.add_particles(particles)
instance.evolve_to_redshift(19.9)
self.assertRaises(
AmuseException,
instance.evolve_model,
1 | units.Myr,
expected_message=(
f"Error when calling 'evolve_model' of a '{self.classname}', "
"errorcode is -9, error is 'This function should not be used "
"with the current value of comoving_integration_flag'"
)
)
self.assertAlmostEqual(instance.model_redshift, 19.9, 5)
self.assertRaises(
AmuseException,
getattr,
instance,
"model_time",
expected_message=(
f"Error when calling 'get_time' of a '{self.classname}', "
"errorcode is -9, error is 'This function should not be used "
"with the current value of comoving_integration_flag'"
)
)
instance.stop()
def xtest26(self):
print("Testing Gadget2 comoving_integration_flag validation (WIP)")
particles = read_set_from_file("cluster_littleendian.dat", "gadget")
particles = ParticlesSuperset(particles[1:4])
instance = Gadget2(self.default_converter, redirection="none", **default_options)
instance.initialize_code()
instance.parameters.comoving_integration_flag = True
instance.parameters.redshift_begin = 23.0
instance.parameters.redshift_max = -0.1
instance.parameters.omega_zero = 0.3
instance.parameters.omega_lambda = 0.7
instance.parameters.omega_baryon = 0.0
instance.parameters.hubble_parameter = 0.7
instance.parameters.epsilon_squared = (72.0 | generic_unit_system.length)**2
instance.parameters.softening_halo_max_phys = 12.0 | generic_unit_system.length
instance.parameters.max_size_timestep = 0.03 | generic_unit_system.time
instance.parameters.tree_domain_update_frequency = 0.1
instance.particles.add_particles(particles)
instance.evolve_to_redshift(5.0)
write_set_to_file(instance.particles, "z5", "hdf5")
instance.evolve_to_redshift(3.0)
write_set_to_file(instance.particles, "z3", "hdf5")
instance.evolve_to_redshift(2.0)
write_set_to_file(instance.particles, "z2", "hdf5")
instance.evolve_to_redshift(1.0)
write_set_to_file(instance.particles, "z1", "hdf5")
instance.evolve_to_redshift(0.0)
write_set_to_file(instance.particles, "z0", "hdf5")
instance.stop()
def xtest27(self):
print("Testing Gadget2 comoving_integration_flag validation II (WIP)")
particles = read_set_from_file("lcdm_gas_littleendian.dat", "gadget")
gas = particles[0]
mu = constants.proton_mass * 4.0 / (1.0 + 3.0 * 0.76)
gas.u = self.default_converter.to_generic(3 * constants.kB * (1000 | units.K) / (2 * mu))
gas.velocity /= 11.0**-0.5 # velocities in Gadget files are in w=sqrt(a)*dx/dt
halo = particles[1]
halo.velocity /= 11.0**-0.5 # velocities in Gadget files are in w=sqrt(a)*dx/dt
gas = convert_comoving_to_physical(gas, redshift=10.0)
halo = convert_comoving_to_physical(halo, redshift=10.0)
instance = Gadget2(self.default_converter, mode="periodic", redirection="none", number_of_workers=1)
instance.parameters.comoving_integration_flag = True
instance.parameters.n_smooth = 33.0
instance.parameters.n_smooth_tol = 2.0 / instance.parameters.n_smooth
instance.parameters.periodic_box_size = 50000.0 | generic_unit_system.length
instance.parameters.redshift_begin = 10.0
instance.parameters.redshift_max = -0.1
instance.parameters.omega_zero = 0.3
instance.parameters.omega_lambda = 0.7
instance.parameters.omega_baryon = 0.04
instance.parameters.hubble_parameter = 1.0 # coordinates in input file are already in kpc/h
instance.parameters.artificial_viscosity_alpha = 0.8
instance.parameters.min_gas_temp = 50.0 | units.K
instance.parameters.gas_epsilon = 600.0 | generic_unit_system.length
instance.parameters.epsilon_squared = (600.0 | generic_unit_system.length)**2
instance.parameters.softening_gas_max_phys = 600.0 | generic_unit_system.length
instance.parameters.softening_halo_max_phys = 600.0 | generic_unit_system.length
instance.parameters.max_size_timestep = 0.03 | generic_unit_system.time
instance.parameters.tree_domain_update_frequency = 0.1
instance.gas_particles.add_particles(gas)
instance.dm_particles.add_particles(halo)
write_set_to_file(instance.particles, "z10", "hdf5")
instance.evolve_to_redshift(5.0)
write_set_to_file(instance.particles, "z5", "hdf5")
instance.evolve_to_redshift(3.0)
write_set_to_file(instance.particles, "z3", "hdf5")
instance.evolve_to_redshift(2.0)
write_set_to_file(instance.particles, "z2", "hdf5")
instance.evolve_to_redshift(1.0)
write_set_to_file(instance.particles, "z1", "hdf5")
instance.evolve_to_redshift(0.0)
write_set_to_file(instance.particles, "z0", "hdf5")
instance.stop()
def test28(self):
print("Testing Gadget get_hydro_state_at_point in periodic mode")
gas = Particles(8000)
gas.mass = 1.0/8000 | generic_unit_system.mass
x, y, z = numpy.mgrid[-1:0.9:20j, -1:0.9:20j, -1:0.9:20j] | units.kpc
gas.x, gas.y, gas.z = x.flatten(), y.flatten(), z.flatten()
gas.velocity = [0, 0, 0] | units.m / units.s
gas.u = (1 + 0.8 * numpy.sin(gas.x * (numpy.pi | units.kpc**-1))) | generic_unit_system.specific_energy
instance = Gadget2(self.default_converter, mode='periodic', **default_options)
instance.parameters.periodic_box_size = 2.0 | units.kpc
instance.gas_particles.add_particles(gas)
self.assertAlmostRelativeEqual(instance.total_mass, 1.0e10 | units.MSun, 3)
self.assertAlmostRelativeEqual(instance.thermal_energy, 1.0e10 | units.MSun * units.km**2 * units.s**-2, 3)
number_of_points = 100
in_domain = numpy.linspace(-1.0, 1.0, 100) | units.kpc
domain_border = numpy.ones(100) | units.kpc
state_left = instance.get_hydro_state_at_point(-domain_border, in_domain, in_domain)
state_right = instance.get_hydro_state_at_point(domain_border, in_domain, in_domain)
for var_left, var_right in zip(state_left, state_right):
self.assertEqual(var_left, var_right)
state_back = instance.get_hydro_state_at_point(in_domain, -domain_border, in_domain)
state_front = instance.get_hydro_state_at_point(in_domain, domain_border, in_domain)
for var_front, var_back in zip(state_front, state_back):
self.assertEqual(var_front, var_back)
state_bottom = instance.get_hydro_state_at_point(in_domain, in_domain, -domain_border)
state_top = instance.get_hydro_state_at_point(in_domain, in_domain, domain_border)
for var_top, var_bottom in zip(state_top, state_bottom):
self.assertEqual(var_top, var_bottom)
self.assertAlmostRelativeEqual(state_left[0].mean(), 1.25e9 | units.MSun * units.kpc**-3, 2)
self.assertAlmostRelativeEqual(state_back[0].mean(), 1.25e9 | units.MSun * units.kpc**-3, 2)
self.assertAlmostRelativeEqual(state_bottom[0].mean(), 1.25e9 | units.MSun * units.kpc**-3, 2)
self.assertAlmostRelativeEqual(state_left[4].mean(), 1.25e9 | units.MSun * units.kpc**-3 * units.km**2 * units.s**-2, 2)
self.assertAlmostRelativeEqual(state_back[4].mean(), 1.25e9 | units.MSun * units.kpc**-3 * units.km**2 * units.s**-2, 2)
self.assertAlmostRelativeEqual(state_bottom[4].mean(), 1.25e9 | units.MSun * units.kpc**-3 * units.km**2 * units.s**-2, 2)
# With x=cst, variations in u (and therefore in rhoe) should be small
self.assertAlmostEqual(state_left[4].std() / (1.25e9 | units.MSun * units.kpc**-3 * units.km**2 * units.s**-2), 0.0, 2)
# Over the entire x domain, variations in rhoe should equal the sine amplitude (=0.8) times the rms(sine) over a whole period (=sqrt(.5))
self.assertAlmostEqual(state_back[4].std() / (1.25e9 | units.MSun * units.kpc**-3 * units.km**2 * units.s**-2), 0.8 * numpy.sqrt(0.5), 1)
self.assertAlmostEqual(state_bottom[4].std() / (1.25e9 | units.MSun * units.kpc**-3 * units.km**2 * units.s**-2), 0.8 * numpy.sqrt(0.5), 1)
instance.stop()
def energy_evolution_plot(time, kinetic, potential, thermal, figname):
if not HAS_MATPLOTLIB:
return
pyplot.figure(figsize=(5, 5))
plot(time, kinetic, label='K')
plot(time, potential, label='U')
plot(time, thermal, label='Q')
plot(time, kinetic + potential + thermal, label='E')
xlabel('Time')
ylabel('Energy')
pyplot.legend(prop={'size': "x-small"}, loc=4)
pyplot.savefig(figname)
print("\nPlot of energy evolution was saved to:", figname)
pyplot.close()
def hydro_plot(view, hydro_code, image_size, figname):
"""
view: the (physical) region to plot [xmin, xmax, ymin, ymax]
hydro_code: hydrodynamics code in which the gas to be plotted is defined
image_size: size of the output image in pixels (x, y)
"""
if not HAS_MATPLOTLIB:
return
shape = (image_size[0], image_size[1], 1)
size = image_size[0] * image_size[1]
axis_lengths = [0.0, 0.0, 0.0] | units.m
axis_lengths[0] = view[1] - view[0]
axis_lengths[1] = view[3] - view[2]
grid = new_regular_grid(shape, axis_lengths)
grid.x += view[0]
grid.y += view[2]
speed = grid.z.reshape(size) * (0 | 1/units.s)
rho, rhovx, rhovy, rhovz, rhoe = hydro_code.get_hydro_state_at_point(grid.x.reshape(size),
grid.y.reshape(size), grid.z.reshape(size))
min_v = 800.0 | units.km / units.s
max_v = 3000.0 | units.km / units.s
min_rho = rho.amin()
max_rho = rho.amax()
fade_rho = min_rho * (max_rho / min_rho)**0.1
min_E = 1.0e11 | units.J / units.kg
max_E = 1.0e13 | units.J / units.kg
v_sqr = (rhovx**2 + rhovy**2 + rhovz**2) / rho**2
E = rhoe / rho
log_v = numpy.log((v_sqr / min_v**2)) / numpy.log((max_v**2 / min_v**2))
log_rho = numpy.log((rho / min_rho)) / numpy.log((max_rho / min_rho))
log_E = numpy.log((E / min_E)) / numpy.log((max_E / min_E))
red = numpy.minimum(numpy.ones_like(rho.number), numpy.maximum(numpy.zeros_like(rho.number), log_rho)).reshape(shape)
green = numpy.minimum(numpy.ones_like(rho.number), numpy.maximum(numpy.zeros_like(rho.number), 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 / min_rho)) / numpy.log((fade_rho / 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()
| 75,272
| 51.8974
| 152
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_athena.py
|
import os
import sys
import numpy
import math
from amuse.test.amusetest import TestWithMPI
from amuse.community.athena.interface import AthenaInterface, Athena
from amuse.units.quantities import VectorQuantity
from amuse.units import generic_unit_system
from amuse.units import units
from amuse.units import generic_unit_converter
from amuse import datamodel
class TestAthenaInterface(TestWithMPI):
def test0(self):
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.stop()
def test1(self):
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.par_seti("test", "testname", "%d", 10, "a test parameter")
x = instance.par_geti("test", "testname")
self.assertEqual(x, 10)
instance.stop()
def test2(self):
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.par_setd("test", "test2", "%.15e", 1.123, "a test parameter")
x = instance.par_getd("test", "test2")
self.assertEqual(x, 1.123)
instance.stop()
def test3(self):
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.setup_mesh(5, 1, 1, 1.0, 0.0, 0.0)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
x = instance.par_geti("domain1", "Nx1")
self.assertEqual(x, 5)
error = instance.commit_parameters()
self.assertEqual(error, 0)
number_of_grids, error = instance.get_number_of_grids()
self.assertEqual(error, 0)
self.assertEqual(number_of_grids, 1)
x, y, z, error = instance.get_position_of_index(0, 0, 0, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, 0.1)
x, y, z, error = instance.get_position_of_index(1, 0, 0, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, 0.3)
x, y, z, error = instance.get_position_of_index(2, 0, 0, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, 0.5)
x, y, z, error = instance.get_position_of_index(3, 0, 0, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, 0.7)
x, y, z, error = instance.get_position_of_index(4, 0, 0, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, 0.9)
x, y, z, error = instance.get_position_of_index(5, 0, 0, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, 1.1)
instance.stop()
def test4(self):
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.setup_mesh(10, 20, 40, 1.0, 1.0, 1.0)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
imin, imax, jmin, jmax, kmin, kmax = instance.get_index_range_inclusive()
x, y, z, error = instance.get_position_of_index(2, 2, 2)
self.assertEqual(error, -1)
result = instance.commit_parameters()
self.assertEqual(result, 0)
x, y, z, error = instance.get_position_of_index(0, 0, 0)
self.assertEqual(error, 0)
print(x, y, z)
self.assertAlmostRelativeEquals(0.05, x)
self.assertAlmostRelativeEquals(0.025, y)
self.assertAlmostRelativeEquals(0.0125, z)
x, y, z, error = instance.get_position_of_index(10, 20, 40)
self.assertEqual(error, 0)
print(x, y, z)
self.assertAlmostRelativeEquals(1.05, x)
self.assertAlmostRelativeEquals(1.025, y)
self.assertAlmostRelativeEquals(1.0125, z)
instance.stop()
def test5(self):
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(5, 5, 5, 1.0, 1.0, 1.0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.4)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
result = instance.commit_parameters()
self.assertEqual(result, 0)
time, error = instance.get_time()
self.assertEqual(error, 0)
self.assertEqual(time, 0.0)
error = instance.set_grid_state(1, 1, 1, 0.1, 0.2, 0.3, 0.4, 0.5)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.1)
self.assertEqual(rhovx, 0.2)
self.assertEqual(rhovy, 0.3)
self.assertEqual(rhovz, 0.4)
self.assertEqual(energy, 0.5)
rhovx, rhovy, rhovz, error = instance.get_grid_momentum_density(1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(rhovx, 0.2)
self.assertEqual(rhovy, 0.3)
self.assertEqual(rhovz, 0.4)
rho, error = instance.get_grid_density(1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.1)
energy, error = instance.get_grid_energy_density(1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(energy, 0.5)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state([1], [1], [1])
self.assertEqual(error[0], 0)
self.assertEqual(rho[0], 0.1)
error = instance.initialize_grid()
self.assertEqual(error, 0)
timestep, error = instance.get_timestep()
self.assertEqual(error, 0)
instance.stop()
def test5a(self):
instance = self.new_instance(AthenaInterface, mode="mhd")
instance.initialize_code()
instance.setup_mesh(5, 5, 5, 1.0, 1.0, 1.0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.4)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
result = instance.commit_parameters()
self.assertEqual(result, 0)
time, error = instance.get_time()
self.assertEqual(error, 0)
self.assertEqual(time, 0.0)
error = instance.set_grid_magnetic_field(1, 1, 1, 0.1, 0.2, 0.3)
self.assertEqual(error, 0)
B1i, B2i, B3i, error = instance.get_grid_magnetic_field(1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(B1i, 0.1)
self.assertEqual(B2i, 0.2)
self.assertEqual(B3i, 0.3)
instance.stop()
def test7(self):
results = []
for x in range(1, 5):
instance = self.new_instance(AthenaInterface, number_of_workers=x)
instance.initialize_code()
instance.setup_mesh(128, 1, 1, 1.0, 0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
result = instance.commit_parameters()
self.assertEqual(result, 0)
nghost, error = instance.get_nghost()
self.assertEqual(4, nghost)
instance.set_grid_state(numpy.arange(0, 128), numpy.zeros(128), numpy.zeros(128), 0.1, 0.2, 0.3, 0.4, 0.5)
error = instance.initialize_grid()
self.assertEqual(error, 0)
result = instance.get_grid_state(numpy.arange(0, 128), numpy.zeros(128), numpy.zeros(128))
results.append(list(result))
instance.stop()
for x in range(128):
for y in range(6):
self.assertEqual(results[1][y][x], results[0][y][x])
self.assertEqual(results[2][y][x], results[0][y][x])
self.assertEqual(results[3][y][x], results[0][y][x])
def test8(self):
instance = self.new_instance(AthenaInterface, number_of_workers=1)
instance.initialize_code()
instance.setup_mesh(128, 1, 1, 1.0, 0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
result = instance.commit_parameters()
self.assertEqual(result, 0)
instance.fill_grid_linearwave_1d(0, 1e-06, 0.0, 1)
error = instance.initialize_grid()
self.assertEqual(error, 0)
print(instance.get_grid_state(numpy.arange(0, 128), numpy.zeros(128), numpy.zeros(128)))
timestep, error = instance.get_timestep()
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(timestep, 0.006249991, 5)
rho0, rhovx0, rhovy0, rhovz0, energy0, error0 = instance.get_grid_state(numpy.arange(0, 128), numpy.zeros(128), numpy.zeros(128))
instance.evolve_model(5.0)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(numpy.arange(0, 128), numpy.zeros(128), numpy.zeros(128))
error_rho = numpy.sum(numpy.abs(rho - rho0))
error_rhovx = numpy.sum(numpy.abs(rhovx - rhovx0))
error_rhovy = numpy.sum(numpy.abs(rhovy - rhovy0))
error_rhovz = numpy.sum(numpy.abs(rhovz - rhovz0))
error_energy = numpy.sum(numpy.abs(energy - energy0))
self.assertAlmostRelativeEquals(error_rho / 128.0, 1.877334e-09, 6)
self.assertAlmostRelativeEquals(error_rhovx / 128.0, 1.877334e-09, 6)
self.assertAlmostRelativeEquals(error_energy / 128.0, 2.816001e-09, 6)
instance.stop()
def test9(self):
results = []
for x in range(1, 5):
instance = self.new_instance(AthenaInterface, number_of_workers=x)
instance.initialize_code()
instance.setup_mesh(128, 1, 1, 1.0, 0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
result = instance.commit_parameters()
self.assertEqual(result, 0)
nghost, error = instance.get_nghost()
self.assertEqual(4, nghost)
instance.fill_grid_linearwave_1d(0, 1e-06, 0.0, 1)
error = instance.initialize_grid()
self.assertEqual(error, 0)
instance.evolve_model(5.0)
result = instance.get_grid_state(numpy.arange(0, 128), numpy.zeros(128), numpy.zeros(128))
results.append(list(result))
instance.stop()
for x in range(128):
for y in range(6):
self.assertEqual(results[1][y][x], results[0][y][x])
self.assertEqual(results[2][y][x], results[0][y][x])
self.assertEqual(results[3][y][x], results[0][y][x])
def test10(self):
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.setup_mesh(5, 5, 5, 1.0, 1.0, 1.0)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
instance.initialize_grid()
x, y, z, error = instance.get_position_of_index([0, 1, 2, 3, 4], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0])
for x0, x1 in zip(x, [0.1, 0.3, 0.5, 0.7, 0.9]):
self.assertAlmostRelativeEqual(x0, x1)
for y0, y1 in zip(y, [0.1, 0.1, 0.1, 0.1, 0.1]):
self.assertAlmostRelativeEqual(y0, y1)
i, j, k, error = instance.get_index_of_position(0.3, 0.1, 0.1)
print(i, j, k)
self.assertAlmostRelativeEqual(i, 1)
self.assertAlmostRelativeEqual(j, 0)
self.assertAlmostRelativeEqual(k, 0)
i, j, k, error = instance.get_index_of_position(0.39, 0.1, 0.1)
self.assertAlmostRelativeEqual(i, 1.0)
self.assertAlmostRelativeEqual(j, 0)
self.assertAlmostRelativeEqual(k, 0)
i, j, k, error = instance.get_index_of_position(0.4, 0.1, 0.1)
self.assertAlmostRelativeEqual(i, 2.0)
self.assertAlmostRelativeEqual(j, 0)
self.assertAlmostRelativeEqual(k, 0)
x, y, z, error = instance.get_position_of_index(-1, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(x, -0.1)
x, y, z, error = instance.get_position_of_index(5, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(x, 1.1)
instance.stop()
def test6(self):
instance = self.new_instance(AthenaInterface, number_of_workers=5)
instance.initialize_code()
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.setup_mesh(100, 200, 400, 10.0, 10.0, 10.0)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
imin, imax, jmin, jmax, kmin, kmax = instance.get_index_range_inclusive()
x, y, z, error = instance.get_position_of_index(2, 2, 2)
self.assertEqual(error, -1)
result = instance.commit_parameters()
self.assertEqual(result, 0)
x, y, z, error = instance.get_position_of_index(0, 0, 0)
self.assertEqual(error, 0)
print(x, y, z)
self.assertAlmostRelativeEquals(0.05, x)
self.assertAlmostRelativeEquals(0.025, y)
self.assertAlmostRelativeEquals(0.0125, z)
x, y, z, error = instance.get_position_of_index(100, 200, 400)
self.assertEqual(error, 0)
print(x, y, z)
self.assertAlmostRelativeEquals(10.05, x)
self.assertAlmostRelativeEquals(10.025, y)
self.assertAlmostRelativeEquals(10.0125, z)
instance.stop()
def test11(self):
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.setup_mesh(10, 20, 40, 1.0, 1.0, 1.0)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
imin, imax, jmin, jmax, kmin, kmax = instance.get_index_range_inclusive()
self.assertEqual(imin, 0)
self.assertEqual(jmin, 0)
self.assertEqual(kmin, 0)
self.assertEqual(imax, 9)
self.assertEqual(jmax, 19)
self.assertEqual(kmax, 39)
imin, imax, jmin, jmax, kmin, kmax = instance.get_index_range_for_potential()
self.assertEqual(imin, -1)
self.assertEqual(jmin, -1)
self.assertEqual(kmin, -1)
self.assertEqual(imax, 10)
self.assertEqual(jmax, 20)
self.assertEqual(kmax, 40)
instance.stop()
def test12(self):
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.setup_mesh(10, 20, 40, 1.0, 1.0, 1.0)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
instance.initialize_grid()
x, y, z, error = instance.get_position_of_index(-1, -1, -1)
self.assertEqual(error, 0)
print(x, y, z)
self.assertAlmostRelativeEquals(-0.05, x)
self.assertAlmostRelativeEquals(-0.025, y)
self.assertAlmostRelativeEquals(-0.0125, z)
instance.stop()
def test13(self):
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.setup_mesh(2, 2, 2, 1.0, 1.0, 1.0)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
instance.initialize_grid()
potential_along_one_axis = [-1.0, 0.0, 1.0, 2.0]
instance.set_potential(
[-1, 0, 1, 2],
[0, 0, 0, 0],
[0, 0, 0, 0],
potential_along_one_axis
)
got_potential, error = instance.get_potential(
[-1, 0, 1, 2],
[0, 0, 0, 0],
[0, 0, 0, 0])
print(got_potential, error)
for expected, actual in zip(potential_along_one_axis, got_potential):
self.assertEqual(expected, actual)
x, y, z, error = instance.get_position_of_index(
[-1, 0, 1, 2],
[0, 0, 0, 0],
[0, 0, 0, 0])
print(x, y, z, error)
for expected, actual in zip([-0.25, 0.25, 0.75, 1.25], x):
self.assertEqual(expected, actual)
for expected, actual in zip([0.25, 0.25, 0.25, 0.25], y):
self.assertEqual(expected, actual)
for expected, actual in zip([0.25, 0.25, 0.25, 0.25], z):
self.assertEqual(expected, actual)
potential, error = instance.get_interpolated_gravitational_potential(0, 0.25, 0.25)
print(potential, error)
self.assertEqual(error, 0)
self.assertEqual(potential, -0.5)
potential, error = instance.get_interpolated_gravitational_potential(0.75, 0.5, 0.25)
print(potential, error)
self.assertEqual(error, 0)
self.assertEqual(potential, 0.5)
potential, error = instance.get_interpolated_gravitational_potential(0.75, 0.25, 0.5)
print(potential, error)
self.assertEqual(error, 0)
self.assertEqual(potential, 0.5)
potential, error = instance.get_interpolated_gravitational_potential(0.75, 0.25, 0.0)
print(potential, error)
self.assertEqual(error, 0)
self.assertEqual(potential, 0.5)
instance.stop()
def test14(self):
instance = self.new_instance(AthenaInterface, mode="scalar")
instance.initialize_code()
instance.setup_mesh(5, 5, 5, 1.0, 1.0, 1.0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.4)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
result = instance.commit_parameters()
self.assertEqual(result, 0)
error = instance.set_grid_scalar(1, 1, 1, 0.45)
self.assertEqual(error, 0)
scalar, error = instance.get_grid_scalar(1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(scalar, 0.45)
scalar, error = instance.get_grid_scalar(1, 1, 2)
self.assertEqual(error, 0)
self.assertEqual(scalar, 0)
instance.stop()
def test15(self):
results = []
for x in range(1, 6):
instance = self.new_instance(AthenaInterface, number_of_workers=x)
instance.initialize_code()
instance.setup_mesh(100, 1, 1, 100.0, 0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
result = instance.commit_parameters()
for index in range(100):
x, y, z, error = instance.get_position_of_index(index, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, index + 0.5)
i, j, k, error = instance.get_index_of_position(x, y, z)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(i, index)
instance.stop()
def test16(self):
for x in range(1, 6):
instance = self.new_instance(AthenaInterface, number_of_workers=x)
instance.initialize_code()
instance.setup_mesh(10, 100, 1, 100.0, 100.0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
result = instance.commit_parameters()
for index in range(100):
x, y, z, error = instance.get_position_of_index(0, index, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(y, index + 0.5)
i, j, k, error = instance.get_index_of_position(x, y, z)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(j, index)
instance.stop()
def test17(self):
results = []
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(100, 1, 1, 100.0, 0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "periodic", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
minx, maxx, miny, maxy, minz, maxz, error = instance.get_boundary_index_range_inclusive(1, 1)
self.assertEqual(error, 0)
self.assertEqual(minx, 0)
self.assertEqual(maxx, 3)
self.assertEqual(miny, 0)
self.assertEqual(maxy, 0)
self.assertEqual(minz, 0)
self.assertEqual(maxz, 0)
for i in range(2, 7):
minx, maxx, miny, maxy, minz, maxz, error = instance.get_boundary_index_range_inclusive(i, 1)
self.assertEqual(error, 0)
self.assertEqual(minx, 0)
self.assertEqual(maxx, 0)
self.assertEqual(miny, 0)
self.assertEqual(maxy, 0)
self.assertEqual(minz, 0)
self.assertEqual(maxz, 0)
def test18(self):
results = []
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(100, 5, 6, 100.0, 0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "periodic", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
minx, maxx, miny, maxy, minz, maxz, error = instance.get_boundary_index_range_inclusive(1, 1)
self.assertEqual(error, 0)
self.assertEqual(minx, 0)
self.assertEqual(maxx, 3)
self.assertEqual(miny, 0)
self.assertEqual(maxy, 4)
self.assertEqual(minz, 0)
self.assertEqual(maxz, 5)
for i in range(2, 7):
minx, maxx, miny, maxy, minz, maxz, error = instance.get_boundary_index_range_inclusive(i, 1)
self.assertEqual(error, 0)
self.assertEqual(minx, 0)
self.assertEqual(maxx, 0)
self.assertEqual(miny, 0)
self.assertEqual(maxy, 0)
self.assertEqual(minz, 0)
self.assertEqual(maxz, 0)
def test19(self):
results = []
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(100, 5, 6, 100.0, 0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "interface", "interface", "interface", "interface")
instance.commit_parameters()
for i in range(1, 7):
minx, maxx, miny, maxy, minz, maxz, error = instance.get_boundary_index_range_inclusive(i, 1)
self.assertEqual(error, 0)
self.assertEqual(minx, 0)
self.assertEqual(miny, 0)
self.assertEqual(minz, 0)
if i == 1 or i == 2:
self.assertEqual(maxx, 3)
self.assertEqual(maxy, 4)
self.assertEqual(maxz, 5)
elif i == 3 or i == 4:
self.assertEqual(maxx, 99+8)
self.assertEqual(maxy, 3)
self.assertEqual(maxz, 5)
elif i == 5 or i == 6:
self.assertEqual(maxx, 99+8)
self.assertEqual(maxy, 4+8)
self.assertEqual(maxz, 3)
def test20(self):
results = []
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(100, 1, 1, 100.0, 100.0, 100.0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "periodic", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
for i in range(4):
error = instance.set_boundary_state(
i, 0, 0, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
1.0, 1.0 # boundary + grid
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i, 0, 0,
1.0, 1.0
)
print(rho, rhovx, rhovy, rhovz, rhoen, error)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test21(self):
results = []
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(100, 1, 1, 100.0, 0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
for i in range(4):
for j in [1, 2]:
error = instance.set_boundary_state(
i, 0, 0, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
j, 1.0 # boundary + grid
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i, 0, 0,
j, 1.0
)
print(j)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test22(self):
results = []
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(5, 6, 7, 100.0, 100.0, 100.0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "interface", "interface", "interface", "interface")
instance.commit_parameters()
x1range = (4, 6, 7)
x2range = (5, 4, 7)
x3range = (5, 6, 4)
for xrange, j in zip([x1range, x1range, x2range, x2range, x3range, x3range], [1, 2, 3, 4, 5, 6]):
for i0 in range(xrange[0]):
for j0 in range(xrange[1]):
for k0 in range(xrange[2]):
i = (i0 * (xrange[2] * xrange[1])) + (j0 * xrange[2]) + k0
error = instance.set_boundary_state(
i0, j0, k0, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
j, 1.0 # boundary + grid
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, k0, # index
j, 1.0
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test24(self):
results = []
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(100, 5, 1, 100.0, 0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "interface", "interface", "interface", "interface")
instance.commit_parameters()
for i in range(1, 7):
minx, maxx, miny, maxy, minz, maxz, error = instance.get_boundary_index_range_inclusive(i, 1)
self.assertEqual(error, 0)
self.assertEqual(minx, 0)
self.assertEqual(miny, 0)
self.assertEqual(minz, 0)
if i == 1 or i == 2:
self.assertEqual(maxx, 3)
self.assertEqual(maxy, 4)
self.assertEqual(maxz, 0)
elif i == 3 or i == 4:
self.assertEqual(maxx, 99+8)
self.assertEqual(maxy, 3)
self.assertEqual(maxz, 0)
elif i == 5 or i == 6:
self.assertEqual(maxx, 99+8)
self.assertEqual(maxy, 4 + 8)
self.assertEqual(maxz, 3)
def test25(self):
results = []
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(100, 1, 1, 100.0, 0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
dx = 1.0
for i in range(4):
x, y, z, error = instance.get_boundary_position_of_index(
i, 0, 0,
1, 1
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) - ((4 - i)*dx))
self.assertAlmostRelativeEquals(y, 0.0)
self.assertAlmostRelativeEquals(z, 0.0)
def test26(self):
results = []
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(100, 1, 1, 100.0, 0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
dx = 1.0
for i in range(4):
x, y, z, error = instance.get_boundary_position_of_index(
i, 0, 0,
2, 1
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, 100.0 + (0.5 * dx) + (i * dx))
self.assertAlmostRelativeEquals(y, 0.0)
self.assertAlmostRelativeEquals(z, 0.0)
def test27(self):
results = []
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(100, 5, 1, 100.0, 100.0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "interface", "interface", "periodic", "periodic")
instance.commit_parameters()
dx = 1.0
dy = 100.0 / 5.0
for i in range(4):
for j in range(5):
x, y, z, error = instance.get_boundary_position_of_index(
i, j, 1,
2, 1
)
print(y, j, (0.5 * dy) - ((4 - j) * dy))
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, 100.0 + (0.5 * dx) + (i * dx))
self.assertAlmostRelativeEquals(y, (0.5 * dy) + (j * dy))
self.assertAlmostRelativeEquals(z, 0.0)
for i in range(100 + 8):
for j in range(4):
x, y, z, error = instance.get_boundary_position_of_index(
i, j, 1,
3, 1
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) + ((i-4) * dx))
self.assertAlmostRelativeEquals(y, ((0.5 * dy) - ((4-j) * dy)))
self.assertAlmostRelativeEquals(z, 0.0)
x, y, z, error = instance.get_boundary_position_of_index(
i, j, 1,
4, 1
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) + ((i-4) * dx))
self.assertAlmostRelativeEquals(y, 100.0 + (0.5 * dy) + (j * dy))
self.assertAlmostRelativeEquals(z, 0.0)
def test28(self):
results = []
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(3, 3, 3, 6, 12, 18)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "interface", "interface", "interface", "interface")
instance.commit_parameters()
dx = 6.0 / 3.0
dy = 12.0 / 3.0
dz = 18.0 / 3.0
for i in range(4):
for j in range(3):
for k in range(3):
x, y, z, error = instance.get_boundary_position_of_index(
i, j, k,
2, 1
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, 6.0 + (0.5 * dx) + (i * dx))
self.assertAlmostRelativeEquals(y, (0.5 * dy) + (j * dy))
self.assertAlmostRelativeEquals(z, (0.5 * dz) + (k * dz))
for i in range(3 + 8):
for j in range(4):
for k in range(3):
x, y, z, error = instance.get_boundary_position_of_index(
i, j, k,
3, 1
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) + ((i-4) * dx))
self.assertAlmostRelativeEquals(y, ((0.5 * dy) - ((4-j) * dy)))
self.assertAlmostRelativeEquals(z, (0.5 * dz) + (k * dz))
x, y, z, error = instance.get_boundary_position_of_index(
i, j, k,
4, 1
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) + ((i-4) * dx))
self.assertAlmostRelativeEquals(y, 12.0 + (0.5 * dy) + (j * dy))
self.assertAlmostRelativeEquals(z, (0.5 * dz) + (k * dz))
for i in range(3 + 8):
for j in range(3 + 8):
for k in range(4):
x, y, z, error = instance.get_boundary_position_of_index(
i, j, k,
5, 1
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) + ((i-4) * dx))
self.assertAlmostRelativeEquals(y, (0.5 * dy) + ((j-4) * dy))
self.assertAlmostRelativeEquals(z, ((0.5 * dz) - ((4-k) * dz)))
x, y, z, error = instance.get_boundary_position_of_index(
i, j, k,
6, 1
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(x, (0.5 * dx) + ((i-4) * dx))
self.assertAlmostRelativeEquals(y, (0.5 * dy) + ((j-4) * dy))
self.assertAlmostRelativeEquals(z, 18.0 + (0.5 * dz) + (k * dz))
def test29(self):
results = []
instance = self.new_instance(AthenaInterface, number_of_workers=3)
instance.initialize_code()
instance.setup_mesh(300, 1, 1, 300.0, 0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
for j in [1, 2]:
print(j)
for i in range(4):
error = instance.set_boundary_state(
i, 0, 0, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
j, 1.0 # boundary + grid
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i, 0, 0,
j, 1.0
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test30(self):
results = []
instance = self.new_instance(AthenaInterface, number_of_workers=3)
instance.initialize_code()
instance.setup_mesh(30, 10, 1, 30.0, 10.0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "interface", "interface", "periodic", "periodic")
instance.commit_parameters()
for boundaryindex in [3, 4]:
for i0 in range(38):
for j0 in range(4):
i = (i0 * (4*38)) + j0
error = instance.set_boundary_state(
i0, j0, 0, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
boundaryindex, 1 # boundary + grid
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, 0,
boundaryindex, 1.0
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test31(self):
results = []
instance = self.new_instance(AthenaInterface, number_of_workers=3)
instance.initialize_code()
instance.set_auto_decomposition(0)
instance.set_parallel_decomposition(1, 3, 1)
instance.setup_mesh(5, 6, 1, 5.0, 6.0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "interface", "interface", "periodic", "periodic")
instance.commit_parameters()
for boundaryindex in [1, 2]:
for i0 in range(4):
for j0 in range(6):
i = (i0 * (4*6)) + j0
error = instance.set_boundary_state(
i0, j0, 0, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
boundaryindex, 1 # boundary + grid
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, 0,
boundaryindex, 1.0
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test32(self):
results = []
instance = self.new_instance(AthenaInterface, number_of_workers=3*3)
instance.initialize_code()
instance.set_auto_decomposition(0)
instance.set_parallel_decomposition(3, 3, 1)
instance.setup_mesh(6, 6, 1, 6.0, 6.0, 0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "interface", "interface", "periodic", "periodic")
instance.commit_parameters()
for boundaryindex in [1, 2]:
for i0 in range(4):
for j0 in range(6):
i = (i0 * (4*6)) + j0
error = instance.set_boundary_state(
i0, j0, 0, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
boundaryindex, 1 # boundary + grid
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, 0,
boundaryindex, 1.0
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
for boundaryindex in [3, 4]:
for i0 in range(6+8):
for j0 in range(4):
i = (i0 * (4*(6+8))) + j0
error = instance.set_boundary_state(
i0, j0, 0, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
boundaryindex, 1 # boundary + grid
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, 0,
boundaryindex, 1.0
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test33(self):
results = []
instance = self.new_instance(AthenaInterface, number_of_workers=3)
instance.initialize_code()
instance.set_auto_decomposition(0)
instance.set_parallel_decomposition(1, 1, 3)
instance.setup_mesh(5, 5, 6, 5.0, 5.0, 30.0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "interface", "interface", "periodic", "periodic")
instance.commit_parameters()
for boundaryindex in [1, 2]:
for i0 in range(4):
for j0 in range(5):
for z0 in range(6):
i = (i0 * (5*6)) + (j0 * 6) + z0
error = instance.set_boundary_state(
i0, j0, z0, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
boundaryindex, 1 # boundary + grid
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, z0,
boundaryindex, 1.0
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test34(self):
results = []
instance = self.new_instance(AthenaInterface, number_of_workers=3)
instance.initialize_code()
instance.set_auto_decomposition(0)
instance.set_parallel_decomposition(3, 1, 1)
instance.setup_mesh(6, 5, 5, 6.0, 5.0, 5.0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "interface", "interface", "interface", "interface")
instance.commit_parameters()
for boundaryindex in [5, 6]:
for i0 in range(6+8):
for j0 in range(5+8):
for z0 in range(4):
i = (i0 * (5*4)) + (j0 * 4) + z0
error = instance.set_boundary_state(
i0, j0, z0, # index
1.0 * (i+1), # density
2.0 * (i+1), 3.0 * (i+1), 4.0 * (i+1), # momentum
5.0 * (i+1), # energy
boundaryindex, 1 # boundary + grid
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
i0, j0, z0,
boundaryindex, 1.0
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (i+1))
def test35(self):
results = []
instance = self.new_instance(AthenaInterface, number_of_workers=9)
instance.initialize_code()
instance.set_auto_decomposition(0)
instance.set_parallel_decomposition(3, 3, 1)
instance.setup_mesh(6, 6, 5, 6.0, 6.0, 5.0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.8)
instance.set_boundary("interface", "interface", "interface", "interface", "interface", "interface")
instance.commit_parameters()
boundary_indices = []
all_i0 = []
all_j0 = []
all_z0 = []
all_i = []
for boundaryindex in [5, 6]:
for i0 in range(6+8):
for j0 in range(6+8):
for z0 in range(4):
boundary_indices.append(boundaryindex)
all_i0.append(i0)
all_j0.append(j0)
all_z0.append(z0)
i = (i0 * (5*4)) + (j0 * 4) + z0
all_i.append(i)
all_i = numpy.asarray(all_i)
error = instance.set_boundary_state(
all_i0, all_j0, all_z0, # index
1.0 * (all_i+1), # density
2.0 * (all_i+1), 3.0 * (all_i+1), 4.0 * (all_i+1), # momentum
5.0 * (all_i+1), # energy
boundary_indices, 1 # boundary + grid
)
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, rhoen, error = instance.get_boundary_state(
all_i0, all_j0, all_z0,
boundaryindex, 1.0
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 1.0 * (all_i+1))
self.assertAlmostRelativeEquals(rhovx, 2.0 * (all_i+1))
self.assertAlmostRelativeEquals(rhovy, 3.0 * (all_i+1))
self.assertAlmostRelativeEquals(rhovz, 4.0 * (all_i+1))
self.assertAlmostRelativeEquals(rhoen, 5.0 * (all_i+1))
def test36(self):
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.setup_mesh(4, 3, 2, 1.0, 1.0, 1.0)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
instance.commit_parameters()
instance.initialize_grid()
ax_in = [1., 2., 3., 4.]
ay_in = [3, 4, 5, 6]
az_in = [5, 6, 7, 8]
instance.set_grid_acceleration(
[0, 1, 2, 3],
[0, 0, 0, 0],
[0, 1, 0, 1],
ax_in,
ay_in,
az_in,
[1, 1, 1, 1],
)
ax_out, ay_out, az_out, error = instance.get_grid_acceleration(
[0, 1, 2, 3],
[0, 0, 0, 0],
[0, 1, 0, 1],
[1, 1, 1, 1]
)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(ax_in, ax_out)
self.assertAlmostRelativeEquals(ay_in, ay_out)
self.assertAlmostRelativeEquals(az_in, az_out)
instance.stop()
def test37(self):
instance = self.new_instance(AthenaInterface)
instance.initialize_code()
instance.setup_mesh(4, 1, 1, 1.0, 1.0, 1.0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.4)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
result = instance.commit_parameters()
self.assertEqual(result, 0)
time, error = instance.get_time()
self.assertEqual(error, 0)
self.assertEqual(time, 0.0)
for i in range(4):
error = instance.set_grid_state(i, 0, 0, 0.1 * (i+1), 0.2 * (i+1), 0.3 * (i+1), 0.4 * (i+1), 0.5 * (i+1))
self.assertEqual(error, 0)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(0, 0, 0)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(-1, 0, 0)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.0)
self.assertEqual(rhovx, 0.0)
self.assertEqual(rhovy, 0.0)
self.assertEqual(rhovz, 0.0)
self.assertEqual(energy, 0.0)
instance.initialize_grid()
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(-1, 0, 0)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.4)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(-2, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.3)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(-3, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.2)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(-4, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(-5, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.0)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(4, 0, 0)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(5, 0, 0)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.2)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(6, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.3)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(7, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.4)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(8, 0, 0)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.0)
instance.stop()
def test38(self):
instance = self.new_instance(AthenaInterface, number_of_workers=8)
instance.initialize_code()
instance.set_auto_decomposition(0)
instance.set_parallel_decomposition(2, 2, 2)
instance.setup_mesh(8, 8, 8, 1.0, 1.0, 1.0)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.4)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
result = instance.commit_parameters()
self.assertEqual(result, 0)
time, error = instance.get_time()
self.assertEqual(error, 0)
self.assertEqual(time, 0.0)
for i in range(8):
error = instance.set_grid_state(i, 0, 0, 0.1 * (i+1), 0.2 * (i+1), 0.3 * (i+1), 0.4 * (i+1), 0.5 * (i+1))
error = instance.set_grid_state(0, i, 0, 0.1 * (i+1), 0.2 * (i+1), 0.3 * (i+1), 0.4 * (i+1), 0.5 * (i+1))
error = instance.set_grid_state(0, 0, i, 0.1 * (i+1), 0.2 * (i+1), 0.3 * (i+1), 0.4 * (i+1), 0.5 * (i+1))
self.assertEqual(error, 0)
instance.initialize_grid()
for i in range(8):
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(i, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, (i+1) * 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(0, i, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, (i+1) * 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(0, 0, i)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, (i+1) * 0.1)
for i in range(4):
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(-(i+1), 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.8 - (i * 0.1))
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(-5, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.0)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(8 + i, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, (i+1) * 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(8 + 4, 0, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.0)
# 2 dimension
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(0, -(i+1), 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.8 - (i * 0.1))
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(0, -5, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.0)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(0, 8 + i, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, (i+1) * 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(0, 8+4, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.0)
# 3 dimension
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(0, 0, -(i+1))
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.8 - (i * 0.1))
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(0, -5, 0)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.0)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(0, 0, 8 + i)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, (i+1) * 0.1)
rho, rhovx, rhovy, rhovz, energy, error = instance.get_grid_state(0, 0, 8+4)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(rho, 0.0)
instance.stop()
class TestAthena(TestWithMPI):
def test0(self):
instance = self.new_instance(Athena)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.parameters.nx = 10
instance.parameters.ny = 20
instance.parameters.nz = 40
instance.parameters.length_x = 1 | generic_unit_system.length
instance.parameters.length_y = 2 | generic_unit_system.length
instance.parameters.length_z = 3 | generic_unit_system.length
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
# print instance.grid[0].y
density = generic_unit_system.mass / (generic_unit_system.length ** 3)
momentum = generic_unit_system.mass / (generic_unit_system.time * (generic_unit_system.length**2))
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
firstx = instance.grid[0][0][0].x
allx = instance.grid[0].x
for j in range(20):
for k in range(40):
self.assertEqual(allx[j][k], firstx)
print(instance.grid[0][0].rho)
self.assertEqual(instance.grid[0][0][0].rho, 0.0 | generic_unit_system.mass / generic_unit_system.length ** 3)
potential_grid = datamodel.Grid(12, 22, 42)
potential_grid.potential = 2.0 | generic_unit_system.potential
channel = potential_grid.new_channel_to(instance.potential_grid)
channel.copy()
self.assertEqual(instance.potential_grid[0][0][0].potential, 2.0 | generic_unit_system.potential)
self.assertEqual(instance.potential_grid[0][2][20].potential, 2.0 | generic_unit_system.potential)
instance.stop()
def test1(self):
instance = self.new_instance(Athena)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.parameters.nx = 10
instance.parameters.ny = 20
instance.parameters.nz = 40
instance.parameters.length_x = 1 | generic_unit_system.length
instance.parameters.length_y = 2 | generic_unit_system.length
instance.parameters.length_z = 3 | generic_unit_system.length
instance.parameters.x_boundary_conditions = "periodic", "periodic"
instance.parameters.y_boundary_conditions = "periodic", "periodic"
instance.parameters.z_boundary_conditions = "periodic", "periodic"
result = instance.commit_parameters()
firstx = instance.potential_grid[0][0][0].x
print(firstx)
self.assertEqual(firstx, -0.05 | generic_unit_system.length)
allx = instance.potential_grid[0].x
for j in range(20):
for k in range(40):
self.assertEqual(allx[j][k], firstx)
instance.stop()
def test2(self):
instance = self.new_instance(Athena)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.setup_mesh(10, 10, 1, 1.0 | generic_unit_system.length, 1.0 | generic_unit_system.length, 0.0 | generic_unit_system.length)
instance.parameters.mesh_size = (10, 10, 1)
instance.parameters.length_x = 1.0 | generic_unit_system.length
instance.parameters.length_y = 1.0 | generic_unit_system.length
instance.parameters.length_z = 0.0 | generic_unit_system.length
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
density = generic_unit_system.mass / (generic_unit_system.length ** 3)
momentum = generic_unit_system.mass / (generic_unit_system.time * (generic_unit_system.length**2))
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid = datamodel.Grid(10, 10, 1)
grid.rho = 0.1 | density
grid.rhovx = 0.0 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
grid.energy = 0.0 | energy
channel = grid.new_channel_to(instance.grid)
channel.copy()
print(instance.grid[1].rho)
self.assertEqual(instance.grid[1][1][0].rho, 0.1 | density)
for x in instance.grid[1].rho.value_in(density).flatten():
self.assertEqual(x, 0.1)
instance.evolve_model(1.0 | generic_unit_system.time)
for x in instance.grid.rho.value_in(density).flatten():
self.assertEqual(x, 0.1)
instance.evolve_model(10.0 | generic_unit_system.time)
for x in instance.grid.rho.value_in(density).flatten():
self.assertEqual(x, 0.1)
instance.stop()
def test3(self):
instance = self.new_instance(Athena)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.parameters.nx = 10
instance.parameters.ny = 10
instance.parameters.nz = 1
instance.parameters.length_x = 1.0 | generic_unit_system.length
instance.parameters.length_y = 1.0 | generic_unit_system.length
instance.parameters.length_z = 0.0 | generic_unit_system.length
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
instance.set_has_external_gravitational_potential(1)
density = generic_unit_system.mass / (generic_unit_system.length ** 3)
momentum = generic_unit_system.mass / (generic_unit_system.time * (generic_unit_system.length**2))
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid = datamodel.Grid(10, 10, 1)
grid.rho = 0.1 | density
grid.rhovx = 0.0 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
grid.energy = 0.0 | energy
self.assertEqual(grid.get_defined_settable_attribute_names(), ['energy', 'rho', 'rhovx', 'rhovy', 'rhovz', ])
channel = grid.new_channel_to(instance.grid)
channel.copy()
potential_grid = datamodel.Grid(12, 12, 1)
potential_grid.potential = 0.0 | generic_unit_system.potential
channel = potential_grid.new_channel_to(instance.potential_grid)
channel.copy()
result = instance.initialize_grid()
self.assertEqual(instance.grid[1][1][0].rho, 0.1 | density)
for x in instance.grid[1].rho.value_in(density).flatten():
self.assertEqual(x, 0.1)
instance.evolve_model(1.0 | generic_unit_system.time)
for x in instance.grid.rho.value_in(density).flatten():
self.assertEqual(x, 0.1)
instance.evolve_model(10.0 | generic_unit_system.time)
for x in instance.grid.rho.value_in(density).flatten():
self.assertEqual(x, 0.1)
instance.stop()
def test4(self):
instance = self.new_instance(Athena)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.parameters.nx = 10
instance.parameters.ny = 10
instance.parameters.nz = 1
instance.parameters.length_x = 1.0 | generic_unit_system.length
instance.parameters.length_y = 1.0 | generic_unit_system.length
instance.parameters.length_z = 0.0 | generic_unit_system.length
instance.set_boundary("outflow", "outflow", "outflow", "outflow", "outflow", "outflow")
instance.set_has_external_gravitational_potential(1)
density = generic_unit_system.mass / (generic_unit_system.length ** 3)
momentum = generic_unit_system.mass / (generic_unit_system.time * (generic_unit_system.length**2))
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid = datamodel.Grid(10, 10, 1)
grid.rho = 0.1 | density
grid.rhovx = 0.0 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
grid.energy = 0.0 | energy
channel = grid.new_channel_to(instance.grid)
channel.copy()
potential_grid = datamodel.Grid(12, 12, 1)
potential_grid.potential = 0.0 | generic_unit_system.potential
x = instance.potential_grid.x
y = instance.potential_grid.y
print(1)
for i in range(12):
for j in range(12):
px = x[i][j][0].value_in(generic_unit_system.length)
py = y[i][j][0].value_in(generic_unit_system.length)
potential = (math.sin(py * math.pi)+math.sin(px * math.pi)) / 200.0
if px < 0 or px > 1.0:
potential = 0.0
if py < 0 or py > 1.0:
potential = 0.0
# print potential
potential_grid.potential[i][j][0] = -0.001 * generic_unit_system.potential.new_quantity([potential])
# instance.potential_grid[i][j][0].potential = -0.001 * generic_unit_system.potential.new_quantity([potential])
channel = potential_grid.new_channel_to(instance.potential_grid)
channel.copy()
print(2)
result = instance.initialize_grid()
self.assertEqual(instance.grid[1][1][0].rho, 0.1 | density)
for x in instance.grid[1].rho.value_in(density).flatten():
self.assertAlmostRelativeEquals(x, 0.1)
# print instance.potential_grid[...,0].potential
instance.evolve_model(1.0 | generic_unit_system.time)
# print "--------------------------"
# print instance.grid.rho[...,0]
z = instance.grid.rho[..., 0]
# z = instance.potential_grid.potential[...,0]
# z = z.value_in(generic_unit_system.potential)
z = z.value_in(density)
# from matplotlib import pyplot
# x = instance.potential_grid[...,50,0].x
## y = instance.potential_grid[...,50,0].y
# z = instance.potential_grid[...,50,0].z
# pyplot.plot(x.value_in(generic_unit_system.length), instance.potential_grid[...,50,0].potential.value_in(generic_unit_system.potential))
# dx = x[1] - x[0]
# x += 1.5 * dx
# interpolated = instance.get_interpolated_gravitational_potential(x,y,z)
# pyplot.plot(x.value_in(generic_unit_system.length), interpolated.value_in(generic_unit_system.potential))
# img = pyplot.imshow(z)
# img.set_interpolation('none')
# pyplot.savefig("bla.png")
for x in instance.grid.rho.value_in(density).flatten():
self.assertNotEqual(x, 0.1)
instance.stop()
def test5(self):
instance = self.new_instance(Athena)
self.assertAlmostRelativeEquals(instance.parameters.isothermal_sound_speed, 0.0 | generic_unit_system.speed)
instance.parameters.isothermal_sound_speed = 0.1 | generic_unit_system.speed
self.assertAlmostRelativeEquals(instance.parameters.isothermal_sound_speed, 0.1 | generic_unit_system.speed)
self.assertAlmostRelativeEquals(instance.parameters.gamma, 1.66666666666666667)
instance.parameters.gamma = 0.1
self.assertAlmostRelativeEquals(instance.parameters.gamma, 0.1)
self.assertAlmostRelativeEquals(instance.parameters.courant_number, 0.3)
instance.parameters.courant_number = 0.1
self.assertAlmostRelativeEquals(instance.parameters.courant_number, 0.1)
print(instance.parameters)
instance.stop()
def test6(self):
instance = self.new_instance(Athena)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.setup_mesh(10, 20, 40, 1.0 | generic_unit_system.length, 1.0 | generic_unit_system.length, 1.0 | generic_unit_system.length)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
density = generic_unit_system.mass / (generic_unit_system.length ** 3)
momentum = generic_unit_system.mass / (generic_unit_system.time * (generic_unit_system.length**2))
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid = datamodel.new_regular_grid((10, 10, 10), [10.0, 10.0, 10.0] | units.m)
grid.rho = 0.4 | density
grid.rhovx = 0.1 | momentum
grid.rhovy = 0.2 | momentum
grid.rhovz = 0.3 | momentum
grid.energy = 0.5 | energy
channel = grid.new_channel_to(instance.grid)
channel.copy()
self.assertEqual(instance.grid[0][0][0].rho, 0.4 | density)
self.assertEqual(instance.grid.rho.number.ndim, 3)
self.assertEqual(len(list(instance.itergrids())), 1)
instance.stop()
def test7(self):
instance = self.new_instance(Athena)
instance.parameters.isothermal_sound_speed = 0.1 | generic_unit_system.speed
instance.parameters.gamma = 0.1
instance.parameters.courant_number = 0.1
instance.parameters.nx = 10
instance.parameters.ny = 20
instance.parameters.nz = 40
instance.parameters.length_x = 10 | generic_unit_system.length
instance.parameters.length_y = 20 | generic_unit_system.length
instance.parameters.length_z = 30 | generic_unit_system.length
print(instance.parameters)
instance.commit_parameters()
mini, maxi, minj, maxj, mink, maxk = instance.get_index_range_inclusive()
self.assertEqual(mini, 0)
self.assertEqual(maxi, 9)
self.assertEqual(minj, 0)
self.assertEqual(maxj, 19)
self.assertEqual(mink, 0)
self.assertEqual(maxk, 39)
self.assertEqual(instance.parameters.mesh_size, (10, 20, 40))
print(instance.parameters)
instance.stop()
def test8(self):
instance = self.new_instance(Athena)
instance.parameters.stopping_conditions_number_of_steps = 10
self.assertEqual(instance.parameters.stopping_conditions_number_of_steps, 10)
instance.stop()
def test8a(self):
instance = self.new_instance(Athena)
instance.parameters.stopping_conditions_timeout = 10 | units.s
self.assertEqual(instance.parameters.stopping_conditions_timeout, 10 | units.s)
instance.stop()
def test9(self):
instance = self.new_instance(Athena)
instance.parameters.x_boundary_conditions = "periodic", "periodic"
instance.parameters.y_boundary_conditions = "periodic", "periodic"
instance.parameters.z_boundary_conditions = "periodic", "periodic"
self.assertEqual(instance.parameters.xbound1, "periodic")
instance.stop()
def xtest10(self):
instance = self.new_instance(Athena)
instance.parameters.gamma = 5/3.0
instance.parameters.courant_number = 0.3
n = 100
instance.parameters.nx = n
instance.parameters.ny = n
instance.parameters.nz = n
instance.parameters.length_x = 1 | generic_unit_system.length
instance.parameters.length_y = 1 | generic_unit_system.length
instance.parameters.length_z = 1 | generic_unit_system.length
instance.x_boundary_conditions = ("periodic", "periodic")
instance.y_boundary_conditions = ("periodic", "periodic")
instance.z_boundary_conditions = ("periodic", "periodic")
result = instance.commit_parameters()
density = generic_unit_system.mass / (generic_unit_system.length**3)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid = datamodel.Grid(n, n, n)
grid.rho = 0.0 | generic_unit_system.density
grid.rhovx = 0.0 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
grid.energy = 0.0 | energy
halfway = n/2 - 1
grid[:halfway].rho = 4.0 | generic_unit_system.density
grid[:halfway].energy = (1.0 | energy) / (instance.parameters.gamma - 1)
grid[halfway:].rho = 1.0 | generic_unit_system.density
grid[halfway:].energy = (0.1795 | energy) / (instance.parameters.gamma - 1)
channel = grid.new_channel_to(instance.grid)
channel.copy()
# from amuse import plot
# from matplotlib import pyplot
# print grid.rho[...,0,0]
# plot.plot(instance.grid.x[...,0,0], grid.rho[...,0,0])
# pyplot.savefig("bla1.png")
error = instance.initialize_grid()
instance.evolve_model(0.12 | generic_unit_system.time)
channel = instance.grid.new_channel_to(grid)
channel.copy()
# print grid.rho[...,0,0]
# plot.plot(instance.grid.x[...,0,0], grid.rho[...,0,0])
# pyplot.savefig("bla2.png")
instance.stop()
def test11(self):
instance = self.new_instance(Athena, mode=AthenaInterface.MODE_SELF_GRAVITY) # , redirection = "none") #, debugger="gdb")
instance.parameters.gamma = 5/3.0
instance.parameters.courant_number = 0.3
density = generic_unit_system.mass / (generic_unit_system.length ** 3)
momentum = generic_unit_system.mass / (generic_unit_system.time * (generic_unit_system.length**2))
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
instance.parameters.four_pi_G = 4 * numpy.pi * (1 | (generic_unit_system.length**3) / (generic_unit_system.mass * (generic_unit_system.time**2))) # G = 1, like nbody
instance.parameters.gravity_mean_rho = 0.0 | density
datamodel.Grid.add_global_vector_attribute("position", ["x", "y", "z"])
n = 10
instance.parameters.nx = n
instance.parameters.ny = n
instance.parameters.nz = n
instance.parameters.length_x = 4.0 | generic_unit_system.length
instance.parameters.length_y = 4.0 | generic_unit_system.length
instance.parameters.length_z = 4.0 | generic_unit_system.length
instance.x_boundary_conditions = ("periodic", "periodic")
instance.y_boundary_conditions = ("periodic", "periodic")
instance.z_boundary_conditions = ("periodic", "periodic")
result = instance.commit_parameters()
grid = datamodel.new_regular_grid((n, n, n), [4.0, 4.0, 4.0] | generic_unit_system.length)
grid.rho = 0.0 | generic_unit_system.density
grid.rhovx = 0.0 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
grid.energy = 0.001 | energy
scaled_radius = 1.0 / 1.695 | generic_unit_system.length
total_mass = 1.0 | generic_unit_system.mass
radii = (grid.position - ([2.0, 2.0, 2.0] | generic_unit_system.length)).lengths()
rho_sphere = ((0.75 * total_mass / (numpy.pi * (scaled_radius ** 3))))
grid.rho = (rho_sphere * ((1 + (radii ** 2) / (scaled_radius ** 2))**(-5.0/2.0)))
internal_energy = (0.25 | generic_unit_system.time ** -2 * generic_unit_system.mass ** -1 * generic_unit_system.length ** 3) * total_mass / scaled_radius
grid.energy = grid.rho * internal_energy/(1+(radii/scaled_radius)**2)**(1.0/2.0)
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.initialize_grid()
instance.evolve_model(0.01 | generic_unit_system.time)
G = 1.0 | generic_unit_system.length ** 3 * generic_unit_system.mass**-1 * generic_unit_system.time**-2
a = instance.grid[5][5].gravitational_potential
b = (-1 * G * total_mass / (radii**2+scaled_radius**2).sqrt())[5][5]
for x in a:
self.assertTrue(x < 0 | generic_unit_system.potential)
a = instance.grid[5][5].gravitational_acceleration_z
for index, x in enumerate(a):
if index < 5:
self.assertTrue(x > 0 | generic_unit_system.acceleration)
else:
self.assertTrue(x < 0 | generic_unit_system.acceleration)
instance.stop()
def test12(self):
print("Testing Athena grid setters")
instance = self.new_instance(Athena)
instance.parameters.isothermal_sound_speed = 0.1 | generic_unit_system.speed
instance.parameters.gamma = 5/3.0
instance.parameters.courant_number = 0.3
instance.parameters.mesh_size = (2, 2, 2)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.grid.rho = 1.0 | generic_unit_system.density
self.assertAlmostEqual(instance.grid.rho,
numpy.ones((2, 2, 2)) | generic_unit_system.density)
instance.grid.momentum = numpy.reshape(
numpy.arange(0.0, 3.0, 0.125), (2, 2, 2, 3)) | generic_unit_system.momentum_density
self.assertAlmostEqual(instance.grid.rhovx,
numpy.reshape(numpy.arange(0.000, 3.0, 0.375), (2, 2, 2)) | generic_unit_system.momentum_density)
self.assertAlmostEqual(instance.grid.rhovy,
numpy.reshape(numpy.arange(0.125, 3.0, 0.375), (2, 2, 2)) | generic_unit_system.momentum_density)
self.assertAlmostEqual(instance.grid.rhovz,
numpy.reshape(numpy.arange(0.250, 3.0, 0.375), (2, 2, 2)) | generic_unit_system.momentum_density)
momentum = instance.grid.momentum
rhovx = -momentum.x
rhovy = 2 * momentum.z
rhovz = -0.5 * momentum.y
instance.grid.momentum = VectorQuantity.new_from_scalar_quantities(rhovx, rhovy, rhovz).transpose(axes=(1, 2, 3, 0))
self.assertAlmostEqual(instance.grid.rhovx,
numpy.reshape(numpy.arange(0.000, -3.0, -0.375), (2, 2, 2)) | generic_unit_system.momentum_density)
self.assertAlmostEqual(instance.grid.rhovy,
numpy.reshape(numpy.arange(0.5, 6.0, 0.75), (2, 2, 2)) | generic_unit_system.momentum_density)
self.assertAlmostEqual(instance.grid.rhovz,
numpy.reshape(numpy.arange(-0.0625, -1.5, -0.1875), (2, 2, 2)) | generic_unit_system.momentum_density)
instance.grid[..., 0, ...].momentum = [12.0, 13.0, 14.0] | generic_unit_system.momentum_density
self.assertAlmostEqual(instance.grid[0, ...].rhovx,
[[12.0, 12.0], [-0.75, -1.125]] | generic_unit_system.momentum_density)
self.assertAlmostEqual(instance.grid[0, ...].rhovy,
[[13.0, 13.0], [2.0, 2.75]] | generic_unit_system.momentum_density)
self.assertAlmostEqual(instance.grid[..., 0].rhovz,
[[14.0, -0.4375], [14.0, -1.1875]] | generic_unit_system.momentum_density)
instance.grid.energy = numpy.reshape(numpy.arange(0.0, 1.0, 0.125), (2, 2, 2)) | generic_unit_system.energy_density
self.assertAlmostEqual(instance.grid[..., 0, 0].energy,
[0.0, 0.5] | generic_unit_system.energy_density)
self.assertAlmostEqual(instance.grid[0, ..., 0].energy,
[0.0, 0.25] | generic_unit_system.energy_density)
self.assertAlmostEqual(instance.grid[0, 0, ...].energy,
[0.0, 0.125] | generic_unit_system.energy_density)
instance.initialize_grid()
instance.stop()
def test13(self):
converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
1 | units.parsec,
1 | units.Myr,
1 | units.MSun
)
instance = self.new_instance(Athena, unit_converter=converter)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.parameters.mesh_size = (10, 20, 40)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | units.parsec
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
density = units.MSun / (units.parsec ** 3)
momentum = units.MSun / (units.Myr * units.parsec ** 2)
energy = units.MSun / (units.parsec * units.Myr ** 2)
grid = datamodel.new_regular_grid((10, 20, 40), [1.0, 1.0, 1.0] | units.parsec)
grid.rho = 0.4 | density
grid.rhovx = 0.1 | momentum
grid.rhovy = 0.2 | momentum
grid.rhovz = 0.3 | momentum
grid.energy = 0.5 | energy
channel = grid.new_channel_to(instance.grid)
channel.copy()
print(instance.grid[0].rho)
self.assertAlmostRelativeEquals(instance.grid[0].rho, 0.4 | density)
self.assertAlmostRelativeEquals(instance.grid[0].rhovx, 0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid[0].rhovy, 0.2 | momentum)
self.assertAlmostRelativeEquals(instance.grid[0].rhovz, 0.3 | momentum)
self.assertAlmostRelativeEquals(instance.grid[0].energy, 0.5 | energy)
self.assertEqual(instance.grid.rho.number.ndim, 3)
self.assertEqual(len(list(instance.itergrids())), 1)
instance.stop()
def test14(self):
instance = self.new_instance(Athena)
instance.parameters.mesh_size = (10, 1, 1)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("interface", "outflow")
instance.parameters.stopping_conditions_number_of_steps = 1
grid = datamodel.new_regular_grid((10, 1, 1), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.1 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (instance.parameters.gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
# instance.grid.boundaries.left.
xbound1 = instance.get_boundary_grid('xbound1')
self.assertEqual(xbound1.shape, (4, 1, 1))
memxbound1 = xbound1.copy()
memxbound1.rho = 0.02 | density
memxbound1.rhovx = 0.2 | momentum
memxbound1.rhovy = 0.0 | momentum
memxbound1.rhovz = 0.0 | momentum
memxbound1.energy = p / (instance.parameters.gamma - 1)
memxbound1.energy += 0.5 * (memxbound1.rhovx ** 2 + memxbound1.rhovy ** 2 + memxbound1.rhovz ** 2) / memxbound1.rho
channel = memxbound1.new_channel_to(xbound1)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
print(instance.stopping_conditions.number_of_steps_detection.is_set())
rho = instance.grid.rho[..., 0, 0]
self.assertAlmostRelativeEquals(rho[-1], 0.01 | density)
self.assertTrue(rho[0] > 0.01 | density)
self.assertTrue(instance.grid.rhovx[0, 0, 0] > 0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovx[-1, 0, 0], 0.1 | momentum)
print(instance.model_time)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[..., 0, 0]
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovx[..., 0, 0], 0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test15(self):
instance = self.new_instance(Athena)
instance.initialize_code()
instance.stop()
def test16(self):
instance = self.new_instance(Athena)
instance.parameters.mesh_size = (10, 1, 1)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("outflow", "interface")
instance.parameters.stopping_conditions_number_of_steps = 1
grid = datamodel.new_regular_grid((10, 1, 1), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = -0.1 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (instance.parameters.gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
# instance.grid.boundaries.left.
xbound = instance.get_boundary_grid('xbound2')
self.assertEqual(xbound.shape, (4, 1, 1))
memxbound = xbound.copy()
memxbound.rho = 0.02 | density
memxbound.rhovx = -0.2 | momentum
memxbound.rhovy = 0.0 | momentum
memxbound.rhovz = 0.0 | momentum
memxbound.energy = p / (instance.parameters.gamma - 1)
memxbound.energy += 0.5 * (memxbound.rhovx ** 2 + memxbound.rhovy ** 2 + memxbound.rhovz ** 2) / memxbound.rho
channel = memxbound.new_channel_to(xbound)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
print(instance.stopping_conditions.number_of_steps_detection.is_set())
rho = instance.grid.rho[..., 0, 0]
self.assertAlmostRelativeEquals(rho[0], 0.01 | density)
self.assertTrue(rho[-1] > 0.01 | density)
self.assertTrue(instance.grid.rhovx[-1, 0, 0] < -0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovx[0, 0, 0], -0.1 | momentum)
print(instance.model_time)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[..., 0, 0]
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovx[..., 0, 0], -0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test17(self):
instance = self.new_instance(Athena, number_of_workers=2)
instance.set_parallel_decomposition(1, 2, 1)
instance.parameters.mesh_size = (10, 4, 1)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("interface", "outflow")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.stopping_conditions_number_of_steps = 1
grid = datamodel.new_regular_grid((10, 4, 1), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.1 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (instance.parameters.gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
xbound = instance.get_boundary_grid('xbound1')
self.assertEqual(xbound.shape, (4, 4, 1))
memxbound = xbound.copy()
memxbound.rho = 0.02 | density
memxbound.rhovx = 0.2 | momentum
memxbound.rhovy = 0.0 | momentum
memxbound.rhovz = 0.0 | momentum
memxbound.energy = p / (instance.parameters.gamma - 1)
memxbound.energy += 0.5 * (memxbound.rhovx ** 2 + memxbound.rhovy ** 2 + memxbound.rhovz ** 2) / memxbound.rho
channel = memxbound.new_channel_to(xbound)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
print(instance.stopping_conditions.number_of_steps_detection.is_set())
print(instance.grid.rho)
rho = instance.grid.rho[..., 0, 0]
self.assertAlmostRelativeEquals(rho[-1], 0.01 | density)
self.assertTrue(rho[0] > 0.01 | density)
self.assertTrue(instance.grid.rhovx[0, 0, 0] > 0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovx[-1, 0, 0], 0.1 | momentum)
print(instance.model_time)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[..., 0, 0]
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovx[..., 0, 0], 0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test18(self):
instance = self.new_instance(Athena, number_of_workers=2)
instance.set_parallel_decomposition(2, 1, 1)
instance.parameters.mesh_size = (4, 10, 1)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("interface", "outflow")
instance.parameters.stopping_conditions_number_of_steps = 1
grid = datamodel.new_regular_grid((4, 10, 1), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.0 | momentum
grid.rhovy = 0.1 | momentum
grid.rhovz = 0.0 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (instance.parameters.gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
ybound = instance.get_boundary_grid('ybound1')
self.assertEqual(ybound.shape, (4+8, 4, 1))
memybound = ybound.copy()
memybound.rho = 0.02 | density
memybound.rhovx = 0.0 | momentum
memybound.rhovy = 0.2 | momentum
memybound.rhovz = 0.0 | momentum
memybound.energy = p / (instance.parameters.gamma - 1)
memybound.energy += 0.5 * (memybound.rhovx ** 2 + memybound.rhovy ** 2 + memybound.rhovz ** 2) / memybound.rho
channel = memybound.new_channel_to(ybound)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
print(instance.stopping_conditions.number_of_steps_detection.is_set())
print(instance.grid.rho)
rho = instance.grid.rho[0, ..., 0]
self.assertAlmostRelativeEquals(rho[-1], 0.01 | density)
self.assertTrue(rho[0] > 0.01 | density)
self.assertTrue(instance.grid.rhovy[0, 0, 0] > 0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovy[0, -1, 0], 0.1 | momentum)
print(instance.model_time)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[0, ..., 0]
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovy[0, ..., 0], 0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test19(self):
instance = self.new_instance(Athena, number_of_workers=1)
instance.set_parallel_decomposition(1, 1, 1)
instance.parameters.mesh_size = (4, 5, 6)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("interface", "outflow")
instance.parameters.stopping_conditions_number_of_steps = 1
grid = datamodel.new_regular_grid((4, 5, 6), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.0 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.1 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (instance.parameters.gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
zbound = instance.get_boundary_grid('zbound1')
self.assertEqual(zbound.shape, (4+8, 5+8, 4))
memzbound = zbound.copy()
memzbound.rho = 0.02 | density
memzbound.rhovx = 0.0 | momentum
memzbound.rhovy = 0.0 | momentum
memzbound.rhovz = 0.2 | momentum
memzbound.energy = p / (instance.parameters.gamma - 1)
memzbound.energy += 0.5 * (memzbound.rhovx ** 2 + memzbound.rhovy ** 2 + memzbound.rhovz ** 2) / memzbound.rho
channel = memzbound.new_channel_to(zbound)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[0, 0, ...]
self.assertAlmostRelativeEquals(rho[-1], 0.01 | density)
self.assertTrue(rho[0] > 0.01 | density)
self.assertTrue(instance.grid.rhovz[0, 0, 0] > 0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovz[0, 0, -1], 0.1 | momentum)
print(instance.model_time)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[0, ..., 0]
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovz[0, 0, ...], 0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test20(self):
instance = self.new_instance(Athena, number_of_workers=4)
instance.parameters.parallel_decomposition = (2, 2, 1)
instance.parameters.mesh_size = (4, 5, 6)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("outflow", "interface")
instance.parameters.stopping_conditions_number_of_steps = 1
grid = datamodel.new_regular_grid((4, 5, 6), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.0 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = -0.1 | momentum
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (instance.parameters.gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
channel = grid.new_channel_to(instance.grid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
zbound = instance.get_boundary_grid('zbound2')
self.assertEqual(zbound.shape, (4+8, 5+8, 4))
memzbound = zbound.copy()
memzbound.rho = 0.02 | density
memzbound.rhovx = 0.0 | momentum
memzbound.rhovy = 0.0 | momentum
memzbound.rhovz = -0.2 | momentum
memzbound.energy = p / (instance.parameters.gamma - 1)
memzbound.energy += 0.5 * (memzbound.rhovx ** 2 + memzbound.rhovy ** 2 + memzbound.rhovz ** 2) / memzbound.rho
channel = memzbound.new_channel_to(zbound)
channel.copy()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[0, 0, ...]
self.assertAlmostRelativeEquals(rho[0], 0.01 | density)
self.assertTrue(rho[-1] > 0.01 | density)
self.assertTrue(instance.grid.rhovz[0, 0, -1] < -0.1 | momentum)
self.assertAlmostRelativeEquals(instance.grid.rhovz[0, 0, 0], -0.1 | momentum)
print(instance.model_time)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(1.0 | generic_unit_system.time)
rho = instance.grid.rho[0, ..., 0]
self.assertAlmostRelativeEquals(rho, 0.02 | density, 8)
self.assertAlmostRelativeEquals(instance.grid.rhovz[0, 0, ...], -0.2 | momentum, 8)
print(instance.model_time)
instance.stop()
def test21(self):
instance = self.new_instance(Athena)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (20.0, 1, 1) | generic_unit_system.length
instance.parameters.mesh_size = (20, 1, 1)
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = inmem.x/(1 | generic_unit_system.length) | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
print(inmem.rho)
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(0.5 | generic_unit_system.length, 0.0 | generic_unit_system.length, 0.0 | generic_unit_system.length)
self.assertEqual(rho, 0.5 | generic_unit_system.density)
for value in numpy.arange(0.5, 19.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, value | generic_unit_system.density)
for value in numpy.arange(0.0, 0.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, ((0.5 + value) * 0.5 + (0.5-value) * 19.5) | generic_unit_system.density)
for value in numpy.arange(0.0, 0.5, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value + 19.5 | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, (19.5 - (value * 19)) | generic_unit_system.density, 9)
# out of range
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
20.0 | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, 0.0 | generic_unit_system.density, 9)
def test22(self):
instance = self.new_instance(Athena, number_of_workers=2)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (20.0, 20.0, 1) | generic_unit_system.length
instance.parameters.mesh_size = (20, 20, 1)
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = (inmem.x + ((inmem.y - (0.5 | generic_unit_system.length)) * 20.0))/(1 | generic_unit_system.length) | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
print(inmem.rho[0], inmem.y[0], inmem.x[0])
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(0.5 | generic_unit_system.length, 0.5 | generic_unit_system.length, 0.0 | generic_unit_system.length)
self.assertEqual(rho, 0.5 | generic_unit_system.density)
for value in numpy.arange(0.5, 19.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value | generic_unit_system.length,
0.5 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, value | generic_unit_system.density)
for x in numpy.arange(8.5, 11.5, 0.25):
for y in numpy.arange(0.5, 19.6, 0.25):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
x | generic_unit_system.length,
y | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, x + (20 * (y-0.5)) | generic_unit_system.density)
def test23(self):
instance = self.new_instance(Athena, number_of_workers=3)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (20.0, 20.0, 20.0) | generic_unit_system.length
instance.parameters.mesh_length = (20.0, 20.0, 20.0) | generic_unit_system.length
instance.parameters.mesh_size = (20, 20, 20)
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = (
(
inmem.x +
((inmem.y - (0.5 | generic_unit_system.length)) * 20.0) +
((inmem.z - (0.5 | generic_unit_system.length)) * 400.0)
)
/ (1 | generic_unit_system.length) | generic_unit_system.density
)
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(0.5 | generic_unit_system.length, 0.5 | generic_unit_system.length, 0.5 | generic_unit_system.length)
self.assertEqual(rho, 0.5 | generic_unit_system.density)
for value in numpy.arange(0.5, 19.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value | generic_unit_system.length,
0.5 | generic_unit_system.length,
0.5 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, value | generic_unit_system.density)
sample = sample = datamodel.new_regular_grid(
(4, 4, 76),
(2, 2, 19) | generic_unit_system.length
)
sample.x += 9.5 | generic_unit_system.length
sample.y += 9.5 | generic_unit_system.length
sample.z += 0.5 | generic_unit_system.length
x = sample.x.flatten()
y = sample.y.flatten()
z = sample.z.flatten()
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
x,
y,
z
)
half = 0.5 | generic_unit_system.length
self.assertAlmostRelativeEquals(rho, (x + (20 * (y-half)) + (400 * (z-half)))/(1 | generic_unit_system.length) | generic_unit_system.density)
def test24(self):
instance = self.new_instance(Athena, number_of_workers=1)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (10.0, 1, 1) | generic_unit_system.length
instance.parameters.mesh_size = (20, 1, 1)
instance.set_has_external_gravitational_potential(1)
instance.commit_parameters()
potential_grid = instance.potential_grid
factor = (2 | generic_unit_system.length / generic_unit_system.time**2)
potential_grid.potential = potential_grid.x * factor
x = numpy.arange(0, 10.25, 0.1) | generic_unit_system.length
y = 0.5 | generic_unit_system.length
z = 0.5 | generic_unit_system.length
interpolated = instance.get_interpolated_gravitational_potential(x, y, z)
self.assertAlmostRelativeEquals(interpolated, x * factor)
def test25(self):
instance = self.new_instance(Athena, number_of_workers=1)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (5.0, 10.0, 1) | generic_unit_system.length
instance.parameters.mesh_size = (20, 20, 1)
instance.set_has_external_gravitational_potential(1)
instance.commit_parameters()
potential_grid = instance.potential_grid
factor = (2 | generic_unit_system.length / generic_unit_system.time**2)
potential_grid.potential = potential_grid.y * factor
print(potential_grid.y * factor)
y = numpy.arange(0, 10.25, 0.1) | generic_unit_system.length
x = (y * 0) + (2 | generic_unit_system.length)
z = 0.5 | generic_unit_system.length
interpolated = instance.get_interpolated_gravitational_potential(x, y, z)
print(y*factor)
self.assertAlmostRelativeEquals(interpolated, y * factor)
def test26(self):
n = 4
instance = self.new_instance(Athena)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.parameters.nx = n
instance.parameters.ny = n
instance.parameters.nz = n
instance.parameters.length_x = n | generic_unit_system.length
instance.parameters.length_y = n | generic_unit_system.length
instance.parameters.length_z = n | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.set_has_external_gravitational_potential(1)
instance.commit_parameters()
density = generic_unit_system.mass / (generic_unit_system.length ** 3)
momentum = generic_unit_system.mass / (generic_unit_system.time * (generic_unit_system.length**2))
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
potential_grid = datamodel.Grid(n + 2, n + 2, n + 2)
potential_grid.potential = 0.0 | generic_unit_system.potential
x = instance.potential_grid.x
y = instance.potential_grid.y
z = instance.potential_grid.z
potential_grid.potential = (1 | generic_unit_system.potential) * ((x + y + z) / (1 | generic_unit_system.length))
channel = potential_grid.new_channel_to(instance.potential_grid)
channel.copy()
result = instance.initialize_grid()
print(x[..., 0, 0])
print(instance.grid.x[..., 0, 0])
print(instance.potential_grid.potential[..., 0, 0])
print(potential_grid.potential[..., 0, 0])
self.assertAlmostRelativeEquals(potential_grid.potential[..., 0, 0], instance.potential_grid.potential[..., 0, 0])
interpolated_inside = instance.get_interpolated_gravitational_potential(x[0, 0, 0], y[0, 0, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[0, 0, 0] - (1.0 | generic_unit_system.length), y[0, 0, 0], z[0, 0, 0])
print(interpolated_inside, interpolated_outside)
self.assertAlmostRelativeEquals(interpolated_inside, interpolated_outside)
interpolated_inside = instance.get_interpolated_gravitational_potential(x[0, 0, 0], y[0, 0, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[0, 0, 0], y[0, 0, 0] - (2.0 | generic_unit_system.length), z[0, 0, 0])
print(interpolated_inside, interpolated_outside)
self.assertAlmostRelativeEquals(interpolated_inside, interpolated_outside)
interpolated_inside = instance.get_interpolated_gravitational_potential(x[0, 0, 0], y[0, 0, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[0, 0, 0], y[0, 0, 0], z[0, 0, 0] - (2.0 | generic_unit_system.length))
print(interpolated_inside, interpolated_outside)
self.assertAlmostRelativeEquals(interpolated_inside, interpolated_outside)
interpolated_inside = instance.get_interpolated_gravitational_potential(x[5, 0, 0], y[0, 0, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[5, 0, 0] + (2.0 | generic_unit_system.length), y[0, 0, 0], z[0, 0, 0])
print(interpolated_inside, interpolated_outside)
self.assertAlmostRelativeEquals(interpolated_inside, interpolated_outside)
interpolated_inside = instance.get_interpolated_gravitational_potential(x[5, 0, 0], y[0, 5, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[5, 0, 0], y[0, 5, 0] + (2.0 | generic_unit_system.length), z[0, 0, 0])
self.assertAlmostRelativeEquals(interpolated_inside, interpolated_outside)
interpolated_inside = instance.get_interpolated_gravitational_potential(x[5, 0, 0], y[0, 5, 0], z[0, 0, 5])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[5, 0, 0], y[0, 5, 0], z[0, 0, 5] + (2.0 | generic_unit_system.length))
self.assertAlmostRelativeEquals(interpolated_inside, interpolated_outside)
interpolated_inside = instance.get_interpolated_gravitational_potential(x[0, 0, 0], y[0, 0, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[0, 0, 0] - (2.0 | generic_unit_system.length), y[0, 0, 0] - (2.0 | generic_unit_system.length), z[0, 0, 0] - (2.0 | generic_unit_system.length))
print(interpolated_inside, interpolated_outside)
def test27(self):
n = 4
instance = self.new_instance(Athena)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.parameters.nx = n
instance.parameters.ny = n
instance.parameters.nz = 1
instance.parameters.length_x = n | generic_unit_system.length
instance.parameters.length_y = n | generic_unit_system.length
instance.parameters.length_z = 0 | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.set_has_external_gravitational_potential(1)
instance.commit_parameters()
density = generic_unit_system.mass / (generic_unit_system.length ** 3)
momentum = generic_unit_system.mass / (generic_unit_system.time * (generic_unit_system.length**2))
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
potential_grid = datamodel.Grid(n + 2, n + 2, 1)
potential_grid.potential = 0.0 | generic_unit_system.potential
x = instance.potential_grid.x
y = instance.potential_grid.y
z = instance.potential_grid.z
potential_grid.potential = (1 | generic_unit_system.potential) * ((x + y) / (1 | generic_unit_system.length))
channel = potential_grid.new_channel_to(instance.potential_grid)
channel.copy()
result = instance.initialize_grid()
self.assertAlmostRelativeEquals(potential_grid.potential[..., 0, 0], instance.potential_grid.potential[..., 0, 0])
interpolated_inside = instance.get_interpolated_gravitational_potential(x[0, 0, 0], y[0, 0, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[0, 0, 0] - (1.0 | generic_unit_system.length), y[0, 0, 0], z[0, 0, 0])
print(interpolated_inside, interpolated_outside)
self.assertAlmostRelativeEquals(interpolated_inside, interpolated_outside)
interpolated_inside = instance.get_interpolated_gravitational_potential(x[0, 0, 0], y[0, 0, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[0, 0, 0], y[0, 0, 0] - (2.0 | generic_unit_system.length), z[0, 0, 0])
print(interpolated_inside, interpolated_outside)
self.assertAlmostRelativeEquals(interpolated_inside, interpolated_outside)
interpolated_inside = instance.get_interpolated_gravitational_potential(x[5, 0, 0], y[0, 0, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[5, 0, 0] + (2.0 | generic_unit_system.length), y[0, 0, 0], z[0, 0, 0])
print(interpolated_inside, interpolated_outside)
self.assertAlmostRelativeEquals(interpolated_inside, interpolated_outside)
interpolated_inside = instance.get_interpolated_gravitational_potential(x[5, 0, 0], y[0, 5, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[5, 0, 0], y[0, 5, 0] + (2.0 | generic_unit_system.length), z[0, 0, 0])
self.assertAlmostRelativeEquals(interpolated_inside, interpolated_outside)
interpolated_inside = instance.get_interpolated_gravitational_potential(x[0, 0, 0], y[0, 0, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[0, 0, 0] - (2.0 | generic_unit_system.length), y[0, 0, 0] - (2.0 | generic_unit_system.length), z[0, 0, 0])
print(interpolated_inside, interpolated_outside)
def test28(self):
n = 4
instance = self.new_instance(Athena)
instance.set_gamma(1.6666666666666667)
instance.set_courant_friedrichs_lewy_number(0.3)
instance.parameters.nx = n
instance.parameters.ny = n
instance.parameters.nz = 1
instance.parameters.length_x = n | generic_unit_system.length
instance.parameters.length_y = n | generic_unit_system.length
instance.parameters.length_z = 0 | generic_unit_system.length
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.set_has_external_gravitational_potential(1)
instance.commit_parameters()
density = generic_unit_system.mass / (generic_unit_system.length ** 3)
momentum = generic_unit_system.mass / (generic_unit_system.time * (generic_unit_system.length**2))
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
potential_grid = datamodel.Grid(n + 2, n + 2, 1)
potential_grid.potential = 0.0 | generic_unit_system.potential
x = instance.potential_grid.x
y = instance.potential_grid.y
z = instance.potential_grid.z
potential_grid.potential = (1 | generic_unit_system.potential) * ((x + y) / (1 | generic_unit_system.length))
channel = potential_grid.new_channel_to(instance.potential_grid)
channel.copy()
result = instance.initialize_grid()
self.assertAlmostRelativeEquals(potential_grid.potential[..., 0, 0], instance.potential_grid.potential[..., 0, 0])
interpolated_inside = instance.get_interpolated_gravitational_potential(x[0, 0, 0], y[0, 0, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[0, 0, 0] - (0.5 | generic_unit_system.length), y[0, 0, 0], z[0, 0, 0])
self.assertAlmostRelativeEquals(potential_grid.potential[..., 0, 0], instance.potential_grid.potential[..., 0, 0])
interpolated_inside = instance.get_interpolated_gravitational_potential(x[5, 0, 0], y[0, 0, 0], z[0, 0, 0])
interpolated_outside = instance.get_interpolated_gravitational_potential(x[5, 0, 0] + (0.5 | generic_unit_system.length), y[0, 0, 0], z[0, 0, 0])
print(interpolated_inside, interpolated_outside)
self.assertAlmostRelativeEquals(interpolated_inside, interpolated_outside)
def test29(self):
instance = self.new_instance(Athena)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (20.0, 1, 1) | generic_unit_system.length
instance.parameters.mesh_size = (20, 1, 1)
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = inmem.x/(1 | generic_unit_system.length) | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
print(inmem.rho)
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(0.5 | generic_unit_system.length, 0.0 | generic_unit_system.length, 0.0 | generic_unit_system.length)
self.assertEqual(rho, 0.5 | generic_unit_system.density)
for value in numpy.arange(0.5, 19.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_for_cell(
value | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length,
1.0 | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, value | generic_unit_system.density, 9)
for value in numpy.arange(0.0, 0.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_for_cell(
value | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length,
1.0 | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, ((0.5 + value) * 0.5 + (0.5-value) * 19.5) | generic_unit_system.density, 9)
for value in numpy.arange(0.0, 0.5, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_for_cell(
value + 19.5 | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length,
1.0 | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, (19.5 - (value * 19)) | generic_unit_system.density, 9)
# out of range
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_for_cell(
21.0 | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length,
1.0 | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, 0.0 | generic_unit_system.density, 9)
def test29(self):
instance = self.new_instance(Athena)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (20.0, 1, 1) | generic_unit_system.length
instance.parameters.mesh_size = (20, 1, 1)
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = inmem.x/(1 | generic_unit_system.length) | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
print(inmem.rho)
def test30(self):
instance = self.new_instance(Athena)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (8, 1, 1) | generic_unit_system.length
instance.parameters.mesh_size = (8, 1, 1)
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = inmem.x/(1 | generic_unit_system.length) | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
print(inmem.rho)
grid = instance.get_extended_grid()
self.assertEqual(grid.shape, (12, 1, 1))
instance.initialize_grid()
self.assertEqual(grid.rho[..., 0, 0], [6.5, 7.5, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 0.5, 1.5] | generic_unit_system.density)
| 125,247
| 44.511628
| 227
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_bhtree.py
|
# -*- coding: utf-8 -*-
from amuse.test.amusetest import TestWithMPI
import os
import sys
import numpy
import time
import math
from amuse.community.bhtree.interface import BHTreeInterface, BHTree
from amuse.support.exceptions import AmuseException
from amuse.units import constants
from amuse.units import nbody_system
from amuse.units import units
from amuse.units import quantities
from amuse import datamodel
from amuse.datamodel import particle_attributes
from amuse.ic import plummer
try:
from matplotlib import pyplot
HAS_MATPLOTLIB = True
except ImportError:
HAS_MATPLOTLIB = False
class TestBHTreeInterface(TestWithMPI):
def test0(self):
instance = BHTreeInterface()
self.assertTrue("Barnes" in instance.all_literature_references_string())
instance.stop()
def test1(self):
instance = BHTreeInterface()
instance.initialize_code()
instance.commit_parameters()
res1 = instance.new_particle(mass=11.0, radius=2.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
res2 = instance.new_particle(mass=21.0, radius=5.0, x=10.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
instance.commit_particles()
self.assertEqual(1, res1['index_of_the_particle'])
self.assertEqual(2, res2['index_of_the_particle'])
retrieved_state1 = instance.get_state(1)
retrieved_state2 = instance.get_state(2)
self.assertEqual(11.0, retrieved_state1['mass'])
self.assertEqual(21.0, retrieved_state2['mass'])
self.assertEqual(0.0, retrieved_state1['x'])
self.assertEqual(10.0, retrieved_state2['x'])
self.assertEqual(1, instance.get_index_of_first_particle()['index_of_the_particle'])
self.assertEqual(2, instance.get_index_of_next_particle(1)['index_of_the_next_particle'])
instance.cleanup_code()
instance.stop()
def test2(self):
instance = BHTreeInterface()
instance.initialize_code()
instance.commit_parameters()
for i in [1, 2, 3]:
temp_particle = instance.new_particle(mass=i, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
self.assertEqual(i, temp_particle['index_of_the_particle'])
instance.commit_particles()
self.assertEqual(1, instance.get_index_of_first_particle()['index_of_the_particle'])
self.assertEqual(2, instance.get_index_of_next_particle(1)['index_of_the_next_particle'])
self.assertEqual(3, instance.get_index_of_next_particle(2)['index_of_the_next_particle'])
instance.delete_particle(1)
self.assertEqual(2, instance.get_number_of_particles()['number_of_particles'])
# the deletion does a swap, so 3 is copied to 1, (overwriting old 1 and treesize -> treesize-1
self.assertEqual(3, instance.get_index_of_first_particle()['index_of_the_particle'])
self.assertEqual(1, instance.get_index_of_next_particle(2)['__result'])
instance.cleanup_code()
instance.stop()
def test5(self):
interface = BHTreeInterface()
interface.initialize_code()
interface.commit_parameters()
interface.new_particle([10, 20], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1])
interface.commit_particles()
retrieved_state = interface.get_state(1)
self.assertEqual(10.0, retrieved_state['mass'])
self.assertEqual(1, retrieved_state['radius'])
retrieved_state = interface.get_state([1, 2])
self.assertEqual(20.0, retrieved_state['mass'][1])
self.assertEqual(interface.get_number_of_particles()['number_of_particles'], 2)
interface.cleanup_code()
interface.stop()
def test6(self):
instance = BHTreeInterface()
instance.initialize_code()
instance.commit_parameters()
ids = []
for i in [1, 2, 3]:
id, error = instance.new_particle(mass=i, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
ids.append(id)
print(ids)
instance.commit_particles()
instance.delete_particle(ids[0])
id, error = instance.new_particle(mass=4, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
self.assertNotEqual(id, ids[-1])
instance.cleanup_code()
instance.stop()
def test7(self):
interface = BHTreeInterface() # channel_type="remote") #, debugger="xterm")
interface.initialize_code()
interface.commit_parameters()
interface.new_particle([10, 20], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1])
interface.commit_particles()
retrieved_state = interface.get_state(1)
self.assertEqual(10.0, retrieved_state['mass'])
self.assertEqual(1, retrieved_state['radius'])
retrieved_state = interface.get_state([1, 2])
self.assertEqual(20.0, retrieved_state['mass'][1])
self.assertEqual(interface.get_number_of_particles()['number_of_particles'], 2)
interface.cleanup_code()
interface.stop()
def test8(self):
instance = BHTreeInterface()
instance.initialize_code()
instance.set_epsilon_squared(0.1 * 0.1)
instance.commit_parameters()
id1, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
id2, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=2.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
instance.commit_particles()
potential, errorcode = instance.get_potential(id1)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -10.0 / numpy.sqrt(2.0**2 + 0.1**2), 8)
instance.cleanup_code()
instance.stop()
class TestBHTree(TestWithMPI):
def new_system_of_sun_and_earth(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
return stars
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = BHTree(convert_nbody)
instance.parameters.epsilon_squared = 0.001 | units.AU**2
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = [0.0, 0.0, 0.0] | units.m
sun.velocity = [0.0, 0.0, 0.0] | units.ms
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = [149.5e6, 0.0, 0.0] | units.km
earth.velocity = [0.0, 29800, 0.0] | units.ms
# instance.particles.add_particles(stars)
instance.particles.add_particles(stars)
postion_at_start = earth.position.value_in(units.AU)[0]
instance.evolve_model(365.0 | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
postion_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(postion_at_start, postion_after_full_rotation, 3)
instance.evolve_model(365.0 + (365.0 / 2) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
postion_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-postion_at_start, postion_after_half_a_rotation, 2)
instance.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
postion_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostEqual(-postion_at_start, postion_after_half_a_rotation, 1)
instance.cleanup_code()
instance.stop()
def test2(self):
# not completed
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = BHTree(convert_nbody)
# instance.dt_dia = 1
instance.parameters.epsilon_squared = 0.001 | units.AU**2
# instance.timestep = 0.0001
# instance.use_self_gravity = 0
instance.commit_parameters()
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertAlmostRelativeEquals(sun.radius, instance.particles[0].radius)
for x in range(1, 2000, 10):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
if HAS_MATPLOTLIB:
figure = pyplot.figure()
plot = figure.add_subplot(1, 1, 1)
x_points = earth.get_timeline_of_attribute("x")
y_points = earth.get_timeline_of_attribute("y")
x_points_in_AU = [t_x[1].value_in(units.AU) for t_x in x_points]
y_points_in_AU = [t_x1[1].value_in(units.AU) for t_x1 in y_points]
plot.scatter(x_points_in_AU, y_points_in_AU, color="b", marker='o')
plot.set_xlim(-1.5, 1.5)
plot.set_ylim(-1.5, 1.5)
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "bhtree-earth-sun.svg")
figure.savefig(output_file)
instance.cleanup_code()
instance.stop()
def test3(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = BHTree(convert_nbody)
# instance.dt_dia = 1
instance.parameters.epsilon_squared = 0.001 | units.AU**2
# instance.timestep = 0.0001
# instance.use_self_gravity = 0
instance.commit_parameters()
stars = datamodel.Stars(2)
star1 = stars[0]
star2 = stars[1]
star1.mass = units.MSun(1.0)
star1.position = units.AU(numpy.array((-.10, 0.0, 0.0)))
star1.velocity = units.AUd(numpy.array((0.0, 0.0, 0.0)))
star1.radius = units.RSun(1.0)
star2.mass = units.MSun(1.0)
star2.position = units.AU(numpy.array((.10, 0.0, 0.0)))
star2.velocity = units.AUd(numpy.array((0.0, 0.0, 0.0)))
star2.radius = units.RSun(100.0)
instance.particles.add_particles(stars)
instance.commit_particles()
for x in range(1, 200, 1):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
# instance.get_indices_of_colliding_particles()
# print stars[0].position-stars[1].position
stars.savepoint()
instance.cleanup_code()
instance.stop()
def test4(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = BHTree(convert_nbody)
instance.commit_parameters()
index = instance.new_particle(
15.0 | units.kg,
10.0 | units.m, 20.0 | units.m, 30.0 | units.m,
# 1.0 | units.m/units.s, 1.0 | units.m/units.s, 3.0 | units.m/units.s
0.0 | units.m/units.s, 0.0 | units.m/units.s, 0.0 | units.m/units.s,
10.0 | units.m
)
instance.commit_particles()
self.assertEqual(instance.get_mass(index), 15.0 | units.kg)
self.assertEqual(instance.get_radius(index), 10.0 | units.m)
instance.cleanup_code()
instance.stop()
def test5(self):
instance = BHTree()
instance.commit_parameters()
index = instance.new_particle(
15.0 | nbody_system.mass,
10.0 | nbody_system.length, 20.0 | nbody_system.length, 30.0 | nbody_system.length,
1.0 | nbody_system.speed, 1.0 | nbody_system.speed, 3.0 | nbody_system.speed,
10.0 | nbody_system.length
)
instance.commit_particles()
self.assertEqual(instance.get_mass(index), 15.0 | nbody_system.mass)
self.assertEqual(instance.get_radius(index), 10.0 | nbody_system.length)
instance.cleanup_code()
instance.stop()
def test6(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = BHTree(convert_nbody)
instance.commit_parameters()
indices = instance.new_particle(
[15.0, 30.0] | units.kg,
[10.0, 20.0] | units.m, [20.0, 40.0] | units.m, [30.0, 50.0] | units.m,
# 1.0 | units.m/units.s, 1.0 | units.m/units.s, 3.0 | units.m/units.s
[0.0, 0.01] | units.m/units.s, [0.0, 0.01] | units.m/units.s, [0.0, 0.01] | units.m/units.s,
[10.0, 20.0] | units.m
)
instance.commit_particles()
self.assertEqual(instance.get_mass(indices[0]), 15.0 | units.kg)
self.assertEqual(instance.get_mass(indices)[0], 15.0 | units.kg)
self.assertRaises(AmuseException, instance.get_mass, [4, 5],
expected_message="Error when calling 'get_mass' of a '<class 'amuse.community.bhtree.interface.BHTree'>', errorcode is -1")
instance.cleanup_code()
instance.stop()
def test7(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = BHTree(convert_nbody)
instance.commit_parameters()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(instance.get_mass(1), 15.0 | units.kg)
self.assertAlmostRelativeEquals(instance.get_position(1)[2], 30.0 | units.m)
self.assertEqual(len(instance.particles), 2)
self.assertAlmostRelativeEquals(instance.particles.mass[1], 30.0 | units.kg)
self.assertAlmostRelativeEquals(instance.particles.position[1][2], 60.0 | units.m)
instance.cleanup_code()
instance.stop()
def test8(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = BHTree(convert_nbody)
instance.commit_parameters()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
instance.commit_particles()
instance.particles.mass = [17.0, 33.0] | units.kg
self.assertEqual(instance.get_mass(1), 17.0 | units.kg)
instance.cleanup_code()
instance.stop()
def test9(self):
instance = BHTree()
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00001 | nbody_system.length**2
particles = datamodel.Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, 1.0 | nbody_system.length, zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration, 3)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fx0, -1.0 * fx1, 5)
fx = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0, 2)
self.assertAlmostEqual(potential0, potential1, 5)
instance.cleanup_code()
instance.stop()
def test10(self):
instance = BHTree()
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00001 | nbody_system.length**2
instance.commit_parameters()
particles = datamodel.Particles(6)
particles.mass = 1.0 | nbody_system.mass
particles.radius = 0.00001 | nbody_system.length
particles.position = [[-1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, -1.0], [0.0, 0.0, 1.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
instance.commit_particles()
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, zero, zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration, 3)
for position in (0.25, 0.5, 0.75):
p0 = position | nbody_system.length
p1 = -position | nbody_system.length
for i in range(3):
args0 = [zero] * 4
args1 = [zero] * 4
args0[1 + i] = p0
args1[1 + i] = p1
f0 = instance.get_gravity_at_point(*args0)
f1 = instance.get_gravity_at_point(*args1)
for j in range(3):
if j != i:
self.assertAlmostEqual(f0[j], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(f1[j], 0.0 | nbody_system.acceleration, 3)
else:
self.assertAlmostEqual(f0[j], -1.0 * f1[j], 5)
instance.stop()
def test11(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = BHTree(convert_nbody)
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
copyof = instance.particles.copy()
self.assertAlmostEqual(30 | units.kg, copyof[1].mass, 6)
copyof[1].mass = 35 | units.kg
copyof.copy_values_of_all_attributes_to(instance.particles)
self.assertAlmostEqual(35 | units.kg, instance.particles[1].mass, 6)
instance.stop()
def test12(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = BHTree(convert_nbody)
instance.commit_parameters()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
instance.commit_particles()
copyof = instance.particles.copy()
instance.set_state(1, 16 | units.kg, 20.0 | units.m, 40.0 | units.m, 60.0 | units.m,
1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms)
curr_state = instance.get_state(1)
for expected, actual in zip((16 | units.kg, 20.0 | units.m, 40.0 | units.m, 60.0 | units.m,
1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms, 0 | units.m), curr_state):
self.assertAlmostRelativeEquals(actual, expected)
instance.set_state(1, 16 | units.kg, 20.0 | units.m, 40.0 | units.m, 60.0 | units.m,
1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms, 20.0 | units.m)
curr_state = instance.get_state(1)
for expected, actual in zip((16 | units.kg, 20.0 | units.m, 40.0 | units.m, 60.0 | units.m,
1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms, 20 | units.m), curr_state):
self.assertAlmostRelativeEquals(actual, expected)
instance.stop()
def test13(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.m)
instance = BHTree(convert_nbody)
instance.commit_parameters()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [30.0, 30.0] | units.kg
particles.radius = [1.0, 1.0] | units.m
particles.position = [[-10.0, 0.0, 0.0], [10.0, 0.0, 0.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
instance.commit_particles()
copyof = instance.particles.copy()
com = instance.center_of_mass_position
self.assertAlmostEqual(com[0], quantities.new_quantity(0.0, units.m), constants.precision)
instance.stop()
def test14(self):
print("Test14: Testing BHTree parameters (I)")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.yr, 1.0 | units.AU)
instance = BHTree(convert_nbody)
value, error = instance.legacy_interface.get_epsilon_squared()
self.assertEqual(0, error)
self.assertEqual(0.125, value)
self.assertAlmostEqual(0.125 | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2)
for x in [0.01, 0.1, 0.2]:
instance.parameters.epsilon_squared = x | units.AU**2
self.assertAlmostEqual(x | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2)
(value, error) = instance.legacy_interface.get_time_step()
self.assertEqual(0, error)
self.assertEqual(0.015625, value)
self.assertAlmostEqual(0.015625 | units.yr, instance.parameters.timestep, in_units=units.yr)
for x in [0.001, 0.01, 0.1]:
instance.parameters.timestep = x | units.yr
self.assertAlmostEqual(x | units.yr, instance.parameters.timestep, in_units=units.yr)
(value, error) = instance.legacy_interface.get_theta_for_tree()
self.assertEqual(0, error)
self.assertEqual(0.75, value)
self.assertEqual(0.75, instance.parameters.opening_angle)
for x in [0.2, 0.5, 0.7]:
instance.parameters.opening_angle = x
self.assertEqual(x, instance.parameters.opening_angle)
(value, error) = instance.legacy_interface.get_use_self_gravity()
self.assertEqual(0, error)
self.assertEqual(1, value)
self.assertEqual(1, instance.parameters.use_self_gravity)
for x in [0, 1]:
instance.parameters.use_self_gravity = x
self.assertEqual(x, instance.parameters.use_self_gravity)
(value, error) = instance.legacy_interface.get_ncrit_for_tree()
self.assertEqual(0, error)
self.assertEqual(12, value)
self.assertEqual(12, instance.parameters.ncrit_for_tree)
for x in [512, 2048, 4096]:
instance.parameters.ncrit_for_tree = x
self.assertEqual(x, instance.parameters.ncrit_for_tree)
(value, error) = instance.legacy_interface.get_dt_dia()
self.assertEqual(0, error)
self.assertEqual(1.0, value)
self.assertAlmostEqual(1.0 | units.yr, instance.parameters.dt_dia, in_units=units.yr)
for x in [0.1, 10.0, 100.0]:
instance.parameters.dt_dia = x | units.yr
self.assertAlmostEqual(x | units.yr, instance.parameters.dt_dia, in_units=units.yr)
instance.stop()
def test15(self):
print("Test15: Testing effect of BHTree parameter epsilon_squared")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
particles = datamodel.Particles(2)
sun = particles[0]
sun.mass = 1.0 | units.MSun
sun.position = [0.0, 0.0, 0.0] | units.AU
sun.velocity = [0.0, 0.0, 0.0] | units.AU / units.yr
sun.radius = 1.0 | units.RSun
earth = particles[1]
earth.mass = 5.9736e24 | units.kg
earth.radius = 6371.0 | units.km
earth.position = [0.0, 1.0, 0.0] | units.AU
earth.velocity = [2.0*numpy.pi, -0.0001, 0.0] | units.AU / units.yr
initial_direction = math.atan((earth.velocity[0]/earth.velocity[1]))
final_direction = []
for log_eps2 in range(-9, 10, 2):
instance = BHTree(convert_nbody)
instance.initialize_code()
instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU ** 2
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.25 | units.yr)
final_direction.append(math.atan((instance.particles[1].velocity[0] /
instance.particles[1].velocity[1])))
instance.stop()
# Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees
self.assertAlmostEqual(abs(final_direction[0]), abs(initial_direction+math.pi/2.0), 2)
# Large values of epsilon_squared should result in ~ no interaction
self.assertAlmostEqual(final_direction[-1], initial_direction, 2)
# Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2
delta = [abs(final_direction[i+1]-final_direction[i]) for i in range(len(final_direction)-1)]
self.assertEqual(delta[len(final_direction)//2 - 1], max(delta))
def test16(self):
numpy.random.seed(0)
number_of_stars = 2
stars = plummer.new_plummer_model(number_of_stars)
stars.radius = 0.00001 | nbody_system.length
stars.scale_to_standard()
instance = BHTree()
instance.initialize_code()
instance.parameters.epsilon_squared = (1.0 / 20.0 / (number_of_stars**0.33333) | nbody_system.length)**2
instance.parameters.timestep = 0.004 | nbody_system.time
instance.parameters.timestep = 0.00001 | nbody_system.time
instance.commit_parameters()
print(instance.parameters.timestep)
instance.particles.add_particles(stars)
instance.commit_particles()
energy_total_t0 = instance.potential_energy + instance.kinetic_energy
request = instance.evolve_model.asynchronous(1.0 | nbody_system.time)
request.result()
energy_total_t1 = instance.potential_energy + instance.kinetic_energy
self.assertAlmostRelativeEqual(energy_total_t0, energy_total_t1, 3)
instance.stop()
numpy.random.seed()
def test17(self):
print("Testing BHTree collision_detection")
particles = datamodel.Particles(7)
particles.mass = 0.001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = BHTree(redirection='none')
instance.initialize_code()
instance.parameters.set_defaults()
# Uncommenting any of the following two lines will suppress collision detection
# ~ instance.parameters.use_self_gravity = 0
# ~ instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
instance.parameters.opening_angle = 0.1
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 3)
self.assertEqual(len(collisions.particles(1)), 3)
self.assertEqual(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = datamodel.Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print(instance.model_time)
print(instance.particles)
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print()
print(instance.model_time)
print(instance.particles)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test18(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
instance = BHTree()
instance.initialize_code()
instance.parameters.stopping_conditions_number_of_steps = 2
self.assertEqual(instance.parameters.stopping_conditions_number_of_steps, 2)
instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2
instance.particles.add_particles(particles)
instance.stopping_conditions.number_of_steps_detection.enable()
instance.evolve_model(10 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
self.assertTrue(instance.model_time < 10 | nbody_system.time)
instance.stop()
def test19(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0.0 | nbody_system.length
particles.z = 0.0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0.0 | nbody_system.speed
particles.vy = 0.0 | nbody_system.speed
particles.vz = 0.0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
very_short_time_to_evolve = 1 | units.s
very_long_time_to_evolve = 1e9 | nbody_system.time
instance = BHTree()
instance.initialize_code()
instance.parameters.stopping_conditions_timeout = very_short_time_to_evolve
self.assertEqual(instance.parameters.stopping_conditions_timeout, very_short_time_to_evolve)
instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2
instance.particles.add_particles(particles)
instance.stopping_conditions.timeout_detection.enable()
start = time.time()
instance.evolve_model(very_long_time_to_evolve)
end = time.time()
self.assertTrue(instance.stopping_conditions.timeout_detection.is_set())
self.assertTrue((end-start) < very_short_time_to_evolve.value_in(units.s) + 2) # 2 = some overhead compensation
instance.stop()
def test20(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0.0 | nbody_system.length
particles.z = 0.0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0.0 | nbody_system.speed
particles.vy = 0.0 | nbody_system.speed
particles.vz = 0.0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
very_short_time_to_evolve = 1 | units.s
very_long_time_to_evolve = 1e9 | nbody_system.time
instance = BHTree()
instance.initialize_code()
instance.parameters.stopping_conditions_timeout = very_short_time_to_evolve
self.assertEqual(instance.parameters.stopping_conditions_timeout, very_short_time_to_evolve)
instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2
instance.particles.add_particles(particles)
codeparticles1 = instance.particles
instance.particles.add_particle(datamodel.Particle(
position=[0, 1, 2] | nbody_system.length,
velocity=[0, 0, 0] | nbody_system.speed,
radius=0.005 | nbody_system.length,
mass=1 | nbody_system.mass
))
codeparticles2 = instance.particles
self.assertTrue(codeparticles1 is codeparticles2)
instance.cleanup_code()
codeparticles3 = instance.particles
self.assertFalse(codeparticles1 is codeparticles3)
instance.stop()
def test21(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0.0 | nbody_system.length
particles.z = 0.0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0.0 | nbody_system.speed
particles.vy = 0.0 | nbody_system.speed
particles.vz = 0.0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
very_short_time_to_evolve = 1 | units.s
very_long_time_to_evolve = 1e9 | nbody_system.time
instance = BHTree()
instance.initialize_code()
instance.parameters.epsilon_squared = (1e-5 | nbody_system.length)**2
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertAlmostRelativeEquals(instance.potential_energy, -0.1 | nbody_system.energy, 5)
instance.stop()
def test22(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0.0 | nbody_system.length
particles.z = 0.0 | nbody_system.length
particles.vx = 0.0 | nbody_system.speed
particles.vy = 0.0 | nbody_system.speed
particles.vz = 0.0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
instance = BHTree()
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(instance.particles[0].radius, 0.0 | nbody_system.length)
p = datamodel.Particle(
x=1.0 | nbody_system.length,
y=2.0 | nbody_system.length,
z=3.0 | nbody_system.length,
vx=1.0 | nbody_system.speed,
vy=2.0 | nbody_system.speed,
vz=3.0 | nbody_system.speed,
mass=1.0 | nbody_system.mass,
radius=4.0 | nbody_system.length,
)
instance.particles.add_particle(p)
self.assertEqual(instance.particles[0].radius, 0.0 | nbody_system.length)
self.assertEqual(instance.particles[1].radius, 0.0 | nbody_system.length)
self.assertEqual(instance.particles[2].radius, 4.0 | nbody_system.length)
instance.stop()
def test23(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0.0 | nbody_system.length
particles.z = 0.0 | nbody_system.length
particles.vx = 1.0 | nbody_system.speed
particles.vy = 0.0 | nbody_system.speed
particles.vz = 0.0 | nbody_system.speed
particles.mass = 0.1 | nbody_system.mass
instance = BHTree(redirection="none")
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.1 | nbody_system.time)
self.assertFalse(instance.particles[0].vy > 0 | nbody_system.speed)
self.assertAlmostRelativeEquals(instance.particles[0].x, 0.1 | nbody_system.length, 4)
instance.particles.new_channel_to(particles).copy()
particles.vy = 1 | nbody_system.speed
particles.new_channel_to(instance.particles).copy()
instance.evolve_model(0.2 | nbody_system.time)
self.assertTrue(instance.particles[0].vy > 0 | nbody_system.speed)
self.assertAlmostRelativeEquals(instance.particles[0].y, 0.1 | nbody_system.length, 4)
instance.stop()
| 39,059
| 41
| 156
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_particle_attributes.py
|
import random
import numpy.random
import sys
from amuse.test import amusetest
from amuse.units import units
from amuse.units import constants
from amuse.units import nbody_system
from amuse.support.interface import ConvertArgumentsException
from amuse.ic.plummer import new_plummer_sphere
from amuse.ic.salpeter import new_salpeter_mass_distribution_nbody
from amuse.datamodel import Particle, Particles, ParticlesWithUnitsConverted
from amuse.datamodel import particle_attributes
class TestParticlesAttributes(amusetest.TestCase):
def test3(self):
print("Test new_particle_from_cluster_core - nbody units")
numpy.random.seed(123)
plummer = new_plummer_sphere(10000)
result = plummer.new_particle_from_cluster_core(density_weighting_power=1, reuse_hop=True)
self.assertTrue(isinstance(result, Particle))
# Casertano & Hut (1985, ApJ, 298, 80): density weighted core radius = 0.6791 * r_plummer
plummer_radius = 3 * constants.pi / 16.0 | nbody_system.length
self.assertAlmostRelativeEqual(result.radius, 0.6791 * plummer_radius, 2)
self.assertAlmostEqual(result.position, [0.0, 0.0, 0.0] | nbody_system.length, 1)
self.assertAlmostEqual(result.velocity, [0.0, 0.0, 0.0] | nbody_system.speed, 1)
self.assertAlmostEqual(result.density, 3.55015420914 | nbody_system.density)
plummer.vx += 42 | nbody_system.speed
plummer.vy += (1 - plummer.y / abs(plummer.y).amax()) * (13 | nbody_system.speed)
plummer.position *= 0.1
plummer.position += [1.0, 2.0, 3.0] | nbody_system.length
result = plummer.new_particle_from_cluster_core(density_weighting_power=1, reuse_hop=False)
self.assertTrue(isinstance(result, Particle))
self.assertAlmostRelativeEqual(result.radius, 0.06791 * plummer_radius, 2)
self.assertAlmostEqual(result.position, [1.0, 2.0, 3.0] | nbody_system.length, 1)
self.assertAlmostEqual(result.velocity, [42.0, 13.0, 0.0] | nbody_system.speed, 1)
self.assertAlmostRelativeEqual(result.density, 3.55015420914e3 | nbody_system.density, 4)
def test4(self):
print("Test new_particle_from_cluster_core - SI units")
numpy.random.seed(123)
converter = nbody_system.nbody_to_si(1000.0 | units.MSun, 1.0 | units.parsec)
plummer = new_plummer_sphere(10000, convert_nbody=converter)
result = plummer.new_particle_from_cluster_core(unit_converter=converter, density_weighting_power=1, reuse_hop=True)
self.assertTrue(isinstance(result, Particle))
# Casertano & Hut (1985, ApJ, 298, 80): density weighted core radius = 0.6791 * r_plummer
plummer_radius = 3 * constants.pi / 16.0 | units.parsec
self.assertAlmostRelativeEqual(result.radius, 0.6791 * plummer_radius, 2)
self.assertAlmostEqual(result.position, [0.0, 0.0, 0.0] | units.parsec, 1)
self.assertAlmostEqual(result.velocity, [0.0, 0.0, 0.0] | units.km / units.s, 1)
self.assertAlmostEqual(result.density, 3.55015420914e3 | units.MSun * units.parsec**-3)
plummer.vx += 42 | units.km / units.s
plummer.vy += (1 - plummer.y / abs(plummer.y).amax()) * (13 | units.km / units.s)
plummer.position *= 0.1
plummer.position += [1.0, 2.0, 3.0] | units.parsec
result = plummer.new_particle_from_cluster_core(unit_converter=converter, density_weighting_power=1, reuse_hop=False)
self.assertTrue(isinstance(result, Particle))
self.assertAlmostRelativeEqual(result.radius, 0.06791 * plummer_radius, 2)
self.assertAlmostEqual(result.position, [1.0, 2.0, 3.0] | units.parsec, 1)
self.assertAlmostEqual(result.velocity, [42.0, 13.0, 0.0] | units.km / units.s, 1)
self.assertAlmostRelativeEqual(result.density, 3.55015420914e6 | units.MSun * units.parsec**-3, 4)
def test5(self):
print("Test new_particle_from_cluster_core - reuse_hop or not")
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.parsec)
plummer = new_plummer_sphere(100, convert_nbody=converter)
result = plummer.new_particle_from_cluster_core(unit_converter=converter, reuse_hop=True)
# Hop wasn't stopped, will use same Hop instance:
result = plummer.new_particle_from_cluster_core(unit_converter=converter, reuse_hop=True)
nbody_plummer = new_plummer_sphere(100)
# Hop wasn't stopped, unit_converters don't match:
self.assertRaises(AttributeError, nbody_plummer.new_particle_from_cluster_core,
expected_message="Cannot combine units from different systems: m and length")
result = plummer.new_particle_from_cluster_core(unit_converter=converter, reuse_hop=False)
# Hop was stopped, new instance will be made with supplied unit_converter (None in this case):
result = nbody_plummer.new_particle_from_cluster_core(reuse_hop=True)
self.assertRaises(ConvertArgumentsException, plummer.new_particle_from_cluster_core, unit_converter=converter, # ,
expected_message="error while converting parameter 'mass', error: Cannot express kg in mass, the units do not have the same bases")
result = nbody_plummer.new_particle_from_cluster_core(reuse_hop=False)
result = plummer.new_particle_from_cluster_core(unit_converter=converter, reuse_hop=False)
def test6(self):
print("Test all particle attributes using Hop - each different function creates its own instance of Hop")
numpy.random.seed(123)
nbody_plummer = new_plummer_sphere(100)
nbody_plummer.mass = new_salpeter_mass_distribution_nbody(100)
# Each different function creates its own instance of Hop
result = nbody_plummer.new_particle_from_cluster_core(reuse_hop=True)
result = nbody_plummer.bound_subset(G=nbody_system.G, reuse_hop=True)
result = nbody_plummer.mass_segregation_Gini_coefficient(reuse_hop=True)
result = nbody_plummer.LagrangianRadii(reuse_hop=True)
result = nbody_plummer.densitycentre_coreradius_coredens(reuse_hop=True)
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.parsec)
si_plummer = ParticlesWithUnitsConverted(nbody_plummer, converter.as_converter_from_si_to_nbody())
functions_using_hop = [
si_plummer.new_particle_from_cluster_core,
si_plummer.bound_subset,
si_plummer.mass_segregation_Gini_coefficient,
si_plummer.LagrangianRadii,
si_plummer.densitycentre_coreradius_coredens
]
# Each fails since the Hop instance it tries to reuse has a different unit_converter
for function_using_hop in functions_using_hop:
self.assertRaises(Exception, function_using_hop, unit_converter=converter)
# expected_message="error while converting parameter 'mass', error: Cannot express kg in mass, the units do not have the same bases (note: check whether Hop needs a converter here)")
# Close all Hop instances:
nbody_results = []
nbody_results.append(nbody_plummer.new_particle_from_cluster_core(reuse_hop=False))
nbody_results.append(nbody_plummer.bound_subset(G=nbody_system.G, reuse_hop=False))
nbody_results.append(nbody_plummer.mass_segregation_Gini_coefficient(reuse_hop=False))
nbody_results.append(nbody_plummer.LagrangianRadii(reuse_hop=False))
nbody_results.append(nbody_plummer.densitycentre_coreradius_coredens(reuse_hop=False))
# Now it works, because the Hop instances were closed, and new ones will be instantiated
si_results = []
for function_using_hop in functions_using_hop:
si_results.append(function_using_hop(unit_converter=converter))
convert = converter.as_converter_from_si_to_nbody()
self.assertAlmostRelativeEqual(si_results[0].position,
ParticlesWithUnitsConverted(nbody_results[0].as_set(), convert)[0].position)
self.assertAlmostRelativeEqual(si_results[1].position,
ParticlesWithUnitsConverted(nbody_results[1], convert).position)
self.assertAlmostRelativeEqual(si_results[2], nbody_results[2], places=10)
self.assertAlmostRelativeEqual(si_results[3][0], convert.from_target_to_source(nbody_results[3][0]), places=10)
for in_si, in_nbody in zip(si_results[4], nbody_results[4]):
self.assertAlmostRelativeEqual(in_si, convert.from_target_to_source(in_nbody), places=10)
| 8,517
| 56.945578
| 197
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_rebound.py
|
from amuse.community import *
from amuse.test.amusetest import TestWithMPI
from amuse.community.rebound.interface import ReboundInterface
from amuse.community.rebound.interface import Rebound
import math
try:
from matplotlib import pyplot
HAS_MATPLOTLIB = True
except ImportError:
HAS_MATPLOTLIB = False
class ReboundInterfaceTests(TestWithMPI):
def test1(self):
instance = self.new_instance_of_an_optional_code(ReboundInterface)
instance.initialize_code()
res1, error = instance.new_particle(mass=11.0, radius=2.0, x=1.0, y=2.0, z=3.0, vx=4.0, vy=5.0, vz=6.0)
res2, error = instance.new_particle(mass=21.0, radius=5.0, x=10.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
self.assertEqual(error, 0)
self.assertEqual(res1, 0)
self.assertEqual(res2, 1)
m1, error = instance.get_mass(res1)
self.assertEqual(error, 0)
self.assertEqual(m1, 11)
m2, error = instance.get_mass(res2)
self.assertEqual(error, 0)
self.assertEqual(m2, 21)
x, y, z, error = instance.get_position(res1)
self.assertEqual(error, 0)
self.assertEqual(x, 1)
self.assertEqual(y, 2)
self.assertEqual(z, 3)
vx, vy, vz, error = instance.get_velocity(res1)
self.assertEqual(error, 0)
self.assertEqual(vx, 4)
self.assertEqual(vy, 5)
self.assertEqual(vz, 6)
instance.cleanup_code()
instance.stop()
def test2(self):
instance = self.new_instance_of_an_optional_code(ReboundInterface)
instance.initialize_code()
instance.new_particle([10, 20], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1])
retrieved_state = instance.get_state(0)
self.assertEqual(10.0, retrieved_state['mass'])
retrieved_state = instance.get_state([0, 1])
self.assertEqual(10.0, retrieved_state['mass'][0])
self.assertEqual(20.0, retrieved_state['mass'][1])
instance.cleanup_code()
instance.stop()
def test3(self):
instance = self.new_instance_of_an_optional_code(ReboundInterface)
instance.initialize_code()
indices, error = instance.new_particle([10, 20, 30], [1, 2, 3], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [1, 0, 1])
n, error = instance.get_number_of_particles()
self.assertEqual(n, 3)
error = instance.delete_particle(indices[1])
n, error = instance.get_number_of_particles()
self.assertEqual(n, 2)
instance.commit_particles()
retrieved_state = instance.get_state([0, 2])
self.assertEqual(10.0, retrieved_state['mass'][0])
self.assertEqual(30.0, retrieved_state['mass'][1])
mass, error = instance.get_mass(1)
self.assertEqual(error, -1)
instance.cleanup_code()
instance.stop()
def test4(self):
instance = self.new_instance_of_an_optional_code(ReboundInterface)
instance.initialize_code()
error = 0
integrator = instance.get_integrator()
self.assertEqual(error, 0)
self.assertEqual("ias15", integrator)
error = instance.set_integrator("whfast")
self.assertEqual(error, 0)
integrator = instance.get_integrator()
self.assertEqual(error, 0)
self.assertEqual("whfast", integrator)
instance.cleanup_code()
instance.stop()
def test5(self):
instance = self.new_instance_of_an_optional_code(ReboundInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
# Set up an equal-mass binary on a circular orbit:
self.assertEqual([0, 0], list(instance.new_particle(0.5, 0.5, 0, 0, 0, 0.5, 0, 0.01).values()))
self.assertEqual([1, 0], list(instance.new_particle(0.5, -0.5, 0, 0, 0, -0.5, 0, 0.01).values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(math.pi))
for result, expected in zip(list(instance.get_position(0).values()), [-0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
for result, expected in zip(list(instance.get_position(1).values()), [0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
self.assertEqual(0, instance.evolve_model(2 * math.pi))
for result, expected in zip(list(instance.get_position(0).values()), [0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
for result, expected in zip(list(instance.get_position(1).values()), [-0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 3)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test6(self):
instance = self.new_instance_of_an_optional_code(ReboundInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
index, err = instance.new_particle(0.5, 0.5, 0, 0, 0, 0.5, 0, 0.01, 1)
self.assertEqual(-10, err)
instance.cleanup_code()
instance.stop()
def test7(self):
instance = self.new_instance_of_an_optional_code(ReboundInterface)
instance.initialize_code()
instance.set_eps2(0.1 * 0.1)
eps2 = instance.get_eps2()['epsilon_squared']
self.assertEqual(0.1 * 0.1, eps2)
instance.cleanup_code()
instance.stop()
def test8(self):
instance = self.new_instance_of_an_optional_code(ReboundInterface)
instance.initialize_code()
instance.set_boundary("none")
boundary_type = instance.get_boundary()
self.assertEqual("none", boundary_type)
instance.set_boundary("periodic")
boundary_type = instance.get_boundary()
self.assertEqual("periodic", boundary_type)
instance.set_boundary_size(42.1)
boundary_size = instance.get_boundary_size()['boundary_size']
self.assertEqual(42.1, boundary_size)
instance.cleanup_code()
instance.stop()
class TestRebound(TestWithMPI):
def new_system_of_sun_and_earth(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
return stars
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
interface = self.new_instance_of_an_optional_code(Rebound, convert_nbody)
interface.initialize_code()
interface.parameters.epsilon_squared = 0.0 | units.AU**2
interface.dt_dia = 5000
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
interface.particles.add_particles(stars)
interface.evolve_model(365.0 | units.day)
interface.particles.copy_values_of_all_attributes_to(stars)
position_at_start = earth.position.value_in(units.AU)[0]
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostRelativeEqual(position_at_start, position_after_full_rotation, 6)
interface.evolve_model(365.0 + (365.0 / 2) | units.day)
self.assertAlmostRelativeEqual(interface.model_time, 365.0 + (365.0 / 2) | units.day, 3)
interface.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostRelativeEqual(-position_at_start, position_after_half_a_rotation, 3)
interface.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
self.assertAlmostRelativeEqual(interface.model_time, 365.0 + (365.0 / 2) + (365.0 / 4) | units.day, 3)
interface.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostRelativeEqual(-position_at_start, position_after_half_a_rotation, 3)
interface.cleanup_code()
interface.stop()
def test2(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = self.new_instance_of_an_optional_code(Rebound, convert_nbody)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | units.AU**2
instance.dt_dia = 5000
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
for x in range(1, 500, 10):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
if HAS_MATPLOTLIB:
figure = pyplot.figure()
plot = figure.add_subplot(1, 1, 1)
x_points = earth.get_timeline_of_attribute("x")
y_points = earth.get_timeline_of_attribute("y")
x_points_in_AU = [t_x[1].value_in(units.AU) for t_x in x_points]
y_points_in_AU = [t_x1[1].value_in(units.AU) for t_x1 in y_points]
plot.scatter(x_points_in_AU, y_points_in_AU, color="b", marker='o')
plot.set_xlim(-1.5, 1.5)
plot.set_ylim(-1.5, 1.5)
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "rebound-earth-sun2.svg")
figure.savefig(output_file)
instance.cleanup_code()
instance.stop()
def test3(self):
particles = datamodel.Particles(7)
particles.mass = 0.001 | nbody_system.mass
particles.radius = 0.1 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = self.new_instance_of_an_optional_code(Rebound)
instance.initialize_code()
instance.parameters.set_defaults()
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
print(instance.particles)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 3)
self.assertEqual(len(collisions.particles(1)), 3)
self.assertEqual(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <=
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = datamodel.Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print(instance.model_time)
print(instance.particles)
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
print(instance.particles)
instance.evolve_model(1.0 | nbody_system.time)
print()
print(instance.model_time)
print(instance.particles)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <=
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test4(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = self.new_instance_of_an_optional_code(Rebound, convert_nbody)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | units.AU**2
instance.dt_dia = 5000
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
self.assertAlmostRelativeEquals(instance.kinetic_energy, stars.kinetic_energy())
self.assertAlmostRelativeEquals(instance.potential_energy, stars.potential_energy(), 10)
instance.stop()
def test5(self):
instance = self.new_instance_of_an_optional_code(Rebound)
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles = datamodel.Particles(2)
particles.position = ([0, 0, 0], [1, 0, 0]) | nbody_system.length
particles.velocity = ([-1, 0, 0], [2, 0, 0]) | nbody_system.speed
particles.radius = 0 | nbody_system.length
particles.mass = 0.1 | nbody_system.mass
instance.particles.add_particles(particles)
instance.stopping_conditions.out_of_box_detection.enable()
instance.parameters.stopping_conditions_out_of_box_size = 2 | nbody_system.length
instance.parameters.stopping_conditions_out_of_box_use_center_of_mass = False
instance.evolve_model(1 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.out_of_box_detection.is_set())
self.assertEqual(len(instance.stopping_conditions.out_of_box_detection.particles(0)), 1)
self.assertEqual(instance.stopping_conditions.out_of_box_detection.particles(0)[0].key, particles[1].key)
instance.stop()
def test6(self):
instance = self.new_instance_of_an_optional_code(Rebound)
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles = datamodel.Particles(2)
particles.position = ([0, 0, 0], [1, 0, 0]) | nbody_system.length
particles.velocity = ([-1, 0, 0], [2, 0, 0]) | nbody_system.speed
particles.radius = 0 | nbody_system.length
particles.mass = 0.1 | nbody_system.mass
instance.particles.add_particles(particles)
self.assertAlmostRelativeEquals(instance.kinetic_energy, particles.kinetic_energy())
self.assertAlmostRelativeEquals(instance.potential_energy, particles.potential_energy(G=nbody_system.G))
instance.stop()
def test7(self):
instance = self.new_instance_of_an_optional_code(Rebound)
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
subset0 = 0
subset1 = instance.new_subset()
print(subset1)
self.assertEqual(subset1, 1)
particles = datamodel.Particles(2)
particles.position = ([0, 0, 0], [1, 0, 0]) | nbody_system.length
particles.velocity = ([-1, 0, 0], [2, 0, 0]) | nbody_system.speed
particles.radius = 0 | nbody_system.length
particles.mass = 0.1 | nbody_system.mass
particles2 = datamodel.Particles(2)
particles2.position = ([0, 0, 0], [1, 0, 0]) | nbody_system.length
particles2.velocity = ([-1, 0, 0], [2, 0, 0]) | nbody_system.speed
particles2.radius = 0 | nbody_system.length
particles2.mass = 2 | nbody_system.mass
particles2.subset = subset1
instance.particles.add_particles(particles)
instance.particles.add_particles(particles2)
print(instance.particles)
self.assertAlmostRelativeEquals(instance.kinetic_energy, particles.kinetic_energy())
self.assertAlmostRelativeEquals(instance.potential_energy, particles.potential_energy(G=nbody_system.G))
self.assertAlmostRelativeEquals(instance.get_kinetic_energy(subset1), particles2.kinetic_energy())
self.assertAlmostRelativeEquals(instance.get_potential_energy(subset1), particles2.potential_energy(G=nbody_system.G))
# instance.stop()
def test8(self):
instance = self.new_instance_of_an_optional_code(Rebound)
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
subset0 = 0
subset1 = instance.new_subset()
print(subset1)
self.assertEqual(subset1, 1)
particles = datamodel.Particles(2)
particles.position = ([0, 0, 0], [1, 0, 0]) | nbody_system.length
particles.velocity = ([0, 0, 0], [0, 0.5, 0]) | nbody_system.speed
particles.radius = 0 | nbody_system.length
particles.mass = 0.1 | nbody_system.mass
particles2 = datamodel.Particles(2)
particles2.position = ([0, 0, 0], [2, 0, 0]) | nbody_system.length
particles2.velocity = ([0, 0, 0], [0, 1, 0]) | nbody_system.speed
particles2.radius = 0 | nbody_system.length
particles2.mass = 1 | nbody_system.mass
particles2.subset = subset1
instance.particles.add_particles(particles)
instance.particles.add_particles(particles2)
instance.evolve_model(0.1 | nbody_system.time)
self.assertAlmostRelativeEquals(instance.kinetic_energy, particles.kinetic_energy(), 2)
self.assertAlmostRelativeEquals(instance.potential_energy, particles.potential_energy(G=nbody_system.G), 2)
self.assertAlmostRelativeEquals(instance.get_kinetic_energy(subset1), particles2.kinetic_energy(), 2)
self.assertAlmostRelativeEquals(instance.get_potential_energy(subset1), particles2.potential_energy(G=nbody_system.G), 2)
particles_evolved = instance.particles.copy()
instance.stop()
instance1 = self.new_instance_of_an_optional_code(Rebound)
instance1.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles1c = particles.copy()
instance1.particles.add_particles(particles1c)
instance1.evolve_model(0.1 | nbody_system.time)
particles1evolved = particles_evolved[particles_evolved.subset == 0]
print("HHH:", particles_evolved.subset)
print("p2e:", particles1evolved)
print(instance1.particles)
self.assertAlmostRelativeEquals(instance1.particles.position, particles1evolved.position, 10)
self.assertAlmostRelativeEquals(instance1.particles.velocity, particles1evolved.velocity, 10)
instance1.stop()
instance2 = self.new_instance_of_an_optional_code(Rebound)
instance2.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles2c = particles2.copy()
particles2c.subset = 0
instance2.particles.add_particles(particles2c)
instance2.evolve_model(0.1 | nbody_system.time)
particles2evolved = particles_evolved[particles_evolved.subset == subset1]
print("HHH:", particles_evolved.subset)
print("p2e:", particles2evolved)
print(instance2.particles)
self.assertAlmostRelativeEquals(instance2.particles.position, particles2evolved.position, 10)
self.assertAlmostRelativeEquals(instance2.particles.velocity, particles2evolved.velocity, 10)
instance2.stop()
def test9(self):
instance = self.new_instance_of_an_optional_code(Rebound)
# instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles = datamodel.Particles(10)
particles.x = numpy.arange(0, 10, 1) | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [0, 1, 0] | nbody_system.speed
particles[5].velocity = [0, 0, 0] | nbody_system.speed
particles.radius = 0 | nbody_system.length
particles[5].mass = 1 | nbody_system.mass
instance.particles.add_particles(particles)
self.assertEqual(instance.particles[5].mass, 1 | nbody_system.mass)
self.assertEqual(instance.particles[6].mass, 0 | nbody_system.mass)
instance.evolve_model(1 | nbody_system.time)
self.assertEqual(instance.particles[5].mass, 1 | nbody_system.mass)
self.assertEqual(instance.particles[6].mass, 0 | nbody_system.mass)
self.assertEqual(instance.particles[5].x, 5 | nbody_system.length)
self.assertAlmostRelativeEquals(instance.particles[6].x, 5.5403023 | nbody_system.length, 5)
instance.particles.remove_particle(particles[4])
self.assertEqual(instance.particles[4].mass, 1 | nbody_system.mass)
self.assertEqual(instance.particles[5].mass, 0 | nbody_system.mass)
instance.evolve_model(1 | nbody_system.time)
self.assertEqual(instance.particles[4].x, 5 | nbody_system.length)
instance.stop()
def test10(self):
instance = self.new_instance_of_an_optional_code(Rebound)
# instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles = datamodel.Particles(1)
particles.x = 0 | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [0, 2, 0] | nbody_system.speed
particles.radius = 1 | nbody_system.length
particles.mass = 1 | nbody_system.mass
instance.particles.add_particles(particles)
instance.evolve_model(4 | nbody_system.time)
self.assertAlmostRelativeEquals(instance.particles[0].velocity, [0, 2, 0] | nbody_system.speed)
self.assertAlmostRelativeEquals(instance.particles[0].position, [0, 2 * 4, 0] | nbody_system.length, 8)
instance.stop()
| 22,107
| 43.039841
| 137
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_mocassin.py
|
import os
from amuse.test.amusetest import TestWithMPI
from amuse.units import units
from amuse import datamodel
from amuse.community.mocassin.interface import MocassinInterface, Mocassin, mocassin_rydberg_unit
import numpy
class TestMocassinInterface(TestWithMPI):
def test0(self):
instance = self.new_instance_of_an_optional_code(MocassinInterface)
instance.initialize_code()
instance.stop()
def test1(self):
instance = self.new_instance_of_an_optional_code(MocassinInterface)
instance.initialize_code()
# instance.redirect_outputs_to("moc-out.txt", "moc-err.txt")
instance.setup_mesh(11, 11, 11, 100, 100, 100)
instance.setup_abundancies()
print(instance.get_default_input_directory())
instance.set_input_directory(instance.get_default_input_directory())
instance.set_constant_hydrogen_density(900.0)
instance.commit_parameters()
indices_x = range(1, 12, 1)
x, y, z, error = instance.get_position_of_index(indices_x, [1]*len(indices_x), [1]*len(indices_x))
self.assertEqual(error, 0)
for index, expected_x in enumerate(range(-100, 120, 20)):
self.assertAlmostRelativeEqual(x[index], expected_x, 6)
self.assertAlmostRelativeEqual(y[index], -100)
self.assertAlmostRelativeEqual(z[index], -100)
instance.stop()
def test2(self):
instance = self.new_instance_of_an_optional_code(MocassinInterface) # , debugger = "ddd")
instance.initialize_code()
instance.set_symmetricXYZ(True)
instance.setup_mesh(13, 13, 13, 0.95E+19, 0.95E+19, 0.95E+19)
instance.setup_abundancies()
instance.set_input_directory(instance.get_default_input_directory())
instance.set_constant_hydrogen_density(100.0)
instance.set_initial_nebular_temperature(6000.0)
instance.set_maximum_number_of_monte_carlo_iterations(20)
instance.set_minimum_convergence_level(100)
instance.set_total_number_of_photons(10000000)
instance.set_total_number_of_points_in_frequency_mesh(600)
instance.set_high_limit_of_the_frequency_mesh(15)
instance.set_low_limit_of_the_frequency_mesh(1.001e-5)
instance.set_convergence_limit(0.09)
instance.set_number_of_ionisation_stages(6)
instance.setup_auto_convergence(0.2, 2.0, 1000000000)
instance.commit_parameters()
instance.define_stars(0.0, 0.0, 0.0, 20000, 6003.6396)
instance.commit_particles()
instance.commit_grid()
x, error = instance.get_number_of_elements_used()
self.assertEqual(0, error)
self.assertEqual(x, 7)
indices_x = range(1, 12, 1)
is_active, error = instance.get_grid_active(indices_x, [1]*len(indices_x), [1]*len(indices_x), 1)
self.assertEqual(0, error)
is_active = numpy.array(is_active, dtype=bool)
self.assertEqual([True, True, True, True, True, True, True, True, True, True, True], is_active)
indices_x = range(5, 12, 1)
temperatures, error = instance.get_grid_electron_temperature(indices_x, [1]*len(indices_x), [1]*len(indices_x), 1)
self.assertEqual(0, error)
self.assertEqual([6000.0] * len(indices_x), temperatures)
indices_x = range(1, 5, 1)
temperatures, error = instance.get_grid_electron_temperature(indices_x, [1]*len(indices_x), [1]*len(indices_x), 1)
self.assertEqual(0, error)
self.assertEqual([6000.0] * len(indices_x), temperatures)
ni, nj, nk, error = instance.get_max_indices(1)
self.assertEqual(0, error)
self.assertEqual(ni, 13)
self.assertEqual(nj, 13)
self.assertEqual(nj, 13)
instance.stop()
def xtest3(self):
instance = self.new_instance_of_an_optional_code(MocassinInterface) # , debugger = "ddd")
# instance.redirect_outputs_to("moc3-out.txt", "moc3-err.txt")
instance.initialize_code()
instance.set_symmetricXYZ(True)
instance.setup_mesh(13, 13, 13, 0.95E+19, 0.95E+19, 0.95E+19)
instance.setup_abundancies()
# instance.set_abundancies_filename('abunHII20.in')
instance.set_input_directory(instance.get_default_input_directory())
instance.set_constant_hydrogen_density(100.0)
instance.set_initial_nebular_temperature(6000.0)
instance.set_maximum_number_of_monte_carlo_iterations(20)
instance.set_minimum_convergence_level(100)
instance.set_total_number_of_photons(10000000)
instance.set_total_number_of_points_in_frequency_mesh(600)
instance.set_high_limit_of_the_frequency_mesh(15.)
instance.set_low_limit_of_the_frequency_mesh(1.001e-5)
instance.set_convergence_limit(0.09)
instance.set_number_of_ionisation_stages(6)
instance.setup_auto_convergence(0.8, 2.0, 1000000000)
# instance.set_emit_rate_of_photons(1.006e13)
instance.commit_parameters()
instance.define_stars(0.0, 0.0, 0.0, 20000.0, 6003.6396)
instance.commit_particles()
instance.commit_grid()
x, error = instance.get_number_of_elements_used()
self.assertEqual(0, error)
self.assertEqual(x, 7)
instance.iterate()
indices_x = range(1, 12, 1)
temperatures, error = instance.get_grid_electron_temperature(indices_x, [1]*len(indices_x), [1]*len(indices_x), 1)
self.assertEqual(0, error)
print(temperatures)
instance.stop()
def test4(self):
instance = self.new_instance_of_an_optional_code(MocassinInterface)
instance.initialize_code()
instance.setup_mesh(3, 3, 3, 0.95E+19, 0.95E+19, 0.95E+19)
instance.setup_abundancies()
instance.set_input_directory(instance.get_default_input_directory())
instance.set_initial_nebular_temperature(6000.0)
instance.set_maximum_number_of_monte_carlo_iterations(20)
instance.set_minimum_convergence_level(100)
instance.set_total_number_of_photons(10000000)
instance.set_total_number_of_points_in_frequency_mesh(600)
instance.set_high_limit_of_the_frequency_mesh(15)
instance.set_low_limit_of_the_frequency_mesh(1.001e-5)
instance.set_convergence_limit(0.09)
instance.set_number_of_ionisation_stages(6)
instance.setup_auto_convergence(0.2, 2.0, 1000000000)
instance.commit_parameters()
error = instance.define_stars(0.0, 0.0, 0.0, 20000, 6003.6396)
self.assertEqual(error, 0)
instance.set_grid_hydrogen_density(1, 1, 1, 100)
value, error = instance.get_grid_hydrogen_density(1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(value, 100)
is_active, error = instance.get_grid_active(1, 1, 1)
self.assertEqual(error, 0)
self.assertFalse(is_active)
is_active, error = instance.get_grid_active(1, 2, 1)
self.assertEqual(error, 0)
self.assertFalse(is_active)
value, error = instance.get_grid_hydrogen_density(1, 2, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(value, 0)
instance.commit_particles()
instance.commit_grid()
is_active, error = instance.get_grid_active(1, 1, 1)
self.assertEqual(error, 0)
self.assertTrue(is_active)
value, error = instance.get_grid_hydrogen_density(1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(value, 100)
value, error = instance.get_grid_ion_density(1, 1, 1, 1, 1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEquals(value, 1e-5, 6)
is_active, error = instance.get_grid_active(1, 2, 1)
self.assertEqual(error, 0)
self.assertFalse(is_active)
value, error = instance.get_grid_hydrogen_density(1, 2, 1)
self.assertEqual(error, 0)
self.assertEqual(value, 0)
instance.stop()
class TestMocassin(TestWithMPI):
def test1(self):
instance = self.new_instance_of_an_optional_code(Mocassin)
instance.initialize_code()
self.assertEqual(0.0 | units.cm**-3, instance.parameters.constant_hydrogen_density)
print(instance.parameters.abundancies_filename)
instance.parameters.constant_hydrogen_density = 100.0 | units.cm**-3
self.assertEqual(100.0 | units.cm**-3, instance.parameters.constant_hydrogen_density)
self.assertEqual(10000 | units.K, instance.parameters.initial_nebular_temperature)
self.assertEqual("", instance.parameters.abundancies_filename)
instance.stop()
def test2(self):
instance = self.new_instance_of_an_optional_code(Mocassin) # , redirection = "none")
instance.initialize_code()
instance.set_input_directory(instance.get_default_input_directory())
instance.set_symmetricXYZ(True)
instance.parameters.nx = 11
instance.parameters.ny = 12
instance.parameters.nz = 13
instance.parameters.length_x = 1 | units.km
instance.parameters.length_y = 1 | units.km
instance.parameters.length_z = 1 | units.km
instance.commit_parameters()
self.assertEqual(instance.grid.shape[0], 11)
self.assertEqual(instance.grid.shape[1], 12)
self.assertEqual(instance.grid.shape[2], 13)
instance.stop()
def test3(self):
instance = self.new_instance_of_an_optional_code(Mocassin) # , debugger = "xterm")
instance.initialize_code()
instance.set_random_seed(1)
instance.set_input_directory(instance.get_default_input_directory())
instance.set_mocassin_output_directory(instance.output_directory + os.sep)
instance.set_initial_nebular_temperature(200.0 | units.K)
instance.parameters.nx = 7
instance.parameters.ny = 7
instance.parameters.nz = 7
print((0.95E+19 | units.cm).value_in(units.parsec))
instance.parameters.length_x = 0.95E+19 | units.cm
instance.parameters.length_y = 0.95E+19 | units.cm
instance.parameters.length_z = 0.95E+19 | units.cm
instance.set_high_limit_of_the_frequency_mesh(15 | mocassin_rydberg_unit)
instance.set_low_limit_of_the_frequency_mesh(1.001e-5 | mocassin_rydberg_unit)
instance.set_maximum_number_of_monte_carlo_iterations(1)
instance.set_total_number_of_photons(100)
# ~ instance.set_constant_hydrogen_density(100 | units.cm**-3)
instance.commit_parameters()
instance.grid.hydrogen_density = 100 | units.cm**-3
instance.commit_grid()
p = datamodel.Particle()
p.x = 0 | units.cm
p.y = 0 | units.cm
p.z = 0 | units.cm
p.temperature = 20000 | units.K
p.luminosity = 1. | units.LSun
instance.particles.add_particle(p)
instance.commit_particles()
self.assertAlmostRelativeEquals(1e-5, instance.ion_density_grid.density[3][1][2][0][0], 7)
self.assertAlmostRelativeEquals(1e-5, instance.ion_density_grid.density[3][1][3][0][0], 7)
instance.step()
print(instance.grid.electron_density.mean())
self.assertAlmostRelativeEquals(0.0, instance.get_percentage_converged())
self.assertGreater(instance.grid.electron_density.mean(), 65. | units.cm**-3)
self.assertLess(instance.grid.electron_density.mean(), 95. | units.cm**-3)
instance.stop()
| 11,478
| 39.277193
| 122
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_simplex.py
|
import os.path
import numpy
from amuse.test.amusetest import TestWithMPI
from amuse.community.simplex.interface import SimpleXInterface, SimpleX, SimpleXSplitSet
from amuse.units import units
from amuse.datamodel import Particles
from amuse.datamodel import Particle
from amuse.ext.molecular_cloud import ism_cube
# default_options = dict(number_of_workers=2, redirection="none")
default_options = dict(number_of_workers=1) # ,debugger='gdb')
class TestSimpleXInterface(TestWithMPI):
def test1(self):
print("Test 1: initialization")
instance = SimpleXInterface(**default_options)
self.assertEqual(0, instance.set_simplex_output_directory(instance.output_directory))
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test2(self):
print("Test 2: commit_particles, getters and setters")
instance = SimpleXInterface(**default_options)
self.assertEqual(0, instance.set_simplex_output_directory(instance.output_directory))
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
x, y, z, n_H, flux, X_ion, u = read_input_file(input_file)
x = numpy.array(x)
y = numpy.array(y)
z = numpy.array(z)
number_of_particles = len(x)
indices, errors = instance.new_particle(x, y, z, n_H, flux, X_ion, u)
self.assertEqual(errors, [0]*number_of_particles)
self.assertEqual(indices, list(range(number_of_particles)))
self.assertEqual(0, instance.commit_particles())
x_out, y_out, z_out, n_H_out, flux_out, X_ion_out, u_out, metallicity_out, error = instance.get_state(indices)
self.assertAlmostEqual((x-x_out)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((y-y_out)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual((z-z_out)/13200., numpy.zeros_like(x), 7)
self.assertAlmostEqual(flux, flux_out, 7)
self.assertAlmostEqual(n_H, n_H_out, 7)
self.assertAlmostEqual(X_ion, X_ion_out, 7)
self.assertAlmostRelativeEqual(u, u_out, 7)
# self.assertAlmostRelativeEqual(metallicity,metallicity_out, 7)
x, y, z, n_H, flux, X_ion, u, metallicity, error = instance.get_state(0)
for expected, received in zip([0, 0, 0, 0.001, 5.0, 0.0, 831447247704, 0],
[x, y, z, n_H, flux, X_ion, u, error]):
self.assertAlmostRelativeEqual(expected, received, 6)
x, y, z, error1 = instance.get_position(0)
n_H, error2 = instance.get_density(0)
flux, error3 = instance.get_flux(0)
X_ion, error4 = instance.get_ionisation(0)
for expected, received in zip([0., 0., 0., 0.001, 5.0, 0.0, 0, 0, 0, 0],
[x, y, z, n_H, flux, X_ion, error1, error2, error3, error4]):
self.assertAlmostRelativeEqual(expected, received, 5)
self.assertEqual(0, instance.set_state(3, 1.0, 2.0, 3.0, 4.0, 5.0, 0.6, 77.0))
x, y, z, n_H, flux, X_ion, u, metallicity, error = instance.get_state(3)
for expected, received in zip([1.0, 2.0, 3.0, 4.0, 5.0, 0.6, 77, 0],
[x, y, z, n_H, flux, X_ion, u, error]):
self.assertAlmostRelativeEqual(expected, received, 5)
self.assertEqual(0, instance.set_position(4, 3.0, 2.0, 1.0))
self.assertEqual(0, instance.set_density(4, 0.6))
self.assertEqual(0, instance.set_flux(4, 0.5))
self.assertEqual(0, instance.set_ionisation(4, 0.4))
self.assertEqual(0, instance.set_internal_energy(4, 1234.))
x, y, z, n_H, flux, X_ion, u, metallicity, error = instance.get_state(4)
for expected, received in zip([3.0, 2.0, 1.0, 0.6, 0.5, 0.4, 1234., 0],
[x, y, z, n_H, flux, X_ion, u, error]):
self.assertAlmostRelativeEqual(expected, received, 5)
self.assertEqual(0, instance.set_dinternal_energy_dt(4, 12345.))
du_dt, err = instance.get_dinternal_energy_dt(4)
self.assertEqual(12345, du_dt)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test3(self):
print("Test 3: evolve")
instance = SimpleXInterface(**default_options)
self.assertEqual(0, instance.set_simplex_output_directory(instance.output_directory))
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
x, y, z, n_H, flux, X_ion, u = read_input_file(input_file)
number_of_particles = len(x)
indices, errors = instance.new_particle(x, y, z, n_H, flux, X_ion, u)
self.assertEqual(errors, [0]*number_of_particles)
self.assertEqual(indices, list(range(number_of_particles)))
self.assertEqual(0, instance.commit_particles())
X_ion, errors = instance.get_ionisation(indices)
self.assertEqual(errors, [0]*number_of_particles)
self.assertAlmostEqual(X_ion.sum()/number_of_particles, 0.0)
density, errors = instance.get_density(indices)
self.assertEqual(errors, [0]*number_of_particles)
self.assertAlmostEqual(density.sum(), 1.0, 6)
self.assertEqual(0, instance.evolve_model(0.5))
density, errors = instance.get_density(indices)
self.assertEqual(errors, [0]*number_of_particles)
self.assertAlmostEqual(density.sum(), 1.0, 6)
flux, errors = instance.get_flux(indices)
self.assertEqual(errors, [0]*number_of_particles)
self.assertEqual(flux.sum(), 5.0)
X_ion, errors = instance.get_ionisation(indices)
self.assertEqual(errors, [0]*number_of_particles)
self.assertAlmostEqual(X_ion.sum()/number_of_particles, 0.000845247683257)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test4(self):
print("Test 4: set boxsize, hilbert_order, timestep")
instance = SimpleXInterface(**default_options)
self.assertEqual(0, instance.set_simplex_output_directory(instance.output_directory))
self.assertEqual(0, instance.initialize_code())
instance.set_box_size(16384.)
instance.set_hilbert_order(1)
instance.set_timestep(0.5)
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(16384., instance.get_box_size()['box_size'])
self.assertEqual(1, instance.get_hilbert_order()['hilbert_order'])
self.assertEqual(0.5, instance.get_timestep()['timestep'])
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
x, y, z, n_H, flux, X_ion, u = read_input_file(input_file)
number_of_particles = len(x)
indices, errors = instance.new_particle(x, y, z, n_H, flux, X_ion, u)
instance.commit_particles()
self.assertEqual(16384., instance.get_box_size()['box_size'])
self.assertEqual(1, instance.get_hilbert_order()['hilbert_order'])
self.assertEqual(0.5, instance.get_timestep()['timestep'])
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test5(self):
print("Test 2: delete particles")
instance = SimpleXInterface(**default_options)
self.assertEqual(0, instance.set_simplex_output_directory(instance.output_directory))
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
x, y, z, n_H, flux, X_ion, u = read_input_file(input_file)
x = numpy.array(x)
y = numpy.array(y)
z = numpy.array(z)
number_of_particles = len(x)
indices, errors = instance.new_particle(x, y, z, n_H, flux, X_ion, u)
self.assertEqual(errors, [0]*number_of_particles)
self.assertEqual(indices, list(range(number_of_particles)))
error = instance.delete_particle(indices[0])
self.assertEqual(error, -1)
instance.commit_particles()
error = instance.delete_particle(indices[0])
# this one I don't understand:
self.assertEqual(error, -1)
self.assertEqual(0, instance.evolve_model(0.125))
error = instance.delete_particle(indices[0])
self.assertEqual(error, 0)
class TestSimpleX(TestWithMPI):
def test1(self):
print("Test 1: initialization")
instance = SimpleX(**default_options)
instance.initialize_code()
instance.commit_parameters()
instance.cleanup_code()
instance.stop()
def test2(self):
print("Test 2: commit_particles, getters and setters")
instance = SimpleX(**default_options)
instance.initialize_code()
instance.commit_parameters()
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
particles = particles_from_input_file(input_file)
instance.particles.add_particles(particles)
instance.commit_particles()
# for attribute in ['position', 'rho', 'flux', 'xion']:
# self.assertAlmostEqual(13200.*getattr(particles, attribute),
# 13200.*getattr(instance.particles, attribute), 5)
# setattr(instance.particles, attribute, getattr(particles, attribute)/2.0)
# self.assertAlmostEqual(13200.*getattr(particles, attribute)/2.0,
# 13200.*getattr(instance.particles, attribute), 5)
instance.cleanup_code()
instance.stop()
def test3(self):
print("Test 3: evolve")
instance = SimpleX(**default_options)
instance.initialize_code()
instance.commit_parameters()
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
particles = particles_from_input_file(input_file)
particles.du_dt = particles.u/(10 | units.Myr)
instance.particles.add_particles(particles)
# instance.particles.du_dt=particles.du_dt
# instance.commit_particles()
instance.particles.du_dt = particles.du_dt
self.assertAlmostEqual(instance.particles.xion.mean(), 0.0)
self.assertAlmostEqual(instance.particles.du_dt.mean().in_(units.cm**2/units.s**3), particles.du_dt.mean().in_(units.cm**2/units.s**3))
instance.evolve_model(0.5 | units.Myr)
self.assertAlmostEqual(instance.particles.du_dt.mean().in_(units.cm**2/units.s**3), particles.du_dt.mean().in_(units.cm**2/units.s**3))
self.assertAlmostEqual(instance.particles.xion.mean(), 0.000845247683257)
instance.cleanup_code()
instance.stop()
def test4(self):
print("Test 4: default parameters")
instance = SimpleX(**default_options)
default = dict(timestep=0.05 | units.Myr,
source_effective_T=1.e5 | units.K,
hilbert_order=1,
number_of_freq_bins=1,
thermal_evolution_flag=0,
blackbody_spectrum_flag=0,
box_size=13200 | units.parsec,
metal_cooling_flag=0,
collisional_ionization_flag=0)
for x in default:
self.assertEqual(getattr(instance.parameters, x), default[x])
instance.commit_parameters()
for x in default:
self.assertEqual(getattr(instance.parameters, x), default[x])
tnow = instance.model_time
self.assertEqual(tnow, 0. | units.Myr)
instance.model_time = 321. | units.Myr
tnow = instance.model_time
self.assertEqual(tnow, 321. | units.Myr)
def test5(self):
print("Test 4: default parameters")
instance = SimpleX(**default_options)
param = dict(timestep=0.1 | units.Myr,
source_effective_T=2.e5 | units.K,
hilbert_order=3,
number_of_freq_bins=4,
thermal_evolution_flag=1,
blackbody_spectrum_flag=1,
box_size=32100 | units.parsec,
metal_cooling_flag=1,
collisional_ionization_flag=1,
simplex_data_directory='.')
for x in param:
setattr(instance.parameters, x, param[x])
for x in param:
self.assertEqual(getattr(instance.parameters, x), param[x])
def test6(self):
print("Test 2: print parameters,data directory")
instance = SimpleX(**default_options)
print(instance.parameters)
instance.parameters.simplex_data_directory = "some/dir"
self.assertEqual(instance.parameters.simplex_data_directory, "some/dir")
def test7(self):
print("Test 7: two step evolve")
instance = SimpleX(**default_options)
instance.parameters.recombination_radiation_flag = 1
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
particles = particles_from_input_file(input_file)
instance.particles.add_particles(particles)
self.assertAlmostEqual(instance.particles.xion.mean(), 0.0)
instance.evolve_model(0.25 | units.Myr)
flux_before = instance.particles.flux.sum()
instance.particles.flux = particles.flux
flux_after = instance.particles.flux.sum()
self.assertEqual(flux_before, flux_after)
instance.evolve_model(0.5 | units.Myr)
self.assertAlmostRelativeEqual(instance.particles.xion.mean(), 0.00084660917243, 3)
self.assertEqual(instance.particles.flux.max().value_in(1.e48 * units.s**-1), 5)
instance.cleanup_code()
instance.stop()
def test8(self):
print("Test 8: two step evolve")
instance = SimpleX(**default_options)
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
particles = particles_from_input_file(input_file)
instance.particles.add_particles(particles)
self.assertAlmostEqual(instance.particles.xion.mean(), 0.0)
instance.evolve_model(0.25 | units.Myr)
instance.evolve_model(0.5 | units.Myr)
self.assertEqual(instance.particles.flux.max().value_in(1.e48 * units.s**-1), 5)
self.assertAlmostRelativeEqual(instance.particles.xion.mean(), 0.00084660917243, 3)
instance.cleanup_code()
instance.stop()
def test9(self):
print("Test 9: add test")
instance = SimpleX(number_of_workers=1)
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
particles = particles_from_input_file(input_file)
N = len(particles)
toadd = particles[0:10].copy()
particles = particles[10:].copy()
instance.particles.add_particles(particles)
instance.evolve_model(0.25 | units.Myr)
# instance.commit_particles()
instance.particles.add_particles(toadd)
self.assertEqual(len(instance.particles), N)
def test10(self):
print("Test 10: add test")
instance = SimpleX(number_of_workers=2)
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
particles = particles_from_input_file(input_file)
N = len(particles)
toadd = particles[0:10].copy()
particles = particles[10:].copy()
instance.particles.add_particles(particles)
instance.evolve_model(0.25 | units.Myr)
# instance.commit_particles()
instance.particles.add_particles(toadd)
self.assertEqual(len(instance.particles), N)
def test11(self):
print("Test 11: add test")
instance = SimpleX(number_of_workers=1)
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
particles = particles_from_input_file(input_file)
N = len(particles)
toadd = particles[0:10].copy()
particles = particles[10:].copy()
instance.particles.add_particles(particles)
instance.commit_particles()
instance.particles.add_particles(toadd)
self.assertEqual(len(instance.particles), N)
def test12(self):
N = 1000
Lstar = 100 | units.LSun
boxsize = 10 | units.parsec
rho = 1.0 | (units.amu/units.cm**3)
t_end = 0.01 | units.Myr
internal_energy = (9. | units.kms)**2
source = Particle()
source.position = (0, 0, 0) | units.parsec
source.flux = Lstar/(20. | units.eV)
source.rho = rho
source.xion = 0.0
source.u = internal_energy
ism = ism_cube(N, boxsize/2., rho, internal_energy).result
ism.rho = rho
ism.flux = 0. | units.s**-1
ism.xion = source.xion
radiative = SimpleX()
radiative.parameters.box_size = 1.001*boxsize
radiative.parameters.timestep = 0.001 | units.Myr
radiative.particles.add_particle(source)
radiative.particles.add_particles(ism)
radiative.evolve_model(t_end)
self.assertAlmostRelativeEquals(0.0750819123073, radiative.particles.xion.mean(), 1)
radiative.stop()
class TestSimpleXSplitSet(TestWithMPI):
def test1(self):
print("Test 1: initialization")
instance = SimpleXSplitSet(**default_options)
instance.initialize_code()
instance.commit_parameters()
instance.cleanup_code()
instance.stop()
def test2(self):
print("Test 2: commit_particles, getters and setters")
instance = SimpleXSplitSet(**default_options)
instance.initialize_code()
instance.commit_parameters()
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
particles, src_particles = splitset_from_input_file(input_file)
instance.gas_particles.add_particles(particles)
instance.src_particles.add_particles(src_particles)
instance.commit_particles()
# for attribute in ['position', 'rho', 'flux', 'xion']:
# self.assertAlmostEqual(13200.*getattr(particles, attribute),
# 13200.*getattr(instance.particles, attribute), 5)
# setattr(instance.particles, attribute, getattr(particles, attribute)/2.0)
# self.assertAlmostEqual(13200.*getattr(particles, attribute)/2.0,
# 13200.*getattr(instance.particles, attribute), 5)
instance.cleanup_code()
instance.stop()
def test3(self):
print("Test 3: evolve")
instance = SimpleXSplitSet(**default_options)
instance.initialize_code()
instance.commit_parameters()
input_file = os.path.join(os.path.dirname(__file__), "test_simplex_data.txt")
particles, src_particles = splitset_from_input_file(input_file)
instance.src_particles.add_particles(src_particles)
particles.du_dt = particles.u/(10 | units.Myr)
instance.gas_particles.add_particles(particles)
self.assertAlmostEqual(instance.gas_particles.xion.mean(), 0.0)
self.assertAlmostEqual(instance.gas_particles.du_dt.mean().in_(units.cm**2/units.s**3), particles.du_dt.mean().in_(units.cm**2/units.s**3))
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.evolve_model(0.5 | units.Myr)
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
self.assertAlmostEqual(instance.gas_particles.du_dt.mean().in_(units.cm**2/units.s**3), particles.du_dt.mean().in_(units.cm**2/units.s**3))
self.assertAlmostEqual(instance.gas_particles.xion.mean(), 0.000845247683257)
instance.gas_particles.remove_particles(particles[0:4])
# this is what we would like....
# self.assertEquals(instance.get_name_of_current_state(), 'UPDATE')
# instance.recommit_particles()
instance.evolve_model(0.75 | units.Myr)
self.assertEqual(len(instance.particles), len(particles)-4)
instance.cleanup_code()
instance.stop()
def test4(self):
print("Test 4: default parameters")
instance = SimpleXSplitSet(**default_options)
default = dict(timestep=0.05 | units.Myr,
source_effective_T=1.e5 | units.K,
hilbert_order=1,
number_of_freq_bins=1,
thermal_evolution_flag=0,
blackbody_spectrum_flag=0,
box_size=13200 | units.parsec,
metal_cooling_flag=0,
collisional_ionization_flag=0)
for x in default:
self.assertEqual(getattr(instance.parameters, x), default[x])
instance.commit_parameters()
for x in default:
self.assertEqual(getattr(instance.parameters, x), default[x])
tnow = instance.model_time
self.assertEqual(tnow, 0. | units.Myr)
instance.model_time = 321. | units.Myr
tnow = instance.model_time
self.assertEqual(tnow, 321. | units.Myr)
def test5(self):
print("Test 4: default parameters")
instance = SimpleXSplitSet(**default_options)
param = dict(timestep=0.1 | units.Myr,
source_effective_T=2.e5 | units.K,
hilbert_order=3,
number_of_freq_bins=4,
thermal_evolution_flag=1,
blackbody_spectrum_flag=1,
box_size=32100 | units.parsec,
metal_cooling_flag=1,
collisional_ionization_flag=1)
for x in param:
setattr(instance.parameters, x, param[x])
for x in param:
self.assertEqual(getattr(instance.parameters, x), param[x])
def read_input_file(input_file):
file = open(input_file, 'r')
lines = file.readlines()
lines.pop(0)
x, y, z, nh, flux, xion, u = [], [], [], [], [], [], []
for line in lines:
l = line.strip().split()
if len(l) >= 7:
x.append(float(l[1]))
y.append(float(l[2]))
z.append(float(l[3]))
nh.append(float(l[4]))
flux.append(float(l[5]))
xion.append(float(l[6]))
u.append(float(l[7]))
return x, y, z, nh, flux, xion, u
def particles_from_input_file(input_file):
x, y, z, n_H, flux, X_ion, u = read_input_file(input_file)
particles = Particles(len(x))
particles.x = x | units.parsec
particles.y = y | units.parsec
particles.z = z | units.parsec
particles.rho = n_H | units.amu / units.cm**3
particles.flux = flux | 1.0e48 / units.s
particles.xion = X_ion | units.none
particles.u = u | (units.cm**2/units.s**2)
return particles
def splitset_from_input_file(input_file):
x, y, z, n_H, flux, X_ion, u = read_input_file(input_file)
particles = Particles(len(x))
particles.x = x | units.parsec
particles.y = y | units.parsec
particles.z = z | units.parsec
particles.rho = n_H | units.amu / units.cm**3
particles.xion = X_ion | units.none
particles.u = u | (units.cm**2/units.s**2)
a = numpy.where(numpy.array(flux) > 0.)[0]
src_particles = Particles(len(a))
src_particles.x = numpy.array(x)[a] | units.parsec
src_particles.y = numpy.array(y)[a] | units.parsec
src_particles.z = numpy.array(z)[a] | units.parsec
src_particles.luminosity = numpy.array(flux)[a] | 1.e48*units.s**-1
return particles, src_particles
| 23,585
| 41.883636
| 147
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/gd_tests.py
|
import numpy
from amuse.units import nbody_system
from amuse import datamodel
from amuse.ic.plummer import new_plummer_model
class _TestGravitationalDynamicsInterface:
def gravity_code_interface(self):
self.skip("abstract test")
def reference_includes(self):
self.skip("abstract test")
def starting_particle_index(self):
return 0
def check_for_energy(self, *args, **kwargs):
return self.assertEqual(*args, **kwargs)
def almost_equal_precision(self):
return 7
def test_initialise(self):
interface = self.gravity_code_interface()
instance = self.new_instance_of_an_optional_code(interface)
instance.initialize_code()
instance.stop()
def test_literature_reference(self):
interface = self.gravity_code_interface()
instance = self.new_instance_of_an_optional_code(interface)
instance.initialize_code()
reference_string = self.reference_includes()
self.assertTrue(
reference_string in instance.all_literature_references_string()
)
instance.stop()
def test_add_and_retrieve_particle(self):
interface = self.gravity_code_interface()
instance = self.new_instance_of_an_optional_code(interface)
instance.initialize_code()
index, error = instance.new_particle(
11.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 2.0)
self.assertEqual(error, 0)
self.assertEqual(index, self.starting_particle_index())
error = instance.commit_particles()
self.assertEqual(error, 0)
retrieved_state = instance.get_state(index)
self.assertEqual(retrieved_state['__result'], 0)
self.assertEqual(11.0, retrieved_state['mass'])
self.assertEqual(2.0, retrieved_state['radius'])
self.assertEqual(
instance.get_number_of_particles()['number_of_particles'], 1
)
instance.stop()
def test_add_and_retrieve_particles(self):
interface = self.gravity_code_interface()
instance = self.new_instance_of_an_optional_code(interface)
instance.initialize_code()
instance.new_particle(
[11.0, 12.0, 13.0, 14.0],
[2.1, 3.1, 4.1, 5.1],
[2.2, 3.2, 4.2, 5.2],
[2.3, 3.3, 4.3, 5.3],
[2.4, 3.4, 4.4, 5.4],
[2.5, 3.5, 4.5, 5.5],
[2.6, 3.6, 4.6, 5.6],
[2.0, 3.0, 4.0, 5.0],
),
error = instance.commit_particles()
self.assertEqual(error, 0)
retrieved_state = instance.get_state(self.starting_particle_index())
self.assertEqual(11.0, retrieved_state['mass'])
retrieved_state = instance.get_state(
[
self.starting_particle_index()+1,
self.starting_particle_index()+2,
self.starting_particle_index()+3,
]
)
self.assertEqual(12.0, retrieved_state['mass'][0])
self.assertEqual(
instance.get_number_of_particles()['number_of_particles'], 4
)
instance.stop()
def test_add_and_retrieve_many_particles(self):
interface = self.gravity_code_interface()
instance = self.new_instance_of_an_optional_code(interface)
instance.initialize_code()
n = 4000
values = [1.0 * i for i in range(1, n)]
instance.new_particle(
values,
values,
values,
values,
values,
values,
values,
values,
)
error = instance.commit_particles()
self.assertEqual(error, 0)
retrieved_state = instance.get_state(self.starting_particle_index())
self.assertEqual(1.0, retrieved_state['mass'])
retrieved_state = instance.get_state(
self.starting_particle_index()+3998
)
instance.cleanup_code()
instance.stop()
self.assertEqual(3999.0, retrieved_state['mass'])
def test_epsilon_squared(self):
interface = self.gravity_code_interface()
instance = self.new_instance_of_an_optional_code(interface)
instance.initialize_code()
for x in [0.101, 4.0]:
error = instance.set_eps2(x)
self.assertEqual(error, 0)
value, error = instance.get_eps2()
self.assertEqual(error, 0)
self.assertEqual(x, value)
instance.stop()
def test_reversed_time_allowed(self):
interface = self.gravity_code_interface()
instance = self.new_instance_of_an_optional_code(interface)
instance.initialize_code()
self.assertEqual(
[0, 0], list(instance.get_is_time_reversed_allowed().values())
)
self.assertEqual(0, instance.set_is_time_reversed_allowed(1))
self.assertEqual(
[1, 0], list(instance.get_is_time_reversed_allowed().values())
)
instance.stop()
def test_calculate_energies(self):
interface = self.gravity_code_interface()
instance = self.new_instance_of_an_optional_code(interface)
instance.initialize_code()
instance.set_eps2(0.0**2)
instance.commit_parameters()
instance.new_particle(
[1.0, 1.0, 1.0],
[1.0, 0.0, -1.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
)
instance.commit_particles()
Ep = instance.get_potential_energy()['potential_energy']
Ek = instance.get_kinetic_energy()['kinetic_energy']
self.check_for_energy(Ek, 0.5)
self.check_for_energy(Ep, -2.5)
instance.delete_particle(self.starting_particle_index()+1)
instance.recommit_particles()
n = instance.get_number_of_particles()['number_of_particles']
Ep = instance.get_potential_energy()['potential_energy']
Ek = instance.get_kinetic_energy()['kinetic_energy']
instance.cleanup_code()
instance.stop()
self.assertEqual(n, 2)
self.check_for_energy(Ek, 0.)
self.check_for_energy(Ep, -0.5)
class _TestGravityCodes:
length_unit = nbody_system.length
speed_unit = nbody_system.speed
mass_unit = nbody_system.mass
time_unit = nbody_system.time
@property
def nbody_converter(self):
return None
def gravity_code_factory(self):
self.skip("abstract test")
def test1(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
particles = new_plummer_model(100, convert_nbody=self.nbody_converter)
particles.radius = 0 | self.length_unit
particles.move_to_center()
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(len(instance.particles), 100)
outer = particles.select(lambda r: r.length() > (
0.5 | self.length_unit), ["position"])
print(len(outer))
self.assertTrue(len(outer) > 0)
self.assertTrue(len(outer) < 100)
instance.synchronize_model()
instance.particles.remove_particles(outer)
instance.recommit_particles()
self.assertEqual(len(instance.particles), 100-len(outer))
number_of_particles_in_module = instance.legacy_interface.get_number_of_particles()[
'number_of_particles']
self.assertEqual(number_of_particles_in_module, 100-len(outer))
instance.stop()
def getset_attribute(self, attributename, attributevalue1, attributevalue2):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
try:
particles = new_plummer_model(100)
particles.move_to_center()
particles.radius = 0.0 | nbody_system.length
instance.particles.add_particles(particles)
instance.commit_particles()
setattr(instance.particles, attributename, attributevalue1)
actual = getattr(instance.particles, attributename)
self.assertAlmostRelativeEqual(actual, attributevalue1)
setattr(instance.particles, attributename, attributevalue2)
actual = getattr(instance.particles, attributename)
print(actual.as_quantity_in(attributevalue2.unit))
self.assertAlmostRelativeEqual(actual, attributevalue2)
finally:
instance.stop()
def test2(self):
self.getset_attribute(
"radius", 1.0 | self.length_unit, 2.0 | self.length_unit)
def test3(self):
self.getset_attribute("position", [1.0, 2.0, 3.0] | self.length_unit, [
5.0, 6.0, 7.0] | self.length_unit)
def test4(self):
self.getset_attribute("velocity", [1.0, 2.0, 3.0] | self.speed_unit, [
5.0, 6.0, 7.0] | self.speed_unit)
def test5(self):
self.getset_attribute(
"mass", 1.0 | self.mass_unit, 2.0 | self.mass_unit)
def test6(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
try:
particles = new_plummer_model(
100, convert_nbody=self.nbody_converter)
more_particles = new_plummer_model(
50, convert_nbody=self.nbody_converter)
particles.radius = 0 | self.length_unit
more_particles.radius = 1.0 | self.length_unit
particles.move_to_center()
more_particles.move_to_center()
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(len(instance.particles), 100)
instance.synchronize_model()
instance.particles.add_particles(more_particles)
instance.recommit_particles()
number_of_particles_in_module = instance.legacy_interface.get_number_of_particles()[
'number_of_particles']
self.assertEqual(len(instance.particles), 150)
self.assertEqual(number_of_particles_in_module, 150)
instance.synchronize_model()
instance.particles.remove_particles(particles)
self.assertEqual(len(instance.particles), 50)
instance.recommit_particles()
instance.synchronize_model()
number_of_particles_in_module = instance.legacy_interface.get_number_of_particles()[
'number_of_particles']
self.assertEqual(len(instance.particles), 50)
self.assertEqual(number_of_particles_in_module, 50)
finally:
instance.stop()
def test7(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
try:
particles = new_plummer_model(
100, convert_nbody=self.nbody_converter)
new_particles = new_plummer_model(
50, convert_nbody=self.nbody_converter)
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(len(instance.particles), 100)
instance.synchronize_model()
instance.particles.remove_particle(particles[40])
instance.particles.remove_particle(particles[70])
instance.particles.add_particle(new_particles[0])
print(new_particles[0].key)
instance.recommit_particles()
# test the get_mass, get_position and get_velocity functions
# if they are implemented for the code, otherwise will call
# get_state multiple times
# todo, fi fails, need to check with inti
# self.assertAlmostRelativeEqual(instance.particles[-1].mass, new_particles[0].mass)
# self.assertAlmostRelativeEqual(instance.particles[-1].velocity, new_particles[0].velocity)
# self.assertAlmostRelativeEqual(instance.particles[-1].position, new_particles[0].position)
instance.particles.synchronize_to(particles)
self.assertEqual(len(particles), 99)
self.assertEqual(particles[-1], new_particles[0])
finally:
instance.stop()
def test8(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
random = numpy.random.mtrand.RandomState(3456)
particles = new_plummer_model(
10, convert_nbody=self.nbody_converter, random=random)
particles.radius = 0.2 | self.length_unit
particles.move_to_center()
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 10)
collision_detection = instance.stopping_conditions.collision_detection
collision_detection.enable()
instance.evolve_model(1 | self.time_unit)
self.assertTrue(collision_detection.is_set())
instance.stop()
def test9(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
instance.parameters.stopping_conditions_out_of_box_size = 2 | self.length_unit
particles = datamodel.Particles(3)
particles.x = [0, 1, 2] | self.length_unit
particles.y = 0 | self.length_unit
particles.z = 0 | self.length_unit
particles.vx = [0, 0, 2] | self.speed_unit
particles.vy = [1, -1, 0] | self.speed_unit
particles.vz = 0 | self.speed_unit
particles.mass = 1 | self.mass_unit
particles.radius = 0.0 | self.length_unit
instance.particles.add_particles(particles)
stopping_condition = instance.stopping_conditions.out_of_box_detection
stopping_condition.enable()
instance.evolve_model(1 | self.time_unit)
print(instance.particles)
print(instance.particles.center_of_mass())
print((instance.particles.position -
instance.particles.center_of_mass()).lengths())
self.assertTrue(stopping_condition.is_set())
instance.stop()
def test10(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
particle = datamodel.Particle()
particle.position = [0, 0, 0] | self.length_unit
particle.velocity = [1, -2, 3.0] | self.speed_unit
particle.mass = 1 | self.mass_unit
particle.radius = 0.0 | self.length_unit
instance.particles.add_particle(particle)
instance.evolve_model(1 | self.time_unit)
self.assertAlmostEqual(instance.model_time, 1 | self.time_unit)
self.assertAlmostEqual(instance.kinetic_energy,
7.0 | self.mass_unit * self.speed_unit**2)
self.assertAlmostEqual(instance.potential_energy,
0.0 | self.mass_unit * self.speed_unit**2)
self.assertAlmostEqual(instance.particles[0].position, [
1.0, -2.0, 3.0] | self.length_unit)
instance.stop()
def new_gravity_code(self):
self.gravity_code_factory()
| 15,229
| 39.184697
| 104
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_higpus.py
|
import numpy
from amuse.test.amusetest import TestWithMPI
from amuse.units import nbody_system
from amuse.units import units
from amuse import datamodel
from amuse.community.higpus.interface import HiGPUsInterface, HiGPUs
from amuse.ic.plummer import new_plummer_model
class HiGPUsInterfaceTests(TestWithMPI):
def test0(self):
instance = self.new_instance_of_an_optional_code(HiGPUsInterface)
instance.initialize_code()
instance.cleanup_code()
instance.stop()
def test1(self):
instance = self.new_instance_of_an_optional_code(HiGPUsInterface)
instance.initialize_code()
instance.set_number_of_Threads(32)
instance.set_number_of_GPU(1)
error = instance.commit_parameters()
index, error = instance.new_particle(1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
self.assertEqual(error, 0)
self.assertEqual(index, 0)
index, error = instance.new_particle(0.000003003, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)
self.assertEqual(error, 0)
self.assertEqual(index, 1)
error = instance.commit_particles()
self.assertEqual(error, 0)
retrieved_state = instance.get_state(index)
self.assertEqual(retrieved_state['__result'], 0)
self.assertEqual(0.000003003, retrieved_state['mass'])
self.assertEqual(0.0, retrieved_state['radius'])
self.assertEqual(instance.get_number_of_particles()['number_of_particles'], 2)
instance.cleanup_code()
instance.stop()
def test2(self):
instance = self.new_instance_of_an_optional_code(HiGPUsInterface)
instance.initialize_code()
for x in [0.101, 4.0]:
error = instance.set_eta4(x)
self.assertEqual(error, 0)
value, error = instance.get_eta4()
self.assertEqual(error, 0)
self.assertEqual(x, value)
instance.cleanup_code()
instance.stop()
def test3(self):
instance = self.new_instance_of_an_optional_code(HiGPUsInterface)
instance.initialize_code()
instance.set_number_of_Threads(32)
instance.set_number_of_GPU(1)
error = instance.commit_parameters()
instance.new_particle([11.0, 12.0, 13.0, 14.0],
[2.0, 3.0, 4.0, 5.0],
[2.1, 3.1, 4.1, 5.1],
[2.2, 3.2, 4.2, 5.2],
[2.3, 3.3, 4.3, 5.3],
[2.4, 3.4, 4.4, 5.4],
[2.5, 3.5, 4.5, 5.5],
[2.6, 3.6, 4.6, 5.6])
error = instance.commit_particles()
retrieved_state = instance.get_state(0)
self.assertEqual(11.0, retrieved_state['mass'])
retrieved_state = instance.get_state([2, 3, 4])
self.assertEqual(14.0, retrieved_state['mass'][1])
self.assertEqual(instance.get_number_of_particles()['number_of_particles'], 4)
instance.cleanup_code()
instance.stop()
def test4(self):
instance = self.new_instance_of_an_optional_code(HiGPUsInterface)
instance.initialize_code()
instance.set_number_of_Threads(128)
instance.set_number_of_GPU(1)
error = instance.commit_parameters()
n = 4000
ids = [i for i in range(1, n)]
values = [1.0 * i for i in range(1, n)]
instance.new_particle(values, values, values, values, values, values, values)
error = instance.commit_particles()
retrieved_state = instance.get_state(0)
self.assertEqual(1.0, retrieved_state['mass'])
retrieved_state = instance.get_state(3998)
self.assertEqual(3999.0, retrieved_state['mass'])
instance.cleanup_code()
instance.stop()
def test5(self):
instance = self.new_instance_of_an_optional_code(HiGPUsInterface)
instance.initialize_code()
instance.set_number_of_Threads(32)
instance.set_number_of_GPU(1)
instance.set_gpu_name("GeForce GTX 480")
instance.set_eps(0.0)
error = instance.commit_parameters()
instance.new_particle(
[1.0, 1.0, 1.0],
[0.0, 0.0, 0.0],
[1.0, 0.0, -1.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0])
instance.commit_particles()
Ep = instance.get_potential_energy()['potential_energy']
Ek = instance.get_kinetic_energy()['kinetic_energy']
self.assertEqual(Ek, 0.5)
self.assertEqual(Ep, -2.5)
instance.delete_particle(1)
instance.recommit_particles()
n = instance.get_number_of_particles()['number_of_particles']
Ep = instance.get_potential_energy()['potential_energy']
Ek = instance.get_kinetic_energy()['kinetic_energy']
self.assertEqual(n, 2)
self.assertEqual(Ek, 0.)
self.assertEqual(Ep, -0.5)
instance.cleanup_code()
instance.stop()
def test6(self):
instance = self.new_instance_of_an_optional_code(HiGPUsInterface)
instance.initialize_code()
instance.set_number_of_Threads(32)
instance.set_number_of_GPU(1)
instance.set_gpu_name("GeForce GTX 480")
instance.set_eps(0.0)
error = instance.commit_parameters()
id1, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
id2, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=2.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
instance.commit_particles()
potential, errorcode = instance.get_potential(id1)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -10.0 / (2.0**2 + 0.1**2)**0.5, 2)
total_potential, errorcode = instance.get_potential_energy()
potentials, errorcode = instance.get_potential([id1, id2])
self.assertAlmostRelativeEquals(total_potential, numpy.sum(potentials * 10.0) / 2.0)
instance.cleanup_code()
instance.stop()
def test7(self):
instance = self.new_instance_of_an_optional_code(HiGPUsInterface)
instance.initialize_code()
instance.set_number_of_Threads(32)
instance.set_number_of_GPU(1)
instance.set_gpu_name("GeForce GTX 480")
instance.set_eps(0.0)
error = instance.commit_parameters()
id1, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
id2, errorcode = instance.new_particle(mass=1.0, radius=1.0, x=2.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
instance.commit_particles()
potential, errorcode = instance.get_potential(id1)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -1.0 / numpy.sqrt(2.0**2), 8)
potential, errorcode = instance.get_potential(id2)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -10.0 / numpy.sqrt(2.0**2), 8)
total_potential, errorcode = instance.get_potential_energy()
potentials, errorcode = instance.get_potential([id1, id2])
self.assertAlmostRelativeEquals(total_potential, numpy.sum(potentials * [10.0, 1.0]) / 2.0)
instance.cleanup_code()
instance.stop()
class TestHiGPUs(TestWithMPI):
def new_system_of_sun_and_earth(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371.)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800., 0.0)))
return stars
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = self.new_instance_of_an_optional_code(HiGPUs, convert_nbody)
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
instance.evolve_model(365 | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_at_start = earth.position.value_in(units.AU)[0]
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(position_at_start, position_after_full_rotation, 6)
instance.evolve_model(365.0 + (365.0 / 2) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 2)
instance.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 2)
instance.stop()
def test2(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = self.new_instance_of_an_optional_code(HiGPUs, convert_nbody)
instance.initialize_code()
instance.commit_parameters()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
instance.particles.mass = [17.0, 33.0] | units.kg
self.assertEqual(instance.get_mass(0), 17.0 | units.kg)
self.assertEqual(instance.get_mass(1), 33.0 | units.kg)
instance.cleanup_code()
instance.stop()
def test3(self):
instance = self.new_instance_of_an_optional_code(HiGPUs)
instance.initialize_code()
instance.parameters.eps = 0.0 | nbody_system.length
instance.commit_parameters()
particles = datamodel.Particles(4)
particles.mass = nbody_system.mass.new_quantity(range(1, 5))
particles.radius = 0.00001 | nbody_system.length
particles.position = [[-1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 1.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
instance.commit_particles()
copyof = instance.particles.copy()
instance.cleanup_code()
instance.stop()
self.assertEqual(2 | nbody_system.mass, copyof[1].mass)
def test4(self):
self.skip("Need to implement get_gravity_at_point for HiGPUs")
instance = self.new_instance_of_an_optional_code(HiGPUs)
instance.initialize_code()
instance.parameters.eps = 0.0
instance.commit_parameters()
particles = datamodel.Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
instance.commit_particles()
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(0.0000001 | nbody_system.length, 2.0 | nbody_system.length, zero, zero)
self.assertAlmostEqual(fx, -0.25 | nbody_system.acceleration)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(0.0000001 | nbody_system.length, x0, zero, zero)
potential1 = instance.get_potential_at_point(0.0000001 | nbody_system.length, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(0.0000001 | nbody_system.length, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(0.0000001 | nbody_system.length, x1, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fx0, -1.0 * fx1, 5)
fx = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0, 2)
self.assertAlmostEqual(potential0, potential1, 5)
instance.cleanup_code()
instance.stop()
def test5(self):
instance = self.new_instance_of_an_optional_code(HiGPUs)
instance.initialize_code()
instance.parameters.eta6 = 0.01
instance.commit_parameters()
stars = new_plummer_model(64)
instance.particles.add_particles(stars)
instance.commit_particles()
instance.evolve_model(0.001 | nbody_system.time)
e0 = instance.get_kinetic_energy() + instance.get_potential_energy()
stars.mass *= 0.9
instance.synchronize_model()
e1 = instance.get_kinetic_energy() + instance.get_potential_energy()
instance.cleanup_code()
instance.stop()
delta_e = e1 - e0
self.assertTrue(e1 != e0)
def test6(self):
particles = datamodel.Particles(2)
particles.mass = [1.0, 0.000003003] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 1.0, 0.0]] | nbody_system.speed
particle = datamodel.Particles(1)
particle.mass = 0.000003003 | nbody_system.mass
particle.radius = 0.0001 | nbody_system.length
particle.position = [0.0, 1.0, 0.0] | nbody_system.length
particle.velocity = [-1.0, 0.0, 0.0] | nbody_system.speed
instance = self.new_instance_of_an_optional_code(HiGPUs)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(1 | nbody_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
instance.particles.remove_particle(particles[1])
instance.particles.add_particle(particle)
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
instance.recommit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(1 | nbody_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
instance.synchronize_model()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
def test7(self):
instance = self.new_instance_of_an_optional_code(HiGPUs)
instance.parameters.eta6 = 0.5
instance.commit_parameters()
self.assertEqual(instance.parameters.eta6, 0.5)
self.assertEqual(instance.parameters.eta4, 0.01)
self.assertEqual(instance.parameters.begin_time, 0.0 | nbody_system.time)
self.assertEqual(instance.parameters.r_core_plummer, 0.0 | nbody_system.length)
self.assertEqual(instance.parameters.mass_plummer, 0.0 | nbody_system.mass)
self.assertEqual(instance.parameters.Threads, 128)
self.assertEqual(instance.parameters.n_Print, 1000000)
self.assertEqual(instance.parameters.dt_Print, 1000000.0 | nbody_system.time)
self.assertEqual(instance.parameters.max_step, pow(2., -3.0) | nbody_system.time)
self.assertEqual(instance.parameters.min_step, pow(2., -30.0) | nbody_system.time)
self.assertEqual(instance.parameters.gpu_name, "")
self.assertEqual(instance.parameters.n_gpu, 1)
instance.cleanup_code()
instance.stop()
def test8(self):
instance = self.new_instance_of_an_optional_code(HiGPUs)
particles = new_plummer_model(128)
instance.particles.add_particles(particles)
E0 = instance.kinetic_energy+instance.potential_energy
instance.evolve_model(1. | nbody_system.time)
E1 = instance.kinetic_energy+instance.potential_energy
self.assertLess(abs(E1-E0)/abs(E0), 1.e-6)
instance.stop()
def test9(self):
instance = self.new_instance_of_an_optional_code(HiGPUs)
particles = new_plummer_model(128)
particles[0:64].mass *= 0
particles[64:].mass *= 2
instance.particles.add_particles(particles)
E0 = instance.kinetic_energy+instance.potential_energy
instance.evolve_model(1. | nbody_system.time)
E1 = instance.kinetic_energy+instance.potential_energy
self.assertLess(abs(E1-E0)/abs(E0), 1.e-6)
instance.stop()
| 17,967
| 39.196868
| 122
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_vader.py
|
import numpy as np
from amuse.community import *
from amuse.test.amusetest import TestWithMPI
from amuse.units import units, constants
from amuse.community.vader.interface import VaderInterface, Vader
default_options = dict()
class TestVaderInterface(TestWithMPI):
def test1(self):
instance = self.new_instance_of_an_optional_code(
VaderInterface, **default_options)
instance.initialize_code()
instance.set_nUserOut(nUserOut=1)
instance.initialize_flat_grid(n=99, linear=True, rmin=1., rmax=100.,
vphi=1.23)
index = 25
self.assertEqual(1.23,
instance.get_rotational_velocity_of_index([index])['vphi'][0])
self.assertEqual(float(index)+1.5,
instance.get_position_of_index([index])['r'][0])
instance.cleanup_code()
instance.stop()
def test2(self):
instance = self.new_instance_of_an_optional_code(
VaderInterface, **default_options)
instance.initialize_code()
instance.set_nUserOut(nUserOut=1)
instance.initialize_keplerian_grid(n=100, linear=False, rmin=1., rmax=100.,
m=1.)
G = 6.67384e-8 # From VADER source
index = 50
r = instance.get_position_of_index([index])['r'][0]
v_kepler = (G/r)**0.5
# Should be exactly equal, but different roundoff in python/c could ruin this
# self.assertEqual(v_kepler,
# instance.get_rotational_velocity_of_index([index])['vphi'][0])
self.assertAlmostEqual(v_kepler,
instance.get_rotational_velocity_of_index([index])['vphi'][0])
self.assertAlmostEqual(v_kepler*v_kepler,
instance.get_gravitational_potential_of_index([index])['psi_grav'][0])
instance.cleanup_code()
instance.stop()
def test3(self):
instance = self.new_instance_of_an_optional_code(
VaderInterface, **default_options)
instance.initialize_code()
instance.set_nUserOut(nUserOut=1)
instance.initialize_flat_grid(n=100, linear=False, rmin=1., rmax=100.,
vphi=1.23)
instance.set_grid_column_density(np.arange(100), np.logspace(0, -2, num=100))
instance.set_grid_pressure(np.arange(100), 10.*np.logspace(0, -2, num=100))
index = 75
self.assertEqual(10.,
instance.get_grid_pressure([index])['pressure'][0] /
instance.get_grid_column_density([index])['sigma'][0])
instance.cleanup_code()
instance.stop()
def test4(self):
instance = self.new_instance_of_an_optional_code(
VaderInterface, **default_options)
instance.initialize_code()
instance.set_nUserOut(nUserOut=1)
instance.initialize_flat_grid(n=100, linear=False, rmin=1., rmax=100.,
vphi=1.23)
instance.set_number_of_user_parameters(5)
instance.set_parameter(0, 1.)
instance.set_parameter(4, 2.)
self.assertEqual(1., instance.get_parameter(0)['param'])
self.assertEqual(2., instance.get_parameter(4)['param'])
instance.cleanup_code()
instance.stop()
class TestVader(TestWithMPI):
def test1(self):
instance = self.new_instance_of_an_optional_code(
Vader, **default_options)
instance.initialize_flat_grid(100, False, 1. | units.AU, 100. | units.AU,
1. | units.kms)
self.assertEqual(1. | units.kms, instance.grid.rotational_velocity[0])
instance.update_flat_grid(2. | units.kms)
self.assertEqual(2. | units.kms, instance.grid.rotational_velocity[0])
instance.stop()
def test2(self):
instance = self.new_instance_of_an_optional_code(
Vader, **default_options)
instance.initialize_keplerian_grid(100, False, 1. | units.AU, 100. | units.AU,
1. | units.MSun)
G = 6.67384e-8 | units.cm**3/units.g/units.s**2 # From VADER source
index = 25
v_kepler = (G*(1. | units.MSun)/instance.grid.r[index])**0.5
self.assertEqual(v_kepler, instance.grid.rotational_velocity[index])
instance.update_keplerian_grid(2. | units.MSun)
v_kepler = (G*(2. | units.MSun)/instance.grid.r[index])**0.5
self.assertEqual(v_kepler, instance.grid.rotational_velocity[index])
self.assertEqual((v_kepler*v_kepler).value_in((units.cm/units.s)**2),
-instance.grid.gravitational_potential[index].value_in(
(units.cm/units.s)**2))
instance.stop()
def test3(self):
instance = self.new_instance_of_an_optional_code(
Vader, **default_options)
instance.initialize_keplerian_grid(100, False, 1. | units.AU, 100. | units.AU,
1. | units.MSun)
instance.parameters.alpha = 1e-3
instance.parameters.gamma = 5./3.
instance.parameters.delta = 1. | (units.cm/units.s)**2
self.assertEqual(0.001, instance.parameters.alpha)
self.assertEqual(5./3., instance.parameters.gamma)
self.assertEqual(1.,
instance.parameters.delta.value_in((units.cm/units.s)**2))
col = np.logspace(0, -2, num=100) | units.g/units.cm**2
pres = col * constants.kB*(100. | units.K)/(constants.u)
instance.grid.column_density = col
instance.grid.pressure = pres
mass0 = instance.mass
instance.evolve_model(1. | units.kyr)
mass1 = instance.mass
self.assertAlmostEqual(mass0.value_in(units.MSun),
mass1.value_in(units.MSun))
instance.stop()
def test4(self):
instance = self.new_instance_of_an_optional_code(
Vader, **default_options)
instance.initialize_keplerian_grid(100, False, 1. | units.AU, 100. | units.AU,
1. | units.MSun)
instance.parameters.alpha = 1e-3
instance.parameters.inner_pressure_boundary_mass_flux = \
-1e-10 | units.MSun/units.yr
instance.parameters.outer_pressure_boundary_mass_flux = \
1e-12 | units.MSun/units.yr
col = np.logspace(0, -2, num=100) | units.g/units.cm**2
pres = col * constants.kB*(100. | units.K)/(constants.u)
instance.grid.column_density = col
instance.grid.pressure = pres
mass0 = instance.mass
instance.evolve_model(1. | units.kyr)
mass1 = instance.mass
self.assertAlmostEqual(mass0.value_in(units.MSun),
(mass1 -
instance.inner_boundary_mass_out -
instance.outer_boundary_mass_out
).value_in(units.MSun))
instance.stop()
| 6,743
| 32.72
| 86
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_mikkola.py
|
import numpy
from numpy import pi
from amuse.community import *
from amuse.test.amusetest import TestWithMPI
from amuse.units import constants
from amuse.community.mikkola.interface import MikkolaInterface
from amuse.community.mikkola.interface import Mikkola
class MikkolaInterfaceTests(TestWithMPI):
def xtest0(self):
instance = MikkolaInterface()
def test1(self):
# instance = MikkolaInterface(debugger="ddd")
instance = MikkolaInterface()
# instance = MikkolaInterface()
instance.initialize_code()
instance.set_lightspeed(1e4)
instance.commit_parameters()
res1 = instance.new_particle(mass=1.0, radius=0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
res2 = instance.new_particle(mass=0.001, radius=0, x=1.0, y=0.0, z=0.0, vx=0.0, vy=1.0, vz=0.0)
self.assertEqual(1, res1['index_of_the_particle'])
self.assertEqual(2, res2['index_of_the_particle'])
retrieved_state1 = instance.get_state(1)
retrieved_state2 = instance.get_state(2)
end_time = 10.0
instance.evolve_model(end_time)
instance.cleanup_code()
instance.stop()
def test2(self):
instance = MikkolaInterface()
instance.initialize_code()
instance.set_lightspeed(1e4)
instance.commit_parameters()
index1, error = instance.new_particle(mass=1.0, radius=0.1, x=1.0, y=2.0, z=3.0, vx=1.1, vy=2.2, vz=3.3)
self.assertEqual(error, 0)
index2, error = instance.new_particle(mass=0.001, radius=0.2, x=3.0, y=4.0, z=5.0, vx=3.3, vy=4.4, vz=5.5)
self.assertEqual(error, 0)
self.assertEqual(1, index1)
self.assertEqual(2, index2)
mass, error = instance.get_mass(1)
self.assertEqual(error, 0)
self.assertEqual(mass, 1.0)
mass, error = instance.get_mass(2)
self.assertEqual(error, 0)
self.assertEqual(mass, 0.001)
radius, error = instance.get_radius(1)
self.assertEqual(error, 0)
self.assertEqual(radius, 0.1)
radius, error = instance.get_radius(2)
self.assertEqual(error, 0)
self.assertEqual(radius, 0.2)
x, y, z, error = instance.get_position(1)
self.assertEqual(error, 0)
self.assertEqual(x, 1.0)
self.assertEqual(y, 2.0)
self.assertEqual(z, 3.0)
x, y, z, error = instance.get_position(2)
self.assertEqual(error, 0)
self.assertEqual(x, 3.0)
self.assertEqual(y, 4.0)
self.assertEqual(z, 5.0)
vx, vy, vz, error = instance.get_velocity(1)
self.assertEqual(error, 0)
self.assertEqual(vx, 1.1)
self.assertEqual(vy, 2.2)
self.assertEqual(vz, 3.3)
instance.cleanup_code()
instance.stop()
def test3(self):
instance = MikkolaInterface()
instance.initialize_code()
instance.set_lightspeed(1e4)
instance.commit_parameters()
index1, error = instance.new_particle(mass=1.0, radius=0, x=1.0, y=2.0, z=3.0, vx=1.1, vy=2.2, vz=3.3)
self.assertEqual(error, 0)
index2, error = instance.new_particle(mass=0.001, radius=0, x=3.0, y=4.0, z=5.0, vx=3.3, vy=4.4, vz=5.5)
self.assertEqual(error, 0)
self.assertEqual(1, index1)
self.assertEqual(2, index2)
mass, error = instance.get_mass(1)
self.assertEqual(error, 0)
self.assertEqual(mass, 1.0)
mass, error = instance.get_mass(2)
self.assertEqual(error, 0)
self.assertEqual(mass, 0.001)
error = instance.delete_particle(1)
mass, error = instance.get_mass(1)
self.assertEqual(error, -1)
index1, error = instance.new_particle(mass=2.0, radius=0, x=1.0, y=2.0, z=3.0, vx=1.1, vy=2.2, vz=3.3)
self.assertEqual(error, 0)
self.assertEqual(1, index1)
mass, error = instance.get_mass(1)
self.assertEqual(error, 0)
self.assertEqual(mass, 2.0)
mass, error = instance.get_mass(2)
self.assertEqual(error, 0)
self.assertEqual(mass, 0.001)
def test4(self):
instance = MikkolaInterface()
instance.initialize_code()
instance.set_lightspeed(1e4)
instance.commit_parameters()
index1, error = instance.new_particle(mass=1.0, radius=0, x=1.0, y=2.0, z=3.0, vx=1.1, vy=2.2, vz=3.3)
self.assertEqual(error, 0)
self.assertEqual(index1, 1)
instance.commit_particles()
error = instance.cleanup_code()
self.assertEqual(error, 0)
mass, error = instance.get_mass(1)
self.assertEqual(error, -1)
instance.commit_parameters()
index1, error = instance.new_particle(mass=1.0, radius=0, x=1.0, y=2.0, z=3.0, vx=1.1, vy=2.2, vz=3.3)
self.assertEqual(error, 0)
self.assertEqual(index1, 1)
instance.commit_particles()
error = instance.cleanup_code()
self.assertEqual(error, 0)
# run with:
# %>nosetests -v test_mikkola.py:TestMikkola.test1
class TestMikkola(TestWithMPI):
def new_system_of_sun_and_earth(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
return stars
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
instance.parameters.timestep = 0.5 | units.day
stars = self.new_system_of_sun_and_earth()
instance.particles.add_particles(stars)
Sun = stars[0]
earth = stars[1]
postion_at_start = earth.position.value_in(units.AU)[0]
# instance.evolve_model(365.0 | units.day)
instance.evolve_model(1.0 | units.yr)
channel = instance.particles.new_channel_to(stars)
channel.copy()
self.assertAlmostRelativeEquals(instance.potential_energy * -0.5, instance.kinetic_energy, 3)
self.assertAlmostRelativeEquals(instance.radiated_gravitational_energy, -6222456075.98 | units.m**2 * units.kg * units.s**-2, 4)
postion_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(postion_at_start, instance.particles[1].position.value_in(units.AU)[0], 3)
self.assertAlmostEqual(postion_at_start, postion_after_full_rotation, 3)
instance.evolve_model(1.5 | units.yr)
channel.copy()
postion_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-postion_at_start, postion_after_half_a_rotation, 3)
instance.evolve_model(1.75 | units.yr)
channel.copy()
postion_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostEqual(-postion_at_start, postion_after_half_a_rotation, 3)
instance.cleanup_code()
del instance
# run with:
# %>nosetests -v test_mikkola.py:TestMikkola.test1
def new_system_of_sun_and_mercury(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
mercury = stars[1]
mercury.mass = 3.3022e23 | units.kg
mercury.radius = 0 | units.RSun
mercury.position = [0.387098, 0, 0] | units.AU
mercury.velocity = [0.0, 47.87, 0.0] | units.km/units.s
return stars
def test2(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
instance.parameters.timestep = 1 | units.day
stars = self.new_system_of_sun_and_mercury()
instance.particles.add_particles(stars)
Sun = stars[0]
mercury = stars[1]
postion_at_start = mercury.position.value_in(units.AU)[0]
period_mercury = 87.9691 | units.day
instance.evolve_model(period_mercury)
channel = instance.particles.new_channel_to(stars)
channel.copy()
postion_after_full_rotation = mercury.position.value_in(units.AU)[0]
self.assertAlmostEqual(postion_at_start, postion_after_full_rotation, 4)
instance.evolve_model(1.5 * period_mercury)
channel.copy()
postion_after_half_a_rotation = mercury.position.value_in(units.AU)[0]
self.assertAlmostEqual(-postion_at_start, postion_after_half_a_rotation, 3)
instance.evolve_model(1.75 * period_mercury)
channel.copy()
postion_after_half_a_rotation = mercury.position.value_in(units.AU)[1]
self.assertAlmostEqual(-postion_at_start, postion_after_half_a_rotation, 3)
instance.cleanup_code()
del instance
# run with:
# %>nosetests -v test_mikkola.py:TestMikkola.test3
def new_system_of_Hulse_Taylor_pulsar(self):
stars = datamodel.Stars(2)
Hulse = stars[0]
Hulse.mass = 1.441 | units.MSun
Hulse.radius = 1.4e-5 | units.RSun
Hulse.position = [-1576800.0, 0, 0] | units.km
# Hulse.velocity = [0.0, -55.0, 0.0] | units.km/units.s
# Hulse.position = [-1546691.3719943422, 0, 0] | units.km
Hulse.velocity = [0.0, -110.0, 0.0] | units.km/units.s
Taylor = stars[1]
Taylor.mass = 1.387 | units.MSun
Taylor.radius = 1.4e-5 | units.RSun
Taylor.position = [1606908.6280056578, 0, 0] | units.km
Taylor.velocity = [0.0, 114.28262436914201, 0.0] | units.km/units.s
# Taylor.position = [1576800.0, 0, 0] | units.km
# Taylor.velocity = [0.0, 55.0, 0.0] | units.km/units.s
return stars
def test3(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
instance.parameters.lightspeed = constants.c
stars = self.new_system_of_Hulse_Taylor_pulsar()
instance.particles.add_particles(stars)
Hulse = stars[0]
Taylor = stars[1]
postion_at_start = Taylor.position.value_in(units.AU)[0]
# orbital period
# see http://www.johnstonsarchive.net/relativity/binpulsar.html
period_HTpulsar = 7.75 | units.hour
# period_HTpulsar = 77.51939106 | units.hour
# period for abseidal motion
# period_HTpulsar = 85.0 | units.yr #4.2degrees/year
# period_HTpulsar = 1.0 | units.yr
instance.evolve_model(period_HTpulsar)
channel = instance.particles.new_channel_to(stars)
channel.copy()
postion_after_full_rotation = Taylor.position.value_in(units.AU)[0]
print("Time=", instance.model_time, period_HTpulsar)
self.assertAlmostEqual(postion_at_start, postion_after_full_rotation, 3)
instance.stop()
del instance
def test4(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
stars = self.new_system_of_Hulse_Taylor_pulsar()
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertEqual(len(instance.particles), 2)
instance.cleanup_code()
self.assertEqual(len(instance.particles), 0)
instance.initialize_code()
instance.particles.add_particles(stars)
self.assertEqual(len(instance.particles), 2)
instance.commit_particles()
self.assertEqual(len(instance.particles), 2)
instance.cleanup_code()
self.assertEqual(len(instance.particles), 0)
def test5(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
stars = datamodel.Stars(3)
stars[0].mass = 1.0 | units.MSun
stars[0].radius = 1.0 | units.RSun
stars[0].position = [0.0, 0, 0] | units.km
stars[0].velocity = [0.0, 0.0, 0.0] | units.km/units.s
stars[1].mass = 1.0 | units.MSun
stars[1].radius = 1.0 | units.RSun
stars[1].position = [0.1, 0, 0] | units.RSun
stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
stars[2].mass = 0.01 | units.MSun
stars[2].radius = 1.0 | units.RSun
stars[2].position = [6000, 0, 0] | units.RSun
stars[2].velocity = [0.0, -10, 0.0] | units.km/units.s
instance.particles.add_particles(stars)
instance.evolve_model(0.25 | units.yr)
self.assertEqual(instance.get_number_of_particles_added(), 1)
self.assertRaises(Exception, instance.get_id_of_added_particle, [2])
self.assertEqual(instance.get_id_of_added_particle(0), 4)
self.assertAlmostRelativeEquals(instance.get_mass(4), 2 | units.MSun)
self.assertAlmostRelativeEquals(instance.get_mass(1), 1 | units.MSun)
self.assertAlmostRelativeEquals(instance.get_mass(2), 1 | units.MSun)
pos1 = quantities.as_vector_quantity(instance.get_position(1))
pos2 = quantities.as_vector_quantity(instance.get_position(2))
posmerger = quantities.as_vector_quantity(instance.get_position(4))
print(pos1)
print(pos2)
print(posmerger)
distance = (pos1-pos2).length()
self.assertTrue(distance < 1e-4 | units.RSun)
self.assertTrue(distance > 1e-6 | units.RSun)
distance = (pos1-posmerger).length()
print(distance.as_quantity_in(units.RSun))
self.assertAlmostRelativeEquals(distance, 0.718548184852 | units.RSun, 5)
distance = (pos2-posmerger).length()
print(distance.as_quantity_in(units.RSun))
self.assertAlmostRelativeEquals(distance, 0.718548184852 | units.RSun, 5)
instance.update_particle_set()
print(instance.particles[0].mass.as_quantity_in(units.MSun))
# self.assertEquals(len(instance.particles), 4)
def test6(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
stars = datamodel.Stars(4)
stars[0].mass = 1.0 | units.MSun
stars[0].radius = 1.0 | units.RSun
stars[0].position = [0.0, 0, 0] | units.km
stars[0].velocity = [0.0, 0.0, 0.0] | units.km/units.s
stars[1].mass = 1.0 | units.MSun
stars[1].radius = 1.0 | units.RSun
stars[1].position = [0.1, 0, 0] | units.RSun
stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
stars[2].mass = 1.0 | units.MSun
stars[2].radius = 1.0 | units.RSun
stars[2].position = [0.3, 0, 0] | units.RSun
stars[2].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
stars[3].mass = 0.01 | units.MSun
stars[3].radius = 1.0 | units.RSun
stars[3].position = [6000, 0, 0] | units.RSun
stars[3].velocity = [0.0, -10, 0.0] | units.km/units.s
instance.particles.add_particles(stars)
instance.evolve_model(0.25 | units.yr)
self.assertEqual(instance.get_number_of_particles_added(), 2)
self.assertRaises(Exception, instance.get_id_of_added_particle, [2])
self.assertEqual(instance.get_id_of_added_particle(0), 5)
self.assertEqual(instance.get_id_of_added_particle(1), 6)
self.assertAlmostRelativeEquals(instance.get_mass(6), 3 | units.MSun)
self.assertAlmostRelativeEquals(instance.get_mass(5), 2 | units.MSun)
instance.update_particle_set()
print(instance.particles[0].mass.as_quantity_in(units.MSun))
# self.assertEquals(len(instance.particles), 4)
def test7(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
stars = datamodel.Stars(3)
stars[0].mass = 1.0 | units.MSun
stars[0].radius = 1.0 | units.RSun
stars[0].position = [0.0, 0, 0] | units.km
stars[0].velocity = [0.0, 0.0, 0.0] | units.km/units.s
stars[1].mass = 1.0 | units.MSun
stars[1].radius = 1.0 | units.RSun
stars[1].position = [0.1, 0, 0] | units.RSun
stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
stars[2].mass = 0.01 | units.MSun
stars[2].radius = 1.0 | units.RSun
stars[2].position = [6000, 0, 0] | units.RSun
stars[2].velocity = [0.0, -10, 0.0] | units.km/units.s
instance.particles.add_particles(stars)
instance.evolve_model(0.25 | units.yr)
self.assertEqual(instance.get_number_of_particles_added(), 1)
self.assertEqual(instance.get_id_of_added_particle(0), 4)
child1, child2 = instance.get_children_of_particle([4])
self.assertEqual(child1[0], instance.particles[0])
self.assertEqual(child2[0], instance.particles[1])
for i in range(3):
child1, child2 = instance.get_children_of_particle([i+1])
self.assertEqual(child1[0], None)
self.assertEqual(child2[0], None)
def test8(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
stars = datamodel.Stars(3)
stars[0].mass = 1.0 | units.MSun
stars[0].radius = 1.0 | units.RSun
stars[0].position = [0.0, 0, 0] | units.km
stars[0].velocity = [0.0, 0.0, 0.0] | units.km/units.s
stars[1].mass = 1.0 | units.MSun
stars[1].radius = 1.0 | units.RSun
stars[1].position = [0.1, 0, 0] | units.RSun
stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
stars[2].mass = 0.01 | units.MSun
stars[2].radius = 1.0 | units.RSun
stars[2].position = [6000, 0, 0] | units.RSun
stars[2].velocity = [0.0, -10, 0.0] | units.km/units.s
instance1 = Mikkola(convert_nbody)
instance1.particles.add_particles(stars)
instance1.evolve_model(0.45 | units.yr)
pos11 = quantities.as_vector_quantity(instance1.get_position(1))
pos12 = quantities.as_vector_quantity(instance1.get_position(2))
posmerger1 = quantities.as_vector_quantity(instance1.get_position(4))
instance1.stop()
instance2 = Mikkola(convert_nbody)
instance2.particles.add_particles(stars)
instance2.evolve_model(0.15 | units.yr)
self.assertAlmostRelativeEquals(instance2.model_time, 0.15 | units.yr, 3)
instance2.evolve_model(0.3 | units.yr)
print(instance2.model_time.as_quantity_in(units.yr))
self.assertAlmostRelativeEquals(instance2.model_time, 0.45 | units.yr, 3)
pos21 = quantities.as_vector_quantity(instance2.get_position(1))
pos22 = quantities.as_vector_quantity(instance2.get_position(2))
posmerger2 = quantities.as_vector_quantity(instance2.get_position(4))
print(pos11, pos21)
print(pos12, pos22)
print(posmerger1, posmerger2)
instance2.stop()
self.assertAlmostRelativeEquals(pos11, pos21)
self.assertAlmostRelativeEquals(pos12, pos22)
self.assertAlmostRelativeEquals(posmerger1[0], posmerger2[0], 4)
self.assertAlmostRelativeEquals(posmerger1[1], posmerger2[1], 1)
def test9(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
stars = datamodel.Stars(4)
stars[0].mass = 1.0 | units.MSun
stars[0].radius = 1.0 | units.RSun
stars[0].position = [0.0, 0, 0] | units.km
stars[0].velocity = [0.0, 0.0, 0.0] | units.km/units.s
stars[1].mass = 1.0 | units.MSun
stars[1].radius = 1.0 | units.RSun
stars[1].position = [0.1, 0, 0] | units.RSun
stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
stars[2].mass = 1.0 | units.MSun
stars[2].radius = 1.0 | units.RSun
stars[2].position = [0.3, 0, 0] | units.RSun
stars[2].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
stars[3].mass = 0.01 | units.MSun
stars[3].radius = 1.0 | units.RSun
stars[3].position = [6000, 0, 0] | units.RSun
stars[3].velocity = [0.0, -10, 0.0] | units.km/units.s
instance.particles.add_particles(stars)
instance.evolve_model(0.15 | units.yr)
instance.update_particle_set()
self.assertEqual(instance.get_id_of_added_particle(0), 5)
self.assertEqual(instance.get_id_of_added_particle(1), 6)
instance.evolve_model(0.30 | units.yr)
instance.update_particle_set()
self.assertEqual(instance.get_number_of_particles_added(), 0)
child1, child2 = instance.get_children_of_particle([5])
self.assertEqual(child1[0], instance.particles[0])
self.assertEqual(child2[0], instance.particles[1])
child1, child2 = instance.get_children_of_particle([6])
self.assertEqual(child2[0], instance.particles[2])
self.assertEqual(child1[0], instance.particles[4])
def test10(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
instance.parameters.maximum_number_of_particles = 2
stars = datamodel.Stars(3)
stars[0].mass = 1.0 | units.MSun
stars[0].radius = 1.0 | units.RSun
stars[0].position = [0.0, 0, 0] | units.km
stars[0].velocity = [0.0, 0.0, 0.0] | units.km/units.s
stars[1].mass = 1.0 | units.MSun
stars[1].radius = 1.0 | units.RSun
stars[1].position = [0.1, 0, 0] | units.RSun
stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
stars[2].mass = 0.01 | units.MSun
stars[2].radius = 1.0 | units.RSun
stars[2].position = [6000, 0, 0] | units.RSun
stars[2].velocity = [0.0, -10, 0.0] | units.km/units.s
self.assertRaises(exceptions.AmuseException, instance.particles.add_particles, stars)
def test10b(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
instance.parameters.maximum_number_of_particles = 3
stars = datamodel.Stars(3)
stars[0].mass = 1.0 | units.MSun
stars[0].radius = 1.0 | units.RSun
stars[0].position = [0.0, 0, 0] | units.km
stars[0].velocity = [0.0, 0.0, 0.0] | units.km/units.s
stars[1].mass = 1.0 | units.MSun
stars[1].radius = 1.0 | units.RSun
stars[1].position = [0.1, 0, 0] | units.RSun
stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
stars[2].mass = 0.01 | units.MSun
stars[2].radius = 1.0 | units.RSun
stars[2].position = [6000, 0, 0] | units.RSun
stars[2].velocity = [0.0, -10, 0.0] | units.km/units.s
instance.particles.add_particles(stars)
self.assertRaises(exceptions.AmuseException, instance.evolve_model, 0.3 | units.yr)
def test11(self):
instance = Mikkola()
self.assertTrue(instance.parameters.evolve_to_exact_time)
instance.parameters.evolve_to_exact_time = False
self.assertFalse(instance.parameters.evolve_to_exact_time)
self.assertEqual(instance.parameters.maximum_number_of_particles, 100)
instance.parameters.maximum_number_of_particles = 200
self.assertEqual(instance.parameters.maximum_number_of_particles, 200)
self.assertAlmostRelativeEquals(instance.parameters.tolerance, 1e-13, 6)
instance.parameters.tolerance = 1e-10
self.assertAlmostRelativeEquals(instance.parameters.tolerance, 1e-10)
instance.stop()
def test12(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
stars = datamodel.Stars(4)
stars[0].mass = 1.0 | units.MSun
stars[0].radius = 1.0 | units.RSun
stars[0].position = [0.0, 0, 0] | units.km
stars[0].velocity = [0.0, 0.0, 0.0] | units.km/units.s
stars[1].mass = 1.0 | units.MSun
stars[1].radius = 1.0 | units.RSun
stars[1].position = [0.1, 0, 0] | units.RSun
stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
stars[2].mass = 1.0 | units.MSun
stars[2].radius = 1.0 | units.RSun
stars[2].position = [2, 0, 0] | units.RSun
stars[2].velocity = [-0.1, 0.0, 0.0] | units.km/units.s
stars[3].mass = 0.01 | units.MSun
stars[3].radius = 1.0 | units.RSun
stars[3].position = [6000, 0, 0] | units.RSun
stars[3].velocity = [0.0, -10, 0.0] | units.km/units.s
instance.particles.add_particles(stars)
instance.evolve_model(0.000001 | units.yr)
instance.update_particle_set()
self.assertEqual(instance.get_number_of_particles_added(), 1)
self.assertEqual(instance.get_id_of_added_particle(0), 5)
instance.evolve_model(0.30 | units.yr)
self.assertEqual(instance.get_number_of_particles_added(), 1)
self.assertEqual(instance.get_id_of_added_particle(0), 6)
instance.update_particle_set()
child1, child2 = instance.get_children_of_particle([5])
self.assertEqual(child1[0], instance.particles[0])
self.assertEqual(child2[0], instance.particles[1])
child1, child2 = instance.get_children_of_particle([6])
self.assertEqual(child1[0], instance.particles[2])
self.assertEqual(child2[0], instance.particles[4])
def test13(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
stars = datamodel.Stars(2)
stars[0].mass = 1.0 | units.MSun
stars[0].radius = 1.0 | units.RSun
stars[0].position = [0.0, 0, 0] | units.km
stars[0].velocity = [0.0, 0.0, 0.0] | units.km/units.s
stars[1].mass = 1.0 | units.MSun
stars[1].radius = 1.0 | units.RSun
stars[1].position = [0.1, 0, 0] | units.RSun
stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
instance.particles.add_particles(stars)
self.assertRaises(exceptions.AmuseException, instance.evolve_model, 0.3 | units.yr)
self.assertEqual(instance.get_number_of_particles_added(), 1)
self.assertEqual(instance.get_id_of_added_particle(0), 3)
instance.update_particle_set()
child1, child2 = instance.get_children_of_particle([3])
self.assertEqual(child1[0], instance.particles[0])
self.assertEqual(child2[0], instance.particles[1])
self.assertAlmostRelativeEquals(instance.get_mass(3), 2 | units.MSun)
def test14(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
stars = datamodel.Stars(3)
stars[0].mass = 1.0 | units.MSun
stars[0].radius = 1.0 | units.RSun
stars[0].position = [0.0, 0, 0] | units.km
stars[0].velocity = [0.0, 0.0, 0.0] | units.km/units.s
stars[1].mass = 1.0 | units.MSun
stars[1].radius = 1.0 | units.RSun
stars[1].position = [0.1, 0, 0] | units.RSun
stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
stars[2].mass = 1e-9 | units.MSun
stars[2].radius = 1.0 | units.RSun
stars[2].position = [10000, 0, 0] | units.RSun
stars[2].velocity = [0.0, -100, 0.0] | units.km/units.s
instance = Mikkola(convert_nbody)
instance.particles.add_particles(stars)
instance.evolve_model(0.3 | units.yr)
pos11 = quantities.as_vector_quantity(instance.get_position(1))
pos12 = quantities.as_vector_quantity(instance.get_position(2))
instance.stop()
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
stars = datamodel.Stars(2)
stars[0].mass = 1.0 | units.MSun
stars[0].radius = 1.0 | units.RSun
stars[0].position = [0.0, 0, 0] | units.km
stars[0].velocity = [0.0, 0.0, 0.0] | units.km/units.s
stars[1].mass = 1.0 | units.MSun
stars[1].radius = 1.0 | units.RSun
stars[1].position = [0.1, 0, 0] | units.RSun
stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
instance.particles.add_particles(stars)
self.assertRaises(exceptions.AmuseException, instance.evolve_model, 0.3 | units.yr)
pos21 = quantities.as_vector_quantity(instance.get_position(1))
pos22 = quantities.as_vector_quantity(instance.get_position(2))
instance.stop()
# positions will not be the same but distances will be comparable
self.assertAlmostRelativeEquals((pos22-pos21).length(), (pos12-pos11).length(), 1)
def test15(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.yr/(2.0*pi))
instance = Mikkola(convert_nbody)
stars = datamodel.Stars(2)
stars[0].mass = 1.0 | units.MSun
stars[0].radius = 1.0 | units.RSun
stars[0].position = [0.0, 0, 0] | units.km
stars[0].velocity = [0.0, 0.0, 0.0] | units.km/units.s
stars[1].mass = 1.0 | units.MSun
stars[1].radius = 1.0 | units.RSun
stars[1].position = [0.1, 0, 0] | units.RSun
stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
instance.particles.add_particles(stars)
try:
instance.evolve_model(0.3 | units.yr)
except exceptions.AmuseException as ex:
self.assertEqual(ex.errorcode, -4)
def test16(self):
particles = datamodel.Particles(3)
particles.mass = [0.1, 0.1, 0.0001] | nbody_system.mass
particles.radius = [0.3, 0.3, 0.1] | nbody_system.length
particles.x = [-0.5, 0.5, 10] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [0, 0, 0] | nbody_system.speed
particles[-1].vy = 10 | nbody_system.speed
instance = Mikkola()
instance.initialize_code()
instance.parameters.set_defaults()
instance.parameters.lightspeed = 0 | nbody_system.speed
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(10.0 | nbody_system.time)
print(instance.particles.position)
self.assertTrue(collisions.is_set())
print(instance.model_time)
print(len(collisions.particles(0)))
self.assertTrue(instance.model_time < 2 | nbody_system.time)
print(collisions.particles(0).key)
print(collisions.particles(1).key)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
instance.stop()
| 31,202
| 38.749045
| 136
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_huayno.py
|
from amuse.test.amusetest import TestWithMPI
import os
import sys
import numpy
import math
from amuse.community.huayno.interface import HuaynoInterface, Huayno
from amuse.units import nbody_system
from amuse.units import units, constants
from amuse import datamodel
from amuse.ic import plummer
try:
from matplotlib import pyplot
HAS_MATPLOTLIB = True
except ImportError:
HAS_MATPLOTLIB = False
def elements(starmass, x, y, z, vx, vy, vz, G=constants.G):
mu = G*starmass
r = (x**2+y**2+z**2)**0.5
v2 = (vx**2+vy**2+vz**2)
e = v2/2-mu/r
a = -mu/2/e
hx = y*vz-z*vy
hy = z*vx-x*vz
hz = x*vy-y*vx
rdotv = x*vx+y*vy+z*vz
ex = v2*x/mu-rdotv*vx/mu-x/r
ey = v2*y/mu-rdotv*vy/mu-y/r
ez = v2*z/mu-rdotv*vz/mu-z/r
h2 = (hx**2+hy**2+hz**2)
eps = (1-h2/mu/a)**0.5
return a, eps
def energy(mass, eps, orbiters):
return (0.5*orbiters.velocity.lengths()**2-constants.G*mass/(orbiters.position.lengths()**2+eps**2)**0.5)
def angular_momentum(orbiters):
return orbiters.position.cross(orbiters.velocity).lengths()
class TestHuaynoInterface(TestWithMPI):
def test1(self):
instance = HuaynoInterface()
instance.initialize_code()
res1 = instance.new_particle(mass=11.0, radius=2.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
res2 = instance.new_particle(mass=21.0, radius=5.0, x=10.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
self.assertEqual(0, res1['index_of_the_particle'])
self.assertEqual(1, res2['index_of_the_particle'])
retrieved_state1 = instance.get_state(0)
retrieved_state2 = instance.get_state(1)
self.assertEqual(11.0, retrieved_state1['mass'])
self.assertEqual(21.0, retrieved_state2['mass'])
self.assertEqual(0.0, retrieved_state1['x'])
self.assertEqual(10.0, retrieved_state2['x'])
instance.cleanup_code()
instance.stop()
def test2(self):
instance = HuaynoInterface()
instance.initialize_code()
for i in [0, 1, 2]:
temp_particle = instance.new_particle(mass=i, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
self.assertEqual(i, temp_particle['index_of_the_particle'])
instance.delete_particle(1)
self.assertEqual(2, instance.get_number_of_particles()['number_of_particles'])
self.assertEqual(0, instance.get_index_of_first_particle()['index_of_the_particle'])
self.assertEqual(2, instance.get_index_of_next_particle(0)['index_of_the_next_particle'])
self.assertEqual(0, instance.get_index_of_next_particle(0)['__result'])
self.assertEqual(-2, instance.get_index_of_next_particle(1)['__result'])
self.assertEqual(1, instance.get_index_of_next_particle(2)['__result'])
instance.cleanup_code()
instance.stop()
def test3(self):
huayno = HuaynoInterface()
huayno.set_eps2(0.101)
self.assertEqual(0.101, huayno.get_eps2()['eps2'])
huayno.set_eps2(0.110)
self.assertEqual(0.110, huayno.get_eps2()['eps2'])
huayno.cleanup_code()
huayno.stop()
def test5(self):
huayno = HuaynoInterface()
huayno.initialize_code()
huayno.new_particle([10, 20], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1])
retrieved_state = huayno.get_state(0)
self.assertEqual(10.0, retrieved_state['mass'])
self.assertEqual(1, retrieved_state['radius'])
retrieved_state = huayno.get_state([0, 1])
self.assertEqual(20.0, retrieved_state['mass'][1])
self.assertEqual(huayno.get_number_of_particles()['number_of_particles'], 2)
huayno.cleanup_code()
huayno.stop()
class TestHuayno(TestWithMPI):
def new_system_of_sun_and_earth(self):
particles = datamodel.Particles(2)
particles.mass = [1.0, 3.0037e-6] | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * particles.total_mass() / (1.0 | units.AU)).sqrt()
particles.move_to_center()
return particles
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
huayno = Huayno(convert_nbody)
huayno.initialize_code()
huayno.parameters.epsilon_squared = 0.0 | units.AU**2
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
huayno.particles.add_particles(stars)
huayno.evolve_model(365.0 | units.day)
huayno.particles.copy_values_of_all_attributes_to(stars)
position_at_start = earth.position.value_in(units.AU)[0]
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(position_at_start, position_after_full_rotation, 6)
huayno.evolve_model(365.0 + (365.0 / 2) | units.day)
huayno.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 2)
huayno.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
huayno.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 3)
huayno.cleanup_code()
huayno.stop()
def test2(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = Huayno(convert_nbody)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | units.AU**2
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
for x in range(1, 2000, 10):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
if HAS_MATPLOTLIB:
figure = pyplot.figure()
plot = figure.add_subplot(1, 1, 1)
x_points = earth.get_timeline_of_attribute("x")
y_points = earth.get_timeline_of_attribute("y")
x_points_in_AU = [t_x[1].value_in(units.AU) for t_x in x_points]
y_points_in_AU = [t_x1[1].value_in(units.AU) for t_x1 in y_points]
plot.scatter(x_points_in_AU, y_points_in_AU, color="b", marker='o')
plot.set_xlim(-1.5, 1.5)
plot.set_ylim(-1.5, 1.5)
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "huayno-earth-sun2.svg")
figure.savefig(output_file)
instance.cleanup_code()
del instance
def test3(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = Huayno(convert_nbody)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00001 | units.AU**2
stars = datamodel.Stars(2)
star1 = stars[0]
star2 = stars[1]
star1.mass = units.MSun(1.0)
star1.position = units.AU(numpy.array((-1.0, 0.0, 0.0)))
star1.velocity = units.AUd(numpy.array((0.0, 0.0, 0.0)))
star1.radius = units.RSun(1.0)
star2.mass = units.MSun(1.0)
star2.position = units.AU(numpy.array((1.0, 0.0, 0.0)))
star2.velocity = units.AUd(numpy.array((0.0, 0.0, 0.0)))
star2.radius = units.RSun(100.0)
instance.particles.add_particles(stars)
for x in range(1, 2000, 10):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
def test4(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = Huayno(convert_nbody)
instance.initialize_code()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
instance.particles.mass = [17.0, 33.0] | units.kg
self.assertEqual(instance.get_mass(0), 17.0 | units.kg)
self.assertEqual(instance.get_mass(1), 33.0 | units.kg)
def test5(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = Huayno(convert_nbody)
instance.initialize_code()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
instance.set_state(1, 16 | units.kg, 20.0 | units.m, 40.0 | units.m, 60.0 | units.m,
1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms)
curr_state = instance.get_state(1)
for expected, actural in zip((16 | units.kg, 20.0 | units.m, 40.0 | units.m, 60.0 | units.m,
1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms, 0 | units.m), curr_state):
self.assertAlmostRelativeEquals(actural, expected)
instance.set_state(1, 16 | units.kg, 20.0 | units.m, 40.0 | units.m, 60.0 | units.m,
1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms, 20.0 | units.m)
curr_state = instance.get_state(1)
for expected, actural in zip((16 | units.kg, 20.0 | units.m, 40.0 | units.m, 60.0 | units.m,
1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms, 20 | units.m), curr_state):
self.assertAlmostRelativeEquals(actural, expected)
def test6(self):
print("Test6: Testing Huayno parameters")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.yr, 1.0 | units.AU)
instance = Huayno(convert_nbody)
(value, error) = instance.legacy_interface.get_eps2()
self.assertEqual(0, error)
self.assertEqual(0.0, value)
self.assertAlmostEqual(0.0 | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2)
for x in [0.01, 0.1, 0.2]:
instance.parameters.epsilon_squared = x | units.AU**2
self.assertAlmostEqual(x | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2)
(value, error) = instance.legacy_interface.get_time()
self.assertEqual(0, error)
self.assertEqual(0.0, value)
self.assertAlmostEqual(0.0 | units.yr, instance.parameters.begin_time, in_units=units.yr)
for x in [1.0, 10.0, 100.0]:
instance.parameters.begin_time = x | units.yr
self.assertAlmostEqual(x | units.yr, instance.parameters.begin_time, in_units=units.yr)
instance.stop()
def test7(self):
print("Test7: Testing effect of Huayno parameter epsilon_squared")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
particles = datamodel.Particles(2)
sun = particles[0]
sun.mass = 1.0 | units.MSun
sun.position = [0.0, 0.0, 0.0] | units.AU
sun.velocity = [0.0, 0.0, 0.0] | units.AU / units.yr
sun.radius = 1.0 | units.RSun
earth = particles[1]
earth.mass = 5.9736e24 | units.kg
earth.radius = 6371.0 | units.km
earth.position = [0.0, 1.0, 0.0] | units.AU
earth.velocity = [2.0*numpy.pi, -0.0001, 0.0] | units.AU / units.yr
initial_direction = math.atan((earth.velocity[0]/earth.velocity[1]))
final_direction = []
for log_eps2 in range(-9, 10, 2):
instance = Huayno(convert_nbody)
instance.initialize_code()
instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU ** 2
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.25 | units.yr)
final_direction.append(math.atan((instance.particles[1].velocity[0] /
instance.particles[1].velocity[1])))
instance.stop()
# Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees
self.assertAlmostEqual(abs(final_direction[0]), abs(initial_direction+math.pi/2.0), 2)
# Large values of epsilon_squared should result in ~ no interaction
self.assertAlmostEqual(final_direction[-1], initial_direction, 2)
# Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2
delta = [abs(final_direction[i+1]-final_direction[i]) for i in range(len(final_direction)-1)]
self.assertEqual(delta[len(final_direction)//2 - 1], max(delta))
def test13(self):
particles = plummer.new_plummer_model(31)
instance = Huayno(number_of_workers=1) # , debugger="xterm")
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length ** 2
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
expected_positions = instance.particles.position
instance.stop()
def test14(self):
import hashlib
numpy.random.seed(123456)
particles = plummer.new_plummer_model(32)
sha = hashlib.sha1()
test_set = ["CONSTANT", "SHARED2", "EXTRAPOLATE",
"PASS_KDK", "PASS_DKD", "HOLD_KDK", "HOLD_DKD",
"PPASS_DKD", "BRIDGE_KDK", "BRIDGE_DKD",
"CC", "CC_KEPLER", "CC_BS", "CC_BSA",
"OK", "SHAREDBS", "SHARED4", "SHARED6", "SHARED8",
"SHARED10"]
# ~ test_set=["CONSTANT"]
for itype in test_set:
# ~ print()
# ~ print(itype)
instance = Huayno()
instance.parameters.inttype_parameter = Huayno.all_inttypes[itype]
# ~ instance.parameters.accelerate_zero_mass=False
instance.particles.add_particles(particles)
E1 = instance.kinetic_energy+instance.potential_energy
instance.evolve_model(0.125 | nbody_system.time)
E2 = instance.kinetic_energy+instance.potential_energy
if itype != "CONSTANT":
self.assertLess(abs(E2-E1).number, 1.e-5)
# ~ print((E2-E1).number)
part_out = instance.particles.copy()
position = part_out.position.number
if hasattr(position, 'tobytes'):
as_bytes = position.tobytes()
else:
as_bytes = numpy.array(position.data, copy=True, order='C')
sha.update(as_bytes)
instance.stop()
# this result is probably dependent on system architecture hence no good for assert
print()
print(sha.hexdigest())
print("4f2aac4d8761f3b07545dcea53f1a65f84a5275b")
def test14b(self):
import hashlib
numpy.random.seed(123456)
particles = plummer.new_plummer_model(32)
p2 = plummer.new_plummer_model(32)
p2.mass *= 0
sha = hashlib.sha1()
test_set = ["CONSTANT", "SHARED2", "EXTRAPOLATE",
"PASS_KDK", "PASS_DKD", "HOLD_KDK", "HOLD_DKD",
"PPASS_DKD", "BRIDGE_KDK", "BRIDGE_DKD",
"CC", "CC_KEPLER", "CC_BS", "CC_BSA",
"OK", "SHAREDBS", "SHARED4", "SHARED6", "SHARED8",
"SHARED10"]
for itype in test_set:
# ~ print()
# ~ print(itype)
instance = Huayno(redirection="none")
instance.parameters.inttype_parameter = Huayno.all_inttypes[itype]
instance.parameters.accelerate_zero_mass = True
instance.particles.add_particles(particles)
instance.particles.add_particles(p2)
E1 = instance.kinetic_energy+instance.potential_energy
instance.evolve_model(0.125 | nbody_system.time)
E2 = instance.kinetic_energy+instance.potential_energy
if itype != "CONSTANT":
self.assertLess((E2-E1).number, 1.e-5)
part_out = instance.particles.copy()
position = part_out.position.number
if hasattr(position, 'tobytes'):
as_bytes = position.tobytes()
else:
as_bytes = numpy.array(position.data, copy=True, order='C')
sha.update(as_bytes)
instance.stop()
# this result is probably dependent on system architecture hence no good for assert
print()
print(sha.hexdigest())
print("f3563453fb9b959d8337c6e57a526e1ff52572a7")
def test14c(self):
import hashlib
numpy.random.seed(123456)
particles = plummer.new_plummer_model(16)
particles.mass *= 0.25
p2 = plummer.new_plummer_model(16)
p2.mass *= 0.75
sha = hashlib.sha1()
test_set = ["CONSTANT", "SHARED2", "EXTRAPOLATE",
"PASS_KDK", "PASS_DKD", "HOLD_KDK", "HOLD_DKD",
"PPASS_DKD", "BRIDGE_KDK", "BRIDGE_DKD",
"CC", "CC_KEPLER", "CC_BS", "CC_BSA",
"OK", "SHAREDBS", "SHARED4", "SHARED6", "SHARED8",
"SHARED10"]
# ~ test_set=["CC_BS"]
for itype in test_set:
# ~ print()
# ~ print(itype)
instance = Huayno(redirection="none")
instance.parameters.inttype_parameter = Huayno.all_inttypes[itype]
instance.parameters.accelerate_zero_mass = True
instance.particles.add_particles(particles)
instance.particles.add_particles(p2)
E1 = instance.kinetic_energy+instance.potential_energy
instance.evolve_model(0.125 | nbody_system.time)
E2 = instance.kinetic_energy+instance.potential_energy
# ~ if itype!="CONSTANT":
# ~ self.assertLess(abs(E2-E1).number, 1.e-5)
# ~ print((E2-E1).number)
part_out = instance.particles.copy()
position = part_out.position.number
if hasattr(position, 'tobytes'):
as_bytes = position.tobytes()
else:
as_bytes = numpy.array(position.data, copy=True, order='C')
sha.update(as_bytes)
instance.stop()
# this result is probably dependent on system architecture hence no good for assert
print()
print(sha.hexdigest())
print("0af7eaea472989ea4be1bb0e2b8633d6b9af41e4")
def test15(self):
particles = plummer.new_plummer_model(512)
expected_positions = None
for mode in ["cpu", "openmp", "opencl"]:
try:
instance = Huayno(mode=mode, number_of_workers=1) # , debugger="xterm")
except:
print("Running huayno with mode=", mode, " was unsuccessful.")
continue
else:
print("Running huayno with mode=", mode, "... ")
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length ** 2
instance.particles.add_particles(particles)
instance.evolve_model(0.2 | nbody_system.time)
instance.synchronize_model()
if expected_positions is None:
expected_positions = instance.particles.position
else:
self.assertAlmostRelativeEquals(expected_positions, instance.particles.position, 8)
instance.stop()
def test16(self):
instance = Huayno()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles = datamodel.Particles(2)
particles.mass = [1.] | nbody_system.mass
particles.radius = [0.0] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration, 14)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration, 14)
fx = (-1.0 / (x0**2)+1.0 / (((1.0 | nbody_system.length)-x0)**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0, 14)
self.assertAlmostEqual(potential0, -nbody_system.G*(1. | nbody_system.mass)*(1./x0+1./((1. | nbody_system.length)-x0)), 14)
instance.stop()
def _compare_integrator_with_collision_integrator(self, inttype_parameter1, inttype_parameter2):
numpy.random.seed(12345)
particles = plummer.new_plummer_model(101)
instance = Huayno()
instance.parameters.inttype_parameter = inttype_parameter1
instance.particles.add_particles(particles)
instance.evolve_model(0.2 | nbody_system.time)
expected_position = instance.particles.position
expected_velocity = instance.particles.velocity
instance.reset()
instance.parameters.inttype_parameter = inttype_parameter2
instance.particles.add_particles(particles)
instance.evolve_model(0.2 | nbody_system.time)
self.assertAlmostRelativeEquals(expected_position, instance.particles.position, 8)
self.assertAlmostRelativeEquals(expected_velocity, instance.particles.velocity, 8)
instance.stop()
def _run_collision_with_integrator(self, inttype_parameter):
particles = datamodel.Particles(7)
particles.mass = 0.001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = Huayno()
instance.parameters.inttype_parameter = inttype_parameter
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 3)
self.assertEqual(len(collisions.particles(1)), 3)
self.assertEqual(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <=
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = datamodel.Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <=
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test17(self):
print("Compare the SHARED2 integrator with the collision-detection enabled SHARED2_COLLISIONS integrator")
self._compare_integrator_with_collision_integrator(Huayno.inttypes.SHARED2_COLLISIONS, Huayno.inttypes.SHARED2)
print("Testing Huayno collision_detection with SHARED2_COLLISIONS")
self._run_collision_with_integrator(Huayno.inttypes.SHARED2_COLLISIONS)
def test18(self):
print("Compare the SHARED4 integrator with the collision-detection enabled SHARED4_COLLISIONS integrator")
self._compare_integrator_with_collision_integrator(Huayno.inttypes.SHARED4_COLLISIONS, Huayno.inttypes.SHARED4)
print("Testing Huayno collision_detection with SHARED4_COLLISIONS")
self._run_collision_with_integrator(Huayno.inttypes.SHARED4_COLLISIONS)
def test19(self):
print("Compare the SHARED6 integrator with the collision-detection enabled SHARED6_COLLISIONS integrator")
self._compare_integrator_with_collision_integrator(Huayno.inttypes.SHARED6_COLLISIONS, Huayno.inttypes.SHARED6)
print("Testing Huayno collision_detection with SHARED6_COLLISIONS")
self._run_collision_with_integrator(Huayno.inttypes.SHARED6_COLLISIONS)
def test20(self):
print("Compare the SHARED8 integrator with the collision-detection enabled SHARED8_COLLISIONS integrator")
self._compare_integrator_with_collision_integrator(Huayno.inttypes.SHARED8_COLLISIONS, Huayno.inttypes.SHARED8)
print("Testing Huayno collision_detection with SHARED8_COLLISIONS")
self._run_collision_with_integrator(Huayno.inttypes.SHARED8_COLLISIONS)
def test21(self):
print("Compare the SHARED10 integrator with the collision-detection enabled SHARED10_COLLISIONS integrator")
self._compare_integrator_with_collision_integrator(Huayno.inttypes.SHARED10_COLLISIONS, Huayno.inttypes.SHARED10)
print("Testing Huayno collision_detection with SHARED10_COLLISIONS")
self._run_collision_with_integrator(Huayno.inttypes.SHARED10_COLLISIONS)
def test22(self):
print("Testing zero-mass test particles in Huayno, can be used for removing particles when inside recursive evolve loop")
sun_and_earth = self.new_system_of_sun_and_earth()
period = (4.0 * math.pi**2 * (1.0 | units.AU)**3 / (constants.G * sun_and_earth.total_mass())).sqrt()
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
huayno = Huayno(convert_nbody)
huayno.parameters.epsilon_squared = 0.0 | units.AU**2
huayno.parameters.inttype_parameter = huayno.inttypes.SHARED8
test_particle = datamodel.Particle(mass=0 | units.MSun, position=[4, 0, 0] | units.AU, velocity=[0, 0, 0] | units.kms)
test_particle.vy = (constants.G * sun_and_earth.total_mass() / (4.0 | units.AU)).sqrt()
sun_and_earth.add_particle(test_particle)
huayno.particles.add_particles(sun_and_earth)
huayno.evolve_model(period)
self.assertAlmostRelativeEqual(huayno.particles[:2].x, sun_and_earth[:2].x, 13)
huayno.evolve_model(1.25 * period)
self.assertAlmostRelativeEqual(huayno.particles[1].y, sun_and_earth[1].x, 13)
huayno.evolve_model(8.0 * period)
self.assertAlmostRelativeEqual(huayno.particles.x, sun_and_earth.x, 8)
huayno.stop()
def test23(self):
print("testing removing and adding particles repeatedly")
N = 1100
p1 = plummer.new_plummer_model(N)
p2 = plummer.new_plummer_model(N)
h1 = Huayno()
h1.particles.add_particles(p1[:N//2])
h1.particles.add_particles(p2[-N//2:])
h2 = Huayno()
h2.particles.add_particles(p1)
h2.particles.remove_particles(p1[N//2:])
h2.particles.add_particles(p2)
h2.particles.remove_particles(p2[:-N//2])
self.assertEqual(len(h1.particles), len(h2.particles))
self.assertAlmostEqual(h1.kinetic_energy, h2.kinetic_energy, 15)
self.assertAlmostEqual(h1.potential_energy, h2.potential_energy, 15)
def test24(self):
print("test massless particles/ kepler integrator")
N = 20
tend = 2. | units.yr
numpy.random.seed(12345)
conv = nbody_system.nbody_to_si(4. | units.MSun, 5. | units.AU)
orbiters = plummer.new_plummer_model(N, conv)
sun = datamodel.Particle(mass=1. | units.MSun)
sun.position = [12.3, 1., -.2] | units.AU
sun.velocity = [10, 50., -20.] | units.kms
orbiters.mass *= 0.
a0, eps0 = elements(sun.mass, orbiters.x, orbiters.y, orbiters.z,
orbiters.vx, orbiters.vy, orbiters.vz)
orbiters.position += sun.position
orbiters.velocity += sun.velocity
pos = dict()
for inttype in [20, 14]:
code = Huayno(conv)
code.parameters.inttype_parameter = inttype
code.parameters.timestep_parameter = 0.1
code.particles.add_particle(sun)
orbiters2 = code.particles.add_particles(orbiters).copy()
orbiters2.position -= sun.position
orbiters2.velocity -= sun.velocity
code.evolve_model(tend)
a, eps = elements(sun.mass, orbiters2.x, orbiters2.y, orbiters2.z,
orbiters2.vx, orbiters2.vy, orbiters2.vz)
da = abs((a-a0)/a0)
deps = abs(eps-eps0)/eps0
dev = numpy.where(da > 1.e-12)[0]
self.assertEqual(len(dev), 0)
dev = numpy.where(deps > 1.e-12)[0]
self.assertEqual(len(dev), 0)
pos[inttype] = [orbiters2.x.value_in(units.AU), orbiters2.y.value_in(units.AU), orbiters2.z.value_in(units.AU)]
self.assertAlmostEqual(pos[20][0], pos[14][0], 12)
self.assertAlmostEqual(pos[20][1], pos[14][1], 12)
self.assertAlmostEqual(pos[20][2], pos[14][2], 12)
def test25(self):
print("test massless particles/ kepler integrator, smoothed")
N = 10
tend = 20. | units.yr
numpy.random.seed(12345)
conv = nbody_system.nbody_to_si(4. | units.MSun, 5. | units.AU)
orbiters = plummer.new_plummer_model(N, conv)
sun = datamodel.Particle(mass=1. | units.MSun)
sun.position = [0, 0, 0] | units.AU
sun.velocity = [0, 0, 0] | units.kms
orbiters.mass *= 0.
eps = (5. | units.AU)
e0 = energy(sun.mass, eps, orbiters)
l0 = angular_momentum(orbiters)
pos = dict()
for inttype in [20, 14]:
code = Huayno(conv)
code.parameters.inttype_parameter = inttype
code.parameters.timestep_parameter = 0.1
code.parameters.epsilon_squared = eps**2
code.particles.add_particle(sun)
orbiters2 = code.particles.add_particles(orbiters)
code.evolve_model(tend)
e1 = energy(sun.mass, eps, orbiters2)
l1 = angular_momentum(orbiters2)
de, dl = abs((e1-e0)/e0).max(), abs((l1-l0)/l1).max()
self.assertTrue(numpy.all(de < 1.e-8))
self.assertTrue(numpy.all(dl < 1.e-8))
pos[inttype] = [orbiters2.x.value_in(units.AU), orbiters2.y.value_in(units.AU), orbiters2.z.value_in(units.AU)]
self.assertAlmostRelativeEqual(pos[20][0], pos[14][0], 4) # still not clear why 4
self.assertAlmostRelativeEqual(pos[20][1], pos[14][1], 4)
self.assertAlmostRelativeEqual(pos[20][2], pos[14][2], 4)
def test26(self):
print("test massless particles (negative time)")
N = 10
tend = -5. | units.yr
numpy.random.seed(12345)
conv = nbody_system.nbody_to_si(4. | units.MSun, 5. | units.AU)
orbiters = plummer.new_plummer_model(N, conv)
sun = datamodel.Particle(mass=1. | units.MSun)
sun.position = [0, 0, 0] | units.AU
sun.velocity = [0, 0, 0] | units.kms
orbiters.mass *= 0.
a0, eps0 = elements(sun.mass, orbiters.x, orbiters.y, orbiters.z,
orbiters.vx, orbiters.vy, orbiters.vz)
pos = dict()
for inttype in [20, 14]:
code = Huayno(conv)
code.parameters.inttype_parameter = inttype
code.parameters.timestep_parameter = 0.1
code.particles.add_particle(sun)
orbiters2 = code.particles.add_particles(orbiters)
code.evolve_model(tend)
a, eps = elements(sun.mass, orbiters2.x, orbiters2.y, orbiters2.z,
orbiters2.vx, orbiters2.vy, orbiters2.vz)
da = abs((a-a0)/a0)
deps = abs(eps-eps0)/eps0
dev = numpy.where(da > 1.e-12)[0]
self.assertEqual(len(dev), 0)
dev = numpy.where(deps > 1.e-12)[0]
self.assertEqual(len(dev), 0)
pos[inttype] = [orbiters.x.value_in(units.AU), orbiters.y.value_in(units.AU), orbiters.z.value_in(units.AU)]
self.assertAlmostEqual(pos[20][0], pos[14][0], 12)
self.assertAlmostEqual(pos[20][1], pos[14][1], 12)
self.assertAlmostEqual(pos[20][2], pos[14][2], 12)
def test27(self):
particles = plummer.new_plummer_model(31)
tend = 0.25 | nbody_system.time
instance = Huayno()
instance.particles.add_particles(particles)
instance.evolve_model(tend)
expected_positions = instance.particles.position
self.assertEqual(instance.model_time, tend)
instance.stop()
particles2 = particles.copy()
particles2.velocity *= -1
instance = Huayno()
instance.particles.add_particles(particles2)
instance.evolve_model(-tend)
positions = instance.particles.position
self.assertEqual(instance.model_time, -tend)
instance.stop()
self.assertAlmostEqual(positions, expected_positions)
def test28(self):
particles = plummer.new_plummer_model(31)
instance = Huayno()
instance.particles.add_particles(particles)
self.assertAlmostEqual(particles.total_mass(), instance.total_mass)
self.assertAlmostEqual(particles.center_of_mass(), instance.center_of_mass_position)
self.assertAlmostEqual(particles.center_of_mass_velocity(), instance.center_of_mass_velocity)
def test29(self):
instance = Huayno()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles = datamodel.Particles(2)
particles.position = ([0, 0, 0], [1, 0, 0]) | nbody_system.length
particles.velocity = ([-1, 0, 0], [2, 0, 0]) | nbody_system.speed
particles.radius = 0 | nbody_system.length
particles.mass = 0.1 | nbody_system.mass
instance.particles.add_particles(particles)
instance.stopping_conditions.out_of_box_detection.enable()
instance.parameters.stopping_conditions_out_of_box_size = 2 | nbody_system.length
instance.parameters.stopping_conditions_out_of_box_use_center_of_mass = False
instance.evolve_model(1 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.out_of_box_detection.is_set())
self.assertEqual(len(instance.stopping_conditions.out_of_box_detection.particles(0)), 1)
self.assertEqual(instance.stopping_conditions.out_of_box_detection.particles(0)[0].key, particles[1].key)
instance.stop()
| 36,345
| 41.559719
| 137
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/__init__.py
| 0
| 0
| 0
|
py
|
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_pikachu.py
|
import math
import numpy
import os.path
from amuse.test.amusetest import TestWithMPI
from amuse.units import nbody_system, units, constants
from amuse.datamodel import Particles, Particle
from amuse.community.pikachu.interface import PikachuInterface, Pikachu
from amuse.ic.plummer import new_plummer_model
default_options = dict(mode='normal')
# ~default_options = dict(redirection="none", mode='normal')
# ~default_options = dict(debugger="gdb", mode='normal')
# ~default_options = dict(redirection="none", mode='large_n')
class TestPikachuInterface(TestWithMPI):
def test1(self):
print("Test PikachuInterface initialization")
instance = self.new_instance_of_an_optional_code(PikachuInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
directory, error = instance.get_kernel_directory()
self.assertEqual(0, error)
self.assertEqual("./", directory)
self.assertEqual(0, instance.set_kernel_directory(instance.default_kernel_directory))
directory, error = instance.get_kernel_directory()
self.assertEqual(error, 0)
self.assertEqual(directory, os.path.join(instance.amuse_root_directory, "src", "amuse", "community", "pikachu"))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test2(self):
print("Test PikachuInterface new_particle / get_state")
instance = self.new_instance_of_an_optional_code(PikachuInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_kernel_directory(instance.default_kernel_directory))
self.assertEqual(0, instance.commit_parameters())
id, error = instance.new_particle(mass=11.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0, radius=1.0)
self.assertEqual(0, error)
self.assertEqual(1, id)
id, error = instance.new_particle(mass=21.0, x=10.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0, radius=2.0)
self.assertEqual(0, error)
self.assertEqual(2, id)
self.assertEqual(0, instance.commit_particles())
retrieved_state1 = instance.get_state(1)
retrieved_state2 = instance.get_state(2)
self.assertEqual(0, retrieved_state1['__result'])
self.assertEqual(0, retrieved_state2['__result'])
self.assertEqual(11.0, retrieved_state1['mass'])
self.assertEqual(21.0, retrieved_state2['mass'])
self.assertEqual(0.0, retrieved_state1['x'])
self.assertEqual(10.0, retrieved_state2['x'])
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test3(self):
print("Test PikachuInterface particle property getters/setters")
instance = self.new_instance_of_an_optional_code(PikachuInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_kernel_directory(instance.default_kernel_directory))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([1, 0], list(instance.new_particle(0.01, 1, 0, 0, 0, 1, 0, 0.1).values()))
self.assertEqual([2, 0], list(instance.new_particle(0.02, -1, 0, 0, 0, -1, 0, 0.1).values()))
self.assertEqual(-3, instance.get_mass(1)['__result']) # Have to commit first
self.assertEqual(0, instance.commit_particles())
# getters
mass, result = instance.get_mass(1)
self.assertAlmostEqual(0.01, mass)
self.assertEqual(0, result)
radius, result = instance.get_radius(2)
self.assertAlmostEqual(0.1, radius)
self.assertEqual(0, result)
self.assertEqual(-3, instance.get_mass(3)['__result']) # Particle not found
self.assertEqual([1, 0, 0, 0], list(instance.get_position(1).values()))
self.assertEqual([-1, 0, 0, 0], list(instance.get_position(2).values()))
self.assertEqual([0, 1, 0, 0], list(instance.get_velocity(1).values()))
self.assertEqual([0, -1, 0, 0], list(instance.get_velocity(2).values()))
# setters
self.assertEqual(0, instance.set_state(1, 0.01, 1, 2, 3, 4, 5, 6, 0.1))
self.assertEqual([0.01, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.1, 0], list(instance.get_state(1).values()))
self.assertEqual(0, instance.set_mass(1, 0.02))
self.assertEqual([0.02, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.1, 0], list(instance.get_state(1).values()))
self.assertEqual(0, instance.set_radius(1, 0.2))
self.assertEqual([0.02, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.2, 0], list(instance.get_state(1).values()))
self.assertEqual(0, instance.set_position(1, 10, 20, 30))
self.assertEqual([0.02, 10.0, 20.0, 30.0, 4.0, 5.0, 6.0, 0.2, 0], list(instance.get_state(1).values()))
self.assertEqual(0, instance.set_velocity(1, 40, 50, 60))
self.assertEqual([0.02, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 0.2, 0], list(instance.get_state(1).values()))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test4(self):
print("Test PikachuInterface parameters")
instance = self.new_instance_of_an_optional_code(PikachuInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_kernel_directory(instance.default_kernel_directory))
# Pikachu has separate epsilon_squared parameters for different interactions!
self.assertEqual([1.0e-8, 0], list(instance.get_eps2_fs_fs().values()))
self.assertEqual([1.0e-8, 0], list(instance.get_eps2_fs_bh().values()))
self.assertEqual([0, 0], list(instance.get_eps2_bh_bh().values()))
self.assertEqual(-2, instance.get_eps2()['__result']) # Not implemented (would be ambiguous)
self.assertEqual(0, instance.set_eps2_fs_fs(0.2))
self.assertEqual([0.2, 0], list(instance.get_eps2_fs_fs().values()))
self.assertEqual(0, instance.set_eps2_fs_bh(0.3))
self.assertEqual([0.3, 0], list(instance.get_eps2_fs_bh().values()))
self.assertEqual(0, instance.set_eps2_bh_bh(0.4))
self.assertEqual([0.4, 0], list(instance.get_eps2_bh_bh().values()))
self.assertEqual(-2, instance.set_eps2(0.1)) # Not implemented (would be ambiguous)
self.assertEqual([0.005, 0], list(instance.get_eta_s().values()))
self.assertEqual([0.025, 0], list(instance.get_eta_fs().values()))
self.assertEqual([0.025, 0], list(instance.get_eta_smbh().values()))
self.assertEqual(0, instance.set_eta_s(0.01))
self.assertEqual([0.01, 0], list(instance.get_eta_s().values()))
self.assertEqual(0, instance.set_eta_fs(0.02))
self.assertEqual([0.02, 0], list(instance.get_eta_fs().values()))
self.assertEqual(0, instance.set_eta_smbh(0.03))
self.assertEqual([0.03, 0], list(instance.get_eta_smbh().values()))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
class TestPikachu(TestWithMPI):
default_converter = nbody_system.nbody_to_si(1.0e4 | units.MSun, 1.0 | units.AU)
def new_sun_earth_system(self):
particles = Particles(2)
particles.mass = [1.0, 3.0037e-6] | units.MSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * particles.total_mass() / (1.0 | units.AU)).sqrt()
return particles
def test1(self):
print("Testing Pikachu initialization")
instance = self.new_instance_of_an_optional_code(Pikachu, self.default_converter, **default_options)
instance.initialize_code()
instance.commit_parameters()
instance.cleanup_code()
instance.stop()
def test2(self):
print("Testing Pikachu parameters")
instance = self.new_instance_of_an_optional_code(Pikachu, self.default_converter, **default_options)
instance.initialize_code()
self.assertEqual(instance.parameters.epsilon_squared,
instance.unit_converter.to_si(1.0e-8 | nbody_system.length**2))
self.assertEqual(instance.parameters.timestep_parameter, 0.025)
for par, value in [('epsilon_squared_star_star', 1.0e-8 | nbody_system.length**2),
('epsilon_squared_star_blackhole', 1.0e-8 | nbody_system.length**2),
('epsilon_squared_blackhole_blackhole', 0.0 | nbody_system.length**2),
('initial_timestep_parameter', 0.005),
('timestep_parameter_stars', 0.025),
('timestep_parameter_black_holes', 0.025),
('timestep', 1.0/2048.0 | nbody_system.time),
('search_factor', 3.0),
('velocity_dispersion', 0.707106781 | nbody_system.speed),
('rcut_out_star_star', 2.0e-3 | nbody_system.length),
('rcut_out_star_blackhole', 2.0e-2 | nbody_system.length),
('rcut_out_blackhole_blackhole', 1.0e5 | nbody_system.length),
('rsearch_star_star', 0.0 | nbody_system.length),
('rsearch_star_blackhole', 0.0 | nbody_system.length),
('rsearch_blackhole_blackhole', 0.0 | nbody_system.length),
('opening_angle', 0.4)]:
self.assertEqual(instance.unit_converter.to_si(value),
getattr(instance.parameters, par))
if hasattr(value, 'unit'):
new_value = 3.0 | value.unit
else:
new_value = 3.0
setattr(instance.parameters, par, new_value)
self.assertEqual(instance.unit_converter.to_si(new_value),
getattr(instance.parameters, par))
# epsilon_squared is an alias for epsilon_squared_star_star, so epsilon_squared also has become 3:
self.assertEqual(instance.parameters.epsilon_squared,
instance.unit_converter.to_si(3.0 | nbody_system.length**2))
instance.parameters.epsilon_squared = 0.1 | nbody_system.length**2
self.assertEqual(instance.parameters.epsilon_squared,
instance.unit_converter.to_si(0.1 | nbody_system.length**2))
# timestep_parameter is an alias for timestep_parameter_stars, so timestep_parameter also has become 3:
self.assertEqual(instance.parameters.timestep_parameter, 3.0)
instance.parameters.timestep_parameter = 0.01
self.assertEqual(instance.parameters.timestep_parameter, 0.01)
self.assertEqual(instance.parameters.calculate_quadrupole_moments, False)
instance.parameters.calculate_quadrupole_moments = True
self.assertEqual(instance.parameters.calculate_quadrupole_moments, True)
instance.commit_parameters()
p = instance.parameters
self.assertAlmostRelativeEquals(p.rsearch_star_star,
p.rcut_out_star_star + p.search_factor * p.velocity_dispersion * p.timestep, 10)
self.assertAlmostRelativeEquals(p.rsearch_star_blackhole,
p.rcut_out_star_blackhole + p.search_factor * p.velocity_dispersion * p.timestep, 10)
self.assertAlmostRelativeEquals(p.rsearch_blackhole_blackhole,
p.rcut_out_blackhole_blackhole + p.search_factor * p.velocity_dispersion * p.timestep, 10)
instance.stop()
def test3(self):
print("Testing Pikachu particles")
instance = self.new_instance_of_an_optional_code(Pikachu, self.default_converter, **default_options)
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(self.new_sun_earth_system())
instance.commit_particles()
self.assertAlmostEqual(instance.particles.mass, [1.0, 3.0037e-6] | units.MSun)
self.assertAlmostEqual(instance.particles.position,
[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU)
self.assertAlmostEqual(instance.particles.velocity,
[[0.0, 0.0, 0.0], [0.0, 29.7885, 0.0]] | units.km / units.s, 3)
instance.cleanup_code()
instance.stop()
def test4(self):
print("Testing Pikachu evolve_model, 2 particles")
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * (2.0 | units.MSun) / (2.0 | units.AU)).sqrt()
particles.move_to_center()
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Pikachu, converter, **default_options)
instance.initialize_code()
instance.parameters.timestep = 0.0125 * math.pi * particles[0].x / particles[0].vy
instance.parameters.rcut_out_star_star = 10.0 | units.AU
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3)
instance.cleanup_code()
instance.stop()
def test5(self):
print("Testing Pikachu evolve_model, earth-sun system")
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Pikachu, converter, **default_options)
instance.initialize_code()
instance.parameters.timestep = 0.005 | units.yr
instance.parameters.rcut_out_star_star = 1.0 | units.AU
instance.commit_parameters()
instance.particles.add_particles(self.new_sun_earth_system())
instance.commit_particles()
earth = instance.particles[1]
position_at_start = earth.position.x
instance.evolve_model(0.25 | units.yr)
self.assertAlmostRelativeEqual(position_at_start, earth.position.y, 3)
instance.evolve_model(0.5 | units.yr)
self.assertAlmostRelativeEqual(position_at_start, -earth.position.x, 3)
instance.evolve_model(1.0 | units.yr)
self.assertAlmostRelativeEqual(position_at_start, earth.position.x, 3)
instance.cleanup_code()
instance.stop()
def test6a(self):
print("Testing effect of Pikachu parameter epsilon_squared (using recommit_particles)")
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
particles = self.new_sun_earth_system()
particles.rotate(0.0, 0.0, math.pi/4)
particles.move_to_center()
tan_initial_direction = particles[1].vy/particles[1].vx
self.assertAlmostEqual(tan_initial_direction, math.tan(-math.pi/4))
tan_final_direction = []
instance = self.new_instance_of_an_optional_code(Pikachu, converter, **default_options)
instance.initialize_code()
instance.parameters.timestep = 0.005 | units.yr
for log_eps2 in range(-5, 6, 2):
instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU ** 2
if len(instance.particles) > 0:
instance.particles.remove_particles(instance.particles)
instance.particles.add_particles(particles)
instance.evolve_model(instance.model_time.as_quantity_in(units.yr) + (0.25 | units.yr))
tan_final_direction.append(instance.particles[1].velocity[1] /
instance.particles[1].velocity[0])
print(tan_final_direction)
# Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees
self.assertAlmostRelativeEquals(tan_final_direction[0], math.tan(math.pi / 4.0), 1)
# Large values of epsilon_squared should result in ~ no interaction
self.assertAlmostEqual(tan_final_direction[-1], tan_initial_direction, 2)
# Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2
delta = [abs(tan_final_direction[i+1]-tan_final_direction[i]) for i in range(len(tan_final_direction)-1)]
self.assertEqual(delta[len(tan_final_direction)/2 - 1], max(delta))
def test6b(self):
print("Testing effect of Pikachu parameter epsilon_squared (using reset)")
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
particles = self.new_sun_earth_system()
particles.rotate(0.0, 0.0, math.pi/4)
particles.move_to_center()
tan_initial_direction = particles[1].vy/particles[1].vx
self.assertAlmostEqual(tan_initial_direction, math.tan(-math.pi/4))
tan_final_direction = []
instance = self.new_instance_of_an_optional_code(Pikachu, converter, **default_options)
instance.initialize_code()
instance.parameters.timestep = 0.005 | units.yr
for log_eps2 in range(-5, 6, 2):
instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU ** 2
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.25 | units.yr)
tan_final_direction.append(instance.particles[1].velocity[1] /
instance.particles[1].velocity[0])
instance.reset()
instance.cleanup_code()
instance.stop()
print(tan_final_direction)
# Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees
self.assertAlmostRelativeEquals(tan_final_direction[0], math.tan(math.pi / 4.0), 1)
# Large values of epsilon_squared should result in ~ no interaction
self.assertAlmostEqual(tan_final_direction[-1], tan_initial_direction, 2)
# Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2
delta = [abs(tan_final_direction[i+1]-tan_final_direction[i]) for i in range(len(tan_final_direction)-1)]
self.assertEqual(delta[len(tan_final_direction)/2 - 1], max(delta))
def test7(self):
print("Testing Pikachu states")
stars = new_plummer_model(100)
black_hole = Particle()
black_hole.mass = 1.0 | nbody_system.mass
black_hole.radius = 0.0 | nbody_system.length
black_hole.position = [0.0, 0.0, 0.0] | nbody_system.length
black_hole.velocity = [0.0, 0.0, 0.0] | nbody_system.speed
print("First do everything manually:")
instance = self.new_instance_of_an_optional_code(Pikachu, **default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
# ~ instance.parameters.rcut_out_star_star = 1.0 | nbody_system.length
instance.parameters.timestep = 0.001 | nbody_system.time
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.particles.remove_particle(stars[0])
instance.particles.add_particle(black_hole)
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
instance.recommit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.001 | nbody_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
instance.synchronize_model()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("initialize_code(), commit_parameters(), (re)commit_particles(), "
"synchronize_model(), and cleanup_code() should be called "
"automatically before editing parameters, new_particle(), get_xx(), and stop():")
instance = self.new_instance_of_an_optional_code(Pikachu, **default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.timestep = 0.001 | nbody_system.time
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(stars)
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.particles.remove_particle(stars[0])
instance.particles.add_particle(black_hole)
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.001 | nbody_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
| 21,731
| 50.49763
| 120
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_fastkick.py
|
import numpy
import math
from amuse.units import nbody_system, units, constants, quantities
from amuse.datamodel import Particles, Particle
from amuse.ic.plummer import new_plummer_model
from amuse.couple.bridge import Bridge, CalculateFieldForCodesUsingReinitialize
from amuse.test.amusetest import TestWithMPI
from amuse.community.fastkick.interface import FastKickInterface, FastKick
class TestFastKickInterface(TestWithMPI):
number_of_workers = 2
mode = "cpu"
def test1(self):
instance = FastKickInterface(mode=self.mode, number_of_workers=self.number_of_workers)
instance.initialize_code()
id1, error1 = instance.new_particle(mass=11.0, x=0.0, y=0.0, z=0.0)
id2, error2 = instance.new_particle(mass=21.0, x=10.0, y=0.0, z=0.0)
self.assertEqual(0, id1)
self.assertEqual(0, error1)
self.assertEqual(1, id2)
self.assertEqual(0, error2)
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test2(self):
fastkick = FastKickInterface(mode=self.mode, number_of_workers=self.number_of_workers)
self.assertEqual(0, fastkick.set_eps2(0.101))
self.assertEqual([0.101, 0], list(fastkick.get_eps2().values()))
self.assertEqual(0, fastkick.set_eps2(0.2))
self.assertEqual([0.2, 0], list(fastkick.get_eps2().values()))
fastkick.cleanup_code()
fastkick.stop()
def test3(self):
fastkick = FastKickInterface(mode=self.mode, number_of_workers=self.number_of_workers)
fastkick.initialize_code()
fastkick.new_particle([10, 10], [-1, 1], [0, 0], [0, 0])
self.assertEqual(0, fastkick.commit_particles())
self.assertEqual([-20.0, 0], list(fastkick.get_potential_at_point(0, 0, 0, 0).values()))
self.assertAlmostEqual(-10.0*math.sqrt(2.0), list(fastkick.get_potential_at_point(1.0, 0, 0, 0).values())[0], 4)
fastkick.cleanup_code()
fastkick.stop()
def test4(self):
numpy.random.seed(12345)
plummer = new_plummer_model(100)
fastkick = FastKickInterface(mode=self.mode, number_of_workers=self.number_of_workers)
fastkick.initialize_code()
fastkick.new_particle([1]*100, plummer.x.number, plummer.y.number, plummer.z.number)
self.assertEqual(0, fastkick.commit_particles())
points = new_plummer_model(73)
potential1, error = fastkick.get_potential_at_point([0]*73,
points.x.number, points.y.number, points.z.number)
ax1, ay1, az1, error = fastkick.get_gravity_at_point([0]*73,
points.x.number, points.y.number, points.z.number)
fastkick.cleanup_code()
fastkick.initialize_code()
self.assertEqual(0, fastkick.commit_particles())
potential0, error = fastkick.get_potential_at_point([0]*73,
points.x.number, points.y.number, points.z.number)
ax0, ay0, az0, error = fastkick.get_gravity_at_point([0]*73,
points.x.number, points.y.number, points.z.number)
self.assertAlmostEqual(potential0, 0)
self.assertAlmostEqual(ax0, 0)
self.assertAlmostEqual(ay0, 0)
self.assertAlmostEqual(az0, 0)
fastkick.cleanup_code()
fastkick.initialize_code()
for p in plummer:
fastkick.new_particle(1, p.x.number, p.y.number, p.z.number)
self.assertEqual(0, fastkick.commit_particles())
potential2, error = fastkick.get_potential_at_point([0]*73,
points.x.number, points.y.number, points.z.number)
ax2, ay2, az2, error = fastkick.get_gravity_at_point([0]*73,
points.x.number, points.y.number, points.z.number)
self.assertAlmostEqual(potential1, potential2, 4)
self.assertAlmostEqual(ax1, ax2, 4)
self.assertAlmostEqual(ay1, ay2, 4)
self.assertAlmostEqual(az1, az2, 4)
fastkick.cleanup_code()
fastkick.stop()
class TestFastKick(TestWithMPI):
mode = "cpu"
def new_fastkick_instance(self, convert_nbody=None, number_of_workers=2, **kwargs):
return FastKick(convert_nbody, mode=self.mode, number_of_workers=number_of_workers, **kwargs)
def test1(self):
print("Testing FastKick (SI)")
sun = Particle()
sun.mass = 1.0 | units.MSun
sun.position = [0, 0, 0] | units.m
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
fastkick = self.new_fastkick_instance(convert_nbody)
fastkick.particles.add_particle(sun)
ax, ay, az = fastkick.get_gravity_at_point(0 | units.AU, 1 | units.AU, 0 | units.AU, 0 | units.AU)
fastkick.stop()
self.assertAlmostRelativeEqual(ax, -4*math.pi**2 | units.AU / units.yr**2, 3)
self.assertAlmostRelativeEqual(ay, 0 | units.m * units.s**-2, 6)
self.assertAlmostRelativeEqual(az, 0 | units.m * units.s**-2, 6)
def test2(self):
print("Testing FastKick reset")
particles = new_plummer_model(50)
instance = self.new_fastkick_instance()
instance.parameters.epsilon_squared = 0.12345 | nbody_system.length**2
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 50)
instance.reset()
self.assertAlmostRelativeEquals(instance.parameters.epsilon_squared, 0.12345 | nbody_system.length**2)
self.assertEqual(len(instance.particles), 0)
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 50)
def test3(self):
print("Testing FastKick parameters")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.yr, 1.0 | units.AU)
instance = self.new_fastkick_instance(convert_nbody)
self.assertAlmostEqual(0.0 | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2)
for x in [0.01, 0.1, 0.2]:
instance.parameters.epsilon_squared = x | units.AU**2
self.assertAlmostEqual(x | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2)
instance.stop()
def test4(self):
numpy.random.seed(12345)
plummer = new_plummer_model(100)
fastkick = self.new_fastkick_instance()
fastkick.initialize_code()
fastkick.particles.add_particles(plummer)
points = new_plummer_model(73)
potential1 = fastkick.get_potential_at_point(0*points.x, points.x, points.y, points.z)
ax1, ay1, az1 = fastkick.get_gravity_at_point(0*points.x, points.x, points.y, points.z)
fastkick.reset()
potential0 = fastkick.get_potential_at_point(0*points.x, points.x, points.y, points.z)
ax0, ay0, az0 = fastkick.get_gravity_at_point(0*points.x, points.x, points.y, points.z)
self.assertAlmostEqual(potential0, 0 | nbody_system.potential)
self.assertAlmostEqual(ax0, 0 | nbody_system.acceleration)
self.assertAlmostEqual(ay0, 0 | nbody_system.acceleration)
self.assertAlmostEqual(az0, 0 | nbody_system.acceleration)
fastkick.reset()
for p in plummer:
fastkick.particles.add_particle(p)
potential2 = fastkick.get_potential_at_point(0*points.x, points.x, points.y, points.z)
ax2, ay2, az2 = fastkick.get_gravity_at_point(0*points.x, points.x, points.y, points.z)
self.assertAlmostEqual(potential1, potential2, 5)
self.assertAlmostEqual(ax1, ax2, 5)
self.assertAlmostEqual(ay1, ay2, 5)
self.assertAlmostEqual(az1, az2, 5)
fastkick.cleanup_code()
fastkick.stop()
def test5(self):
print("Testing FastKick states")
plummer = new_plummer_model(100)
print("First do everything manually:")
instance = self.new_fastkick_instance()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particles(plummer)
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("commit_parameters(), (re)commit_particles(), and cleanup_code() should be called "
"automatically before new_xx_particle(), get_xx(), and stop():")
instance = self.new_fastkick_instance()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
eps = instance.parameters.epsilon_squared
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(plummer[:-1])
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
acc = instance.get_gravity_at_point(0*plummer[-1].x, plummer[-1].x, plummer[-1].y, plummer[-1].z)
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.particles.add_particle(plummer[-1])
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
acc = instance.get_gravity_at_point(0*plummer[-1].x, plummer[-1].x, plummer[-1].y, plummer[-1].z)
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
def test6(self):
plummer = new_plummer_model(100)
points = new_plummer_model(73)
instance = self.new_fastkick_instance(number_of_workers=1)
instance.particles.add_particles(plummer)
potential1 = instance.get_potential_at_point(0*points.x, points.x, points.y, points.z)
ax1, ay1, az1 = instance.get_gravity_at_point(0*points.x, points.x, points.y, points.z)
instance.stop()
expected_accuracy = 13 if self.mode == "cpu" else 5
number_of_workers_range = [2, 3, 4, 5] if self.mode == "cpu" else [2]
for n in number_of_workers_range:
instance = self.new_fastkick_instance(number_of_workers=n)
instance.particles.add_particles(plummer)
potential = instance.get_potential_at_point(0*points.x, points.x, points.y, points.z)
ax, ay, az = instance.get_gravity_at_point(0*points.x, points.x, points.y, points.z)
instance.stop()
self.assertAlmostEqual(potential, potential1, expected_accuracy)
self.assertAlmostEqual(ax, ax1, expected_accuracy)
self.assertAlmostEqual(ay, ay1, expected_accuracy)
self.assertAlmostEqual(az, az1, expected_accuracy)
def test7(self):
instance = self.new_fastkick_instance()
instance.parameters.epsilon_squared = 0.00001 | nbody_system.length**2
particles = Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
ax, ay, az = instance.get_gravity_at_point(zero, 1.0 | nbody_system.length, zero, zero)
self.assertAlmostEqual(ax, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(ay, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(az, 0.0 | nbody_system.acceleration, 6)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
ax0, ay0, az0 = instance.get_gravity_at_point(zero, x0, zero, zero)
ax1, ay1, az1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(ay0, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(az0, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(ay1, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(az1, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(ax0, -ax1, 5)
ax = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length**3 / nbody_system.time**2)
self.assertAlmostEqual(ax, ax0, 2)
self.assertAlmostEqual(potential0, potential1, 5)
instance.stop()
def test8(self):
print("Testing FastKick for Bridge: potential energy")
numpy.random.seed(12345)
stars = new_plummer_model(100)
cluster = new_gravity_code(stars)
first_half = stars.select_array(lambda x: (x > 0 | nbody_system.length), ['x'])
second_half = stars - first_half
cluster1 = new_gravity_code(first_half)
cluster2 = new_gravity_code(second_half)
kick_from_cluster1 = CalculateFieldForCodesUsingReinitialize(self.new_fastkick_instance(), (cluster1,))
kick_from_cluster2 = CalculateFieldForCodesUsingReinitialize(self.new_fastkick_instance(), (cluster2,))
bridgesys = Bridge()
bridgesys.add_system(cluster1, (kick_from_cluster2,))
bridgesys.add_system(cluster2, (kick_from_cluster1,))
self.assertAlmostRelativeEqual(cluster.potential_energy, bridgesys.potential_energy, 7)
self.assertAlmostRelativeEqual(cluster.kinetic_energy, bridgesys.kinetic_energy)
kick_from_cluster1.code.stop()
kick_from_cluster2.code.stop()
def test9(self):
print("Testing FastKick for Bridge: evolving a binary")
particles = Particles(2)
particles.mass = [3.0, 1.0] | units.MSun
particles.position = [0, 0, 0] | units.AU
particles.velocity = [0, 0, 0] | units.km / units.s
particles[1].x = 2.0 | units.AU
particles[1].vy = (constants.G * (4.0 | units.MSun) / (2.0 | units.AU)).sqrt()
particles.move_to_center()
primary_sys = new_gravity_code(particles[:1])
secondary_sys = new_gravity_code(particles[1:])
primary = primary_sys.particles[0]
P = 2 * math.pi * primary.x / primary.vy
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
kick_from_primary = CalculateFieldForCodesUsingReinitialize(self.new_fastkick_instance(converter), (primary_sys,))
kick_from_secondary = CalculateFieldForCodesUsingReinitialize(self.new_fastkick_instance(converter), (secondary_sys,))
bridgesys = Bridge(timestep=P / 64.0)
bridgesys.add_system(primary_sys, (kick_from_secondary,))
bridgesys.add_system(secondary_sys, (kick_from_primary,))
position_at_start = primary.position.x
bridgesys.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 2)
bridgesys.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 2)
bridgesys.evolve_model(P)
kick_from_primary.code.stop()
kick_from_secondary.code.stop()
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 2)
def test10(self):
number_of_sources = 10
number_of_points = 1000000
mass, length, G = nbody_system.mass, nbody_system.length, nbody_system.G
sources = Particles(mass=numpy.ones(number_of_sources) | mass, x=0 | length, y=0 | length, z=0 | length)
points = Particles(x=0 | length, y=0 | length, z=numpy.arange(number_of_points)+1.0 | length)
instance = self.new_fastkick_instance()
instance.particles.add_particles(sources)
potential = instance.get_potential_at_point(0*points.x, points.x, points.y, points.z)
ax, ay, az = instance.get_gravity_at_point(0*points.x, points.x, points.y, points.z)
self.assertAlmostEqual(ax, G * (0 | mass/length**2), 5)
self.assertAlmostEqual(ay, G * (0 | mass/length**2), 5)
self.assertAlmostRelativeEqual(az, -G*sources.total_mass()/points.z**2, 3)
self.assertAlmostRelativeEqual(potential, -G*sources.total_mass()/points.z, 3)
instance.stop()
def test11(self):
print("Test that a source is not included when calculating gravity on itself.")
number_of_sources = 100
mass, length, G = nbody_system.mass, nbody_system.length, nbody_system.G
sources = Particles(mass=numpy.ones(number_of_sources) | mass, x=0 | length, y=0 | length, z=0 | length)
point = Particle(x=0 | length, y=0 | length, z=1.0 | length)
instance = self.new_fastkick_instance()
instance.particles.add_particles(sources)
potential = instance.get_potential_at_point(0 | length, point.x, point.y, point.z)
ax, ay, az = instance.get_gravity_at_point(0 | length, point.x, point.y, point.z)
self.assertAlmostEqual(ax, G * (0 | mass/length**2), 5)
self.assertAlmostEqual(ay, G * (0 | mass/length**2), 5)
self.assertAlmostRelativeEqual(az, -G*sources.total_mass()/point.z**2, 3)
self.assertAlmostRelativeEqual(potential, -G*sources.total_mass()/point.z, 3)
point.mass = 1e6 | mass
instance.particles.add_particle(point)
potential = instance.get_potential_at_point(0 | length, point.x, point.y, point.z)
ax, ay, az = instance.get_gravity_at_point(0 | length, point.x, point.y, point.z)
self.assertAlmostEqual(ax, G * (0 | mass/length**2), 5)
self.assertAlmostEqual(ay, G * (0 | mass/length**2), 5)
self.assertAlmostRelativeEqual(az, -G*sources.total_mass()/point.z**2, 3)
self.assertAlmostRelativeEqual(potential, -G*sources.total_mass()/point.z, 3)
instance.stop()
def test12(self):
print("Test FastKick potential energy")
number_of_sources = 1000
numpy.random.seed(12345)
plummer = new_plummer_model(number_of_sources)
fastkick = self.new_fastkick_instance()
fastkick.particles.add_particles(plummer)
self.assertAlmostRelativeEqual(fastkick.potential_energy, plummer.potential_energy(G=nbody_system.G), 6)
fastkick.cleanup_code()
fastkick.stop()
def test13(self):
number_of_sources = 10
mass, length, G = nbody_system.mass, nbody_system.length, nbody_system.G
sources = Particles(
mass=numpy.ones(number_of_sources) | mass,
x=0 | length,
y=0 | length,
z=0 | length)
instance = self.new_fastkick_instance()
instance.particles.add_particles(sources)
self.assertAlmostRelativeEqual(instance.particles.mass, 1 | mass)
instance.particles.mass = 2 | mass
self.assertAlmostRelativeEqual(instance.particles.mass, 2 | mass)
class TestFastKickGPU(TestFastKick):
mode = "gpu"
def new_fastkick_instance(self, convert_nbody=None, number_of_workers=1, **kwargs):
return self.new_instance_of_an_optional_code(FastKick, convert_nbody,
mode=self.mode, number_of_workers=number_of_workers, **kwargs)
class GravityCodeForTesting(object):
def __init__(self):
self.particles = Particles()
self.model_time = quantities.zero
def evolve_model(self, t_end):
self.particles.position += self.particles.velocity * (t_end - self.model_time)
self.model_time = t_end
@property
def potential_energy(self):
G = nbody_system.G if self.particles.x.unit == nbody_system.length else constants.G
return self.particles.potential_energy(G=G)
@property
def kinetic_energy(self):
return self.particles.kinetic_energy()
def new_gravity_code(particles):
instance = GravityCodeForTesting()
instance.particles.add_particles(particles)
return instance
| 19,883
| 46.007092
| 126
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_mobse.py
|
from amuse.community.mobse.interface import MOBSE, MOBSEInterface
from amuse.test.amusetest import TestWithMPI
from amuse.units import units
from amuse.units import constants
from amuse.datamodel import Particles
import numpy
class TestMOBSEInterface(TestWithMPI):
class state(object):
def __init__(self):
self.type1 = 0.0
self.type2 = 0.0
self.initial_mass1 = 0.0
self.initial_mass2 = 0.0
self.mass1 = 0.0
self.mass2 = 0.0
self.radius1 = 0.0
self.radius2 = 0.0
self.luminosity1 = 0.0
self.luminosity2 = 0.0
self.core_mass1 = 0.0
self.core_mass2 = 0.0
self.core_radius1 = 0.0
self.core_radius2 = 0.0
self.envelope_mass1 = 0.0
self.envelope_mass2 = 0.0
self.envelope_radius1 = 0.0
self.envelope_radius2 = 0.0
self.spin1 = 0.0
self.spin2 = 0.0
self.epoch1 = 0.0
self.epoch2 = 0.0
self.t_ms1 = 0.0
self.t_ms2 = 0.0
self.bse_age = 0.0
self.orbital_period = 0.0
self.eccentricity = 0.0
def test1(self):
print("Test initialization...")
instance = MOBSEInterface()
metallicity = 0.02
neta = 0.5
bwind = 0.0
hewind = 0.5
alpha1 = 1.0
CElambda = 0.1
ceflag = 0
tflag = 1
ifflag = 0
wdflag = 1
bhflag = 1
nsflag = 3
piflag = 1
mxns = 3.0
idum = 29769
pts1 = 0.05
pts2 = 0.01
pts3 = 0.02
sigma1 = 265.0
sigma2 = 7.0
beta = 1.0/8.0
xi = 1.0
acc2 = 3.0/2.0
epsnov = 0.001
eddfac = 1.0
gamma = -1.0
status = instance.initialize(metallicity,
neta, bwind, hewind, alpha1, CElambda,
ceflag, tflag, ifflag, wdflag, bhflag,
nsflag, piflag, mxns, idum, pts1, pts2, pts3,
sigma1, sigma2, beta, xi, acc2, epsnov, eddfac, gamma)
self.assertEqual(status, 0)
instance.stop()
def test2(self):
print("Test basic operations (legacy functions evolve & get_time_step)...")
instance = MOBSEInterface()
status = instance.initialize(0.02, 0.5, 0.0, 0.5, 1.0, 0.1, 0, 1, 0, 1, 1, 3, 1, 3.0,
29769, 0.05, 0.01, 0.02, 265.0, 7.0, 1.0/8.0, 1.0, 3.0/2.0, 0.001, 1.0, -1.0)
new_state = self.state()
new_state.mass1 = 3.0
new_state.mass2 = 1.0
new_state.initial_mass1 = 3.0
new_state.initial_mass2 = 1.0
new_state.type1 = 1.0
new_state.type2 = 1.0
new_state.end_time = 1e-06
new_state.orbital_period = 200.0
new_state.eccentricity = 0.5
result = instance.evolve_binary(
new_state.type1, new_state.type2, new_state.initial_mass1, new_state.initial_mass2,
new_state.mass1, new_state.mass2, new_state.radius1, new_state.radius2,
new_state.luminosity1, new_state.luminosity2, new_state.core_mass1,
new_state.core_mass2, new_state.core_radius1, new_state.core_radius2,
new_state.envelope_mass1, new_state.envelope_mass2, new_state.envelope_radius1,
new_state.envelope_radius2, new_state.spin1, new_state.spin2, new_state.epoch1,
new_state.epoch2, new_state.t_ms1, new_state.t_ms2, new_state.bse_age,
new_state.orbital_period, new_state.eccentricity, new_state.end_time
)
updated_state = self.state()
(updated_state.type1, updated_state.type2, updated_state.initial_mass1, updated_state.initial_mass2,
updated_state.mass1, updated_state.mass2, updated_state.radius1, updated_state.radius2,
updated_state.luminosity1, updated_state.luminosity2, updated_state.core_mass1,
updated_state.core_mass2, updated_state.core_radius1, updated_state.core_radius2,
updated_state.envelope_mass1, updated_state.envelope_mass2, updated_state.envelope_radius1,
updated_state.envelope_radius2, updated_state.spin1, updated_state.spin2,
updated_state.epoch1, updated_state.epoch2, updated_state.t_ms1, updated_state.t_ms2,
updated_state.bse_age, updated_state.orbital_period,
updated_state.eccentricity, updated_state.end_time) = result
expected = {
'radius2': '0x1.c6c8a1c793bcep-1',
'luminosity2': '0x1.653b1b2d0333bp-1',
'core_mass2': '0x0.0p+0',
'bse_age': '0x1.0c6f7a0b5ed8dp-20',
'end_time': '0x1.0c6f7a0b5ed8dp-20',
'envelope_mass2': '0x1.0d6fc100ab510p-5',
'mass2': '0x1.0000000000000p+0',
'initial_mass2': '0x1.0000000000000p+0',
'envelope_radius2': '0x1.db27631ba0e5ap-3',
'core_radius2': '0x0.0p+0',
'epoch2': '0x0.0p+0',
't_ms2': '0x1.57d90abe54643p+13',
'spin2': '0x1.07413b0522dabp+10',
}
for x in expected:
print("'%s' : '%s'," % (x, getattr(updated_state, x).hex()))
self.assertAlmostRelativeEqual(float.fromhex(expected[x]), getattr(updated_state, x))
self.assertEqual(updated_state.end_time, 1e-06)
dt = instance.get_time_step(updated_state.type1, updated_state.type2,
updated_state.initial_mass1, updated_state.initial_mass2, updated_state.mass1,
updated_state.mass2, updated_state.t_ms1, updated_state.t_ms2,
updated_state.epoch1, updated_state.epoch2, updated_state.bse_age)
self.assertAlmostEqual(dt, 18.8768, 3)
instance.stop()
def test3(self):
print("Test whether the interface can handle arrays...")
instance = MOBSEInterface()
status = instance.initialize(0.02, 0.5, 0.0, 0.5, 1.0, 0.1, 0, 1, 0, 1, 1, 3, 1, 3.0,
29769, 0.05, 0.01, 0.02, 265.0, 7.0, 1.0/8.0, 1.0, 3.0/2.0, 0.001, 1.0, -1.0)
masses1 = [10.0, 5.0, 4.0, 40.0, 130.0]
masses2 = [1.0, 1.0, 1.0, 10.0, 60.0]
types1 = types2 = [1, 1, 1, 1, 1]
orbital_periods = [100.0, 200.0, 300.0, 500.0, 600.0]
eccentricities = [0.5, 0.6, 0.7, 0.3, 0.2]
radii1 = luminosity1 = core_mass1 = core_radius1 = envelope_mass1 =\
envelope_radius1 = spin1 = epoch1 = t_ms1 = [0.0, 0.0, 0.0, 0.0, 0.0]
radii2 = luminosity2 = core_mass2 = core_radius2 = envelope_mass2 =\
envelope_radius2 = spin2 = epoch2 = t_ms2 = [0.0, 0.0, 0.0, 0.0, 0.0]
init_mass1 = masses1
init_mass2 = masses2
bse_age = [0.0, 0.0, 0.0, 0.0, 0.0]
end_time = [10.0, 10.0, 10.0, 10.0, 10.0]
result = instance.evolve_binary(
types1, types2, init_mass1, init_mass2,
masses1, masses2, radii1, radii2,
luminosity1, luminosity2, core_mass1, core_mass2,
core_radius1, core_radius2, envelope_mass1, envelope_mass2,
envelope_radius1, envelope_radius2, spin1, spin2,
epoch1, epoch2, t_ms1, t_ms2,
bse_age, orbital_periods, eccentricities, end_time
)
self.assertAlmostEqual(result['mass1'][0], 9.99356, 2)
self.assertAlmostEqual(result['mass1'][1], 4.99956, 2)
self.assertAlmostEqual(result['mass1'][2], 3.99992, 2)
self.assertAlmostEqual(result['mass1'][3], 3.07374, 2)
self.assertAlmostEqual(result['mass1'][4], 13.61644, 2)
instance.stop()
def test4(self):
print("Test large number of particles...")
number_of_particles = 2000
instance = MOBSEInterface()
status = instance.initialize(0.02, 0.5, 0.0, 0.5, 1.0, 0.1, 0, 1, 0, 1, 1, 3, 1, 3.0,
29769, 0.05, 0.01, 0.02, 265.0, 7.0, 1.0/8.0, 1.0, 3.0/2.0, 0.001, 1.0, -1.0)
masses1 = [1.0 + ((x / 1.0*number_of_particles) * 10.0) for x in range(1, number_of_particles+1)]
masses2 = [2.0 + ((x / 1.0*number_of_particles) * 5.0) for x in range(1, number_of_particles+1)]
orbital_periods = [100.0 + ((x / 1.0*number_of_particles) * 900.0) for x in range(1, number_of_particles+1)]
eccentricities = [0.5 + ((x / 1.0*number_of_particles) * 0.4) for x in range(1, number_of_particles+1)]
types1 = types2 = [1 for x in range(1, number_of_particles+1)]
radii1 = luminosity1 = core_mass1 = core_radius1 = envelope_mass1 =\
envelope_radius1 = spin1 = epoch1 = t_ms1 =\
radii2 = luminosity2 = core_mass2 = core_radius2 = envelope_mass2 =\
envelope_radius2 = spin2 = epoch2 = t_ms2 =\
bse_age = [0.0 for x in range(1, number_of_particles+1)]
end_time = [1.0 for x in range(1, number_of_particles+1)]
init_mass1 = masses1
init_mass2 = masses2
result = instance.evolve_binary(
types1, types2, init_mass1, init_mass2,
masses1, masses2, radii1, radii2,
luminosity1, luminosity2, core_mass1, core_mass2,
core_radius1, core_radius2, envelope_mass1, envelope_mass2,
envelope_radius1, envelope_radius2, spin1, spin2,
epoch1, epoch2, t_ms1, t_ms2,
bse_age, orbital_periods, eccentricities, end_time
)
self.assertEqual(len(result['mass1']), number_of_particles)
instance.stop()
class TestMOBSE(TestWithMPI):
def test1(self):
print("Testing evolution of a close binary system...")
instance = MOBSE()
instance.initialize_code()
instance.parameters.metallicity = 0.001
instance.parameters.common_envelope_efficiency = 3.0
instance.parameters.Eddington_mass_transfer_limit_factor = 10.0
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 3.0 | units.MSun
stars[1].mass = 0.3 | units.MSun
orbital_period = 200.0 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass, stars[1].mass)
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.5
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_mobse_to_model = instance.particles.new_channel_to(stars)
from_mobse_to_model.copy()
from_mobse_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_mobse_to_model_binaries.copy()
previous_type = binary.child1.stellar_type
results = []
current_time = 0 | units.Myr
while current_time < (480 | units.Myr):
instance.update_time_steps()
# The next line appears a bit weird, but saves time for this simple test.
current_time = current_time + max(5.0*instance.binaries[0].time_step, 0.3 | units.Myr)
instance.evolve_model(current_time)
from_mobse_to_model.copy()
from_mobse_to_model_binaries.copy()
if not binary.child1.stellar_type == previous_type:
results.append((binary.age, binary.child1.mass, binary.child1.stellar_type))
previous_type = binary.child1.stellar_type
self.assertEqual(len(results), 6)
types = (
"Hertzsprung Gap",
"First Giant Branch",
"Core Helium Burning",
"First Asymptotic Giant Branch",
"Hertzsprung Gap Naked Helium star",
"Carbon/Oxygen White Dwarf",
)
for result, expected in zip(results, types):
self.assertEqual(str(result[2]), expected)
times = (
284.8632 | units.Myr,
287.0713 | units.Myr,
287.7967 | units.Myr,
331.1631 | units.Myr,
331.4164 | units.Myr,
332.2864 | units.Myr,
)
for result, expected in zip(results, times):
self.assertAlmostEqual(result[0].value_in(units.Myr), expected.value_in(units.Myr), 0)
masses = (
3.000 | units.MSun,
3.000 | units.MSun,
2.999 | units.MSun,
2.956 | units.MSun,
0.888 | units.MSun,
0.701 | units.MSun,
)
for result, expected in zip(results, masses):
self.assertAlmostEqual(result[1].value_in(units.MSun), expected.value_in(units.MSun), 2)
instance.stop()
def test2(self):
print("Testing evolution of a wide binary system.")
instance = MOBSE()
instance.parameters.metallicity = 0.001
instance.parameters.common_envelope_efficiency = 3.0
instance.parameters.Eddington_mass_transfer_limit_factor = 10.0
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 4.0 | units.MSun
stars[1].mass = 0.3 | units.MSun
orbital_period = 2.0e5 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass, stars[1].mass)
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.5
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_mobse_to_model = instance.particles.new_channel_to(stars)
from_mobse_to_model.copy()
from_mobse_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_mobse_to_model_binaries.copy()
previous_type = binary.child1.stellar_type
results = []
current_time = 0 | units.Myr
while current_time < (170 | units.Myr):
instance.update_time_steps()
# The next line appears a bit weird, but saves time for this simple test.
current_time = current_time + max(2.0*instance.binaries[0].time_step, 0.04 | units.Myr)
instance.evolve_model(current_time)
from_mobse_to_model.copy()
from_mobse_to_model_binaries.copy()
if not binary.child1.stellar_type == previous_type:
results.append((binary.age, binary.child1.mass, binary.child1.stellar_type))
previous_type = binary.child1.stellar_type
print(results)
self.assertEqual(len(results), 6)
times = (
147.1282 | units.Myr,
148.0345 | units.Myr,
148.2282 | units.Myr,
167.2811 | units.Myr,
168.0344 | units.Myr,
168.7475 | units.Myr
)
for result, expected in zip(results, times):
self.assertAlmostEqual(result[0].value_in(units.Myr), expected.value_in(units.Myr), 0)
masses = (
4.000 | units.MSun,
3.999 | units.MSun,
3.999 | units.MSun,
3.942 | units.MSun,
3.906 | units.MSun,
1.016 | units.MSun
)
for result, expected in zip(results, masses):
self.assertAlmostEqual(result[1].value_in(units.MSun), expected.value_in(units.MSun), 2)
types = (
"Hertzsprung Gap",
"First Giant Branch",
"Core Helium Burning",
"First Asymptotic Giant Branch",
"Second Asymptotic Giant Branch",
"Carbon/Oxygen White Dwarf",
)
for result, expected in zip(results, types):
self.assertEqual(str(result[2]), expected)
instance.stop()
def test3(self):
print("Testing standard MOBSE example 2...")
instance = MOBSE()
instance.parameters.common_envelope_efficiency = 3.0
instance.parameters.common_envelope_binding_energy_factor = 0.5
instance.parameters.Eddington_mass_transfer_limit_factor = 10.0
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 7.816 | units.MSun
stars[1].mass = 4.387 | units.MSun
orbital_period = 1964.18453 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass, stars[1].mass)
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.0
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_mobse_to_model = instance.particles.new_channel_to(stars)
from_mobse_to_model.copy()
from_mobse_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_mobse_to_model_binaries.copy()
previous_type1 = binary.child1.stellar_type
previous_type2 = binary.child2.stellar_type
results = []
current_time = 0 | units.Myr
while current_time < (170 | units.Myr):
instance.update_time_steps()
# The next line appears a bit weird, but saves time for this simple test.
current_time = current_time + max(2.0*instance.binaries[0].time_step, 0.04 | units.Myr)
instance.evolve_model(current_time)
from_mobse_to_model.copy()
from_mobse_to_model_binaries.copy()
if not (binary.child1.stellar_type == previous_type1 and binary.child2.stellar_type == previous_type2):
results.append((binary.age, str(binary.child1.stellar_type)+" and "+str(binary.child2.stellar_type)))
previous_type1 = binary.child1.stellar_type
previous_type2 = binary.child2.stellar_type
print('\n'.join(map(str, results)))
self.assertEqual(len(results), 12)
times = (
39.1037 | units.Myr,
39.2242 | units.Myr,
39.2565 | units.Myr,
43.9911 | units.Myr,
44.1842 | units.Myr,
44.2644 | units.Myr,
141.8444 | units.Myr,
142.4835 | units.Myr,
142.9234 | units.Myr,
166.3238 | units.Myr,
166.8385 | units.Myr,
167.1731 | units.Myr
)
for result, expected in zip(results, times):
self.assertAlmostEqual(result[0].value_in(units.Myr), expected.value_in(units.Myr), 0)
types = (
"Hertzsprung Gap and Main Sequence star",
"First Giant Branch and Main Sequence star",
"Core Helium Burning and Main Sequence star",
"First Asymptotic Giant Branch and Main Sequence star",
"Second Asymptotic Giant Branch and Main Sequence star",
"Oxygen/Neon White Dwarf and Main Sequence star",
"Oxygen/Neon White Dwarf and Hertzsprung Gap",
"Oxygen/Neon White Dwarf and First Giant Branch",
"Oxygen/Neon White Dwarf and Core Helium Burning",
"Oxygen/Neon White Dwarf and First Asymptotic Giant Branch",
"Oxygen/Neon White Dwarf and Hertzsprung Gap Naked Helium star",
"Neutron Star and Carbon/Oxygen White Dwarf",
)
for result, expected in zip(results, types):
self.assertEqual(result[1], expected)
self.assertAlmostEqual(binary.child1.mass.value_in(units.MSun), 1.26079, 3)
self.assertAlmostEqual(binary.child2.mass.value_in(units.MSun), 0.76080, 3)
instance.stop()
def test4(self):
print("Quick testing standard MOBSE example 2...")
instance = MOBSE()
instance.parameters.common_envelope_efficiency = 3.0
instance.parameters.common_envelope_binding_energy_factor = 0.5
instance.parameters.Eddington_mass_transfer_limit_factor = 10.0
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 7.816 | units.MSun
stars[1].mass = 4.387 | units.MSun
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
orbital_period = 1964.18453 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass, stars[1].mass)
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.0
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_mobse_to_model = instance.particles.new_channel_to(stars)
from_mobse_to_model.copy()
from_mobse_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_mobse_to_model_binaries.copy()
instance.evolve_model(170 | units.Myr)
from_mobse_to_model.copy()
from_mobse_to_model_binaries.copy()
self.assertAlmostEqual(binary.child1.mass.value_in(units.MSun), 1.26079, 3)
self.assertAlmostEqual(binary.child2.mass.value_in(units.MSun), 0.76080, 3)
self.assertEqual(str(binary.child1.stellar_type), "Neutron Star")
self.assertEqual(str(binary.child2.stellar_type), "Carbon/Oxygen White Dwarf")
instance.stop()
def test5(self):
print("Testing stellar collision...")
instance = MOBSE()
instance.parameters.common_envelope_efficiency = 3.0
instance.parameters.Eddington_mass_transfer_limit_factor = 10.0
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 130.0 | units.MSun
stars[1].mass = 50 | units.MSun
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
orbital_period = 300.0 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass, stars[1].mass)
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.99
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_mobse_to_model = instance.particles.new_channel_to(stars)
from_mobse_to_model.copy()
from_mobse_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_mobse_to_model_binaries.copy()
instance.evolve_model(170 | units.Myr)
from_mobse_to_model.copy()
from_mobse_to_model_binaries.copy()
print(binaries)
self.assertAlmostEqual(binary.child1.mass.value_in(units.MSun), 180.00, 3)
self.assertAlmostEqual(binary.child2.mass.value_in(units.MSun), 0.000, 3)
self.assertEqual(str(binary.child1.stellar_type), "Main Sequence star")
self.assertEqual(str(binary.child2.stellar_type), "Massless Supernova")
instance.stop()
def test6(self):
print("Testing additional parameters for initialization...")
instance = MOBSE()
instance.initialize_code()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
myvalue = 0.7
instance.parameters.reimers_mass_loss_coefficient = myvalue
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, myvalue)
instance.commit_parameters()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, myvalue)
instance.stop()
instance = MOBSE()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
myvalue = 0.7
instance.parameters.reimers_mass_loss_coefficient = myvalue
instance.parameters.set_defaults()
instance.commit_parameters()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
instance.stop()
def test7(self):
print("Test evolve_model optional arguments: end_time and keep_synchronous")
instance = MOBSE()
instance.commit_parameters()
stars = Particles(6)
stars.mass = [1.0, 2.0, 3.0, 0.1, 0.2, 0.3] | units.MSun
binaries = Particles(3)
binaries.eccentricity = 0.0
for i in range(3):
binaries[i].child1 = stars[i]
binaries[i].child2 = stars[i+3]
orbital_period = 200.0 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(
orbital_period,
binaries.child1.as_set().mass,
binaries.child2.as_set().mass
)
binaries.semi_major_axis = semi_major_axis
instance.particles.add_particles(stars)
instance.binaries.add_particles(binaries)
self.assertAlmostEqual(instance.binaries.age, [0.0, 0.0, 0.0] | units.yr)
self.assertAlmostEqual(instance.binaries.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
print("evolve_model without arguments: use shared timestep = min(particles.time_step)")
instance.evolve_model()
self.assertAlmostEqual(instance.binaries.age, [18.8768, 18.8768, 18.8768] | units.Myr, 3)
self.assertAlmostEqual(instance.binaries.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.binaries.age, [100.0, 100.0, 100.0] | units.Myr, 3)
self.assertAlmostEqual(instance.binaries.time_step, [550.1565, 58.2081, 18.8785] | 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.binaries.age, (100 | units.Myr) + ([550.1565, 58.2081, 18.8785] | units.Myr), 3)
self.assertAlmostEqual(instance.binaries.time_step, [550.1565, 58.2081, 18.8785] | units.Myr, 3)
self.assertAlmostEqual(instance.model_time, 100.0 | units.Myr, 3) # Unchanged!
instance.stop()
def test8(self):
print("Testing adding and removing particles from stellar evolution code...")
instance = MOBSE()
instance.initialize_code()
stars = Particles(6)
stars.mass = [1.0, 1.0, 1.0, 0.2, 0.2, 0.2] | units.MSun
binaries = Particles(3)
binaries.eccentricity = 0.0
for i in range(3):
binaries[i].child1 = stars[i]
binaries[i].child2 = stars[i+3]
orbital_period = 200.0 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(
orbital_period,
binaries.child1.as_set().mass,
binaries.child2.as_set().mass
)
binaries.semi_major_axis = semi_major_axis
instance.commit_parameters()
self.assertEqual(len(instance.particles), 0)
self.assertEqual(len(instance.binaries), 0) # before creation
instance.particles.add_particles(stars)
instance.binaries.add_particles(binaries[:-1])
instance.commit_particles()
instance.evolve_model(1.0 | units.Myr)
self.assertEqual(len(instance.binaries), 2) # before remove
self.assertAlmostEqual(instance.binaries.age, 1.0 | units.Myr)
instance.binaries.remove_particle(binaries[0])
self.assertEqual(len(instance.binaries), 1)
instance.evolve_model(2.0 | units.Myr)
self.assertAlmostEqual(instance.binaries[0].age, 2.0 | units.Myr)
instance.binaries.add_particles(binaries[::2])
self.assertEqual(len(instance.binaries), 3) # it's back...
self.assertAlmostEqual(instance.binaries[0].age, 2.0 | units.Myr)
self.assertAlmostEqual(instance.binaries[1].age, 0.0 | units.Myr)
self.assertAlmostEqual(instance.binaries[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.binaries.age, [3.0, 1.0, 1.0] | units.Myr)
instance.evolve_model(4.0 | units.Myr)
self.assertAlmostEqual(instance.binaries.age, [4.0, 2.0, 2.0] | units.Myr)
instance.stop()
def test9(self):
print("Testing MOBSE states")
instance = MOBSE()
stars = Particles(2)
stars.mass = [1.0, 0.2] | units.MSun
binaries = Particles(1)
orbital_period = 200.0 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass, stars[1].mass)
binaries.semi_major_axis = semi_major_axis
binaries.eccentricity = 0.0
binaries[0].child1 = stars[0]
binaries[0].child2 = stars[1]
print("First do everything manually:", end=' ')
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("ok")
print("initialize_code(), commit_parameters(), "
"and cleanup_code() should be called automatically:", end=' ')
instance = MOBSE()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.reimers_mass_loss_coefficient = 0.5
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(stars)
instance.binaries.add_particles(binaries)
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
print("ok")
| 29,891
| 40.401662
| 120
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_adaptb.py
|
import os
import os.path
import math
from amuse.community import *
from amuse.test.amusetest import TestWithMPI
from amuse.units import units, nbody_system, constants
from amuse.datamodel import Particles
from amuse.community.adaptb.interface import AdaptbInterface, Adaptb
from amuse.community.adaptb.functions import read_log, read_out, read_xy
class TestAdaptbInterface(TestWithMPI):
def test1(self):
print("Test AdaptbInterface initialization")
instance = self.new_instance_of_an_optional_code(AdaptbInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_adaptb_output_directory(instance.output_directory))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test2(self):
print("Test AdaptbInterface new_particle / get_state")
instance = self.new_instance_of_an_optional_code(AdaptbInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_adaptb_output_directory(instance.output_directory))
self.assertEqual(0, instance.commit_parameters())
id, error = instance.new_particle(mass=11.0, radius=2.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
self.assertEqual(0, error)
self.assertEqual(0, id)
id, error = instance.new_particle(mass=21.0, radius=5.0, x=10.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
self.assertEqual(0, error)
self.assertEqual(1, id)
self.assertEqual(0, instance.commit_particles())
retrieved_state1 = instance.get_state(0)
retrieved_state2 = instance.get_state(1)
self.assertEqual(0, retrieved_state1['__result'])
self.assertEqual(0, retrieved_state2['__result'])
self.assertEqual(11.0, retrieved_state1['mass'])
self.assertEqual(21.0, retrieved_state2['mass'])
self.assertEqual(0.0, retrieved_state1['x'])
self.assertEqual(10.0, retrieved_state2['x'])
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test4(self):
print("Test AdaptbInterface particle property getters/setters")
instance = self.new_instance_of_an_optional_code(AdaptbInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_adaptb_output_directory(instance.output_directory))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([0, 0], list(instance.new_particle(0.01, 1, 0, 0, 0, 1, 0, 0.1).values()))
self.assertEqual([1, 0], list(instance.new_particle(0.02, -1, 0, 0, 0, -1, 0, 0.1).values()))
self.assertEqual(0, instance.commit_particles())
# getters
mass, result = instance.get_mass(0)
self.assertAlmostEqual(0.01, mass)
self.assertEqual(0, result)
radius, result = instance.get_radius(1)
self.assertAlmostEqual(0.1, radius)
self.assertEqual(0, result)
self.assertEqual(-3, instance.get_mass(2)['__result']) # Particle not found
self.assertEqual([1, 0, 0, 0], list(instance.get_position(0).values()))
self.assertEqual([-1, 0, 0, 0], list(instance.get_position(1).values()))
self.assertEqual([0, 1, 0, 0], list(instance.get_velocity(0).values()))
self.assertEqual([0, -1, 0, 0], list(instance.get_velocity(1).values()))
# setters
self.assertEqual(0, instance.set_state(0, 0.01, 1, 2, 3, 4, 5, 6, 0.1))
self.assertEqual([0.01, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.1, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_mass(0, 0.02))
self.assertEqual([0.02, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.1, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_radius(0, 0.2))
self.assertEqual([0.02, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.2, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_position(0, 10, 20, 30))
self.assertEqual([0.02, 10.0, 20.0, 30.0, 4.0, 5.0, 6.0, 0.2, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_velocity(0, 40, 50, 60))
self.assertEqual([0.02, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 0.2, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test5(self):
print("Test AdaptbInterface parameters")
instance = self.new_instance_of_an_optional_code(AdaptbInterface)
self.assertEqual(0, instance.initialize_code())
# word length
self.assertEqual([64, 0], list(instance.get_word_length().values()))
self.assertEqual(0, instance.set_word_length(80))
self.assertEqual([80, 0], list(instance.get_word_length().values()))
# bs tolerance, default (double) implementation
self.assertEqual([1.0e-6, 0], list(instance.get_bs_tolerance_float64().values()))
self.assertEqual(0, instance.set_bs_tolerance_float64(1.0e-8))
self.assertEqual([1.0e-8, 0], list(instance.get_bs_tolerance_float64().values()))
# bs tolerance, string implementation for values requiring higher precision (note: actual accuracy depends on word_length)
self.assertEqual(1e-8, eval(instance.get_bs_tolerance_string()["bs_tolerance"]))
self.assertEqual(0, instance.set_bs_tolerance_string("1e-10"))
self.assertEqual([1e-10, 0], list(instance.get_bs_tolerance_float64().values()))
# new mpreal 1e-10 prints as 9.99999...e-11
# self.assertEquals(["1e-10", 0], instance.get_bs_tolerance_string().values())
# softening
self.assertEqual([0.0, 0], list(instance.get_eps2().values()))
self.assertEqual(0, instance.set_eps2(2e-1))
self.assertEqual([0.2, 0], list(instance.get_eps2().values()))
# print intervals
self.assertEqual([1e-1, 0], list(instance.get_dt_print().values()))
self.assertEqual(0, instance.set_dt_print(1e-2))
self.assertEqual([1e-2, 0], list(instance.get_dt_print().values()))
# max cpu time
self.assertEqual([3600, 0], list(instance.get_max_cpu_time().values()))
self.assertEqual(0, instance.set_max_cpu_time(120))
self.assertEqual([120, 0], list(instance.get_max_cpu_time().values()))
# output dir
self.assertEqual(["./", 0], list(instance.get_adaptb_output_directory().values()))
self.assertEqual(0, instance.set_adaptb_output_directory("./out"))
self.assertEqual(["./out/", 0], list(instance.get_adaptb_output_directory().values()))
self.assertEqual(0, instance.set_adaptb_output_directory(instance.output_directory))
self.assertEqual([instance.output_directory+"/", 0], list(instance.get_adaptb_output_directory().values()))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test6(self):
print("Test AdaptbInterface evolve_model, equal-mass binary")
instance = self.new_instance_of_an_optional_code(AdaptbInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_dt_print(1e-1))
self.assertEqual(0, instance.set_word_length(64))
self.assertEqual(0, instance.set_bs_tolerance_float64(1.0e-8))
self.assertEqual(0, instance.set_adaptb_output_directory(instance.output_directory))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([0, 0], list(instance.new_particle(0.5, 0.5, 0, 0, 0, 0.5, 0).values()))
self.assertEqual([1, 0], list(instance.new_particle(0.5, -0.5, 0, 0, 0, -0.5, 0).values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(math.pi)) # half an orbit
for result, expected in zip(list(instance.get_position(0).values()), [-0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 5)
self.assertEqual(0, instance.evolve_model(2 * math.pi)) # full orbit
for result, expected in zip(list(instance.get_position(0).values()), [0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 5)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test7(self):
print("Test AdaptbInterface evolve_model, pythagorean problem")
instance = self.new_instance_of_an_optional_code(AdaptbInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_dt_print(10.0))
self.assertEqual(0, instance.set_bs_tolerance_float64(1.0e-2))
self.assertEqual(0, instance.set_word_length(64))
self.assertEqual(0, instance.set_adaptb_output_directory(instance.output_directory))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([0, 0], list(instance.new_particle("3", "1", "3", "0", "0", "0", "0").values()))
self.assertEqual([1, 0], list(instance.new_particle("4", "-2", "-1", "0", "0", "0", "0").values()))
self.assertEqual([2, 0], list(instance.new_particle("5", "1", "-1", "0", "0", "0", "0").values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(100))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def slowtest8(self):
print("Test AdaptbInterface evolve_model, pythagorean problem, show convergence")
tolerance = [1e-0, 1e-2, 1e-4, 1e-6, 1e-8, 1e-10, 1e-12, 1e-14, 1e-16, 1e-18, 1e-20, 1e-22, 1e-24]
word_length = [64, 64, 64, 64, 64, 64, 80, 80, 96, 96, 112, 112, 128]
for tol, word_len in zip(tolerance, word_length):
instance = self.new_instance_of_an_optional_code(AdaptbInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_dt_print(0.1))
self.assertEqual(0, instance.set_bs_tolerance_float64(tol))
self.assertEqual(0, instance.set_word_length(word_len))
self.assertEqual(0, instance.set_adaptb_output_directory(instance.output_directory))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([0, 0], list(instance.new_particle("3", "0", "1", "3", "0", "0", "0", "0").values()))
self.assertEqual([1, 0], list(instance.new_particle("4", "0", "-2", "-1", "0", "0", "0", "0").values()))
self.assertEqual([2, 0], list(instance.new_particle("5", "0", "1", "-1", "0", "0", "0", "0").values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(100))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
data_log = read_log(os.path.join(instance.output_directory, "file.log"))
data_out = read_out(os.path.join(instance.output_directory, "file.out"))
tcpu = data_log[9]
dE = data_log[10]
x0 = data_out[0]
vx0 = data_out[1]
print("\nTolerance:", tol)
print("Word length:", word_len)
print("CPU time for calculation:", tcpu)
print("Relative energy error:", dE)
print("Final x position and velocity of first particle:", x0, vx0)
def xtest9(self):
print("Test AdaptbInterface evolve_model, pythagorean problem, plot orbits")
tolerance = ["1e-4", "1e-8"] # , "1e-12", "1e-16"]
word_length = [64, 64] # , 80, 96]
x1 = []
y1 = []
x2 = []
y2 = []
x3 = []
y3 = []
i = 0
while i < len(tolerance):
instance = self.new_instance_of_an_optional_code(AdaptbInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_dt_print(1e-1))
self.assertEqual(0, instance.set_bs_tolerance(tolerance[i]))
self.assertEqual(0, instance.set_word_length(word_length[i]))
self.assertEqual(0, instance.set_adaptb_output_directory(instance.output_directory))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([0, 0], list(instance.new_particle("3", "0", "1", "3", "0", "0", "0", "0").values()))
self.assertEqual([1, 0], list(instance.new_particle("4", "0", "-2", "-1", "0", "0", "0", "0").values()))
self.assertEqual([2, 0], list(instance.new_particle("5", "0", "1", "-1", "0", "0", "0", "0").values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(100))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
file_out = "file.out"
my_x1, my_y1, my_x2, my_y2, my_x3, my_y3 = read_xy(file_out)
x1.append(my_x1)
y1.append(my_y1)
x2.append(my_x2)
y2.append(my_y2)
x3.append(my_x3)
y3.append(my_y3)
i += 1
print(x1)
class TestAdaptb(TestWithMPI):
def new_sun_earth_system(self):
particles = Particles(2)
particles.mass = [1.0, 3.0037e-6] | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * particles.total_mass() / (1.0 | units.AU)).sqrt()
return particles
def test1(self):
print("Testing Adaptb initialization")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Adaptb, convert_nbody)
instance.initialize_code()
instance.commit_parameters()
instance.cleanup_code()
instance.stop()
def test2(self):
print("Testing Adaptb parameters")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Adaptb, convert_nbody)
instance.initialize_code()
# ~ print instance.parameters
self.assertEqual(instance.parameters.bs_tolerance, 1.0e-6)
instance.parameters.bs_tolerance = 1.0e-9
self.assertEqual(instance.parameters.bs_tolerance, 1.0e-9)
self.assertEqual(instance.parameters.epsilon_squared, 0.0 | units.m**2)
instance.parameters.epsilon_squared = 1.0e-4 | nbody_system.length**2
self.assertEqual(instance.parameters.epsilon_squared, convert_nbody.to_si(1.0e-4 | nbody_system.length**2))
self.assertEqual(instance.parameters.word_length, 64)
instance.parameters.word_length = 128
self.assertEqual(instance.parameters.word_length, 128)
self.assertEqual(instance.parameters.dt_print, convert_nbody.to_si(0.1 | nbody_system.time))
instance.parameters.dt_print = 1.0e-4 | nbody_system.time
self.assertEqual(instance.parameters.dt_print, convert_nbody.to_si(1.0e-4 | nbody_system.time))
self.assertEqual(instance.parameters.adaptb_output_directory, instance.output_directory + os.sep)
instance.parameters.adaptb_output_directory = "./out"
self.assertEqual(instance.parameters.adaptb_output_directory, "./out/")
instance.parameters.adaptb_output_directory = instance.output_directory
self.assertEqual(instance.parameters.adaptb_output_directory, instance.output_directory + os.sep)
self.assertEqual(instance.parameters.time_limit_cpu, 3600.0 | units.s)
instance.parameters.time_limit_cpu = 7200.0 | units.s
self.assertEqual(instance.parameters.time_limit_cpu, 7200.0 | units.s)
instance.stop()
def test3(self):
print("Testing Adaptb particles")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Adaptb, convert_nbody)
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(self.new_sun_earth_system())
instance.commit_particles()
self.assertAlmostEqual(instance.particles.mass, [1.0, 3.0037e-6] | units.MSun)
self.assertAlmostEqual(instance.particles.radius, 1.0 | units.RSun)
self.assertAlmostEqual(instance.particles.position,
[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU)
self.assertAlmostEqual(instance.particles.velocity,
[[0.0, 0.0, 0.0], [0.0, 29.7885, 0.0]] | units.km / units.s, 3)
instance.cleanup_code()
instance.stop()
def test4(self):
print("Testing Adaptb evolve_model, 2 particles")
particles = Particles(2)
particles.mass = 0.5 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * (1.0 | units.MSun) / (1.0 | units.AU)).sqrt()
particles.move_to_center()
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Adaptb, convert_nbody)
instance.initialize_code()
instance.parameters.dt_print = 0.1 | units.yr
instance.parameters.bs_tolerance = 1.0e-8
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 6)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 6)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 6)
instance.cleanup_code()
instance.stop()
| 18,286
| 48.558266
| 130
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_lab.py
|
import os
import sys
import numpy
from numpy import random
from amuse.test import amusetest
from amuse.test.amusetest import get_path_to_results
from amuse import lab
class TestCodesInLab(amusetest.TestCase):
def test1(self):
codes = (
'SeBa',
'BHTree',
'Mocassin',
'SPHRay',
'Fi',
'Gadget2',
'Bonsai',
'Octgrav',
)
for code in codes:
self.assertTrue(hasattr(lab, code), msg='excpected class {0} in lab module, but the class was not found'.format(code))
| 597
| 19.62069
| 130
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_halogen.py
|
import os.path
import numpy
import subprocess
from amuse.community import *
from amuse.test.amusetest import TestWithMPI
from amuse.community.halogen.interface import HalogenInterface, Halogen
import amuse.community.halogen
# Change the default for some Halogen(-Interface) keyword arguments:
default_options = dict()
# default_options = dict(redirection = "none")
class HalogenInterfaceTests(TestWithMPI):
def test1(self):
print("Testing HalogenInterface initialization")
instance = HalogenInterface(**default_options)
self.assertEqual(instance.initialize_code(), 0)
self.assertEqual(instance.set_model_alpha(2.0), 0)
self.assertEqual(instance.set_model_beta(5.0), 0)
self.assertEqual(instance.set_model_gamma(0.0), 0)
self.assertEqual(instance.set_target_number_of_particles(1000), 0)
self.assertEqual(instance.commit_parameters(), 0)
self.assertEqual(instance.cleanup_code(), 0)
instance.stop()
def test2(self):
print("Testing HalogenInterface parameters")
instance = HalogenInterface(**default_options)
self.assertEqual(instance.initialize_code(), 0)
self.assertEqual(instance.set_model_alpha(2.0), 0)
self.assertEqual(instance.set_model_beta(5.0), 0)
self.assertEqual(instance.set_model_gamma(0.0), 0)
self.assertEqual(instance.set_target_number_of_particles(100), 0)
self.assertEqual(instance.set_random_seed(1), 0)
self.assertEqual(instance.set_total_mass(9.0), 0)
self.assertEqual(instance.set_scale_radius(9.0), 0)
self.assertEqual(instance.set_cutoff_radius(9.0), 0)
self.assertEqual(instance.set_black_hole_mass(9.0), 0)
self.assertEqual(instance.set_do_exact_virial_radius_flag(1.0), 0)
self.assertEqual([2.0, 0], list(instance.get_model_alpha().values()))
self.assertEqual([5.0, 0], list(instance.get_model_beta().values()))
self.assertEqual([0.0, 0], list(instance.get_model_gamma().values()))
self.assertEqual([100, 0], list(instance.get_target_number_of_particles().values()))
self.assertEqual([1, 0], list(instance.get_random_seed().values()))
self.assertEqual([9.0, 0], list(instance.get_total_mass().values()))
self.assertEqual([9.0, 0], list(instance.get_scale_radius().values()))
self.assertEqual([9.0, 0], list(instance.get_cutoff_radius().values()))
self.assertEqual([9.0, 0], list(instance.get_black_hole_mass().values()))
self.assertEqual([1.0, 0], list(instance.get_do_exact_virial_radius_flag().values()))
self.assertEqual(instance.cleanup_code(), 0)
instance.stop()
def test3(self):
print("Testing HalogenInterface generate_particles")
number_of_particles = 100000
instance = HalogenInterface(**default_options)
self.assertEqual(instance.initialize_code(), 0)
self.assertEqual(instance.set_model_alpha(2.0), 0)
self.assertEqual(instance.set_model_beta(5.0), 0)
self.assertEqual(instance.set_model_gamma(0.0), 0)
self.assertEqual(instance.set_target_number_of_particles(number_of_particles), 0)
self.assertEqual(instance.set_random_seed(1), 0)
self.assertEqual(instance.set_output_path(instance.get_output_directory()), 0)
self.assertEqual(instance.commit_parameters(), 0)
self.assertEqual(list(instance.get_number_of_particles_updated().values()), [0, 0])
self.assertEqual(instance.generate_particles(), 0)
self.assertEqual(list(instance.get_number_of_particles_updated().values()), [number_of_particles, 0])
masses, errors = instance.get_mass(range(number_of_particles))
self.assertEqual(errors, numpy.zeros(number_of_particles))
self.assertEqual(masses, numpy.ones(number_of_particles)/number_of_particles)
x_positions, y_positions, z_positions, errors = instance.get_position(range(number_of_particles))
self.assertEqual(errors, numpy.zeros(number_of_particles))
self.assertAlmostEqual(numpy.array([numpy.mean(x_positions), numpy.mean(y_positions),
numpy.mean(z_positions)]), numpy.array([0.0]*3))
self.assertAlmostEqual(numpy.array([numpy.mean(abs(x_positions)), numpy.mean(abs(y_positions)),
numpy.mean(abs(z_positions))]), numpy.array([1.0]*3), 1)
x_velocities, y_velocities, z_velocities, errors = instance.get_velocity(range(number_of_particles))
self.assertEqual(errors, numpy.zeros(number_of_particles))
self.assertAlmostEqual(numpy.array([numpy.mean(x_velocities), numpy.mean(y_velocities),
numpy.mean(z_velocities)]), numpy.array([0.0]*3))
self.assertAlmostEqual(numpy.array([numpy.mean(abs(x_velocities)), numpy.mean(abs(y_velocities)),
numpy.mean(abs(z_velocities))]), numpy.array([0.25]*3), 1)
self.assertEqual(instance.cleanup_code(), 0)
instance.stop()
def test4(self):
print("Testing HalogenInterface output file name and directory")
instance = HalogenInterface(**default_options)
self.assertEqual(instance.initialize_code(), 0)
self.assertEqual(instance.set_model_alpha(2.0), 0)
self.assertEqual(instance.set_model_beta(5.0), 0)
self.assertEqual(instance.set_model_gamma(0.0), 0)
self.assertEqual(instance.set_target_number_of_particles(1000), 0)
self.assertEqual(instance.set_random_seed(1), 0)
self.assertEqual(instance.set_write_output_flag(1.0), 0)
self.assertEqual(list(instance.get_output_basename().values()), ["halogen", 0])
self.assertEqual(list(instance.get_output_path().values()), ["./", 0])
self.assertEqual(instance.set_output_basename("oops_this_output_basename_is_way_too_long"*2), -1)
self.assertEqual(list(instance.get_output_basename().values()), ["halogen", 0])
self.assertEqual(instance.set_output_path("/oops/this/output/path/has/way/too/many/subdirs"*6), -1)
self.assertEqual(list(instance.get_output_path().values()), ["./", 0])
self.assertEqual(instance.set_output_basename("test"), 0)
self.assertEqual(instance.set_output_path(instance.get_output_directory()), 0)
self.assertEqual(list(instance.get_output_basename().values()), ["test", 0])
self.assertEqual(list(instance.get_output_path().values()),
[os.path.join(instance.get_output_directory(), ""), 0])
self.assertEqual(instance.commit_parameters(), 0)
outputfile = os.path.join(instance.get_output_directory(), "test.IC.ascii")
if os.path.exists(outputfile):
os.remove(outputfile)
self.assertEqual(instance.generate_particles(), 0)
self.assertTrue(os.path.exists(outputfile))
halogen4muse_path = os.path.join(os.path.dirname(amuse.community.halogen.__file__), 'src', 'halogen4muse')
if not os.path.exists(halogen4muse_path) or not os.access(halogen4muse_path, os.X_OK):
return
process = subprocess.Popen([
halogen4muse_path,
'-a', '2',
'-b', '5',
'-c', '0',
'-N', '1000',
'-name', 'test_stand_alone',
'-randomseed', '1'
], cwd=instance.get_output_directory(), stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
process.communicate()
self.compare_files(
os.path.join(instance.get_output_directory(), "test.IC.ascii"),
os.path.join(instance.get_output_directory(), "test_stand_alone.IC.ascii")
)
stdoutput = subprocess.Popen(["diff", "test.out", "test_stand_alone.out"],
cwd=instance.get_output_directory(), stdout=subprocess.PIPE).communicate()[0]
stdoutput = stdoutput.decode()
self.assertTrue("< N/A (executed by AMUSE)" in stdoutput)
self.assertTrue("halogen4muse -a 2 -b 5 -c 0 -N 1000 -name test_stand_alone -randomseed 1" in stdoutput)
self.assertEqual(instance.cleanup_code(), 0)
instance.stop()
def compare_files(self, filename1, filename2):
with open(filename1) as stream1:
lines1 = stream1.readlines()
with open(filename2) as stream2:
lines2 = stream2.readlines()
self.assertTrue(len(lines1), len(lines2))
for line1, line2 in zip(lines1, lines2):
columns1 = line1.split()
columns2 = line2.split()
self.assertTrue(len(columns1), len(columns2))
if (len(columns1)) == 0:
continue
self.assertEqual(int(columns1[0]), int(columns2[0]))
for column1, column2 in zip(columns1[1:], columns2[1:]):
self.assertAlmostRelativeEquals(
float(column1),
float(column2),
8
)
class HalogenTests(TestWithMPI):
default_unit_converter = nbody_system.nbody_to_si(1.0 | units.kpc, 1.0e6 | units.MSun)
def test1(self):
print("Testing Halogen initialization")
instance = Halogen(**default_options)
instance.initialize_code()
instance.cleanup_code()
instance.stop()
def test2(self):
print("Testing Halogen parameters (with unit converter)")
instance = Halogen(self.default_unit_converter, **default_options)
instance.initialize_code()
for par, value in [('do_exact_virial_radius_flag', False),
('outputgridr_flag', False), ('outputgriddf_flag', False),
('write_output_flag', False)]:
self.assertTrue(value is getattr(instance.parameters, par))
setattr(instance.parameters, par, not value)
self.assertFalse(value is getattr(instance.parameters, par))
for par, value in [('alpha', -1.0), ('beta', -1.0), ('gamma', -1.0),
('number_of_particles', -1), ('random_seed', 42)]:
self.assertEqual(value, getattr(instance.parameters, par))
setattr(instance.parameters, par, 1)
self.assertEqual(1, getattr(instance.parameters, par))
for par, value in [('total_mass', 1.0 | nbody_system.mass),
('scale_radius', 1.0 | nbody_system.length),
('cutoff_radius', -1.0 | nbody_system.length),
('black_hole_mass', 0.0 | nbody_system.mass)]:
self.assertEqual(instance.unit_converter.to_si(value),
getattr(instance.parameters, par))
setattr(instance.parameters, par, 3.0 | value.unit)
self.assertEqual(instance.unit_converter.to_si(3.0 | value.unit),
getattr(instance.parameters, par))
for par, value in [('output_directory', os.path.join(instance.get_output_directory(), "")),
('output_basename', "halogen")]:
self.assertEqual(value, getattr(instance.parameters, par))
setattr(instance.parameters, par, 'test/')
self.assertEqual("test/", getattr(instance.parameters, par))
instance.cleanup_code()
instance.stop()
def test3(self):
print("Testing Halogen parameters (nbody units, no converter)")
instance = Halogen(**default_options)
instance.initialize_code()
for par, value in [('total_mass', 1.0 | nbody_system.mass),
('scale_radius', 1.0 | nbody_system.length),
('cutoff_radius', -1.0 | nbody_system.length),
('black_hole_mass', 0.0 | nbody_system.mass)]:
self.assertEqual(value, getattr(instance.parameters, par))
setattr(instance.parameters, par, 3.0 | value.unit)
self.assertEqual(3.0 | value.unit, getattr(instance.parameters, par))
instance.cleanup_code()
instance.stop()
def test4(self):
print("Testing Halogen generate_particles")
number_of_particles = 100
instance = Halogen(**default_options)
instance.initialize_code()
instance.parameters.alpha = 2.0
instance.parameters.beta = 5.0
instance.parameters.gamma = 0.0
instance.parameters.number_of_particles = number_of_particles
instance.parameters.random_seed = 1
instance.commit_parameters()
instance.generate_particles()
self.assertEqual(len(instance.particles), number_of_particles)
self.assertAlmostEqual(instance.particles.total_mass(), 1.0 | nbody_system.mass)
self.assertAlmostEqual(instance.particles.kinetic_energy(),
0.17345836639 | nbody_system.energy)
self.assertAlmostEqual(instance.particles.potential_energy(G=nbody_system.G),
-0.310395778644 | nbody_system.energy)
self.assertAlmostEqual(instance.particles.virial_radius(),
1.61084664935 | nbody_system.length)
instance.cleanup_code()
instance.stop()
def test5(self):
print("Testing Halogen generate_particles: generate multiple sets")
number_of_particles = 1000
instance = Halogen(**default_options)
instance.initialize_code()
instance.parameters.alpha = 2.0
instance.parameters.beta = 5.0
instance.parameters.gamma = 0.0
instance.parameters.number_of_particles = number_of_particles
instance.parameters.random_seed = 1
instance.commit_parameters()
instance.generate_particles()
set1 = instance.particles.copy()
self.assertEqual(len(set1), number_of_particles)
instance.parameters.random_seed = 1
instance.generate_particles()
set2 = instance.particles.copy()
self.assertEqual(len(set2), number_of_particles)
# Since a (any would do!) parameter was changed, recommit_parameters was
# called, re-seeding, and the result should be the same:
for attribute in ["mass", "x", "y", "z", "vx", "vy", "vz"]:
self.assertEqual(getattr(set1, attribute), getattr(set2, attribute))
instance.generate_particles()
# No parameter change: draw the next random set of particles
set3 = instance.particles.copy()
self.assertEqual(len(set3), number_of_particles)
self.assertEqual(set1.mass, set3.mass)
self.assertRaises(self.failureException, self.assertEqual, set1.x, set3.x)
self.assertIsOfOrder(abs(set1.x).median(), abs(set3.x).median(), 1)
self.assertAlmostEqual(abs(set1.vy).median(), abs(set3.vy).median(), 1)
instance.cleanup_code()
instance.stop()
def test6(self):
print("Testing Halogen state")
number_of_particles = 1000
print("First do everything manually:")
instance = Halogen(**default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.parameters.alpha = 2.0
instance.parameters.beta = 5.0
instance.parameters.gamma = 0.0
instance.parameters.number_of_particles = number_of_particles
instance.parameters.random_seed = 1
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.overridden().generate_particles()
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
instance.invoke_state_change_updated()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
self.assertEqual(len(instance.particles), number_of_particles)
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("initialize_code(), (re)commit_parameters(), update_particle_set(), "
"and cleanup_code() should be called automatically:")
instance = Halogen(**default_options)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.alpha = 2.0
instance.parameters.beta = 5.0
instance.parameters.gamma = 0.0
instance.parameters.number_of_particles = number_of_particles
instance.parameters.random_seed = 1
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
self.assertEqual(instance.get_number_of_particles_updated(), 0)
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.parameters.random_seed = 2
self.assertEqual(instance.get_name_of_current_state(), 'CHANGE_PARAMETERS_EDIT')
self.assertEqual(instance.get_number_of_particles_updated(), 0)
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.generate_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
self.assertEqual(len(instance.particles), number_of_particles)
self.assertEqual(instance.get_number_of_particles_updated(), 0)
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
def test7(self):
print("Testing Halogen error handling")
number_of_particles = 1000
instance = Halogen(**default_options)
instance.initialize_code()
self.assertRaises(exceptions.AmuseException, instance.commit_parameters, expected_message="Error when calling 'commit_parameters' of a 'Halogen', errorcode is -2, error is "
"'Missing or bad parameter for halo (see amuse/community/halogen/src/doc for details on required parameters).'")
instance.parameters.alpha = 2.0
instance.parameters.beta = 5.0
instance.parameters.gamma = 5.0
instance.parameters.number_of_particles = number_of_particles
instance.parameters.random_seed = 1
self.assertRaises(exceptions.AmuseException, instance.commit_parameters, expected_message="Error when calling 'commit_parameters' of a 'Halogen', errorcode is -2, error is "
"'Missing or bad parameter for halo (see amuse/community/halogen/src/doc for details on required parameters).'")
instance.parameters.gamma = -0.5
self.assertRaises(exceptions.AmuseException, instance.commit_parameters, expected_message="Error when calling 'commit_parameters' of a 'Halogen', errorcode is -2, error is "
"'Missing or bad parameter for halo (see amuse/community/halogen/src/doc for details on required parameters).'")
instance.parameters.gamma = 0.0
instance.parameters.beta = 2.0
self.assertRaises(exceptions.AmuseException, instance.commit_parameters, expected_message="Error when calling 'commit_parameters' of a 'Halogen', errorcode is -2, error is "
"'Missing or bad parameter for halo (see amuse/community/halogen/src/doc for details on required parameters).'")
instance.parameters.beta = 5.0
instance.commit_parameters()
instance.cleanup_code()
instance.stop()
| 18,974
| 48.934211
| 181
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_brutus.py
|
import os
import os.path
import math
from amuse.community import *
from amuse.test.amusetest import TestWithMPI
from amuse.units import units, nbody_system, constants
from amuse.datamodel import Particles
from amuse.community.brutus.interface import BrutusInterface, Brutus
import random
try:
import mpmath
HAS_MPMATH = True
except ImportError:
HAS_MPMATH = False
class TestBrutusInterface(TestWithMPI):
def test1(self):
print("Test BrutusInterface initialization")
instance = self.new_instance_of_an_optional_code(BrutusInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_brutus_output_directory(instance.output_directory))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test2(self):
print("Test BrutusInterface new_particle / get_state")
instance = self.new_instance_of_an_optional_code(BrutusInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_brutus_output_directory(instance.output_directory))
self.assertEqual(0, instance.commit_parameters())
id, error = instance.new_particle(mass=11.0, radius=2.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
self.assertEqual(0, error)
self.assertEqual(0, id)
id, error = instance.new_particle(mass=21.0, radius=5.0, x=10.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
self.assertEqual(0, error)
self.assertEqual(1, id)
self.assertEqual(0, instance.commit_particles())
retrieved_state1 = instance.get_state(0)
retrieved_state2 = instance.get_state(1)
self.assertEqual(0, retrieved_state1['__result'])
self.assertEqual(0, retrieved_state2['__result'])
self.assertEqual(11.0, retrieved_state1['mass'])
self.assertEqual(21.0, retrieved_state2['mass'])
self.assertEqual(0.0, retrieved_state1['x'])
self.assertEqual(10.0, retrieved_state2['x'])
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test4(self):
print("Test BrutusInterface particle property getters/setters")
instance = self.new_instance_of_an_optional_code(BrutusInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_brutus_output_directory(instance.output_directory))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([0, 0], list(instance.new_particle(0.01, 1, 0, 0, 0, 1, 0, 0.1).values()))
self.assertEqual([1, 0], list(instance.new_particle(0.02, -1, 0, 0, 0, -1, 0, 0.1).values()))
self.assertEqual(0, instance.commit_particles())
# getters
mass, result = instance.get_mass(0)
self.assertAlmostEqual(0.01, mass)
self.assertEqual(0, result)
radius, result = instance.get_radius(1)
self.assertAlmostEqual(0.1, radius)
self.assertEqual(0, result)
# self.assertEquals(-3, instance.get_mass(2)['__result']) # Particle not found
self.assertEqual([1, 0, 0, 0], list(instance.get_position(0).values()))
self.assertEqual([-1, 0, 0, 0], list(instance.get_position(1).values()))
self.assertEqual([0, 1, 0, 0], list(instance.get_velocity(0).values()))
self.assertEqual([0, -1, 0, 0], list(instance.get_velocity(1).values()))
# setters
self.assertEqual(0, instance.set_state(0, 0.01, 1, 2, 3, 4, 5, 6, 0.1))
self.assertEqual([0.01, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.1, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_mass(0, 0.02))
self.assertEqual([0.02, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.1, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_radius(0, 0.2))
self.assertEqual([0.02, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.2, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_position(0, 10, 20, 30))
self.assertEqual([0.02, 10.0, 20.0, 30.0, 4.0, 5.0, 6.0, 0.2, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_velocity(0, 40, 50, 60))
self.assertEqual([0.02, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 0.2, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test5(self):
print("Test BrutusInterface parameters")
instance = self.new_instance_of_an_optional_code(BrutusInterface)
self.assertEqual(0, instance.initialize_code())
# word length
self.assertEqual([64, 0], list(instance.get_word_length().values()))
self.assertEqual(0, instance.set_word_length(80))
self.assertEqual([80, 0], list(instance.get_word_length().values()))
# bs tolerance, default (double) implementation
self.assertEqual([1.0e-6, 0], list(instance.get_bs_tolerance().values()))
self.assertEqual(0, instance.set_bs_tolerance(1.0e-8))
self.assertEqual([1.0e-8, 0], list(instance.get_bs_tolerance().values()))
# bs tolerance, string implementation for values requiring higher precision (note: actual accuracy depends on word_length)
# self.assertEquals(1e-8, eval(instance.get_bs_tolerance_string()[""]))
# self.assertEquals(0, instance.set_bs_tolerance_string("1e-10"))
# self.assertEquals(["1e-10", 0], instance.get_bs_tolerance_string().values())
# eta, float64
self.assertEqual([0.24, 0], list(instance.get_eta().values()))
self.assertEqual(0, instance.set_eta(0.10))
self.assertEqual([0.10, 0], list(instance.get_eta().values()))
# eta, string
# self.assertEquals(["0.10", 0], instance.get_eta_string().values())
self.assertEqual(0, instance.set_eta_string("123"))
self.assertEqual(["123", 0], list(instance.get_eta_string().values()))
# output dir
# self.assertEquals(["./", 0], instance.get_brutus_output_directory().values())
self.assertEqual(0, instance.set_brutus_output_directory("./out"))
self.assertEqual(["./out/", 0], list(instance.get_brutus_output_directory().values()))
self.assertEqual(0, instance.set_brutus_output_directory(instance.output_directory))
self.assertEqual([instance.output_directory+"/", 0], list(instance.get_brutus_output_directory().values()))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test6(self):
print("Test BrutusInterface evolve_model, equal-mass binary")
instance = self.new_instance_of_an_optional_code(BrutusInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_bs_tolerance(1.0e-10))
self.assertEqual(0, instance.set_word_length(72))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([0, 0], list(instance.new_particle(0.5, 0.5, 0, 0, 0, 0.5, 0).values()))
self.assertEqual([1, 0], list(instance.new_particle(0.5, -0.5, 0, 0, 0, -0.5, 0).values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(math.pi)) # half an orbit
for result, expected in zip(instance.get_position(0).values(), [-0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 5)
self.assertEqual(0, instance.evolve_model(2 * math.pi)) # full orbit
for result, expected in zip(instance.get_position(0).values(), [0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 5)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test7(self):
print("Test BrutusInterface evolve_model, pythagorean problem")
instance = self.new_instance_of_an_optional_code(BrutusInterface)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.set_bs_tolerance(1.0e-6))
self.assertEqual(0, instance.set_word_length(56))
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([0, 0], list(instance.new_particle("3", "1", "3", "0", "0", "0", "0").values()))
self.assertEqual([1, 0], list(instance.new_particle("4", "-2", "-1", "0", "0", "0", "0").values()))
self.assertEqual([2, 0], list(instance.new_particle("5", "1", "-1", "0", "0", "0", "0").values()))
self.assertEqual(0, instance.commit_particles())
self.assertEqual(0, instance.evolve_model(10))
## add a check for assertequal final coordinates
for result, expected in zip(instance.get_position(0).values(), [0.778480410138085492274810667212415, 0.141392300290086165745727207379442, 0, 0]):
self.assertAlmostEqual(result, expected, 3)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test8(self):
print("Test BrutusInterface string parameters")
instance = self.new_instance_of_an_optional_code(BrutusInterface)
instance.initialize_code()
instance.set_word_length(128)
for i in range(100):
x = random.random()
x = str(x)
instance.set_eta_string(x)
x_, err = instance.get_eta_string()
instance.set_eta_string(x_)
x__, err = instance.get_eta_string()
# ~ assert x==x_
self.assertEqual(x_, x__)
instance.stop()
class TestBrutus(TestWithMPI):
def new_sun_earth_system(self):
particles = Particles(2)
particles.mass = [1.0, 3.0037e-6] | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * particles.total_mass() / (1.0 | units.AU)).sqrt()
return particles
def test1(self):
print("Testing Brutus initialization")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Brutus, convert_nbody)
instance.initialize_code()
instance.commit_parameters()
instance.cleanup_code()
instance.stop()
def test2(self):
print("Testing Brutus parameters")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Brutus, convert_nbody)
instance.initialize_code()
# print instance.parameters
self.assertEqual(instance.parameters.bs_tolerance, 1.0e-6)
instance.parameters.bs_tolerance = 1.0e-9
self.assertEqual(instance.parameters.bs_tolerance, 1.0e-9)
self.assertEqual(instance.parameters.word_length, 64)
instance.parameters.word_length = 128
self.assertEqual(instance.parameters.word_length, 128)
self.assertEqual(instance.parameters.dt_param, 0.24)
instance.parameters.dt_param = 0.10
self.assertEqual(instance.parameters.dt_param, 0.10)
self.assertEqual(instance.parameters.brutus_output_directory, instance.output_directory + os.sep)
instance.parameters.brutus_output_directory = "./out"
self.assertEqual(instance.parameters.brutus_output_directory, "./out/")
instance.parameters.brutus_output_directory = instance.output_directory
self.assertEqual(instance.parameters.brutus_output_directory, instance.output_directory + os.sep)
instance.cleanup_code()
instance.stop()
def test3(self):
print("Testing Brutus particles")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Brutus, convert_nbody)
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(self.new_sun_earth_system())
instance.commit_particles()
self.assertAlmostEqual(instance.particles.mass, [1.0, 3.0037e-6] | units.MSun)
self.assertAlmostEqual(instance.particles.radius, 1.0 | units.RSun)
self.assertAlmostEqual(instance.particles.position,
[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU)
self.assertAlmostEqual(instance.particles.velocity,
[[0.0, 0.0, 0.0], [0.0, 29.7885, 0.0]] | units.km / units.s, 3)
instance.cleanup_code()
instance.stop()
def test4(self):
print("Testing Brutus evolve_model, 2 particles")
particles = Particles(2)
particles.mass = 0.5 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * (1.0 | units.MSun) / (1.0 | units.AU)).sqrt()
particles.move_to_center()
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Brutus, convert_nbody)
instance.initialize_code()
instance.parameters.bs_tolerance = 1e-6
instance.parameters.word_length = 56
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 6)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 6)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 6)
instance.cleanup_code()
instance.stop()
def sun_and_planets(self):
particles = Particles(9)
sun = particles[0]
mercury = particles[1]
venus = particles[2]
earth = particles[3]
mars = particles[4]
jupiter = particles[5]
saturn = particles[6]
uranus = particles[7]
neptune = particles[8]
sun.mass = 1047.517 | units.MJupiter
sun.radius = 1.0 | units.RSun
sun.position = (0.005717, -0.00538, -2.130e-5) | units.AU
sun.velocity = (0.007893, 0.01189, 0.0002064) | units.kms
mercury.mass = 0.000174 | units.MJupiter
mercury.radius = 0 | units.RSun
mercury.position = (-0.31419, 0.14376, 0.035135) | units.AU
mercury.velocity = (-30.729, -41.93, -2.659) | units.kms
venus.mass = 0.002564 | units.MJupiter
venus.radius = 0 | units.RSun
venus.position = (-0.3767, 0.60159, 0.0393) | units.AU
venus.velocity = (-29.7725, -18.849, 0.795) | units.kms
earth.mass = 0.003185 | units.MJupiter
earth.radius = 0 | units.RSun
earth.position = (-0.98561, 0.0762, -7.847e-5) | units.AU
earth.velocity = (-2.927, -29.803, -0.000533) | units.kms
mars.mass = 0.000338 | units.MJupiter
mars.radius = 0 | units.RSun
mars.position = (-1.2895, -0.9199, -0.048494) | units.AU
mars.velocity = (14.9, -17.721, 0.2979) | units.kms
jupiter.mass = 1 | units.MJupiter
jupiter.radius = 0 | units.RSun
jupiter.position = (-4.9829, 2.062, -0.10990) | units.AU
jupiter.velocity = (-5.158, -11.454, -0.13558) | units.kms
saturn.mass = 0.29947 | units.MJupiter
saturn.radius = 0 | units.RSun
saturn.position = (-2.075, 8.7812, 0.3273) | units.AU
saturn.velocity = (-9.9109, -2.236, -0.2398) | units.kms
uranus.mass = 0.045737 | units.MJupiter
uranus.radius = 0 | units.RSun
uranus.position = (-12.0872, -14.1917, 0.184214) | units.AU
uranus.velocity = (5.1377, -4.7387, -0.06108) | units.kms
neptune.mass = 0.053962 | units.MJupiter
neptune.radius = 0 | units.RSun
neptune.position = (3.1652, 29.54882, 0.476391) | units.AU
neptune.velocity = (-5.443317, 0.61054, -0.144172) | units.kms
particles.move_to_center()
return particles
def test5(self):
if not HAS_MPMATH:
self.skip("mpmath not available")
print("MPmath available -> Doing tests")
bodies = self.sun_and_planets()
convert_nbody = nbody_system.nbody_to_si(bodies.mass.sum(), bodies[1].position.length())
gravity = Brutus(convert_nbody, number_of_workers=1)
gravity.parameters.bs_tolerance = 1e-30
gravity.parameters.word_length = 180
gravity.parameters.dt_param = 0.0000000000010
gravity.particles.add_particles(bodies)
Etot_init = gravity.kinetic_energy + gravity.potential_energy
Ein = gravity.get_total_energy_p_si()
gravity.evolve_model(gravity.model_time + (30 | units.day))
Eout = gravity.get_total_energy_p_si()
Ekin = gravity.kinetic_energy
Epot = gravity.potential_energy
Etot = Ekin + Epot
Loss_double = ((Etot_init-Etot)/gravity.get_time())
Loss_mp = (Ein - Eout)/gravity.get_time_p_si()
print("Loss with \"normal\" double =", Loss_double.number, " (W)")
print("Loss with multiprecision =", Loss_mp, " (W)")
gravity.stop()
self.assertTrue((Loss_mp <= 0.0000007) and (Loss_mp > 0.0000006))
| 17,660
| 42.07561
| 153
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_hop.py
|
import numpy
from numpy import random
from amuse.test.amusetest import get_path_to_results, TestCase
from amuse.units import units, nbody_system
from amuse.support.exceptions import AmuseException
from amuse.datamodel.particles import Particles
from amuse.ic.plummer import new_plummer_model
from amuse.community.hop.interface import HopInterface, Hop
class TestHopInterface(TestCase):
def test1(self):
print("First test: adding particles, setting and getting.")
hop = HopInterface()
hop.initialize_code()
n, err = hop.get_number_of_particles()
self.assertEqual(n, 0)
self.assertEqual(err, 0)
for i in range(6):
id, err = hop.new_particle(0, i*i, 0, 0)
n, err = hop.get_number_of_particles()
self.assertEqual(n, i+1)
self.assertEqual(err, 0)
for i in range(6):
x, y, z, err = hop.get_position(i)
self.assertEqual(x, i*i)
self.assertEqual(y, 0)
self.assertEqual(z, 0)
self.assertEqual(err, 0)
hop.set_position(i, x, i*i, 0)
for i in range(6):
x, y, z, err = hop.get_position(i)
self.assertEqual(x, y)
self.assertEqual(z, 0)
self.assertEqual(err, 0)
hop.stop()
def test2(self):
random.seed(1001)
hop = HopInterface()
hop.initialize_code()
particles = new_plummer_model(1000)
ids, errors = hop.new_particle(
particles.mass.value_in(nbody_system.mass),
particles.x.value_in(nbody_system.length),
particles.y.value_in(nbody_system.length),
particles.z.value_in(nbody_system.length)
)
n, err = hop.get_number_of_particles()
self.assertEqual(n, 1000)
self.assertEqual(err, 0)
# distance_to_center = (particles.position - particles.center_of_mass()).lengths()
# print distance_to_center
ds = {0: 0.482308834791, 1: 0.4885137677192688, 2: 0.27442726492881775}
for method in [0, 1, 2]:
hop.set_nDens(7)
hop.set_density_method(method)
hop.calculate_densities()
d, err = hop.get_density(0)
self.assertAlmostRelativeEquals(d, ds[method], 5)
hop.stop()
def test3(self):
random.seed(1001)
print("Third test: densest neighbors and groups.")
hop = HopInterface()
hop.initialize_code()
particles1 = new_plummer_model(10)
particles2 = new_plummer_model(10)
particles3 = new_plummer_model(10)
particles2.position += (10, 0, 0) | nbody_system.length
particles3.position += (0, 20, 0) | nbody_system.length
ids1, errors = hop.new_particle(
particles1.mass.value_in(nbody_system.mass),
particles1.x.value_in(nbody_system.length),
particles1.y.value_in(nbody_system.length),
particles1.z.value_in(nbody_system.length)
)
ids2, errors = hop.new_particle(
particles2.mass.value_in(nbody_system.mass),
particles2.x.value_in(nbody_system.length),
particles2.y.value_in(nbody_system.length),
particles2.z.value_in(nbody_system.length)
)
ids3, errors = hop.new_particle(
particles3.mass.value_in(nbody_system.mass),
particles3.x.value_in(nbody_system.length),
particles3.y.value_in(nbody_system.length),
particles3.z.value_in(nbody_system.length)
)
hop.set_nDens(5)
hop.calculate_densities()
hop.do_hop()
n, err = hop.get_group_id(ids1)
self.assertEqual(n, 2)
self.assertEqual(err, 0)
n, err = hop.get_group_id(ids2)
self.assertEqual(err, 0)
n, err = hop.get_group_id(ids3)
self.assertEqual(err, 0)
n, err = hop.get_densest_particle_in_group(2)
self.assertEqual(n, 7)
for i in range(3):
n, err = hop.get_number_of_particles_in_group(0)
self.assertEqual(err, 0)
self.assertEqual(n, 10)
n, err = hop.get_number_of_groups()
self.assertEqual(n, 3)
n, err = hop.get_densest_neighbor(ids1)
self.assertEqual(n, [7, 7, 12, 0, 7, 7, 7, 7, 12, 7])
hop.stop()
def test4(self):
hop = HopInterface()
hop.initialize_code()
value, error = hop.get_nDens()
self.assertEqual(error, 0)
self.assertEqual(value, 64)
error = hop.set_nDens(7)
self.assertEqual(error, 0)
value, error = hop.get_nDens()
self.assertEqual(value, 7)
value, error = hop.get_nHop()
self.assertEqual(error, 0)
self.assertEqual(value, -1)
error = hop.set_nHop(7)
self.assertEqual(error, 0)
value, error = hop.get_nHop()
self.assertEqual(value, 7)
value, error = hop.get_nBucket()
self.assertEqual(error, 0)
self.assertEqual(value, 16)
error = hop.set_nHop(7)
self.assertEqual(error, 0)
value, error = hop.get_nHop()
self.assertEqual(value, 7)
hop.stop()
class TestHop(TestCase):
def test1(self):
print("First test: adding particles, setting and getting.")
hop = Hop()
particles = Particles(6)
particles.mass = 1.0 | nbody_system.mass
particles.x = [i*i for i in range(6)] | nbody_system.length
particles.y = 0.0 | nbody_system.length
particles.z = 0.0 | nbody_system.length
hop.particles.add_particles(particles)
positions = hop.particles.position
for i in range(6):
x, y, z = positions[i]
self.assertEqual(x, i*i | nbody_system.length)
self.assertEqual(y, 0 | nbody_system.length)
self.assertEqual(z, 0 | nbody_system.length)
hop.stop()
def test2(self):
random.seed(1001)
hop = Hop()
hop.initialize_code()
hop.parameters.number_of_neighbors_for_local_density = 7
hop.commit_parameters()
particles = new_plummer_model(1000)
hop.particles.add_particles(particles)
# distance_to_center = (particles.position - particles.center_of_mass()).lengths()
# print distance_to_center
ds = {0: 0.482308834791, 1: 0.4885137677192688, 2: 0.27442726492881775}
for method in [0, 1, 2]:
hop.set_density_method(method)
hop.calculate_densities()
d = hop.particles[0].density
self.assertAlmostRelativeEquals(d, ds[method] | nbody_system.density, 5)
hop.stop()
def test3(self):
random.seed(1001)
print("Third test: densest neighbors and groups.")
hop = Hop()
hop.parameters.number_of_neighbors_for_local_density = 5
particles1 = new_plummer_model(10)
particles2 = new_plummer_model(10)
particles3 = new_plummer_model(10)
particles2.position += (10, 0, 0) | nbody_system.length
particles3.position += (0, 20, 0) | nbody_system.length
hop.particles.add_particles(particles1)
hop.particles.add_particles(particles2)
hop.particles.add_particles(particles3)
hop.calculate_densities()
hop.do_hop()
print(hop.particles.group_id)
groups = list(hop.groups())
self.assertEqual(len(groups), 3)
self.assertEqual(hop.get_number_of_particles_outside_groups(), 0)
# densities = (0,0,0) | nbody_system.density
for index, group in enumerate(groups):
self.assertEqual(len(group), 10)
self.assertEqual(group.id_of_group(), index)
# self.assertEquals(group.get_density_of_group(), densities[index])
hop.stop()
def test4(self):
random.seed(1001)
print("Test 4: complicated density field.")
# A separate group below peak_density_threshold -> should be dropped
particles0 = new_plummer_model(90, convert_nbody=nbody_system.nbody_to_si(0.9 | units.MSun, 1.0 | units.RSun))
# A nearby group below peak_density_threshold -> should be attached to proper group
particles1 = new_plummer_model(80, convert_nbody=nbody_system.nbody_to_si(0.8 | units.MSun, 1.0 | units.RSun))
particles1.x += 10 | units.RSun
# A proper group very nearby other proper group -> groups should merge
particles2a = new_plummer_model(200, convert_nbody=nbody_system.nbody_to_si(2.0 | units.MSun, 1.0 | units.RSun))
particles2b = new_plummer_model(300, convert_nbody=nbody_system.nbody_to_si(3.0 | units.MSun, 1.0 | units.RSun))
particles2a.x += 11.0 | units.RSun
particles2b.x += 11.2 | units.RSun
# A separate proper group other proper group -> groups should be preserved
particles3 = new_plummer_model(400, convert_nbody=nbody_system.nbody_to_si(4.0 | units.MSun, 1.0 | units.RSun))
particles3.x += 20 | units.RSun
hop = Hop(unit_converter=nbody_system.nbody_to_si(10.7 | units.MSun, 1.0 | units.RSun))
hop.parameters.number_of_neighbors_for_local_density = 100
hop.parameters.saddle_density_threshold_factor = 0.5
hop.parameters.relative_saddle_density_threshold = True
hop.commit_parameters()
for set in [particles0, particles1, particles2a, particles2b, particles3]:
hop.particles.add_particles(set)
hop.calculate_densities()
hop.parameters.outer_density_threshold = 0.1 * hop.particles.density.mean()
hop.parameters.peak_density_threshold = hop.particles.density.amax() / 4.0
hop.recommit_parameters()
hop.do_hop()
groups = list(hop.groups())
self.assertEqual(len(hop.particles), 1070)
self.assertEqual(len(groups), 2)
self.assertEqual(hop.particles.select(lambda x: x < 5 | units.RSun, "x").group_id, -1)
self.assertEqual(hop.get_number_of_particles_outside_groups(), 299)
self.assertEqual(1070 - len(groups[0]) - len(groups[1]), 299)
expected_size = [477, 294] # Less than [580, 400], because particles below outer_density_threshold are excluded
expected_average_x = [11.0, 20] | units.RSun
for index, group in enumerate(groups):
self.assertEqual(group.id_of_group(), index)
self.assertAlmostEqual(group.center_of_mass()[0], expected_average_x[index], 1)
self.assertEqual(len(group), expected_size[index])
if False: # Make a plot
original = hop.particles.copy()
from amuse.plot import scatter, native_plot
colors = ["r", "g", "b", "y", "k", "w"]*100
for group, color in zip(hop.groups(), colors):
scatter(group.x, group.y, c=color)
original -= group
scatter(original.x, original.y, c="m", marker="s")
native_plot.show()
hop.stop()
def test5(self):
print("Test error codes")
unit_converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
particles = new_plummer_model(200, convert_nbody=unit_converter)
hop = Hop(unit_converter=unit_converter) # , redirection="none")
hop.parameters.number_of_neighbors_for_local_density = 100
hop.particles.add_particles(particles[:99])
self.assertRaises(AmuseException, hop.calculate_densities, expected_message="Error when calling 'calculate_densities' of a 'Hop', errorcode is -5, error is 'Too few particles.'")
hop.particles.add_particles(particles[99:101])
hop.calculate_densities()
hop.parameters.number_of_neighbors_for_hop = 200
self.assertRaises(AmuseException, hop.calculate_densities, expected_message="Error when calling 'calculate_densities' of a 'Hop', errorcode is -5, error is 'Too few particles.'")
hop.particles.add_particles(particles[101:])
hop.calculate_densities()
self.assertRaises(AmuseException, hop.get_mass, 200, expected_message="Error when calling 'get_mass' of a 'Hop', errorcode is -3, error is 'A particle with the given index was not found.'")
hop.stop()
def test6(self):
print("Test with different masses")
# Particles on a cubic grid with masses according to a gaussian density profile
grid = numpy.mgrid[-1:1:21j, -1:1:21j, -1:1:21j] | units.m
particles = Particles(9261, x=grid[0].flatten(), y=grid[1].flatten(), z=grid[2].flatten())
peak_positions = [[0.2, -0.4, 0.3], [-0.6, 0.2, 0.7]] | units.m
particles.mass = 2*numpy.exp(-(particles.position-peak_positions[0]).lengths_squared() / (0.1 | units.m**2)) | units.kg
particles.mass += numpy.exp(-(particles.position-peak_positions[1]).lengths_squared() / (0.1 | units.m**2)) | units.kg
self.assertAlmostEqual(particles.position[particles.mass.argmax()], peak_positions[0])
self.assertAlmostEqual(particles[:4000].position[particles[:4000].mass.argmax()], peak_positions[1])
hop = Hop(unit_converter=nbody_system.nbody_to_si(particles.mass.sum(), 1.0 | units.m)) # , redirection="none")
hop.parameters.density_method = 2
hop.parameters.number_of_neighbors_for_local_density = 50
hop.parameters.relative_saddle_density_threshold = True
hop.commit_parameters()
hop.particles.add_particles(particles)
hop.calculate_densities()
self.assertAlmostEqual(hop.particles.position[hop.particles.density.argmax()], peak_positions[0])
self.assertAlmostEqual(hop.particles[:4000].position[hop.particles[:4000].density.argmax()], peak_positions[1])
hop.do_hop()
groups = list(hop.groups())
self.assertEqual(len(groups), 2)
for group, peak_position in zip(groups, peak_positions):
self.assertAlmostEqual(group.center_of_mass(), peak_position, 1)
hop.stop()
def test7(self):
print("Testing Hop states")
unit_converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
particles = new_plummer_model(200, convert_nbody=unit_converter)
print("First do everything manually:", end=' ')
instance = Hop(unit_converter=unit_converter)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("ok")
print("initialize_code(), commit_parameters(), (re)commit_particles(), "
"and cleanup_code() should be called automatically:", end=' ')
instance = Hop(unit_converter=unit_converter)
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.number_of_neighbors_for_local_density = 50
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(particles[:100])
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.particles.add_particles(particles[100:])
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
mass = instance.particles[100].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
print("ok")
def test8(self):
random.seed(1001)
print("Test 8: SI vs nbody units.")
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.RSun)
numpy.random.seed(1234)
particles = new_plummer_model(1000, convert_nbody=converter)
hop = Hop(unit_converter=converter)
hop.particles.add_particles(particles)
hop.calculate_densities()
hop.parameters.outer_density_threshold = 0.1 | nbody_system.mass / nbody_system.length**3
hop.do_hop()
groups = list(hop.groups())
self.assertEqual(len(hop.particles), 1000)
self.assertEqual(len(groups), 1)
self.assertEqual(len(groups[0]), 511)
self.assertEqual(len(hop.no_group()), 489)
hop.stop()
numpy.random.seed(1234)
particles = new_plummer_model(1000)
hop = Hop()
hop.particles.add_particles(particles)
hop.calculate_densities()
hop.parameters.outer_density_threshold = 0.1 | nbody_system.mass / nbody_system.length**3
hop.do_hop()
groups = list(hop.groups())
self.assertEqual(len(hop.particles), 1000)
self.assertEqual(len(groups), 1)
self.assertEqual(len(groups[0]), 511)
self.assertEqual(len(hop.no_group()), 489)
hop.stop()
| 17,278
| 39.183721
| 197
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_mpiamrvac.py
|
from amuse.community import *
from amuse.test.amusetest import TestWithMPI
from amuse import datamodel
from amuse.community.mpiamrvac.interface import MpiAmrVacInterface
from amuse.community.mpiamrvac.interface import MpiAmrVac
from amuse import io
from amuse.units import generic_unit_system
import os
import numpy
class TestMpiAmrVacInterface(TestWithMPI):
def test1(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVacInterface)
instance.initialize_code()
instance.stop()
def test2(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVacInterface)
filename, error = instance.get_parameters_filename()
self.assertEqual(error, 0)
self.assertEqual(filename, "amrvac.par")
error = instance.set_parameters_filename("dontexists.file")
self.assertEqual(error, -1)
filename, error = instance.get_parameters_filename()
self.assertEqual(error, 0)
self.assertEqual(filename, "amrvac.par")
name_of_parametersfile = 'amrvac.tst.par'
with open(name_of_parametersfile, 'w') as f:
f.write('test param')
error = instance.set_parameters_filename(name_of_parametersfile)
self.assertEqual(error, 0)
filename, error = instance.get_parameters_filename()
self.assertEqual(error, 0)
self.assertEqual(filename, name_of_parametersfile)
os.remove(name_of_parametersfile)
instance.initialize_code()
instance.stop()
def test3(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVacInterface)
instance.set_parameters_filename(instance.default_parameters_filename)
error = instance.initialize_code()
self.assertEqual(error, 0)
instance.stop()
def test4(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVacInterface)
instance.set_parameters_filename(instance.default_parameters_filename)
error = instance.initialize_code()
self.assertEqual(error, 0)
instance.setup_mesh(20, 20, 20, 20.0, 20.0, 20.0)
error = instance.commit_parameters()
self.assertEqual(error, 0)
number_of_grids, error = instance.get_number_of_grids()
self.assertEqual(error, 0)
self.assertEqual(number_of_grids, 8)
lx, ly, lz, error = instance.get_mesh_size(1)
self.assertEqual(lx, 10)
self.assertEqual(ly, 10)
self.assertEqual(lz, 10)
x, y, z, error = instance.get_position_of_index(0, 0, 0, 1)
self.assertEqual(error, 0)
self.assertEqual(x % 0.5, 0)
self.assertEqual(y % 0.5, 0)
self.assertEqual(z % 0.5, 0)
instance.stop()
# self.assertTrue(False)
def test5(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVacInterface)
instance.set_parameters_filename(instance.default_parameters_filename)
error = instance.initialize_code()
self.assertEqual(error, 0)
instance.setup_mesh(20, 20, 20, 20.0, 20.0, 20.0)
error = instance.commit_parameters()
self.assertEqual(error, 0)
number_of_grids, error = instance.get_number_of_grids()
self.assertEqual(error, 0)
self.assertEqual(number_of_grids, 8)
rho, error = instance.get_grid_density(1, 1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(rho, 0)
error = instance.set_grid_density(1, 1, 1, 0.1, 1)
self.assertEqual(error, 0)
rho, error = instance.get_grid_density(1, 1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.1)
rho, error = instance.get_grid_density(1, 1, 1, 2)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.0)
instance.stop()
def test6(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVacInterface)
instance.set_parameters_filename(instance.default_parameters_filename)
error = instance.initialize_code()
self.assertEqual(error, 0)
instance.setup_mesh(20, 20, 20, 20.0, 20.0, 20.0)
error = instance.commit_parameters()
self.assertEqual(error, 0)
number_of_grids, error = instance.get_number_of_grids()
self.assertEqual(error, 0)
self.assertEqual(number_of_grids, 8)
rho, error = instance.get_grid_energy_density(1, 1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(rho, 0)
error = instance.set_grid_energy_density(1, 1, 1, 0.1, 1)
self.assertEqual(error, 0)
rho, error = instance.get_grid_energy_density(1, 1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.1)
rho, error = instance.get_grid_density(1, 1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.0)
rho, error = instance.get_grid_energy_density(1, 1, 1, 2)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.0)
instance.stop()
def test7(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVacInterface)
instance.set_parameters_filename(instance.default_parameters_filename)
error = instance.initialize_code()
self.assertEqual(error, 0)
instance.setup_mesh(20, 20, 20, 20.0, 20.0, 20.0)
error = instance.commit_parameters()
self.assertEqual(error, 0)
number_of_grids, error = instance.get_number_of_grids()
self.assertEqual(error, 0)
self.assertEqual(number_of_grids, 8)
rhovx, rhovy, rhovz, error = instance.get_grid_momentum_density(1, 1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(rhovx, 0.0)
self.assertEqual(rhovy, 0.0)
self.assertEqual(rhovz, 0.0)
error = instance.set_grid_momentum_density(1, 1, 1, 0.1, 0.2, 0.3, 1)
self.assertEqual(error, 0)
rhovx, rhovy, rhovz, error = instance.get_grid_momentum_density(1, 1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(rhovx, 0.1)
self.assertEqual(rhovy, 0.2)
self.assertEqual(rhovz, 0.3)
rhovx, rhovy, rhovz, error = instance.get_grid_momentum_density(1, 1, 1, 2)
self.assertEqual(error, 0)
self.assertEqual(rhovx, 0.0)
self.assertEqual(rhovy, 0.0)
self.assertEqual(rhovz, 0.0)
rho, error = instance.get_grid_energy_density(1, 1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(rho, 0.0)
instance.stop()
def test8(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVacInterface)
instance.set_parameters_filename(instance.default_parameters_filename)
error = instance.initialize_code()
self.assertEqual(error, 0)
instance.setup_mesh(20, 20, 20, 20.0, 20.0, 20.0)
error = instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
self.assertEqual(error, 0)
error = instance.commit_parameters()
self.assertEqual(error, 0)
number_of_grids, error = instance.get_number_of_grids()
self.assertEqual(error, 0)
self.assertEqual(number_of_grids, 8)
error = instance.initialize_grid()
self.assertEqual(error, 0)
instance.stop()
def test9(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVacInterface)
instance.set_parameters_filename(instance.default_parameters_filename)
error = instance.initialize_code()
self.assertEqual(error, 0)
instance.setup_mesh(20, 20, 20, 20.0, 20.0, 20.0)
instance.commit_parameters()
n1, n2, n3, error = instance.get_acceleration_grid_size()
self.assertEqual(error, 0)
self.assertEqual(n1, 50)
self.assertEqual(n2, 50)
self.assertEqual(n3, 50)
a1, a2, a3, error = instance.get_acceleration_grid_acceleration(1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(a1, 0.0)
self.assertEqual(a2, 0)
self.assertEqual(a3, 0)
error = instance.set_acceleration_grid_acceleration(1, 1, 1, 10.0, 20.0, 30.0)
self.assertEqual(error, 0)
a1, a2, a3, error = instance.get_acceleration_grid_acceleration(1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(a1, 10.0)
self.assertEqual(a2, 20.0)
self.assertEqual(a3, 30.0)
x, y, z, error = instance.get_acceleration_grid_position_of_index(1, 1, 1)
self.assertEqual(error, 0)
self.assertEqual(x, -1)
self.assertEqual(y, -1)
self.assertEqual(z, -1)
instance.stop()
class TestMpiAmrVac(TestWithMPI):
def test1(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac)
instance.set_parameters_filename(instance.default_parameters_filename)
instance.setup_mesh(20, 20, 20, 20.0 | generic_unit_system.length, 20.0 | generic_unit_system.length, 20.0 | generic_unit_system.length)
error = instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
rhovx, rhovy, rhovz = instance.get_grid_momentum_density(1, 1, 1, 1)
self.assertEqual(rhovx, 0.0 | generic_unit_system.momentum_density)
self.assertEqual(rhovy, 0.0 | generic_unit_system.momentum_density)
self.assertEqual(rhovz, 0.0 | generic_unit_system.momentum_density)
instance.stop()
def test2(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac)
instance.set_parameters_filename(instance.default_parameters_filename)
instance.parameters.mesh_length = (20.0, 20.0, 20.0) | generic_unit_system.length
instance.parameters.mesh_size = (20, 20, 20)
instance.set_boundary("periodic", "periodic", "periodic", "periodic", "periodic", "periodic")
grids = list(instance.itergrids())
self.assertEqual(len(grids), 8)
for grid in grids:
position = grids[0].position
for i in range(3):
max_x = position[..., i].amax()
min_x = position[..., i].amin()
self.assertTrue(min_x >= 0.5 | generic_unit_system.length)
self.assertTrue(min_x <= 11.5 | generic_unit_system.length)
self.assertTrue(max_x >= 9.5 | generic_unit_system.length)
self.assertTrue(max_x <= 19.5 | generic_unit_system.length)
self.assertEqual(grids[0][0][0][0].rho, 0.0 | generic_unit_system.density)
grids[0].rho = 0.2 | generic_unit_system.density
rho1 = grids[1].rho
rho0 = grids[0].rho
for i in range(10):
for j in range(10):
for k in range(10):
self.assertEqual(rho1[0][0][0], 0.0 | generic_unit_system.density)
self.assertEqual(rho0[0][0][0], 0.2 | generic_unit_system.density)
instance.stop()
def test3(self):
for number_of_workers in range(2, 6):
instance = self.new_instance_of_an_optional_code(MpiAmrVac, number_of_workers=number_of_workers)
instance.set_parameters_filename(instance.default_parameters_filename)
instance.parameters.mesh_length = (20.0, 20.0, 20.0) | generic_unit_system.length
instance.parameters.mesh_size = (20, 20, 20)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
grids = list(instance.itergrids())
self.assertEqual(len(grids), 8)
for index, grid in enumerate(grids):
position = grid.position
# print instance.get_level_of_grid(index + 1)
level = instance.get_level_of_grid(index + 1)
self.assertEqual(level, 1)
for i in range(3):
max_x = position[..., i].amax()
min_x = position[..., i].amin()
self.assertTrue(min_x >= 0.5 | generic_unit_system.length)
self.assertTrue(min_x <= 10.5 | generic_unit_system.length)
self.assertTrue(max_x >= 9.5 | generic_unit_system.length)
self.assertTrue(max_x <= 19.5 | generic_unit_system.length)
self.assertEqual(max_x - min_x, 9.0 | generic_unit_system.length)
self.assertEqual(grids[0][0][0][0].rho, 0.0 | generic_unit_system.density)
grids[0].rho = 0.2 | generic_unit_system.density
rho1 = grids[4].rho
rho0 = grids[0].rho
for i in range(10):
for j in range(10):
for k in range(10):
self.assertEqual(rho1[0][0][0], 0.0 | generic_unit_system.density)
self.assertEqual(rho0[0][0][0], 0.2 | generic_unit_system.density)
instance.stop()
def test4(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac, number_of_workers=1)
instance.set_parameters_filename(instance.default_parameters_filename)
instance.parameters.mesh_length = (10.0, 10.0, 10.0) | generic_unit_system.length
instance.parameters.mesh_size = (10, 10, 10)
instance.parameters.maximum_number_of_grid_levels = 5
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
levels = [instance.get_level_of_grid(i+1) for i in range(len(grids))]
self.assertEqual(levels, [1] * 1)
gamma = 5.0 / 3.0
energy = generic_unit_system.mass / (generic_unit_system.time**2 * generic_unit_system.length)
grids_in_memory = []
for grid in grids:
grid.rho = 1.0 | generic_unit_system.density
grid.energy = (0.1795 | energy) / (gamma - 1)
has_advanced = instance.refine_grid()
grids = list(instance.itergrids())
self.assertFalse(has_advanced)
instance.stop()
def test5(self):
def fill_grids(grids):
for grid in grids:
firsthalf = grid.x > 5.0 | generic_unit_system.length
secondhalf = numpy.logical_not(firsthalf)
if(numpy.any(firsthalf)):
grid[firsthalf].rho = 1.0 | generic_unit_system.density
instance = self.new_instance_of_an_optional_code(MpiAmrVac, number_of_workers=1)
instance.set_parameters_filename(instance.default_parameters_filename)
instance.parameters.mesh_length = (10.0, 10.0, 10.0) | generic_unit_system.length
instance.parameters.mesh_size = (10, 10, 10)
instance.parameters.maximum_number_of_grid_levels = 4
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
n = 1
for i in range(3):
expected_length = n ** 3
grids = list(instance.itergrids())
levels = [instance.get_level_of_grid(grid+1) for grid in range(len(grids))]
self.assertEqual(len(grids), expected_length)
self.assertEqual(levels, [i+1] * expected_length)
n *= 2
fill_grids(grids)
has_advanced = instance.refine_grid()
self.assertTrue(has_advanced)
has_advanced = instance.refine_grid()
self.assertFalse(has_advanced)
instance.stop()
def test6(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac, number_of_workers=1)
instance.set_parameters_filename(instance.default_parameters_filename)
instance.parameters.mesh_length = (10.0, 10.0, 10.0) | generic_unit_system.length
instance.parameters.mesh_size = (10, 10, 10)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
self.assertEqual(instance.parameters.maximum_number_of_grid_levels, 3)
instance.parameters.maximum_number_of_grid_levels = 2
self.assertEqual(instance.parameters.maximum_number_of_grid_levels, 2)
self.assertEqual(instance.parameters.entropy_type, 'nul')
instance.parameters.entropy_type = 'powell'
self.assertEqual(instance.parameters.entropy_type, 'powell')
self.assertEqual(instance.parameters.time_integration_procedure, 'twostep')
instance.parameters.time_integration_procedure = 'onestep'
self.assertEqual(instance.parameters.time_integration_procedure, 'onestep')
self.assertEqual(instance.parameters.spatial_discretization_method, 'tvdmu')
instance.parameters.spatial_discretization_method = 'tvdlf'
self.assertEqual(instance.parameters.spatial_discretization_method, 'tvdlf')
self.assertEqual(instance.parameters.predictor_step_discretization_method, 'tvdmu')
instance.parameters.predictor_step_discretization_method = 'hancock'
self.assertEqual(instance.parameters.predictor_step_discretization_method, 'hancock')
instance.commit_parameters()
self.assertEqual(instance.parameters.entropy_type, 'powell')
self.assertEqual(instance.parameters.maximum_number_of_grid_levels, 2)
self.assertEqual(instance.parameters.time_integration_procedure, 'onestep')
self.assertEqual(instance.parameters.spatial_discretization_method, 'tvdlf')
self.assertEqual(instance.parameters.predictor_step_discretization_method, 'hancock')
def test7(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac)
instance.set_parameters_filename(instance.default_parameters_filename)
instance.parameters.mesh_length = (10.0, 10.0, 10.0) | generic_unit_system.length
instance.parameters.mesh_size = (10, 10, 10)
instance.parameters.maximum_number_of_grid_levels = 1
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
grid = datamodel.Grid(10, 10, 10)
grid.rho = 0.1 | generic_unit_system.density
grid.rhovx = 0.0 | generic_unit_system.momentum_density
grid.rhovy = 0.0 | generic_unit_system.momentum_density
grid.rhovz = 0.0 | generic_unit_system.momentum_density
grid.energy = 1.0 | generic_unit_system.energy_density
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
channel = grid.new_channel_to(igrid)
channel.copy()
instance.evolve_model(0.1 | generic_unit_system.time)
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
self.assertAlmostRelativeEquals(igrid.rho, grid.rho)
instance.evolve_model(0.3 | generic_unit_system.time)
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
self.assertAlmostRelativeEquals(igrid.rho, grid.rho)
instance.stop()
def test8(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac)
instance.set_parameters_filename(instance.default_parameters_filename)
instance.parameters.mesh_size = (10, 10, 10)
instance.parameters.maximum_number_of_grid_levels = 1
instance.parameters.length_x = 1.0 | generic_unit_system.length
instance.parameters.length_y = 1.0 | generic_unit_system.length
instance.parameters.length_z = 1.0 | generic_unit_system.length
instance.parameters.x_boundary_conditions = "periodic", "periodic"
instance.parameters.y_boundary_conditions = "periodic", "periodic"
instance.parameters.z_boundary_conditions = "periodic", "periodic"
name = instance.get_typeghostfill()
self.assertEqual(name, 'linear')
instance.commit_parameters()
name = instance.get_typeghostfill()
self.assertEqual(name, 'linear')
grid = datamodel.Grid(10, 10, 10)
grid.rho = 0.1 | generic_unit_system.density
grid.rhovx = 0.0 | generic_unit_system.momentum_density
grid.rhovy = 0.0 | generic_unit_system.momentum_density
grid.rhovz = 0.0 | generic_unit_system.momentum_density
grid.energy = 1.0 | generic_unit_system.energy_density
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
channel = grid.new_channel_to(igrid)
channel.copy()
name = instance.get_typeghostfill()
self.assertEqual(name, 'linear')
self.assertEqual((50, 50, 50), instance.acceleration_grid.shape)
acc_grid = datamodel.Grid(50, 50, 50)
acceleration = 1 | generic_unit_system.acceleration
acc_grid.ax = acceleration
acc_grid.ay = acceleration
acc_grid.az = acceleration
# self.assertEquals(acc_grid.acceleration[0][0][0], ( 1,1,1) | generic_unit_system.acceleration)
channel = acc_grid.new_channel_to(instance.acceleration_grid)
channel.copy()
name = instance.get_typeghostfill()
self.assertEqual(name, 'linear')
result = instance.initialize_grid()
name = instance.get_typeghostfill()
self.assertEqual(name, 'linear')
instance.evolve_model(0.1 | generic_unit_system.time)
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
self.assertAlmostRelativeEquals(igrid.rho, grid.rho)
# self.assertAlmostRelativeEquals(igrid.rhovx, 0.1 * 1.0 * 0.1 | generic_unit_system.momentum_density);
# self.assertAlmostRelativeEquals(igrid.rhovy, 0.1 * 1.0 * 0.1 | generic_unit_system.momentum_density);
# self.assertAlmostRelativeEquals(igrid.rhovz, 0.1 * 1.0 * 0.1 | generic_unit_system.momentum_density);
instance.evolve_model(0.3 | generic_unit_system.time)
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
self.assertAlmostRelativeEquals(igrid.rho, grid.rho)
# self.assertAlmostRelativeEquals(igrid.rhovx, grid.rho * instance.model_time * acceleration,2);
# self.assertAlmostRelativeEquals(igrid.rhovy, grid.rho * instance.model_time * acceleration,2);
# self.assertAlmostRelativeEquals(igrid.rhovz, grid.rho * instance.model_time * acceleration,2);
instance.stop()
def test9(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac, mode="2d")
instance.set_parameters_filename(instance.default_parameters_filename)
instance.parameters.mesh_length = (10.0, 10.0, 1) | generic_unit_system.length
instance.parameters.mesh_size = (10, 10, 1)
instance.parameters.maximum_number_of_grid_levels = 1
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
grid = datamodel.Grid(10, 10, 1)
grid.rho = 0.1 | generic_unit_system.density
grid.rhovx = 0.0 | generic_unit_system.momentum_density
grid.rhovy = 0.0 | generic_unit_system.momentum_density
grid.rhovz = 0.0 | generic_unit_system.momentum_density
grid.energy = 1.0 | generic_unit_system.energy_density
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
channel = grid.new_channel_to(igrid)
channel.copy()
instance.evolve_model(0.1 | generic_unit_system.time)
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
self.assertAlmostRelativeEquals(igrid.rho, grid.rho)
instance.evolve_model(0.3 | generic_unit_system.time)
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
self.assertAlmostRelativeEquals(igrid.rho, grid.rho)
instance.stop()
def test10(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac)
instance.parameters.mesh_size = (10, 10, 10)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.maximum_number_of_grid_levels = 1
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.parameters.stopping_conditions_number_of_steps = 1
gamma = 5.0 / 3.0
grid = datamodel.new_regular_grid((10, 10, 10), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.1 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
grid[0:5].rho = 0.015 | density
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
channel = grid.new_channel_to(igrid)
channel.copy()
instance.stopping_conditions.number_of_steps_detection.enable()
instance.evolve_model(1.0 | generic_unit_system.time)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
rho = next(instance.itergrids()).rho[..., 0, 0]
self.assertAlmostRelativeEquals(rho[7], 0.01 | density)
self.assertTrue(rho[0] < 0.015 | density)
self.assertTrue(instance.model_time < 1.0 | generic_unit_system.time)
instance.stopping_conditions.number_of_steps_detection.disable()
instance.evolve_model(0.1 | generic_unit_system.time)
rho = next(instance.itergrids()).rho[..., 0, 0]
self.assertAlmostRelativeEquals(instance.model_time, 0.1 | generic_unit_system.time)
self.assertAlmostRelativeEquals(rho[7], 0.012812 | density, 3)
self.assertTrue(rho[0] < 0.015 | density)
instance.stop()
def test11(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac)
instance.parameters.mesh_size = (10, 10, 10)
instance.parameters.mesh_length = [1.0, 1.0, 1.0] | generic_unit_system.length
instance.parameters.maximum_number_of_grid_levels = 1
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.parameters.stopping_conditions_timeout = 0.1 | units.s
gamma = 5.0 / 3.0
grid = datamodel.new_regular_grid((10, 10, 10), [1.0, 1.0, 1.0] | generic_unit_system.length)
density = generic_unit_system.density
momentum = generic_unit_system.speed * generic_unit_system.density
energy = generic_unit_system.mass / ((generic_unit_system.time**2) * generic_unit_system.length)
grid.rho = 0.01 | density
grid.rhovx = 0.1 | momentum
grid.rhovy = 0.0 | momentum
grid.rhovz = 0.0 | momentum
grid[0:5].rho = 0.015 | density
p = 1.0 | (generic_unit_system.mass / (generic_unit_system.length * generic_unit_system.time**2))
grid.energy = p / (gamma - 1)
grid.energy += 0.5 * (grid.rhovx ** 2 + grid.rhovy ** 2 + grid.rhovz ** 2) / grid.rho
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
channel = grid.new_channel_to(igrid)
channel.copy()
instance.stopping_conditions.timeout_detection.enable()
instance.evolve_model(1.0 | generic_unit_system.time)
self.assertTrue(instance.stopping_conditions.timeout_detection.is_set())
rho = next(instance.itergrids()).rho[..., 0, 0]
self.assertAlmostRelativeEquals(rho.mean(), 0.0125 | density)
self.assertTrue(instance.model_time < 1.0 | generic_unit_system.time)
instance.stopping_conditions.timeout_detection.disable()
tnext = instance.model_time.round(2) + (0.2 | generic_unit_system.time)
instance.evolve_model(tnext)
rho = next(instance.itergrids()).rho[..., 0, 0]
self.assertAlmostRelativeEquals(instance.model_time.round(2), tnext)
self.assertAlmostRelativeEquals(rho.mean(), 0.0125 | density)
self.assertTrue(rho[0] < 0.015 | density)
instance.stop()
def test12(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac, mode="1d")
instance.set_parameters_filename(instance.default_parameters_filename)
instance.parameters.mesh_length = (10.0, 1, 1) | generic_unit_system.length
instance.parameters.mesh_size = (10, 1, 1)
instance.parameters.maximum_number_of_grid_levels = 1
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
grid = datamodel.Grid(10, 1, 1)
grid.rho = 0.1 | generic_unit_system.density
grid.rhovx = 0.0 | generic_unit_system.momentum_density
grid.rhovy = 0.0 | generic_unit_system.momentum_density
grid.rhovz = 0.0 | generic_unit_system.momentum_density
grid.energy = 1.0 | generic_unit_system.energy_density
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
channel = grid.new_channel_to(igrid)
channel.copy()
instance.evolve_model(0.1 | generic_unit_system.time)
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
self.assertAlmostRelativeEquals(igrid.rho, grid.rho)
instance.evolve_model(0.3 | generic_unit_system.time)
grids = list(instance.itergrids())
self.assertEqual(len(grids), 1)
igrid = grids[0]
self.assertAlmostRelativeEquals(igrid.rho, grid.rho)
instance.stop()
def test13(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac, mode="2d-acc")
instance.set_parameters_filename(instance.default_parameters_filename)
instance.parameters.mesh_length = (10.0, 10.0, 1) | generic_unit_system.length
instance.parameters.mesh_size = (20, 20, 1)
instance.parameters.maximum_number_of_grid_levels = 2
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
must_refine = True
middle = 5.0 | generic_unit_system.length
while must_refine:
must_refine = instance.refine_grid()
for x in instance.itergrids():
inmem = x.copy()
inmem[inmem.x < middle].rho = 0.3 | generic_unit_system.density
inmem[inmem.x >= middle].rho = 0.1 | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.rhovy = 0.0 | generic_unit_system.momentum_density
inmem.rhovz = 0.0 | generic_unit_system.momentum_density
inmem.ax = 0.2 | generic_unit_system.acceleration
inmem.ay = 0.0 | generic_unit_system.acceleration
inmem.az = 0.0 | generic_unit_system.acceleration
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
self.assertAlmostRelativeEquals(x.ax, 0.2 | generic_unit_system.acceleration)
self.assertAlmostRelativeEquals(x.ay, 0.0 | generic_unit_system.acceleration)
self.assertAlmostRelativeEquals(x.az, 0.0 | generic_unit_system.acceleration)
self.assertEqual(len(list(instance.itergrids())), 4)
for igrid in instance.itergrids():
self.assertAlmostRelativeEquals(igrid.ax, 0.2 | generic_unit_system.acceleration)
self.assertAlmostRelativeEquals(igrid.ay, 0.0 | generic_unit_system.acceleration)
self.assertAlmostRelativeEquals(igrid.az, 0.0 | generic_unit_system.acceleration)
instance.evolve_model(0.1 | generic_unit_system.time)
self.assertEqual(len(list(instance.itergrids())), 16)
for igrid in instance.itergrids():
self.assertAlmostRelativeEquals(igrid.ax, 0.2 | generic_unit_system.acceleration)
self.assertAlmostRelativeEquals(igrid.ay, 0.0 | generic_unit_system.acceleration)
self.assertAlmostRelativeEquals(igrid.az, 0.0 | generic_unit_system.acceleration)
instance.stop()
def test14(self):
for ax, ay in ((0.2, 0.0), (0.0, 0.2), (0.2, 0.2)) | generic_unit_system.acceleration:
instance = self.new_instance_of_an_optional_code(MpiAmrVac, mode="2d-acc")
instance.set_parameters_filename(instance.default_parameters_filename)
instance.parameters.mesh_length = (10.0, 10.0, 1) | generic_unit_system.length
instance.parameters.mesh_size = (10, 10, 1)
instance.parameters.maximum_number_of_grid_levels = 1
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
rho = 0.1 | generic_unit_system.density
middle = 5.0 | generic_unit_system.length
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = 0.1 | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.rhovy = 0.0 | generic_unit_system.momentum_density
inmem.ax = ax
inmem.ay = ay
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
self.assertEqual(len(list(instance.itergrids())), 1)
dt = 0.1 | generic_unit_system.time
instance.evolve_model(dt)
self.assertEqual(len(list(instance.itergrids())), 1)
igrid = list(instance.itergrids())[0]
self.assertAlmostRelativeEquals(igrid.rho, 0.1 | generic_unit_system.density)
self.assertAlmostRelativeEquals(igrid.rhovx, ax * dt * rho)
self.assertAlmostRelativeEquals(igrid.rhovy, ay * dt * rho)
instance.stop()
def test15(self):
for ax, ay in ((0.2, 0.0), (0.0, 0.2), (0.2, 0.2)) | generic_unit_system.acceleration: # (0.0,0.0),
instance = self.new_instance_of_an_optional_code(MpiAmrVac, mode="2d-acc")
instance.set_parameters_filename(instance.default_parameters_filename)
instance.parameters.mesh_length = (10.0, 10.0, 1) | generic_unit_system.length
instance.parameters.mesh_size = (20, 20, 1)
instance.parameters.maximum_number_of_grid_levels = 1
instance.parameters.time_accurate = False
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
rho = 0.1 | generic_unit_system.density
middle = 5.0 | generic_unit_system.length
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = 0.1 | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.rhovy = 0.0 | generic_unit_system.momentum_density
inmem.ax = ax
inmem.ay = ay
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
self.assertEqual(len(list(instance.itergrids())), 4)
dt = 0.1 | generic_unit_system.time
instance.evolve_model(dt)
dt = instance.model_time
# ~ for igrid in instance.itergrids():
# ~ print(ax * dt* rho, ax, instance.model_time)
self.assertEqual(len(list(instance.itergrids())), 4)
for igrid in instance.itergrids():
# print igrid.rho[2]
self.assertAlmostRelativeEquals(igrid.rho, rho)
self.assertAlmostRelativeEquals(igrid.rhovx, ax * dt * rho)
self.assertAlmostRelativeEquals(igrid.rhovy, ay * dt * rho)
instance.stop()
def test16(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac, mode="1d")
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (20.0, 1, 1) | generic_unit_system.length
instance.parameters.mesh_size = (20, 1, 1)
instance.parameters.maximum_number_of_grid_levels = 1
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = inmem.x/(1 | generic_unit_system.length) | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(0.5 | generic_unit_system.length, 0.0 | generic_unit_system.length, 0.0 | generic_unit_system.length)
self.assertEqual(rho, 0.5 | generic_unit_system.density)
for value in numpy.arange(0.5, 19.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, value | generic_unit_system.density)
for value in numpy.arange(0.0, 0.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, ((0.5 + value) * 0.5 + (0.5-value) * 19.5) | generic_unit_system.density)
for value in numpy.arange(0.0, 0.5, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value + 19.5 | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, (19.5 - (value * 19)) | generic_unit_system.density, 9)
# out of range
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
20.0 | generic_unit_system.length,
0.0 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, 0.0 | generic_unit_system.density, 9)
def test17(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac, mode="2d", number_of_workers=2)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (20.0, 20.0, 1) | generic_unit_system.length
instance.parameters.mesh_length = (20.0, 20.0, 1) | generic_unit_system.length
instance.parameters.mesh_size = (20, 20, 1)
instance.parameters.maximum_number_of_grid_levels = 1
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = (inmem.x + ((inmem.y - (0.5 | generic_unit_system.length)) * 20.0))/(1 | generic_unit_system.length) | generic_unit_system.density
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(0.5 | generic_unit_system.length, 0.5 | generic_unit_system.length, 0.0 | generic_unit_system.length)
self.assertEqual(rho, 0.5 | generic_unit_system.density)
for value in numpy.arange(0.5, 19.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value | generic_unit_system.length,
0.5 | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, value | generic_unit_system.density)
for x in numpy.arange(8.5, 11.5, 0.25):
for y in numpy.arange(0.5, 19.6, 0.25):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
x | generic_unit_system.length,
y | generic_unit_system.length,
0.0 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, x + (20 * (y-0.5)) | generic_unit_system.density)
def test18(self):
instance = self.new_instance_of_an_optional_code(MpiAmrVac, number_of_workers=3)
instance.parameters.x_boundary_conditions = ("periodic", "periodic")
instance.parameters.y_boundary_conditions = ("periodic", "periodic")
instance.parameters.z_boundary_conditions = ("periodic", "periodic")
instance.parameters.mesh_length = (20.0, 20.0, 20.0) | generic_unit_system.length
instance.parameters.mesh_length = (20.0, 20.0, 20.0) | generic_unit_system.length
instance.parameters.mesh_size = (20, 20, 20)
instance.parameters.maximum_number_of_grid_levels = 1
for x in instance.itergrids():
inmem = x.copy()
inmem.rho = (
(
inmem.x +
((inmem.y - (0.5 | generic_unit_system.length)) * 20.0) +
((inmem.z - (0.5 | generic_unit_system.length)) * 400.0)
)
/ (1 | generic_unit_system.length) | generic_unit_system.density
)
inmem.rhovx = 0.0 | generic_unit_system.momentum_density
inmem.energy = 1.0 | generic_unit_system.energy_density
from_model_to_code = inmem.new_channel_to(x)
from_model_to_code.copy()
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(0.5 | generic_unit_system.length, 0.5 | generic_unit_system.length, 0.5 | generic_unit_system.length)
self.assertEqual(rho, 0.5 | generic_unit_system.density)
for value in numpy.arange(0.5, 19.6, 0.1):
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
value | generic_unit_system.length,
0.5 | generic_unit_system.length,
0.5 | generic_unit_system.length
)
self.assertAlmostRelativeEquals(rho, value | generic_unit_system.density)
sample = sample = datamodel.new_regular_grid(
(4, 4, 76),
(2, 2, 19) | generic_unit_system.length
)
sample.x += 9.5 | generic_unit_system.length
sample.y += 9.5 | generic_unit_system.length
sample.z += 0.5 | generic_unit_system.length
x = sample.x.flatten()
y = sample.y.flatten()
z = sample.z.flatten()
rho, rhovx, rhovy, rhovx, rhoenergy = instance.get_hydro_state_at_point(
x,
y,
z
)
half = 0.5 | generic_unit_system.length
self.assertAlmostRelativeEquals(rho, (x + (20 * (y-half)) + (400 * (z-half)))/(1 | generic_unit_system.length) | generic_unit_system.density)
| 44,902
| 44.083333
| 181
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_sse.py
|
import sys
import os
import os.path
import shutil
import numpy
from subprocess import call
from amuse.community.sse.interface import SSEInterface, SSE
from amuse.test.amusetest import get_path_to_results, TestWithMPI
from amuse import io
from amuse.units import units
from amuse.datamodel import Particle, Particles
from amuse.ic.salpeter import new_salpeter_mass_distribution
class TestMPIInterface(TestWithMPI):
class state(object):
def __init__(self):
self.stellar_type = 0.0
self.zams_mass = 0.0
self.mass = 0.0
self.radius = 0.0
self.luminosity = 0.0
self.core_mass = 0.0
self.core_radius = 0.0
self.envelope_mass = 0.0
self.envelope_radius = 0.0
self.spin = 0.0
self.epoch = 0.0
self.t_ms = 0.0
self.sse_age = 0.0
def initialize_module_with_default_parameters(self, sse):
metallicity = 0.02
neta = 0.5
bwind = 0.0
hewind = 0.5
sigma = 190.0
ifflag = 0
wdflag = 1
bhflag = 0
nsflag = 1
mxns = 3.0
pts1 = 0.05
pts2 = 0.01
pts3 = 0.02
status = sse.initialize(metallicity,
neta, bwind, hewind, sigma,
ifflag, wdflag, bhflag, nsflag, mxns,
pts1, pts2, pts3)
def test1(self):
sse = SSEInterface()
metallicity = 0.02
neta = 0.5
bwind = 0.0
hewind = 0.5
sigma = 190.0
ifflag = 0
wdflag = 1
bhflag = 0
nsflag = 1
mxns = 3.0
pts1 = 0.05
pts2 = 0.01
pts3 = 0.02
status = sse.initialize(metallicity,
neta, bwind, hewind, sigma,
ifflag, wdflag, bhflag, nsflag, mxns,
pts1, pts2, pts3)
self.assertEqual(status, 0)
sse.stop()
def test2(self):
sse = SSEInterface()
metallicity = 0.02
neta = 0.5
bwind = 0.0
hewind = 0.5
sigma = 190.0
ifflag = 0
wdflag = 1
bhflag = 0
nsflag = 1
mxns = 3.0
pts1 = 0.05
pts2 = 0.01
pts3 = 0.02
status = sse.initialize(metallicity,
neta, bwind, hewind, sigma,
ifflag, wdflag, bhflag, nsflag, mxns,
pts1, pts2, pts3)
self.assertEqual(status, 0)
new_state = self.state()
new_state.mass = 1.0
new_state.zams_mass = 1.0
new_state.stellar_type = 1.0
new_state.age = 1e-06
result = sse.evolve_star(
new_state.stellar_type,
new_state.zams_mass, new_state.mass, new_state.radius,
new_state.luminosity, new_state.core_mass, new_state.core_radius,
new_state.envelope_mass, new_state.envelope_radius, new_state.spin,
new_state.epoch, new_state.t_ms, new_state.sse_age, new_state.age
)
updated_state = self.state()
(updated_state.stellar_type, updated_state.zams_mass, updated_state.mass, updated_state.radius,
updated_state.luminosity, updated_state.core_mass, updated_state.core_radius,
updated_state.envelope_mass, updated_state.envelope_radius, updated_state.spin,
updated_state.epoch, updated_state.t_ms, updated_state.sse_age, updated_state.age) = result
attributes = ('stellar_type', 'zams_mass', 'mass', 'radius', 'luminosity', 'core_mass', 'core_radius',
'envelope_mass', 'envelope_radius', 'spin', 'epoch', 't_ms', 'sse_age', 'age')
expected = {
'zams_mass': '0x1.0000000000000p+0',
'mass': '0x1.0000000000000p+0',
'radius': '0x1.c6c8a1c793bcep-1',
'luminosity': '0x1.653b1b2d0333bp-1',
'core_mass': '0x0.0p+0',
'core_radius': '0x0.0p+0',
'envelope_mass': '0x1.0d6fc100ab510p-5',
'envelope_radius': '0x1.db27631ba0e5ap-3',
'spin': '0x1.07413b0522d63p+10',
'epoch': '0x0.0p+0',
't_ms': '0x1.57d90abe54643p+13',
'sse_age': '0x1.0c6f7a0b5ed8dp-20',
'age': '0x1.0c6f7a0b5ed8dp-20',
}
for x in expected:
self.assertAlmostRelativeEqual(float.fromhex(expected[x]), getattr(updated_state, x))
self.assertEqual(updated_state.age, 1e-06)
dt = sse.get_time_step(updated_state.stellar_type,
updated_state.zams_mass,
updated_state.age,
updated_state.mass,
updated_state.t_ms,
updated_state.epoch)
self.assertAlmostEqual(dt, 550.1565, 2)
sse.stop()
def test3(self):
sse = SSEInterface()
self.initialize_module_with_default_parameters(sse)
types = [1, 1, 1]
masses = [10, 5, 4]
radii = [5.0, 2.0, 1.0]
luminosity = core_mass = core_radius = envelope_mass =\
envelope_radius = spin = epoch = t_ms = [0.0, 0.0, 0.0]
sse_age = age = [1e-6, 1e-06, 1e-6]
result = sse.evolve_star(
types,
masses,
masses,
radii,
luminosity,
core_mass,
core_radius,
envelope_mass,
envelope_radius,
spin,
epoch,
t_ms,
sse_age,
age
)
self.assertEqual(result['mass'][0], 10)
self.assertEqual(result['mass'][1], 5)
self.assertAlmostEqual(result['mass'][2], 4.0, 2)
sse.stop()
def test4(self):
sse = SSEInterface()
self.initialize_module_with_default_parameters(sse)
types = [1 for x in range(1, 4000)]
masses = [1.0 + ((x / 4000.0) * 10.0) for x in range(1, 4000)]
radii = [1.0 for x in range(1, 4000)]
luminosity = core_mass = core_radius = envelope_mass =\
envelope_radius = spin = epoch =\
t_ms = [0.0 for x in range(1, 4000)]
sse_age = age = [1e-06 for x in range(1, 4000)]
result = sse.evolve_star(
types,
masses,
masses,
radii,
luminosity,
core_mass,
core_radius,
envelope_mass,
envelope_radius,
spin,
epoch,
t_ms,
sse_age,
age
)
self.assertEqual(len(result['mass']), 3999)
sse.stop()
class TestSSE(TestWithMPI):
def test1(self):
sse = SSE()
sse.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 5 | units.MSun
star.radius = 0.0 | units.RSun
sse.particles.add_particles(stars)
from_sse_to_model = sse.particles.new_channel_to(stars)
from_sse_to_model.copy()
previous_type = star.stellar_type
results = []
t0 = 0 | units.Myr
current_time = t0
while current_time < (125 | units.Myr):
sse.update_time_steps()
current_time = current_time + sse.particles[0].time_step
sse.evolve_model(current_time)
from_sse_to_model.copy()
if not star.stellar_type == previous_type:
results.append((star.age, star.mass, star.stellar_type))
previous_type = star.stellar_type
self.assertEqual(len(results), 6)
times = (
104.0 | units.Myr,
104.4 | units.Myr,
104.7 | units.Myr,
120.1 | units.Myr,
120.9 | units.Myr,
121.5 | units.Myr
)
for result, expected in zip(results, times):
self.assertAlmostEqual(result[0].value_in(units.Myr), expected.value_in(units.Myr), 1)
masses = (
5.000 | units.MSun,
5.000 | units.MSun,
4.998 | units.MSun,
4.932 | units.MSun,
4.895 | units.MSun,
0.997 | units.MSun
)
for result, expected in zip(results, masses):
self.assertAlmostEqual(result[1].value_in(units.MSun), expected.value_in(units.MSun), 3)
types = (
"Hertzsprung Gap",
"First Giant Branch",
"Core Helium Burning",
"First Asymptotic Giant Branch",
"Second Asymptotic Giant Branch",
"Carbon/Oxygen White Dwarf",
)
for result, expected in zip(results, types):
self.assertEqual(str(result[2]), expected)
sse.stop()
def test2(self):
sse = SSE()
sse.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 5 | units.MSun
star.radius = 0.0 | units.RSun
sse.particles.add_particles(stars)
sse.evolve_model(120.1 | units.Myr)
self.assertAlmostEqual(sse.particles[0].mass.value_in(units.MSun), 4.932, 3)
self.assertAlmostEqual(sse.particles[0].temperature.value_in(units.K), 4221., 0)
sse.stop()
def test3(self):
sse = SSE()
sse.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 5 | 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 = sse.particles.stellar_type
results = []
sse.evolve_model(121.5 | units.Myr)
channel.copy_attributes(sse.particles.get_attribute_names_defined_in_store())
self.assertAlmostEqual(star.mass.value_in(units.MSun), 0.997, 3)
sse.stop()
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()
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.assertAlmostEqual(stars[i].age, 125.0 | units.Myr)
self.assertTrue(stars[i].mass <= masses[i])
self.assertEqual(str(stars[i].stellar_type), end_types[i])
instance.stop()
def test7(self):
print("Test: evolve particles one at a time.")
print("Used to be problematic, since initial_mass of idle particle is set to zero.")
stars = Particles(2)
stars.mass = 1.0 | units.MSun
for star in stars:
stellar_evolution = SSE()
stellar_evolution.commit_parameters()
stellar_evolution.particles.add_particles(star.as_set())
stellar_evolution.commit_particles()
from_stellar_evolution_to_model = stellar_evolution.particles.new_channel_to(star.as_set())
stellar_evolution.evolve_model()
from_stellar_evolution_to_model.copy()
stellar_evolution.stop()
self.assertEqual(stars[0].initial_mass, stars[1].initial_mass)
self.assertEqual(stars[0].luminosity, stars[1].luminosity)
self.assertEqual(stars[0].age, stars[1].age)
print("Solved: SSE_muse_interface.f sets initial_mass to mass when necessary.")
def test8(self):
instance = SSE()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
myvalue = 0.7
instance.parameters.reimers_mass_loss_coefficient = myvalue
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, myvalue)
instance.commit_parameters()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, myvalue)
instance.stop()
instance = SSE()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
myvalue = 0.7
instance.parameters.reimers_mass_loss_coefficient = myvalue
instance.parameters.set_defaults()
instance.commit_parameters()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
instance.stop()
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()
def test10(self):
stellar_evolution = SSE()
stellar_evolution.commit_parameters()
stars = Particles(10)
stars.mass = 1.0 | units.MSun
stellar_evolution.particles.add_particles(stars)
self.assertEqual(stellar_evolution.particles._factory_for_new_collection(), Particles)
filename = os.path.join(get_path_to_results(), "test.h5")
if os.path.exists(filename):
os.remove(filename)
io.write_set_to_file(stellar_evolution.particles, filename, 'hdf5')
stored_stars = io.read_set_from_file(filename, 'hdf5')
self.assertEqual(len(stars), len(stored_stars))
self.assertAlmostRelativeEquals(stars.mass, stored_stars.mass)
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()
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.assertEqual(len(instance.particles), 0) # before creation
instance.particles.add_particles(particles[:-1])
instance.commit_particles()
instance.evolve_model(1.0 | units.Myr)
self.assertEqual(len(instance.particles), 2) # before remove
self.assertAlmostEqual(instance.particles.age, 1.0 | units.Myr)
instance.particles.remove_particle(particles[0])
self.assertEqual(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.assertEqual(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()
def test13(self):
print("Testing SSE states")
stars = Particles(1)
stars.mass = 1.0 | units.MSun
print("First do everything manually:", end=' ')
instance = SSE()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("ok")
print("initialize_code(), commit_parameters(), "
"and cleanup_code() should be called automatically:", end=' ')
instance = SSE()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.reimers_mass_loss_coefficient = 0.5
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(stars)
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
print("ok")
def test14a(self):
print("Testing basic operations: evolve_one_step and evolve_for (on particle)")
stars = Particles(2)
stars.mass = 1.0 | units.MSun
instance = SSE()
se_stars = instance.particles.add_particles(stars)
self.assertAlmostEqual(se_stars.age, [0.0, 0.0] | units.yr)
for i in range(3):
se_stars[0].evolve_one_step()
self.assertAlmostEqual(se_stars.age, [1650.46953688, 0.0] | units.Myr, 3)
number_of_steps = 10
step_size = se_stars[0].age / number_of_steps
for i in range(1, number_of_steps + 1):
se_stars[1].evolve_for(step_size)
self.assertAlmostEqual(se_stars.age, [number_of_steps, i] * step_size)
self.assertAlmostRelativeEqual(se_stars[0].age, se_stars[1].age)
self.assertAlmostRelativeEqual(se_stars[0].luminosity, se_stars[1].luminosity, 3)
self.assertAlmostRelativeEqual(se_stars[0].radius, se_stars[1].radius, 3)
self.assertAlmostRelativeEqual(se_stars[0].temperature, se_stars[1].temperature, 3)
instance.stop()
def test14b(self):
print("Testing basic operations: evolve_one_step and evolve_for (on subset)")
stars = Particles(2)
stars.mass = 1.0 | units.MSun
instance = SSE()
se_stars = instance.particles.add_particles(stars)
self.assertAlmostEqual(se_stars.age, [0.0, 0.0] | units.yr)
for i in range(3):
se_stars[:1].evolve_one_step()
self.assertAlmostEqual(se_stars.age, [1650.46953688, 0.0] | units.Myr, 3)
number_of_steps = 10
step_size = se_stars[0].age / number_of_steps
for i in range(1, number_of_steps + 1):
se_stars[1:].evolve_for(step_size)
self.assertAlmostEqual(se_stars.age, [number_of_steps, i] * step_size)
self.assertAlmostRelativeEqual(se_stars[0].age, se_stars[1].age)
self.assertAlmostRelativeEqual(se_stars[0].luminosity, se_stars[1].luminosity, 3)
self.assertAlmostRelativeEqual(se_stars[0].radius, se_stars[1].radius, 3)
self.assertAlmostRelativeEqual(se_stars[0].temperature, se_stars[1].temperature, 3)
instance.stop()
def test15(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:
p.evolve_for(0.1 | units.Myr)
i += 1
instance.stop()
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:
p.evolve_for(13.2 | units.Gyr)
i += 1
instance.stop()
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()
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]
# See issue #957
# 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)
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()
def test20(self):
print("SSE core_mass and CO_core_mass (low mass stars)")
instance = SSE()
stars = instance.particles.add_particles(Particles(mass=[0.6, 1.0] | units.MSun))
instance.evolve_model(100 | units.Gyr)
self.assertEqual(str(stars[0].stellar_type), "Helium White Dwarf")
self.assertAlmostEqual(stars[0].mass, 0.405 | units.MSun, 2)
self.assertEqual(stars[0].core_mass, stars[0].mass)
self.assertEqual(stars[0].CO_core_mass, 0 | units.MSun)
self.assertEqual(str(stars[1].stellar_type), "Carbon/Oxygen White Dwarf")
self.assertAlmostEqual(stars[1].mass, 0.520 | units.MSun, 2)
self.assertEqual(stars[1].core_mass, stars[1].mass)
self.assertEqual(stars[1].CO_core_mass, stars[1].mass)
instance.stop()
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()
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()
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()
| 31,457
| 37.933168
| 121
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_seba.py
|
import numpy
from amuse.test.amusetest import TestWithMPI
from amuse.community.seba.interface import SeBaInterface, SeBa
from amuse.units import units
from amuse.units import constants
from amuse.datamodel import Particle
from amuse.datamodel import Particles
class TestSeBaInterface(TestWithMPI):
def test1(self):
instance = self.new_instance_of_an_optional_code(SeBaInterface)
endtime, mass, radius, luminosity, temperature, time_step, stellar_type, error = instance.evolve_star(1, 4600, 0.02)
self.assertEqual(error, 0)
self.assertTrue(endtime <= 4600.0)
self.assertAlmostRelativeEqual(endtime, 4600.0, 4)
self.assertAlmostRelativeEqual(mass, 1.0, 6)
self.assertAlmostRelativeEqual(radius, 0.9856, 4)
self.assertAlmostRelativeEqual(luminosity, 0.9585, 4)
self.assertAlmostRelativeEqual(temperature, 5751, 4)
self.assertAlmostRelativeEqual(time_step, 1089.3, 4)
self.assertEqual(stellar_type, 1)
instance.stop()
def test2(self):
instance = SeBaInterface() # self.new_instance_of_an_optional_code(SeBaInterface)
error = instance.initialize_code()
self.assertEqual(error, 0)
index, error = instance.new_particle(1.)
self.assertEqual(error, 0)
self.assertEqual(index, 1)
mass, error = instance.get_mass(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 1.0, 6)
value, error = instance.get_radius(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(value, 0.88824945029751212, 6)
stellar_type, error = instance.get_stellar_type(index)
self.assertEqual(error, 0)
self.assertEqual(stellar_type, 1)
instance.stop()
def test3(self):
instance = SeBaInterface() # self.new_instance_of_an_optional_code(SeBaInterface)
error = instance.initialize_code()
self.assertEqual(error, 0)
index, error = instance.new_particle(1.)
self.assertEqual(error, 0)
self.assertEqual(index, 1)
error = instance.evolve_model(4600)
self.assertEqual(error, 0)
mass, error = instance.get_mass(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 1.0, 6)
value, error = instance.get_radius(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(value, 0.9856, 4)
value, error = instance.get_temperature(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(value, 5751, 4)
value, error = instance.get_time_step(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(value, 1089.3, 4)
stellar_type, error = instance.get_stellar_type(index)
self.assertEqual(error, 0)
self.assertEqual(stellar_type, 1)
instance.stop()
def test4(self):
instance = SeBaInterface() # self.new_instance_of_an_optional_code(SeBaInterface)
error = instance.initialize_code()
self.assertEqual(error, 0)
index, error = instance.new_particle(1.)
self.assertEqual(error, 0)
self.assertEqual(index, 1)
for t in range(46):
error = instance.evolve_model((t+1) * 100)
self.assertEqual(error, 0)
mass, error = instance.get_mass(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 1.0, 6)
value, error = instance.get_radius(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(value, 0.9856, 4)
value, error = instance.get_temperature(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(value, 5751, 4)
value, error = instance.get_time_step(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(value, 1089.3, 4)
stellar_type, error = instance.get_stellar_type(index)
self.assertEqual(error, 0)
self.assertEqual(stellar_type, 1)
instance.stop()
def test5(self):
instance = SeBaInterface() # self.new_instance_of_an_optional_code(SeBaInterface)
error = instance.initialize_code()
self.assertEqual(error, 0)
index, error = instance.new_particle([1., 2., 3.])
self.assertEqual(error, 0)
self.assertEqual(index, [1, 2, 3])
mass, error = instance.get_mass(2)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 2, 6)
mass, error = instance.get_mass(3)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 3, 6)
error = instance.evolve_model(4600)
self.assertEqual(error, 0)
mass, error = instance.get_mass(index)
print(mass)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass[0], 1.0, 6)
self.assertAlmostRelativeEqual(mass[1], 0.62973, 4)
self.assertAlmostRelativeEqual(mass[2], 0.75012, 4)
instance.stop()
def test6(self):
instance = SeBaInterface() # self.new_instance_of_an_optional_code(SeBaInterface)
error = instance.initialize_code()
self.assertEqual(error, 0)
index, error = instance.new_particle([1., 2., 3.])
self.assertEqual(error, 0)
self.assertEqual(index, [1, 2, 3])
for t in range(46):
error = instance.evolve_model((t+1) * 100)
self.assertEqual(error, 0)
mass, error = instance.get_mass(index)
print(mass)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, [1.0, 0.62973, 0.75072], 4)
instance.stop()
def test7(self):
instance = SeBaInterface() # self.new_instance_of_an_optional_code(SeBaInterface)
error = instance.initialize_code()
self.assertEqual(error, 0)
index, error = instance.new_particle([1., 2., 3.])
self.assertEqual(error, 0)
self.assertEqual(index, [1, 2, 3])
mass, error = instance.get_mass(2)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 2, 6)
mass, error = instance.get_mass(3)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 3, 6)
mass, error = instance.get_mass(4)
self.assertEqual(error, -1)
error = instance.delete_star(2)
self.assertEqual(error, 0)
mass, error = instance.get_mass(2)
self.assertEqual(error, -1)
mass, error = instance.get_mass(3)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 3, 6)
index, error = instance.new_particle(4.)
self.assertEqual(error, 0)
self.assertEqual(index, 4)
instance.stop()
def test8(self):
instance = SeBaInterface() # self.new_instance_of_an_optional_code(SeBaInterface)
error = instance.initialize_code()
self.assertEqual(error, 0)
index, error = instance.new_particle([3.0, 1.0, 2.0])
self.assertEqual(error, 0)
self.assertEqual(index, [1, 2, 3])
error = instance.delete_star(1)
self.assertEqual(error, 0)
error = instance.evolve_model(4600)
mass, error = instance.get_mass(2)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 1, 6)
error = instance.delete_star(3)
self.assertEqual(error, 0)
index, error = instance.new_particle([5.0])
self.assertEqual(error, 0)
mass, error = instance.get_mass(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 5.0, 6)
error = instance.evolve_model(5000)
mass, error = instance.get_mass(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 0.99057, 4)
error = instance.delete_star(2)
self.assertEqual(error, 0)
error = instance.delete_star(index)
self.assertEqual(error, 0)
for i in range(4):
mass, error = instance.get_mass(index+1)
self.assertEqual(error, -1)
index, error = instance.new_particle([5.0])
self.assertEqual(error, 0)
error = instance.evolve_model(10000)
mass, error = instance.get_mass(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 0.99057, 4)
instance.stop()
def test9(self):
instance = SeBaInterface() # self.new_instance_of_an_optional_code(SeBaInterface)
error = instance.initialize_code()
self.assertEqual(error, 0)
instance.set_metallicity(0.001)
index, error = instance.new_particle([3.0, 0.3])
self.assertEqual(error, 0)
self.assertEqual(index, [1, 2])
mu = (3.3 | units.MSun) * constants.G
orbital_period = 200.0 | units.day
semi_major_axis = (((orbital_period / 2.0 * numpy.pi)**2)*mu)**(1.0/3.0)
print(semi_major_axis.value_in(units.RSun))
eccentricity = 0.5
index, error = instance.new_binary(
semi_major_axis.value_in(units.RSun),
eccentricity,
index[0],
index[1]
)
self.assertEqual(error, 0)
self.assertEqual(index, 3)
mass, error = instance.get_mass(index)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 3.3, 4)
mass, error = instance.get_mass(2)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 0.3, 4)
error = instance.evolve_model(300)
self.assertEqual(error, 0)
mass, error = instance.get_mass(1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 2.98777, 4)
mass, error = instance.get_mass(2)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 0.29999, 4)
error = instance.evolve_model(400)
self.assertEqual(error, 0)
mass, error = instance.get_mass(1)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 0.902743, 4)
mass, error = instance.get_mass(2)
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(mass, 0.3, 4)
error = instance.delete_binary(index)
self.assertEqual(error, 0)
mass, error = instance.get_mass(index)
self.assertEqual(error, -1)
# check if singles are still in the mode and evolve
value, error = instance.get_age([1, 2])
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(value, 400, 4)
error = instance.evolve_model(500)
self.assertEqual(error, 0)
value, error = instance.get_age([1, 2])
self.assertEqual(error, 0)
self.assertAlmostRelativeEqual(value, 500, 4)
class TestSeBa(TestWithMPI):
def test_evolve_star(self):
instance = self.new_instance_of_an_optional_code(SeBa)
endtime, mass, radius, luminosity, temperature, time_step, stellar_type = instance.evolve_star(1 | units.MSun, 4600 | units.Myr, 0.02)
self.assertTrue(endtime <= 4600 | units.Myr)
self.assertAlmostRelativeEqual(mass, 1.0 | units.MSun, 4)
self.assertAlmostRelativeEqual(radius, 0.9856 | units.RSun, 4)
self.assertAlmostRelativeEqual(luminosity, 0.9585 | units.LSun, 4)
self.assertAlmostRelativeEqual(temperature, 5751 | units.K, 4)
self.assertAlmostRelativeEqual(time_step, 1089.3 | units.Myr, 4)
self.assertEqual(stellar_type, 1 | units.stellar_type)
def test_add_particle(self):
instance = self.new_instance_of_an_optional_code(SeBa)
p = Particle()
p.mass = 5 | units.MSun
p.metallicity = 0.02
p = instance.particles.add_particle(p)
instance.evolve_model(130 | units.Myr)
print(p)
self.assertAlmostRelativeEqual(p.mass, 0.9906 | units.MSun, 4)
def test_evolution_of_close_binary_system(self):
# print("Testing evolution of a close binary system...")
instance = self.new_instance_of_an_optional_code(SeBa)
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 3.0 | units.MSun
stars[1].mass = 0.3 | units.MSun
mu = (3.3 | units.MSun) * constants.G
orbital_period = 200.0 | units.day
semi_major_axis = (((orbital_period / (2.0 * numpy.pi))**2)*mu)**(1.0/3.0)
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.5
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_seba_to_model = instance.particles.new_channel_to(stars)
from_seba_to_model.copy()
from_seba_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_seba_to_model_binaries.copy()
previous_type = binary.child1.stellar_type
results = []
current_time = 0 | units.Myr
while current_time < (480 | units.Myr):
instance.update_time_steps()
# The next line appears a bit weird, but saves time for this simple test.
deltat = max(1.0*instance.binaries[0].time_step, 0.1 | units.Myr)
current_time = current_time + deltat
instance.evolve_model(current_time)
from_seba_to_model.copy()
from_seba_to_model_binaries.copy()
if not binary.child1.stellar_type == previous_type:
results.append((binary.age, binary.child1.mass, binary.child1.stellar_type))
previous_type = binary.child1.stellar_type
self.assertEqual(len(results), 6)
for x in results:
print(x)
types = (
"Hertzsprung Gap",
"First Giant Branch",
"Core Helium Burning",
"First Asymptotic Giant Branch",
"Giant Branch Naked Helium star",
"Carbon/Oxygen White Dwarf",
)
for result, expected in zip(results, types):
self.assertEqual(str(result[2]), expected)
times = (
377.6369 | units.Myr,
379.8877 | units.Myr,
382.3112 | units.Myr,
473.4804 | units.Myr,
475.4766 | units.Myr,
476.6182 | units.Myr,
)
for result, expected in zip(results, times):
self.assertAlmostEqual(result[0].value_in(units.Myr), expected.value_in(units.Myr), 0)
masses = (
3.0000 | units.MSun,
3.0000 | units.MSun,
2.9983 | units.MSun,
2.9741 | units.MSun,
0.6710 | units.MSun,
0.6596 | units.MSun,
)
for result, expected in zip(results, masses):
self.assertAlmostEqual(result[1].value_in(units.MSun), expected.value_in(units.MSun), 2)
instance.stop()
def test_set_parameter_metallicity(self):
instance = self.new_instance_of_an_optional_code(SeBa)
self.assertAlmostRelativeEquals(instance.parameters.metallicity, 0.02)
instance.parameters.metallicity = 0.04
self.assertAlmostRelativeEquals(instance.parameters.metallicity, 0.04)
def test_set_parameter_logging(self):
instance = self.new_instance_of_an_optional_code(SeBa)
self.assertFalse(instance.parameters.is_logging_of_evolve_enabled)
instance.parameters.is_logging_of_evolve_enabled = True
self.assertTrue(instance.parameters.is_logging_of_evolve_enabled)
def test_add_binary_particles(self):
instance = self.new_instance_of_an_optional_code(SeBa)
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 3.0 | units.MSun
stars[1].mass = 0.3 | units.MSun
mu = (3.3 | units.MSun) * constants.G
orbital_period = 200.0 | units.day
semi_major_axis = (((orbital_period / (2.0 * numpy.pi))**2)*mu)**(1.0/3.0)
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.5
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
self.assertAlmostRelativeEquals(instance.binaries[0].child1.mass, 3.0 | units.MSun, 4)
self.assertAlmostRelativeEquals(instance.binaries[0].child2.mass, 0.3 | units.MSun, 4)
def xtest7(self):
instance = self.new_instance_of_an_optional_code(SeBa)
instance.parameters.metallicity = 0.03
p = Particle()
p.mass = 99.1605930967 | units.MSun
p = instance.particles.add_particle(p)
instance.evolve_model(614 | units.Myr)
print(p.stellar_type)
self.assertEqual(str(p.stellar_type), 'Black Hole')
self.assertAlmostRelativeEqual(p.mass, 0.9906 | units.MSun, 4)
def test_set_semi_major_axis_eccentricity(self):
instance = self.new_instance_of_an_optional_code(SeBa)
instance.parameters.supernova_kick_velocity = 0 | units.kms
instance.commit_parameters()
print("v_kick=", instance.parameters.supernova_kick_velocity)
stars = Particles(2)
stars[0].mass = 10 | units.MSun
stars[1].mass = 9 | units.MSun
semi_major_axis = 10000 | units.AU
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
instance.evolve_model(30 | units.Myr)
print(instance.particles)
print(instance.binaries)
self.assertAlmostRelativeEquals(instance.binaries[0].eccentricity, 1, 4)
def test_add_stars_at_different_times(self):
instance = self.new_instance_of_an_optional_code(SeBa)
stars = Particles(2)
stars[0].mass = 10.0 | units.MSun
stars[1].mass = 9 | units.MSun
instance.particles.add_particles(stars)
instance.evolve_model(30 | units.Myr)
self.assertAlmostRelativeEquals(instance.particles.age, [30, 30] | units.Myr)
self.assertAlmostRelativeEquals(instance.model_time, 30 | units.Myr)
self.assertAlmostRelativeEquals(instance.particles[0].mass, 1.2507 | units.MSun, 4)
self.assertAlmostRelativeEquals(instance.particles[1].mass, 8.9351 | units.MSun, 4)
stars = Particles(2)
stars[0].mass = 10.0 | units.MSun
stars[1].mass = 9 | units.MSun
instance.particles.add_particles(stars)
instance.evolve_model(60 | units.Myr)
print(instance.particles.age)
print(instance.particles.mass)
self.assertAlmostRelativeEquals(instance.model_time, 60 | units.Myr)
self.assertAlmostRelativeEquals(instance.particles.age, [60, 60, 30, 30] | units.Myr)
self.assertAlmostRelativeEquals(instance.particles[2].mass, 1.2507 | units.MSun, 4)
self.assertAlmostRelativeEquals(instance.particles[3].mass, 8.9351 | units.MSun, 4)
def test_supernova_stopping_condition(self):
""" Test supernova stopping condition """
instance = self.new_instance_of_an_optional_code(SeBa)
instance.stopping_conditions.supernova_detection.enable()
p = Particle()
p.mass = 10 | units.MSun
p.metallicity = 0.02
p = instance.particles.add_particle(p)
instance.set_supernova_kick_velocity(0.0 | units.kms)
instance.evolve_model(30 | units.Myr)
self.assertEqual(instance.stopping_conditions.supernova_detection.is_set(), True)
self.assertEqual(instance.stopping_conditions.supernova_detection.particles(0)[0].key, p.key)
self.assertAlmostRelativeEqual(p.age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(p.mass, 1.2507 | units.MSun, 4)
self.assertAlmostRelativeEqual(p.natal_kick_velocity, [-54.070, 12.818, 42.583] | units.kms, 4)
def test_supernova_stopping_condition_in_a_binary(self):
""" Test supernova stopping condition in a binary """
instance = self.new_instance_of_an_optional_code(SeBa)
instance.stopping_conditions.supernova_detection.enable()
stars = Particles(2)
stars[0].mass = 10.0 | units.MSun
stars[1].mass = 5.0 | units.MSun
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
binary.semi_major_axis = 1.e6 | units.RSun
binary.eccentricity = 0.1
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
instance.evolve_model(30 | units.Myr)
self.assertEqual(instance.stopping_conditions.supernova_detection.is_set(), True)
self.assertEqual(instance.stopping_conditions.supernova_detection.particles(0)[0].key, instance.binaries[0].child1.key)
self.assertEqual(instance.stopping_conditions.supernova_detection.particles(0)[0].key, instance.particles[0].key)
print(instance.parameters)
self.assertAlmostRelativeEqual(instance.particles[0].age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[1].age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[0].mass, 1.2507 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[1].mass, 5.0 | units.MSun, 4)
# self.assertAlmostRelativeEqual(instance.particles[0].natal_kick_velocity, [0,0,0] | units.kms, 4)
self.assertAlmostRelativeEqual(instance.binaries[0].child1.age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.binaries[0].child2.age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.binaries[0].child1.mass, 1.2507 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.binaries[0].child2.mass, 5.0 | units.MSun, 4)
# self.assertAlmostRelativeEqual(instance.binaries[0].child1.natal_kick_velocity, [0,0,0] | units.kms, 4)
def test_supernova_stopping_condition_with_multiple_stars(self):
""" Test supernova stopping condition with multiple stars """
instance = self.new_instance_of_an_optional_code(SeBa)
instance.stopping_conditions.supernova_detection.enable()
stars = Particles(3)
stars[0].mass = 10.0 | units.MSun
stars[1].mass = 5.0 | units.MSun
stars[2].mass = 0.5 | units.MSun
instance.particles.add_particles(stars)
instance.evolve_model(30 | units.Myr)
self.assertEqual(instance.stopping_conditions.supernova_detection.is_set(), True)
self.assertEqual(instance.stopping_conditions.supernova_detection.particles(0)[0].key, instance.particles[0].key)
self.assertAlmostRelativeEqual(instance.particles[0].age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[1].age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[2].age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[0].mass, 1.2507 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[1].mass, 5.0 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[2].mass, 0.5 | units.MSun, 4)
# self.assertAlmostRelativeEqual(instance.particles[0].natal_kick_velocity, [0,0,0] | units.kms, 4)
def test_supernova_stopping_condition_with_multiple_stars_multiple_supernovae(self):
""" Test supernova stopping condition with multiple stars """
instance = self.new_instance_of_an_optional_code(SeBa)
instance.stopping_conditions.supernova_detection.enable()
stars = Particles(3)
stars[0].mass = 10.0 | units.MSun
stars[1].mass = 11.0 | units.MSun
stars[2].mass = 0.5 | units.MSun
instance.particles.add_particles(stars)
instance.evolve_model(30 | units.Myr)
self.assertEqual(instance.stopping_conditions.supernova_detection.is_set(), True)
self.assertEqual(instance.stopping_conditions.supernova_detection.particles(0)[0].key, instance.particles[1].key)
self.assertAlmostRelativeEqual(instance.particles[0].age, 23.02102 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[1].age, 23.02102 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[2].age, 23.02102 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[0].mass, 9.974497 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[1].mass, 1.29259 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[2].mass, 0.5 | units.MSun, 4)
# self.assertAlmostRelativeEqual(instance.particles[0].natal_kick_velocity, [0,0,0] | units.kms, 4)
instance.evolve_model(30 | units.Myr)
self.assertEqual(instance.stopping_conditions.supernova_detection.is_set(), True)
self.assertEqual(instance.stopping_conditions.supernova_detection.particles(0)[0].key, instance.particles[0].key)
self.assertAlmostRelativeEqual(instance.particles[0].age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[1].age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[2].age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[0].mass, 1.2507 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[1].mass, 1.29259 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[2].mass, 0.5 | units.MSun, 4)
# self.assertAlmostRelativeEqual(instance.particles[0].natal_kick_velocity, [0,0,0] | units.kms, 4)
def test_supernova_stopping_condition_with_multiple_stars_of_equal_mass(self):
""" Test supernova stopping condition with multiple stars of equal mass """
instance = self.new_instance_of_an_optional_code(SeBa)
instance.stopping_conditions.supernova_detection.enable()
stars = Particles(3)
stars[0].mass = 10.0 | units.MSun
stars[1].mass = 10.0 | units.MSun
stars[2].mass = 0.5 | units.MSun
instance.particles.add_particles(stars)
instance.evolve_model(30 | units.Myr)
self.assertEqual(instance.stopping_conditions.supernova_detection.is_set(), True)
self.assertEqual(len(instance.stopping_conditions.supernova_detection.particles(0)), 2)
self.assertEqual(instance.stopping_conditions.supernova_detection.particles(0)[0].key, instance.particles[0].key)
self.assertEqual(instance.stopping_conditions.supernova_detection.particles(0)[1].key, instance.particles[1].key)
self.assertAlmostRelativeEqual(instance.particles[0].age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[1].age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[2].age, 27.2715 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[0].mass, 1.2507 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[1].mass, 1.2507 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[2].mass, 0.5 | units.MSun, 4)
# self.assertAlmostRelativeEqual(instance.particles[0].natal_kick_velocity, [0,0,0] | units.kms, 4)
# self.assertAlmostRelativeEqual(instance.particles[1].natal_kick_velocity, [0,0,0] | units.kms, 4)
instance.evolve_model(30 | units.Myr)
self.assertEqual(instance.stopping_conditions.supernova_detection.is_set(), False)
self.assertAlmostRelativeEqual(instance.particles[0].age, 30. | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[1].age, 30. | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[2].age, 30. | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[0].mass, 1.2507 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[1].mass, 1.2507 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[2].mass, 0.5 | units.MSun, 4)
| 28,349
| 40.326531
| 142
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_mosse.py
|
import sys
import os
import os.path
import shutil
import numpy
from subprocess import call
from amuse.community.mosse.interface import MOSSEInterface, MOSSE
from amuse.test.amusetest import get_path_to_results, TestWithMPI
from amuse import io
from amuse.units import units
from amuse.datamodel import Particle, Particles
from amuse.ic.salpeter import new_salpeter_mass_distribution
class TestMPIInterface(TestWithMPI):
class state(object):
def __init__(self):
self.stellar_type = 0.0
self.zams_mass = 0.0
self.mass = 0.0
self.radius = 0.0
self.luminosity = 0.0
self.core_mass = 0.0
self.core_radius = 0.0
self.envelope_mass = 0.0
self.envelope_radius = 0.0
self.spin = 0.0
self.epoch = 0.0
self.t_ms = 0.0
self.sse_age = 0.0
def initialize_module_with_default_parameters(self, mosse):
metallicity = 0.02
neta = 0.5
bwind = 0.0
hewind = 1.0
sigma1 = 265.0
sigma2 = 7.0
ifflag = 0
wdflag = 1
bhflag = 1
nsflag = 3
piflag = 1
mxns = 3.0
idum = 29769
pts1 = 0.05
pts2 = 0.01
pts3 = 0.02
status = mosse.initialize(metallicity,
neta, bwind, hewind, sigma1, sigma2,
ifflag, wdflag, bhflag, nsflag, piflag, mxns, idum,
pts1, pts2, pts3)
def test1(self):
mosse = MOSSEInterface()
metallicity = 0.02
neta = 0.5
bwind = 0.0
hewind = 1.0
sigma1 = 265.0
sigma2 = 7.0
ifflag = 0
wdflag = 1
bhflag = 1
nsflag = 3
piflag = 1
mxns = 3.0
idum = 29769
pts1 = 0.05
pts2 = 0.01
pts3 = 0.02
status = mosse.initialize(metallicity,
neta, bwind, hewind, sigma1, sigma2,
ifflag, wdflag, bhflag, nsflag, piflag, mxns, idum,
pts1, pts2, pts3)
self.assertEqual(status, 0)
mosse.stop()
def test2(self):
mosse = MOSSEInterface()
metallicity = 0.02
neta = 0.5
bwind = 0.0
hewind = 1.0
sigma1 = 265.0
sigma2 = 7.0
ifflag = 0
wdflag = 1
bhflag = 1
nsflag = 3
piflag = 1
mxns = 3.0
idum = 29769
pts1 = 0.05
pts2 = 0.01
pts3 = 0.02
status = mosse.initialize(metallicity,
neta, bwind, hewind, sigma1, sigma2,
ifflag, wdflag, bhflag, nsflag, piflag, mxns, idum,
pts1, pts2, pts3)
self.assertEqual(status, 0)
new_state = self.state()
new_state.mass = 1.0
new_state.zams_mass = 1.0
new_state.stellar_type = 1.0
new_state.age = 1e-06
result = mosse.evolve_star(
new_state.stellar_type,
new_state.zams_mass, new_state.mass, new_state.radius,
new_state.luminosity, new_state.core_mass, new_state.core_radius,
new_state.envelope_mass, new_state.envelope_radius, new_state.spin,
new_state.epoch, new_state.t_ms, new_state.sse_age, new_state.age
)
updated_state = self.state()
(updated_state.stellar_type, updated_state.zams_mass, updated_state.mass, updated_state.radius,
updated_state.luminosity, updated_state.core_mass, updated_state.core_radius,
updated_state.envelope_mass, updated_state.envelope_radius, updated_state.spin,
updated_state.epoch, updated_state.t_ms, updated_state.sse_age, updated_state.age) = result
attributes = ('stellar_type', 'zams_mass', 'mass', 'radius', 'luminosity', 'core_mass', 'core_radius',
'envelope_mass', 'envelope_radius', 'spin', 'epoch', 't_ms', 'sse_age', 'age')
expected = {
'zams_mass': '0x1.0000000000000p+0',
'mass': '0x1.0000000000000p+0',
'radius': '0x1.c6c8a1c793bcep-1',
'luminosity': '0x1.653b1b2d0333bp-1',
'core_mass': '0x0.0p+0',
'core_radius': '0x0.0p+0',
'envelope_mass': '0x1.0d6fc100ab510p-5',
'envelope_radius': '0x1.db27631ba0e5ap-3',
'spin': '0x1.07413b0522d63p+10',
'epoch': '0x0.0p+0',
't_ms': '0x1.57d90abe54643p+13',
'sse_age': '0x1.0c6f7a0b5ed8dp-20',
'age': '0x1.0c6f7a0b5ed8dp-20',
}
for x in expected:
self.assertAlmostRelativeEqual(float.fromhex(expected[x]), getattr(updated_state, x))
self.assertEqual(updated_state.age, 1e-06)
dt = mosse.get_time_step(updated_state.stellar_type,
updated_state.zams_mass,
updated_state.age,
updated_state.mass,
updated_state.t_ms,
updated_state.epoch)
self.assertAlmostEqual(dt, 550.1565, 2)
mosse.stop()
def test3(self):
mosse = MOSSEInterface()
self.initialize_module_with_default_parameters(mosse)
types = [1, 1, 1]
masses = [10, 5, 4]
radii = [5.0, 2.0, 1.0]
luminosity = core_mass = core_radius = envelope_mass =\
envelope_radius = spin = epoch = t_ms = [0.0, 0.0, 0.0]
sse_age = age = [1e-6, 1e-06, 1e-6]
result = mosse.evolve_star(
types,
masses,
masses,
radii,
luminosity,
core_mass,
core_radius,
envelope_mass,
envelope_radius,
spin,
epoch,
t_ms,
sse_age,
age
)
self.assertEqual(result['mass'][0], 10)
self.assertEqual(result['mass'][1], 5)
self.assertAlmostEqual(result['mass'][2], 4.0, 2)
mosse.stop()
def test4(self):
mosse = MOSSEInterface()
self.initialize_module_with_default_parameters(mosse)
types = [1 for x in range(1, 4000)]
masses = [1.0 + ((x / 4000.0) * 10.0) for x in range(1, 4000)]
radii = [1.0 for x in range(1, 4000)]
luminosity = core_mass = core_radius = envelope_mass =\
envelope_radius = spin = epoch =\
t_ms = [0.0 for x in range(1, 4000)]
sse_age = age = [1e-06 for x in range(1, 4000)]
result = mosse.evolve_star(
types,
masses,
masses,
radii,
luminosity,
core_mass,
core_radius,
envelope_mass,
envelope_radius,
spin,
epoch,
t_ms,
sse_age,
age
)
self.assertEqual(len(result['mass']), 3999)
mosse.stop()
class TestSSE(TestWithMPI):
def test1(self):
mosse = MOSSE()
mosse.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 5 | units.MSun
star.radius = 0.0 | units.RSun
mosse.particles.add_particles(stars)
from_sse_to_model = mosse.particles.new_channel_to(stars)
from_sse_to_model.copy()
previous_type = star.stellar_type
results = []
t0 = 0 | units.Myr
current_time = t0
while current_time < (125 | units.Myr):
mosse.update_time_steps()
current_time = current_time + mosse.particles[0].time_step
mosse.evolve_model(current_time)
from_sse_to_model.copy()
if not star.stellar_type == previous_type:
results.append((star.age, star.mass, star.stellar_type))
previous_type = star.stellar_type
self.assertEqual(len(results), 6)
times = (
104.19 | units.Myr,
104.62 | units.Myr,
104.87 | units.Myr,
120.39 | units.Myr,
121.17 | units.Myr,
121.88 | units.Myr
)
for result, expected in zip(results, times):
self.assertAlmostEqual(result[0].value_in(units.Myr), expected.value_in(units.Myr), 1)
masses = (
4.991 | units.MSun,
4.991 | units.MSun,
4.989 | units.MSun,
4.923 | units.MSun,
4.886 | units.MSun,
1.003 | units.MSun
)
for result, expected in zip(results, masses):
self.assertAlmostEqual(result[1].value_in(units.MSun), expected.value_in(units.MSun), 3)
types = (
"Hertzsprung Gap",
"First Giant Branch",
"Core Helium Burning",
"First Asymptotic Giant Branch",
"Second Asymptotic Giant Branch",
"Carbon/Oxygen White Dwarf",
)
for result, expected in zip(results, types):
self.assertEqual(str(result[2]), expected)
mosse.stop()
def test2(self):
mosse = MOSSE()
mosse.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 5 | units.MSun
star.radius = 0.0 | units.RSun
mosse.particles.add_particles(stars)
mosse.evolve_model(120.1 | units.Myr)
self.assertAlmostEqual(mosse.particles[0].mass.value_in(units.MSun), 4.925, 3)
self.assertAlmostEqual(mosse.particles[0].temperature.value_in(units.K), 4271., 0)
mosse.stop()
def test3(self):
mosse = MOSSE()
mosse.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 5 | units.MSun
star.radius = 0.0 | units.RSun
stars.synchronize_to(mosse.particles)
channel = mosse.particles.new_channel_to(stars)
channel.copy_attributes(mosse.particles.get_attribute_names_defined_in_store())
previous_type = mosse.particles.stellar_type
results = []
mosse.evolve_model(121.9 | units.Myr)
channel.copy_attributes(mosse.particles.get_attribute_names_defined_in_store())
self.assertAlmostEqual(star.mass.value_in(units.MSun), 1.002, 3)
mosse.stop()
def test5(self):
mosse = MOSSE()
mosse.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 35 | units.MSun
star.radius = 0.0 | units.RSun
stars.synchronize_to(mosse.particles)
channel = mosse.particles.new_channel_to(stars)
channel.copy_attributes(mosse.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
mosse.evolve_model(t)
self.assertTrue(mosse.particles[0].mass.value_in(units.MSun) < 6.0)
mosse.stop()
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 = MOSSE()
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.assertAlmostEqual(stars[i].age, 125.0 | units.Myr)
self.assertTrue(stars[i].mass <= masses[i])
self.assertEqual(str(stars[i].stellar_type), end_types[i])
instance.stop()
def test7(self):
print("Test: evolve particles one at a time.")
print("Used to be problematic, since initial_mass of idle particle is set to zero.")
stars = Particles(2)
stars.mass = 1.0 | units.MSun
for star in stars:
print(star)
stellar_evolution = MOSSE()
stellar_evolution.commit_parameters()
stellar_evolution.particles.add_particles(star.as_set())
stellar_evolution.commit_particles()
from_stellar_evolution_to_model = stellar_evolution.particles.new_channel_to(star.as_set())
stellar_evolution.evolve_model()
from_stellar_evolution_to_model.copy()
stellar_evolution.stop()
self.assertEqual(stars[0].initial_mass, stars[1].initial_mass)
self.assertEqual(stars[0].luminosity, stars[1].luminosity)
self.assertEqual(stars[0].age, stars[1].age)
print("Solved: SSE_muse_interface.f sets initial_mass to mass when necessary.")
def test8(self):
instance = MOSSE()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
myvalue = 0.7
instance.parameters.reimers_mass_loss_coefficient = myvalue
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, myvalue)
instance.commit_parameters()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, myvalue)
instance.stop()
instance = MOSSE()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
myvalue = 0.7
instance.parameters.reimers_mass_loss_coefficient = myvalue
instance.parameters.set_defaults()
instance.commit_parameters()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
instance.stop()
def test9(self):
print("Test: large number of particles")
stellar_evolution = MOSSE(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()
def test10(self):
stellar_evolution = MOSSE()
stellar_evolution.commit_parameters()
stars = Particles(10)
stars.mass = 1.0 | units.MSun
stellar_evolution.particles.add_particles(stars)
self.assertEqual(stellar_evolution.particles._factory_for_new_collection(), Particles)
filename = os.path.join(get_path_to_results(), "test.h5")
if os.path.exists(filename):
os.remove(filename)
io.write_set_to_file(stellar_evolution.particles, filename, 'hdf5')
stored_stars = io.read_set_from_file(filename, 'hdf5')
self.assertEqual(len(stars), len(stored_stars))
self.assertAlmostRelativeEquals(stars.mass, stored_stars.mass)
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 = MOSSE()
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.877] | units.Myr, 2)
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.877, 18.877, 18.877] | units.Myr, 2)
self.assertAlmostEqual(instance.particles.time_step, [550.157, 58.208, 18.877] | units.Myr, 2)
self.assertAlmostEqual(instance.model_time, 18.877 | units.Myr, 2)
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, 2)
self.assertAlmostEqual(instance.particles.time_step, [550.157, 58.208, 18.877] | units.Myr, 2)
self.assertAlmostEqual(instance.model_time, 100.0 | units.Myr, 2)
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.157, 58.208, 18.877] | units.Myr), 2)
self.assertAlmostEqual(instance.particles.time_step, [550.157, 58.208, 18.877] | units.Myr, 2)
self.assertAlmostEqual(instance.model_time, 100.0 | units.Myr, 2) # Unchanged!
instance.stop()
def test12(self):
print("Testing adding and removing particles from stellar evolution code...")
particles = Particles(3)
particles.mass = 1.0 | units.MSun
instance = MOSSE()
instance.initialize_code()
instance.commit_parameters()
self.assertEqual(len(instance.particles), 0) # before creation
instance.particles.add_particles(particles[:-1])
instance.commit_particles()
instance.evolve_model(1.0 | units.Myr)
self.assertEqual(len(instance.particles), 2) # before remove
self.assertAlmostEqual(instance.particles.age, 1.0 | units.Myr)
instance.particles.remove_particle(particles[0])
self.assertEqual(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.assertEqual(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()
def test13(self):
print("Testing SSE states")
stars = Particles(1)
stars.mass = 1.0 | units.MSun
print("First do everything manually:", end=' ')
instance = MOSSE()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("ok")
print("initialize_code(), commit_parameters(), "
"and cleanup_code() should be called automatically:", end=' ')
instance = MOSSE()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.reimers_mass_loss_coefficient = 0.5
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(stars)
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
print("ok")
def test14a(self):
print("Testing basic operations: evolve_one_step and evolve_for (on particle)")
stars = Particles(2)
stars.mass = 1.0 | units.MSun
instance = MOSSE()
se_stars = instance.particles.add_particles(stars)
self.assertAlmostEqual(se_stars.age, [0.0, 0.0] | units.yr)
for i in range(3):
se_stars[0].evolve_one_step()
self.assertAlmostEqual(se_stars.age, [1650.46953688, 0.0] | units.Myr, 3)
number_of_steps = 10
step_size = se_stars[0].age / number_of_steps
for i in range(1, number_of_steps + 1):
se_stars[1].evolve_for(step_size)
self.assertAlmostEqual(se_stars.age, [number_of_steps, i] * step_size)
print(se_stars)
self.assertAlmostRelativeEqual(se_stars[0].age, se_stars[1].age)
self.assertAlmostRelativeEqual(se_stars[0].luminosity, se_stars[1].luminosity, 3)
self.assertAlmostRelativeEqual(se_stars[0].radius, se_stars[1].radius, 3)
self.assertAlmostRelativeEqual(se_stars[0].temperature, se_stars[1].temperature, 3)
instance.stop()
def test14b(self):
print("Testing basic operations: evolve_one_step and evolve_for (on subset)")
stars = Particles(2)
stars.mass = 1.0 | units.MSun
instance = MOSSE()
se_stars = instance.particles.add_particles(stars)
self.assertAlmostEqual(se_stars.age, [0.0, 0.0] | units.yr)
for i in range(3):
se_stars[:1].evolve_one_step()
self.assertAlmostEqual(se_stars.age, [1650.46953688, 0.0] | units.Myr, 3)
number_of_steps = 10
step_size = se_stars[0].age / number_of_steps
for i in range(1, number_of_steps + 1):
se_stars[1:].evolve_for(step_size)
self.assertAlmostEqual(se_stars.age, [number_of_steps, i] * step_size)
print(se_stars)
self.assertAlmostRelativeEqual(se_stars[0].age, se_stars[1].age)
self.assertAlmostRelativeEqual(se_stars[0].luminosity, se_stars[1].luminosity, 3)
self.assertAlmostRelativeEqual(se_stars[0].radius, se_stars[1].radius, 3)
self.assertAlmostRelativeEqual(se_stars[0].temperature, se_stars[1].temperature, 3)
instance.stop()
def test15(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 = MOSSE()
instance.particles.add_particles(stars)
i = 0
for p in instance.particles:
print(i, p.mass)
p.evolve_for(0.1 | units.Myr)
i += 1
instance.stop()
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 = MOSSE()
instance.particles.add_particles(stars)
i = 0
for p in instance.particles:
print(i, p.mass, end=' ')
p.evolve_for(13.2 | units.Gyr)
print(p.mass)
i += 1
instance.stop()
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 = MOSSE()
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()
def test18(self):
print("MOSSE validation")
mosse_src_path = os.path.join(os.path.dirname(sys.modules[MOSSE.__module__].__file__), 'src')
if not os.path.exists(os.path.join(mosse_src_path, "evolve.in")):
self.skip("Not in a source release")
instance = MOSSE()
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(mosse_src_path, "evolve.in"), os.path.join(testpath, "evolve.in"))
call([os.path.join(mosse_src_path, "mosse")], 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)
def test19(self):
print("MOSSE core_mass and CO_core_mass (high mass star)")
instance = MOSSE()
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), "Hertzsprung Gap")
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), "Core Helium Burning")
self.assertIsOfOrder(star.mass, 10 | units.MSun)
self.assertIsOfOrder(star.core_mass, 10 | units.MSun)
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), "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.70 | 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, 6.70 | 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()
def test20(self):
print("MOSSE core_mass and CO_core_mass (low mass stars)")
instance = MOSSE()
stars = instance.particles.add_particles(Particles(mass=[0.6, 1.0] | units.MSun))
instance.evolve_model(100 | units.Gyr)
self.assertEqual(str(stars[0].stellar_type), "Helium White Dwarf")
self.assertAlmostEqual(stars[0].mass, 0.405 | units.MSun, 2)
self.assertEqual(stars[0].core_mass, stars[0].mass)
self.assertEqual(stars[0].CO_core_mass, 0 | units.MSun)
self.assertEqual(str(stars[1].stellar_type), "Carbon/Oxygen White Dwarf")
self.assertAlmostEqual(stars[1].mass, 0.520 | units.MSun, 2)
self.assertEqual(stars[1].core_mass, stars[1].mass)
self.assertEqual(stars[1].CO_core_mass, stars[1].mass)
instance.stop()
def test21(self):
instance = MOSSE()
stars = instance.particles.add_particles(Particles(mass=30 | units.MSun))
mass_loss_wind = stars[0].mass_loss_wind
self.assertAlmostRelativeEquals(mass_loss_wind, 2.209e-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.7056e-07 | units.MSun / units.yr, 3)
instance.stop()
def test22(self):
instance = MOSSE()
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()
def test23(self):
instance = MOSSE()
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()
| 32,395
| 38.125604
| 118
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_ph4.py
|
import os
import sys
import time
from amuse.community.ph4.interface import ph4Interface, ph4
from amuse.test.amusetest import TestWithMPI
import numpy
import math
from amuse.units import nbody_system
from amuse.units import units, constants
from amuse import datamodel
from amuse.ic.plummer import new_plummer_model
try:
from matplotlib import pyplot
HAS_MATPLOTLIB = True
except ImportError:
HAS_MATPLOTLIB = False
from amuse.test.suite.codes_tests.gd_tests import (
_TestGravitationalDynamicsInterface,
)
class TestPh4Interface(_TestGravitationalDynamicsInterface, TestWithMPI):
def gravity_code_interface(self):
return ph4Interface
def test_reversed_time_allowed(self):
self.skip("not supported")
def starting_particle_index(self):
return 1
def test7(self):
instance = ph4Interface()
instance.initialize_code()
instance.set_eps2(0.1**2)
instance.commit_parameters()
id1, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
id2, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=2.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
instance.commit_particles()
potential, errorcode = instance.get_potential(id1)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -10.0 / numpy.sqrt(2.0**2 + 0.1**2), 8)
total_potential, errorcode = instance.get_potential_energy()
potentials, errorcode = instance.get_potential([id1, id2])
instance.cleanup_code()
instance.stop()
self.assertAlmostRelativeEquals(total_potential, numpy.sum(potentials * [10.0, 10.0]) / 2.0)
def test8(self):
instance = ph4Interface()
instance.initialize_code()
instance.set_eps2(0)
instance.commit_parameters()
id1, errorcode = instance.new_particle(mass=10.0, radius=1.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
id2, errorcode = instance.new_particle(mass=1.0, radius=1.0, x=2.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
instance.commit_particles()
potential, errorcode = instance.get_potential(id1)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -1.0 / numpy.sqrt(2.0**2), 8)
potential, errorcode = instance.get_potential(id2)
self.assertEqual(errorcode, 0)
self.assertAlmostRelativeEquals(potential, -10.0 / numpy.sqrt(2.0**2), 8)
total_potential, errorcode = instance.get_potential_energy()
potentials, errorcode = instance.get_potential([id1, id2])
instance.cleanup_code()
instance.stop()
self.assertAlmostRelativeEquals(total_potential, numpy.sum(potentials * [10.0, 1.0]) / 2.0)
def test9(self):
instance = ph4Interface()
instance.initialize_code()
instance.set_eta(0.01)
index, error = instance.new_particle(11.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 2.0, 10)
self.assertEqual(error, 0)
self.assertEqual(index, 10)
# index, error = instance.new_particle(12.0, 3.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 10)
# print index, error
# self.assertEquals(error, -1)
# self.assertEquals(index, 10)
error = instance.commit_particles()
self.assertEqual(error, 0)
retrieved_state = instance.get_state(index)
self.assertEqual(retrieved_state['__result'], 0)
self.assertEqual(11.0, retrieved_state['mass'])
self.assertEqual(2.0, retrieved_state['radius'])
self.assertEqual(instance.get_number_of_particles()['number_of_particles'], 1)
instance.cleanup_code()
instance.stop()
class TestPH4(TestWithMPI):
def new_system_of_sun_and_earth(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
return stars
def test0(self):
instance = ph4()
instance.stop()
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = ph4(convert_nbody) # , redirection="none")#, debugger="xterm")
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | units.AU**2
instance.parameters.timestep_parameter = 0.01
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
instance.commit_particles()
instance.evolve_model(365 | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_at_start = earth.position.value_in(units.AU)[0]
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(position_at_start, position_after_full_rotation, 6)
instance.evolve_model(365.0 + (365.0 / 2) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 3)
instance.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 3)
instance.cleanup_code()
instance.stop()
def test2(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = ph4(convert_nbody)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | units.AU**2
instance.parameters.timestep_parameter = 0.01
instance.dt_dia = 5000
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
instance.particles.add_particles(stars)
instance.commit_particles()
for x in range(1, 365, 30):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
if HAS_MATPLOTLIB:
figure = pyplot.figure()
plot = figure.add_subplot(1, 1, 1)
x_points = earth.get_timeline_of_attribute("x")
y_points = earth.get_timeline_of_attribute("y")
x_points_in_AU = [t_x[1].value_in(units.AU) for t_x in x_points]
y_points_in_AU = [t_x1[1].value_in(units.AU) for t_x1 in y_points]
plot.scatter(x_points_in_AU, y_points_in_AU, color="b", marker='o')
plot.set_xlim(-1.5, 1.5)
plot.set_ylim(-1.5, 1.5)
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "ph4-earth-sun2.svg")
figure.savefig(output_file)
instance.cleanup_code()
instance.stop()
def test3(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = ph4(convert_nbody)
instance.initialize_code()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
instance.commit_particles()
instance.particles.mass = [17.0, 33.0] | units.kg
self.assertEqual(instance.get_mass(1), 17.0 | units.kg)
self.assertEqual(instance.get_mass(2), 33.0 | units.kg)
instance.cleanup_code()
instance.stop()
def test4(self):
instance = ph4()
instance.initialize_code()
particles = datamodel.Particles(6)
particles.mass = nbody_system.mass.new_quantity(range(1, 7))
particles.radius = 0.00001 | nbody_system.length
particles.position = [[-1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, -1.0], [0.0, 0.0, 1.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
instance.commit_particles()
copyof = instance.particles.copy()
instance.cleanup_code()
instance.stop()
self.assertEqual(2 | nbody_system.mass, copyof[1].mass)
def test5(self):
instance = ph4()
instance.initialize_code()
instance.parameters.manage_encounters = 2
instance.parameters.epsilon_squared = 0.0 | nbody_system.length ** 2
particles = datamodel.Particles(6)
particles.mass = [0.01, 0.1, 0.1, 0.1, 0.1, 0.1] | nbody_system.mass
particles.radius = 0.1 | nbody_system.length
particles.position = [
[-1.0, 0.0, 0.0], # first two close together
[-1.2, 0.0, 0.0],
[0.0, 4.0, 0.0], # rest far away
[0.0, 5.0, 0.0],
[0.0, 6.0, 0.0],
[0.0, 7.0, 0.0]
] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.1 | nbody_system.time)
instance.update_particle_set()
self.assertEqual(len(instance.particles), 5)
self.assertEqual(instance.particles.index_in_code, [3, 4, 5, 6, 10])
self.assertEqual(instance.particles.mass, [0.1, 0.1, 0.1, 0.1, 0.11] | nbody_system.mass)
self.assertEqual(len(particles), 6)
instance.particles.synchronize_to(particles)
self.assertEqual(len(particles), 5)
self.assertEqual(particles.mass, [0.1, 0.1, 0.1, 0.1, 0.11] | nbody_system.mass)
binary_energy1, error = instance.legacy_interface.get_binary_energy()
self.assertEqual(error, 0)
self.assertTrue(binary_energy1 < 0)
binary_energy2 = instance.get_binary_energy()
instance.cleanup_code()
instance.stop()
self.assertEqual(binary_energy2.value_in(nbody_system.energy), binary_energy1)
def test6(self):
instance = ph4()
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles = datamodel.Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
instance.commit_particles()
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, 1.0 | nbody_system.length, zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration, 3)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration, 3)
self.assertAlmostEqual(fx0, -1.0 * fx1, 5)
fx = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0, 2)
self.assertAlmostEqual(potential0, potential1, 5)
instance.stop()
def xtest7(self):
instance = ph4()
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
instance.set_eta(0.01, 0.02)
particles = datamodel.Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
instance.initialize_particles(0.0)
zero = [0.0, 0.0, 0.0] | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, [0.5, 1.0, 1.5] | nbody_system.length, zero, zero)
self.assertAlmostRelativeEqual(fx[0], -3.55555555556 | nbody_system.acceleration, 5)
self.assertAlmostRelativeEqual(fy[0], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostRelativeEqual(fz[0], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostRelativeEqual(fx[1], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostRelativeEqual(fy[1], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostRelativeEqual(fz[1], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostRelativeEqual(fx[2], 3.55555555556 | nbody_system.acceleration, 5)
self.assertAlmostRelativeEqual(fy[2], 0.0 | nbody_system.acceleration, 3)
self.assertAlmostRelativeEqual(fz[2], 0.0 | nbody_system.acceleration, 3)
n = 512
x = nbody_system.length.new_quantity(numpy.linspace(0.1, 1.9, n))
zero = nbody_system.length.new_quantity(numpy.zeros(n))
fx, fy, fz = instance.get_gravity_at_point(zero, x, zero, zero)
for i in range(n/2):
self.assertAlmostRelativeEqual(fx[i], - fx[n - 1 - i], 5)
instance.stop()
def xtest8(self):
particles = datamodel.Particles(6)
particles.mass = nbody_system.mass.new_quantity(range(1, 7))
particles.radius = 0.00001 | nbody_system.length
particles.position = [[-1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, -1.0], [0.0, 0.0, 1.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
for current_mode in ['gpu']:
try:
instance = ph4(mode=current_mode)
except:
print("Running PhiGRAPE with mode=", current_mode, " was unsuccessful.")
else:
print("Running PhiGRAPE with mode=", current_mode, "... ", end=' ')
instance.initialize_code()
instance.particles.add_particles(particles)
instance.initialize_particles(0.0)
instance.evolve_model(0.1 | nbody_system.time)
instance.cleanup_code()
instance.stop()
print("ok")
def test10(self):
instance = ph4()
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
instance.parameters.timestep_parameter = 0.01
stars = new_plummer_model(100)
instance.particles.add_particles(stars)
channel = stars.new_channel_to(instance.particles)
instance.evolve_model(0.001 | nbody_system.time)
e0 = instance.kinetic_energy + instance.potential_energy
stars.mass *= 0.9
channel.copy()
instance.synchronize_model()
e1 = instance.kinetic_energy + instance.potential_energy
instance.cleanup_code()
instance.stop()
delta_e = e1 - e0
self.assertTrue(e1 != e0)
def test10b(self):
instance = ph4(number_of_workers=4)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
instance.parameters.timestep_parameter = 0.01
stars = new_plummer_model(100)
instance.particles.add_particles(stars)
channel = stars.new_channel_to(instance.particles)
instance.evolve_model(0.001 | nbody_system.time)
e0 = instance.kinetic_energy + instance.potential_energy
stars.mass *= 0.9
channel.copy()
instance.synchronize_model()
e1 = instance.kinetic_energy + instance.potential_energy
instance.cleanup_code()
instance.stop()
delta_e = e1 - e0
self.assertTrue(e1 != e0)
def test11(self):
print("Testing PH4 collision_detection")
particles = datamodel.Particles(7)
particles.mass = 0.000001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = ph4()
instance.initialize_code()
instance.parameters.set_defaults()
instance.parameters.epsilon_squared = 0 | nbody_system.length**2
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
for i in range(3): # PH4 can handle only one collision (=closest) at a time
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 5 - i)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius), True)
sticky_merged = datamodel.Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print(instance.model_time)
print(instance.particles)
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print()
print(instance.model_time)
print(instance.particles)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def xtest11(self):
particles = datamodel.Particles(2)
particles.x = [
0.0, 1.0,
# 5,7,
# 10,12,
# 15,17,
# 20,22
] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.75 | nbody_system.length
particles.vx = 0.1 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 0 | nbody_system.mass
instance = ph4()
instance.initialize_code()
instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2
instance.particles.add_particles(particles)
instance.stopping_conditions.collision_detection.enable()
instance.evolve_model(0.5 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.collision_detection.is_set())
self.assertEqual(len(instance.stopping_conditions.collision_detection.particles(0)), 2)
p0 = instance.stopping_conditions.collision_detection.particles(0)[0]
p1 = instance.stopping_conditions.collision_detection.particles(1)[0]
self.assertNotEqual(p0, p1)
self.assertTrue(p1.x - p0.x < 1.5 | nbody_system.length)
instance.stop()
def xtest12(self):
particles = datamodel.Particles(2)
particles.x = [
0.0, 1.0,
# 5,7,
# 10,12,
# 15,17,
# 20,22
] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.75 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
instance = ph4()
instance.initialize_code()
instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2
instance.particles.add_particles(particles)
instance.stopping_conditions.pair_detection.enable()
instance.evolve_model(1.5 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.pair_detection.is_set())
self.assertEqual(len(instance.stopping_conditions.pair_detection.particles(0)), 2)
p0 = instance.stopping_conditions.pair_detection.particles(0)[0]
p1 = instance.stopping_conditions.pair_detection.particles(1)[0]
self.assertNotEqual(p0, p1)
self.assertTrue(p1.x - p0.x < 1.5 | nbody_system.length)
instance.stop()
def xtest13(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
instance = ph4()
instance.initialize_code()
instance.parameters.stopping_conditions_number_of_steps = 2
self.assertEqual(instance.parameters.stopping_conditions_number_of_steps, 2)
instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2
instance.particles.add_particles(particles)
instance.stopping_conditions.number_of_steps_detection.enable()
instance.evolve_model(10 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set())
self.assertTrue(instance.model_time < 10 | nbody_system.time)
instance.stop()
def xtest14(self):
particles = datamodel.Particles(2)
particles.x = [0.0, 10.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.radius = 0.005 | nbody_system.length
particles.vx = 0 | nbody_system.speed
particles.vy = 0 | nbody_system.speed
particles.vz = 0 | nbody_system.speed
particles.mass = 1.0 | nbody_system.mass
very_short_time_to_evolve = 1 | units.s
very_long_time_to_evolve = 1e9 | nbody_system.time
instance = ph4()
instance.initialize_code()
instance.parameters.stopping_conditions_timeout = very_short_time_to_evolve
self.assertEqual(instance.parameters.stopping_conditions_timeout, very_short_time_to_evolve)
instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2
instance.particles.add_particles(particles)
instance.stopping_conditions.timeout_detection.enable()
start = time.time()
instance.evolve_model(very_long_time_to_evolve)
end = time.time()
self.assertTrue(instance.stopping_conditions.timeout_detection.is_set())
self.assertTrue((end-start) < very_short_time_to_evolve.value_in(units.s) + 2) # 2 = some overhead compensation
instance.stop()
def test15(self):
instance = ph4()
instance.initialize_code()
particles = datamodel.Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
mass = instance.particles[0].mass
instance.cleanup_code()
instance.stop()
self.assertEqual(mass, 1.0 | nbody_system.mass)
def test16(self):
print("Testing ph4 states")
stars = new_plummer_model(100)
black_hole = datamodel.Particle()
black_hole.mass = 1.0 | nbody_system.mass
black_hole.radius = 0.0 | nbody_system.length
black_hole.position = [0.0, 0.0, 0.0] | nbody_system.length
black_hole.velocity = [0.0, 0.0, 0.0] | nbody_system.speed
print("First do everything manually:")
instance = ph4()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
instance.parameters.timestep_parameter = 0.01
instance.commit_parameters()
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.particles.remove_particle(stars[0])
instance.particles.add_particle(black_hole)
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
instance.recommit_particles()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.001 | nbody_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
instance.synchronize_model()
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEqual(instance.get_name_of_current_state(), 'END')
instance.stop()
print("initialize_code(), commit_parameters(), (re)commit_particles(), "
"synchronize_model(), and cleanup_code() should be called "
"automatically before editing parameters, new_particle(), get_xx(), and stop():")
instance = ph4()
self.assertEqual(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
instance.parameters.timestep_parameter = 0.01
self.assertEqual(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(stars)
self.assertEqual(instance.get_name_of_current_state(), 'EDIT')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.particles.remove_particle(stars[0])
instance.particles.add_particle(black_hole)
self.assertEqual(instance.get_name_of_current_state(), 'UPDATE')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.001 | nbody_system.time)
self.assertEqual(instance.get_name_of_current_state(), 'EVOLVED')
mass = instance.particles[0].mass
self.assertEqual(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEqual(instance.get_name_of_current_state(), 'STOPPED')
def test17(self):
print("Testing parameter defaults")
instance = ph4()
instance.parameters.epsilon_squared = 0.5 | nbody_system.length * nbody_system.length
particles = datamodel.Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
self.assertAlmostRelativeEquals(instance.parameters.epsilon_squared, 0.5 | nbody_system.length * nbody_system.length)
self.assertAlmostRelativeEquals(instance.parameters.timestep_parameter, 0.14)
self.assertAlmostRelativeEquals(instance.parameters.use_gpu, 0)
self.assertAlmostRelativeEquals(instance.parameters.manage_encounters, 4)
def test18(self):
print("Testing effect of ph4 parameter epsilon_squared")
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
particles = datamodel.Particles(2)
particles.mass = [1.0, 3.0037e-6] | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * particles.total_mass() / (1.0 | units.AU)).sqrt()
particles.rotate(0.0, 0.0, math.pi/4)
particles.move_to_center()
tan_initial_direction = particles[1].vy/particles[1].vx
self.assertAlmostEqual(tan_initial_direction, math.tan(-math.pi/4))
tan_final_direction = []
for log_eps2 in range(-5, 6, 2):
instance = ph4(converter)
instance.initialize_code()
instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU ** 2
instance.parameters.timestep_parameter = 0.001
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.25 | units.yr)
tan_final_direction.append(instance.particles[1].velocity[1] /
instance.particles[1].velocity[0])
instance.cleanup_code()
instance.stop()
# Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees
self.assertAlmostEqual(tan_final_direction[0], math.tan(math.pi / 4.0), 2)
# Large values of epsilon_squared should result in ~ no interaction
self.assertAlmostEqual(tan_final_direction[-1], tan_initial_direction, 2)
# Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2
delta = [abs(tan_final_direction[i+1]-tan_final_direction[i]) for i in range(len(tan_final_direction)-1)]
self.assertEqual(delta[len(tan_final_direction)//2 - 1], max(delta))
def test19(self):
print("Testing ph4 properties")
particles = new_plummer_model(1000, do_scale=True)
particles.position += [1, 2, 3] | nbody_system.length
cluster_velocity = [4, 5, 6] | nbody_system.speed
particles.velocity += cluster_velocity
external_kinetic_energy = (0.5 | nbody_system.mass) * cluster_velocity.length_squared()
instance = ph4()
instance.particles.add_particles(particles)
kinetic_energy = instance.kinetic_energy - external_kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy, 0.25 | nbody_system.energy, 10)
self.assertAlmostRelativeEqual(potential_energy, -0.5 | nbody_system.energy, 10)
self.assertAlmostRelativeEqual(instance.total_mass, 1.0 | nbody_system.mass, 10)
self.assertAlmostRelativeEqual(instance.center_of_mass_position,
[1, 2, 3] | nbody_system.length, 10)
self.assertAlmostRelativeEqual(instance.center_of_mass_velocity,
[4, 5, 6] | nbody_system.speed, 10)
initial_total_energy = kinetic_energy + potential_energy
instance.evolve_model(0.1 | nbody_system.time)
self.assertAlmostRelativeEqual(instance.model_time, 0.1 | nbody_system.time, 3)
kinetic_energy = instance.kinetic_energy - external_kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy+potential_energy, -0.25 | nbody_system.energy, 3)
self.assertAlmostRelativeEqual(instance.total_mass, 1.0 | nbody_system.mass, 3)
self.assertAlmostRelativeEqual(instance.center_of_mass_position,
[1.4, 2.5, 3.6] | nbody_system.length, 3)
self.assertAlmostRelativeEqual(instance.center_of_mass_velocity,
[4, 5, 6] | nbody_system.speed, 3)
instance.cleanup_code()
instance.stop()
def test20(self):
instance = ph4()
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00001 | nbody_system.length**2
particles = datamodel.Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, 1.0 | nbody_system.length, zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration, 6)
potentials = [-4.57110767688, -2.66662518639, -2.13331892165] | nbody_system.length**2 / (nbody_system.time**2)
for x, pot in zip((0.25, 0.5, 0.75), potentials):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostRelativeEquals(fy0, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostRelativeEquals(fz0, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostRelativeEquals(fy1, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostRelativeEquals(fz1, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostRelativeEquals(fx0, -1.0 * fx1, 5)
fx = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
print(fx, fx0)
self.assertAlmostRelativeEquals(fx, fx0, 2)
self.assertAlmostRelativeEquals(potential0, potential1, 5)
self.assertAlmostRelativeEquals(potential0, pot, 5)
instance.stop()
def test21(self):
particles = new_plummer_model(200)
particles.scale_to_standard()
instance = ph4()
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00000 | nbody_system.length**2
instance.particles.add_particles(particles)
x = numpy.arange(-1, 1, 0.1) | nbody_system.length
zero = numpy.zeros(len(x)) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x, zero, zero)
instance.stop()
for n in (2, 3, 4):
instance = ph4(number_of_workers=n)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00000 | nbody_system.length**2
instance.particles.add_particles(particles)
potential = instance.get_potential_at_point(zero, x, zero, zero)
self.assertAlmostRelativeEquals(potential0, potential, 8)
instance.stop()
def test22(self):
particles = new_plummer_model(200)
particles.scale_to_standard()
try:
instance = ph4(mode="gpu")
except:
self.skip("gpu mode is not available")
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00000 | nbody_system.length**2
instance.particles.add_particles(particles)
x = numpy.arange(-1, 1, 0.1) | nbody_system.length
zero = numpy.zeros(len(x)) | nbody_system.length
gpu_potential = instance.get_potential_at_point(zero, x, zero, zero)
instance.stop()
instance = ph4()
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00000 | nbody_system.length**2
instance.particles.add_particles(particles)
nogpu_potential = instance.get_potential_at_point(zero, x, zero, zero)
self.assertAlmostRelativeEquals(nogpu_potential, gpu_potential, 5)
instance.stop()
def test23(self):
particles = datamodel.Particles(
mass=[1, 2] | nbody_system.mass,
x=[-1, 1] | nbody_system.length,
y=[-1, 1] | nbody_system.length,
z=[-1, 1] | nbody_system.length,
vx=[-1, 1] | nbody_system.speed,
vy=[-1, 1] | nbody_system.speed,
vz=[-1, 1] | nbody_system.speed
)
instance = ph4()
overlay = datamodel.ParticlesOverlay(instance.particles)
overlay.add_particles(particles)
all_attributes = overlay.get_values_in_store(overlay.get_all_indices_in_store(), ['mass', 'x', 'y', 'z', 'vx', 'vy', 'vz'])
self.assertEqual(all_attributes[0], [1, 2] | nbody_system.mass)
self.assertEqual(instance.particles.mass, [1, 2] | nbody_system.mass)
self.assertEqual(overlay.mass, [1, 2] | nbody_system.mass)
self.assertEqual(overlay.position, [[-1., -1., -1.], [1., 1., 1.]] | nbody_system.length)
def test24(self):
particles = datamodel.Particles(
mass=[1, 2] | nbody_system.mass,
x=[-1, 1] | nbody_system.length,
y=[-1, 1] | nbody_system.length,
z=[-1, 1] | nbody_system.length,
vx=[-1, 1] | nbody_system.speed,
vy=[-1, 1] | nbody_system.speed,
vz=[-1, 1] | nbody_system.speed
)
instance = ph4()
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
self.assertAlmostRelativeEquals(instance.particles.mass, [1, 2] | nbody_system.mass)
instance.cleanup_code()
instance.initialize_code()
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
self.assertAlmostRelativeEquals(instance.particles.mass, [1, 2] | nbody_system.mass)
def test25(self):
particles = datamodel.Particles(
mass=[1, 2] | nbody_system.mass,
x=[-1, 1] | nbody_system.length,
y=[-1, 1] | nbody_system.length,
z=[-1, 1] | nbody_system.length,
vx=[-1, 1] | nbody_system.speed,
vy=[-1, 1] | nbody_system.speed,
vz=[-1, 1] | nbody_system.speed,
id=[3, 4]
)
instance = ph4()
instance.particles.add_particles(particles)
self.assertEqual(instance.particles.index_in_code, [3, 4])
instance.commit_particles()
instance.particles.remove_particle(particles[1])
instance.recommit_particles()
self.assertEqual(instance.particles.index_in_code, [3])
instance.particles.add_particle(particles[1])
instance.recommit_particles()
self.assertEqual(instance.particles.index_in_code, [3, 4])
def test26(self):
particles = datamodel.Particles(
mass=[1, 2] | nbody_system.mass,
x=[-1, 1] | nbody_system.length,
y=[0, 0] | nbody_system.length,
z=[0, 0] | nbody_system.length,
vx=[-1, 1] | nbody_system.speed,
vy=[-1, 1] | nbody_system.speed,
vz=[-1, 1] | nbody_system.speed,
id=[3, 4]
)
instance = ph4()
instance.particles.add_particles(particles)
self.assertEqual(instance.particles.index_in_code, [3, 4])
instance.commit_particles()
print(instance.particles[0].potential_in_code)
self.assertEqual(instance.particles[0].potential(G=nbody_system.G), -(nbody_system.G * (2 | nbody_system.mass)) / (2 | nbody_system.length))
self.assertEqual(instance.particles[0].potential_in_code, -(nbody_system.G * (2 | nbody_system.mass)) / (2 | nbody_system.length))
def test27(self):
print("Testing get timestep of particles")
with_softening = True
particles = datamodel.Particles(7)
particles.mass = 0.1 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -2.0, 2.0, 98.0, 102.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-5, 0, 0]] | nbody_system.speed
total_energy = particles.potential_energy(G=nbody_system.G) + particles.kinetic_energy()
instance = ph4()
instance.initialize_code()
instance.parameters.set_defaults()
if with_softening:
print("small amount of softening will prevent timesteps far below 1e-6 and huge energy errors...")
instance.parameters.epsilon_squared = 1.0e-10 | nbody_system.length**2
instance.particles.add_particles(particles)
for target_time, min_dt, n_digits in zip([0, 0.23, 0.24, 0.26, 0.27] | nbody_system.time,
[0.5**10, 0.5**11, 0.5**20, 0.5**10, 0.5**10] | nbody_system.time,
[10, 7, 4, 5, 5]):
instance.evolve_model(target_time)
if with_softening:
self.assertEqual(instance.particles.timestep.amin(), min_dt)
self.assertAlmostRelativeEquals(instance.potential_energy + instance.kinetic_energy, total_energy, n_digits)
else:
print("\ntarget_time:", target_time)
print("minimum timestep:", instance.particles.timestep.amin())
print("energy error:", (instance.potential_energy + instance.kinetic_energy - total_energy) / total_energy)
total_energy = instance.potential_energy + instance.kinetic_energy
instance.stop()
def test28(self):
particles = datamodel.Particles(
mass=[1, 2] | nbody_system.mass,
x=[-2, 2] | nbody_system.length,
y=[0, 0] | nbody_system.length,
z=[0, 0] | nbody_system.length,
vx=[-1, 1] | nbody_system.speed,
vy=[-1, 1] | nbody_system.speed,
vz=[-1, 1] | nbody_system.speed
)
instance = ph4()
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
self.assertEqual(len(instance.particles), 2)
instance.particles.remove_particle(particles[0])
instance.evolve_model(0.2 | nbody_system.time)
self.assertEqual(len(instance.particles), 1)
| 44,667
| 42.536062
| 156
|
py
|
amuse
|
amuse-main/src/amuse/test/suite/codes_tests/test_sakura.py
|
import numpy
import math
from amuse.test.amusetest import TestWithMPI
from amuse.units import nbody_system, units, constants
from amuse.datamodel import Particles
from amuse.ic.plummer import new_plummer_model
try:
from amuse.community.sakura.interface import SakuraInterface, Sakura, MODULES_MISSING
except ImportError:
MODULES_MISSING = True
default_options = dict()
class TestSakuraInterface(TestWithMPI):
def test01(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Test SakuraInterface initialization")
instance = self.new_instance_of_an_optional_code(
SakuraInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test02(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Test SakuraInterface new_particle / get_state")
instance = self.new_instance_of_an_optional_code(
SakuraInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
id, error = instance.new_particle(mass=11.0, radius=2.0, x=0.0, y=0.0, z=0.0, vx=0.0, vy=0.0, vz=0.0)
self.assertEqual(0, error)
self.assertEqual(0, id)
id, error = instance.new_particle(mass=21.0, radius=5.0, x=10.0, y=0.0, z=0.0, vx=10.0, vy=0.0, vz=0.0)
self.assertEqual(0, error)
self.assertEqual(1, id)
self.assertEqual(0, instance.commit_particles())
retrieved_state1 = instance.get_state(0)
retrieved_state2 = instance.get_state(1)
self.assertEqual(0, retrieved_state1['__result'])
self.assertEqual(0, retrieved_state2['__result'])
self.assertEqual(11.0, retrieved_state1['mass'])
self.assertEqual(21.0, retrieved_state2['mass'])
self.assertEqual(0.0, retrieved_state1['x'])
self.assertEqual(10.0, retrieved_state2['x'])
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test03(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Test SakuraInterface particle property getters/setters")
instance = self.new_instance_of_an_optional_code(
SakuraInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([0, 0], list(instance.new_particle(0.01, 1, 0, 0, 0, 1, 0, 0.1).values()))
self.assertEqual([1, 0], list(instance.new_particle(0.02, -1, 0, 0, 0, -1, 0, 0.1).values()))
#### self.assertEquals(-1, instance.get_mass(1)['__result']) # Have to commit first
self.assertEqual(0, instance.commit_particles())
# getters
mass, result = instance.get_mass(0)
self.assertAlmostEqual(0.01, mass)
self.assertEqual(0, result)
radius, result = instance.get_radius(1)
self.assertAlmostEqual(0.1, radius)
self.assertEqual(0, result)
self.assertEqual(-1, instance.get_mass(2)['__result']) # Particle not found
self.assertEqual([1, 0, 0, 0], list(instance.get_position(0).values()))
self.assertEqual([-1, 0, 0, 0], list(instance.get_position(1).values()))
self.assertEqual([0, 1, 0, 0], list(instance.get_velocity(0).values()))
self.assertEqual([0, -1, 0, 0], list(instance.get_velocity(1).values()))
# setters
self.assertEqual(0, instance.set_state(0, 0.01, 1, 2, 3, 4, 5, 6, 0.1))
self.assertEqual([0.01, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.1, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_mass(0, 0.02))
self.assertEqual([0.02, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.1, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_radius(0, 0.2))
self.assertEqual([0.02, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.2, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_position(0, 10, 20, 30))
self.assertEqual([0.02, 10.0, 20.0, 30.0, 4.0, 5.0, 6.0, 0.2, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.set_velocity(0, 40, 50, 60))
self.assertEqual([0.02, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 0.2, 0], list(instance.get_state(0).values()))
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test04(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Test SakuraInterface parameters")
instance = self.new_instance_of_an_optional_code(
SakuraInterface, **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual([0.001, 0], list(instance.get_dt().values()))
self.assertEqual(0, instance.set_dt(0.01))
self.assertEqual([0.01, 0], list(instance.get_dt().values()))
self.assertEqual([0.0, 0], list(instance.get_t_begin().values()))
self.assertEqual(0, instance.set_t_begin(1.0))
self.assertEqual([1.0, 0], list(instance.get_t_begin().values()))
self.assertEqual([0.0, 0], list(instance.get_t().values()))
self.assertEqual(0, instance.set_t(1.0))
self.assertEqual([1.0, 0], list(instance.get_t().values()))
# self.assertEquals(["sakura", 0], instance.get_integrator_method().values())
# self.assertEquals(0, instance.set_integrator_method("bogus"))
# self.assertEquals(["bogus", 0], instance.get_integrator_method().values())
# self.assertEquals(-1, instance.commit_parameters())
# self.assertEquals(0, instance.set_integrator_method("asakura"))
# self.assertEquals(["asakura", 0], instance.get_integrator_method().values())
self.assertEqual(0, instance.commit_parameters())
# self.assertEquals(0, instance.set_pn_order(7))
# self.assertEquals([7, 0], instance.get_pn_order().values())
# self.assertEquals(-1, instance.commit_parameters())
# self.assertEquals(0, instance.set_clight(1024))
# self.assertEquals([1024, 0], instance.get_clight().values())
self.assertEqual(0, instance.commit_parameters())
self.assertEqual(0, instance.cleanup_code())
instance.stop()
def test05(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Test SakuraInterface evolve_model, binary")
instance = self.new_instance_of_an_optional_code(
SakuraInterface, redirection='none', **default_options)
self.assertEqual(0, instance.initialize_code())
self.assertEqual(0, instance.commit_parameters())
self.assertEqual([0, 0], list(instance.new_particle(0.5, 0.5, 0, 0, 0, 0.5, 0, 0.001).values()))
self.assertEqual([1, 0], list(instance.new_particle(0.5, -0.5, 0, 0, 0, -0.5, 0, 0.001).values()))
self.assertEqual(0, instance.commit_particles())
P = 2 * math.pi
self.assertEqual(0, instance.evolve_model(P / 2)) # half an orbit
for result, expected in zip(instance.get_position(0).values(), [-0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 2)
self.assertEqual(0, instance.evolve_model(P)) # full orbit
for result, expected in zip(instance.get_position(0).values(), [0.5, 0.0, 0.0, 0]):
self.assertAlmostEqual(result, expected, 2)
self.assertEqual(0, instance.cleanup_code())
instance.stop()
class TestSakura(TestWithMPI):
default_converter = nbody_system.nbody_to_si(1.0e4 | units.MSun, 1.0 | units.AU)
def new_sun_earth_system(self):
particles = Particles(2)
particles.mass = [1.0, 3.0037e-6] | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * particles.total_mass() / (1.0 | units.AU)).sqrt()
return particles
def test01(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing Sakura initialization")
instance = self.new_instance_of_an_optional_code(
Sakura, self.default_converter, **default_options)
instance.initialize_code()
instance.commit_parameters()
instance.cleanup_code()
instance.stop()
def xtest02(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing Sakura parameters")
instance = self.new_instance_of_an_optional_code(
Sakura, self.default_converter, **default_options)
instance.initialize_code()
self.assertEqual(instance.parameters.epsilon_squared,
instance.unit_converter.to_si(0.0 | nbody_system.length**2))
self.assertEqual(instance.parameters.timestep_parameter, 0.125)
for par, value in [('epsilon_squared_star_star', 0.0 | nbody_system.length**2),
('epsilon_squared_star_blackhole', 0.0 | nbody_system.length**2),
('epsilon_squared_blackhole_blackhole', 0.0 | nbody_system.length**2),
('initial_timestep_parameter', 1.0e-4),
('timestep_parameter_stars', 0.1),
('timestep_parameter_supermassive_black_holes', 0.4),
('timestep_parameter_intermediate_mass_black_holes', 0.4),
('max_relative_energy_error', 5.0e-5),
('maximum_timestep', 1.0/1024.0 | nbody_system.time),
('smbh_mass', 1.0 | nbody_system.mass)]:
self.assertEqual(instance.unit_converter.to_si(value),
getattr(instance.parameters, par))
setattr(instance.parameters, par, 3.0 | value.unit)
self.assertEqual(instance.unit_converter.to_si(3.0 | value.unit),
getattr(instance.parameters, par))
# epsilon_squared is an alias for epsilon_squared_star_star, so epsilon_squared also has become 3:
self.assertEqual(instance.parameters.epsilon_squared,
instance.unit_converter.to_si(3.0 | nbody_system.length**2))
instance.parameters.epsilon_squared = 0.1 | nbody_system.length**2
self.assertEqual(instance.parameters.epsilon_squared,
instance.unit_converter.to_si(0.1 | nbody_system.length**2))
# timestep_parameter is an alias for timestep_parameter_stars, so timestep_parameter also has become 3:
self.assertEqual(instance.parameters.timestep_parameter, 3.0)
instance.parameters.timestep_parameter = 0.01
self.assertEqual(instance.parameters.timestep_parameter, 0.01)
self.assertEqual(instance.parameters.include_smbh, False)
instance.parameters.include_smbh = True
self.assertEqual(instance.parameters.include_smbh, True)
self.assertEqual(instance.parameters.calculate_postnewtonian, True)
instance.parameters.calculate_postnewtonian = False
self.assertEqual(instance.parameters.calculate_postnewtonian, False)
self.assertEqual(instance.parameters.drink, "Vodka martini. Shaken, not stirred.")
instance.stop()
def test03(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing Sakura particles")
instance = self.new_instance_of_an_optional_code(
Sakura, self.default_converter, **default_options)
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(self.new_sun_earth_system())
instance.commit_particles()
self.assertAlmostEqual(instance.particles.mass, [1.0, 3.0037e-6] | units.MSun)
self.assertAlmostEqual(instance.particles.radius, 1.0 | units.RSun)
self.assertAlmostEqual(instance.particles.position,
[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU)
self.assertAlmostEqual(instance.particles.velocity,
[[0.0, 0.0, 0.0], [0.0, 29.7885, 0.0]] | units.km / units.s, 3)
instance.cleanup_code()
instance.stop()
def xtest04(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing Sakura evolve_model, 2 particles orbiting the SMBH")
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = ((constants.G * (10001.0 | units.MSun) / (1.0 | units.AU)).sqrt() +
(constants.G * (10000.0 | units.MSun) / (1.0 | units.AU)).sqrt())
particles.move_to_center()
print(particles)
instance = self.new_instance_of_an_optional_code(
Sakura, self.default_converter, **default_options)
instance.initialize_code()
# instance.parameters.include_smbh = True
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
P_corrected = (P) * (2.0 / (1.0 + math.sqrt(1.0001)))
position_at_start = primary.position.x
instance.evolve_model(P_corrected / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3)
instance.evolve_model(P_corrected / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3)
instance.evolve_model(P_corrected)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3)
instance.cleanup_code()
instance.stop()
def test05(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing Sakura evolve_model, 2 particles, no SMBH")
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * (2.0 | units.MSun) / (2.0 | units.AU)).sqrt()
particles.move_to_center()
print(particles)
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(
Sakura, converter, **default_options)
instance.initialize_code()
# instance.parameters.integrator_method = "asakura"
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3)
instance.cleanup_code()
instance.stop()
def test06(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing Sakura evolve_model, earth-sun system, no SMBH")
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(
Sakura, converter, **default_options)
instance.initialize_code()
# instance.parameters.smbh_mass = 0.0 | units.MSun
instance.commit_parameters()
instance.particles.add_particles(self.new_sun_earth_system())
instance.commit_particles()
earth = instance.particles[1]
position_at_start = earth.position.x
instance.evolve_model(0.25 | units.yr)
self.assertAlmostRelativeEqual(position_at_start, earth.position.y, 3)
instance.evolve_model(0.5 | units.yr)
self.assertAlmostRelativeEqual(position_at_start, -earth.position.x, 3)
instance.evolve_model(1.0 | units.yr)
self.assertAlmostRelativeEqual(position_at_start, earth.position.x, 3)
instance.cleanup_code()
instance.stop()
def xtest07(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing effect of Sakura parameter epsilon_squared")
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
particles = self.new_sun_earth_system()
particles.rotate(0.0, 0.0, -math.pi/4)
particles.move_to_center()
tan_initial_direction = particles[1].vy/particles[1].vx
self.assertAlmostEqual(tan_initial_direction, math.tan(math.pi/4))
tan_final_direction = []
for log_eps2 in range(-9, 10, 2):
instance = self.new_instance_of_an_optional_code(
Sakura, converter, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU ** 2
# instance.parameters.smbh_mass = 0.0 | units.MSun
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.25 | units.yr)
tan_final_direction.append(instance.particles[1].velocity[1] /
instance.particles[1].velocity[0])
instance.cleanup_code()
instance.stop()
# Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees
self.assertAlmostEqual(tan_final_direction[0], math.tan(3 * math.pi / 4.0), 2)
# Large values of epsilon_squared should result in ~ no interaction
self.assertAlmostEqual(tan_final_direction[-1], tan_initial_direction, 2)
# Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2
delta = [abs(tan_final_direction[i+1]-tan_final_direction[i]) for i in range(len(tan_final_direction)-1)]
self.assertEqual(delta[len(tan_final_direction)/2 - 1], max(delta))
def xtest08(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing Sakura get_gravity_at_point and get_potential_at_point")
instance = self.new_instance_of_an_optional_code(
Sakura, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
# instance.parameters.smbh_mass = 0.0 | nbody_system.mass
particles = Particles(2)
particles.mass = 1.0 | nbody_system.mass
particles.radius = 0.0 | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, 1.0 | nbody_system.length, zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fx0, -1.0 * fx1)
fx = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0)
self.assertAlmostEqual(potential0, potential1)
instance.stop()
def test09(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing Sakura evolve_model and getters energy, plummer sphere, no SMBH")
converter = nbody_system.nbody_to_si(1.0e2 | units.MSun, 1.0 | units.parsec)
instance = self.new_instance_of_an_optional_code(
Sakura, converter, **default_options)
# instance.parameters.timestep_parameter = 1.0/256
instance.initialize_code()
# instance.parameters.smbh_mass = 0.0 | units.MSun
instance.commit_parameters()
numpy.random.seed(987654321)
instance.particles.add_particles(new_plummer_model(100, convert_nbody=converter))
instance.commit_particles()
kinetic_energy = instance.kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy, 2.12292810174e+37 | units.J, 10)
self.assertAlmostRelativeEqual(potential_energy, -4.33511391248e+37 | units.J, 10)
initial_total_energy = kinetic_energy + potential_energy
instance.evolve_model(0.1 | nbody_system.time)
kinetic_energy = instance.kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy, 2.1362368884e+37 | units.J, 4)
self.assertAlmostRelativeEqual(potential_energy, -4.34842269914e+37 | units.J, 4)
self.assertAlmostRelativeEqual(potential_energy + kinetic_energy, initial_total_energy, 4)
instance.cleanup_code()
instance.stop()
def xtest10(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing Sakura collision_detection")
particles = Particles(7)
particles.mass = 0.00000001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = self.new_instance_of_an_optional_code(
Sakura, **default_options)
instance.initialize_code()
instance.parameters.set_defaults()
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 3)
self.assertEqual(len(collisions.particles(1)), 3)
self.assertEqual(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print(instance.model_time)
print(instance.particles)
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print()
print(instance.model_time)
print(instance.particles)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test11(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing Sakura properties")
numpy.random.seed(12345)
particles = new_plummer_model(10, do_scale=True)
particles.position += [1, 2, 3] | nbody_system.length
cluster_velocity = [4, 5, 6] | nbody_system.speed
particles.velocity += cluster_velocity
external_kinetic_energy = (0.5 | nbody_system.mass) * cluster_velocity.length_squared()
instance = self.new_instance_of_an_optional_code(
Sakura, **default_options)
instance.particles.add_particles(particles)
instance.set_dt(1e-3 | nbody_system.time)
kinetic_energy = instance.kinetic_energy - external_kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy, 0.25 | nbody_system.energy, 10)
self.assertAlmostRelativeEqual(potential_energy, -0.5 | nbody_system.energy, 10)
self.assertAlmostRelativeEqual(instance.total_mass, 1.0 | nbody_system.mass, 10)
self.assertAlmostRelativeEqual(instance.center_of_mass_position,
[1, 2, 3] | nbody_system.length, 10)
self.assertAlmostRelativeEqual(instance.center_of_mass_velocity,
[4, 5, 6] | nbody_system.speed, 10)
initial_total_energy = kinetic_energy + potential_energy
instance.evolve_model(0.1 | nbody_system.time)
self.assertAlmostRelativeEqual(instance.model_time, 0.1 | nbody_system.time, 3)
kinetic_energy = instance.kinetic_energy - external_kinetic_energy
potential_energy = instance.potential_energy
self.assertAlmostRelativeEqual(kinetic_energy+potential_energy, -0.25 | nbody_system.energy, 3)
self.assertAlmostRelativeEqual(instance.total_mass, 1.0 | nbody_system.mass, 3)
self.assertAlmostRelativeEqual(instance.center_of_mass_position,
[1.4, 2.5, 3.6] | nbody_system.length, 3)
self.assertAlmostRelativeEqual(instance.center_of_mass_velocity,
[4, 5, 6] | nbody_system.speed, 3)
instance.cleanup_code()
instance.stop()
| 27,706
| 47.6942
| 114
|
py
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.