def test_config_add_module_invalid_name():
class NoNameModuleModel(ModuleModel):
pass
config = SimulationConfig()
with raises(ValueError, match=r'^Invalid module name'):
config.add_module(NoNameModuleModel)
def test_config_add_module_invalid_subclass():
class NonModule:
name = 'NonModule'
config = SimulationConfig()
with raises(TypeError, match=r'^Invalid module class for'):
config.add_module(NonModule)
def __init__(self, config: SimulationConfig):
if not config.has_section(self.section):
config.add_section(self.section)
self.config = config[self.section]
values = dict(**self.config)
self.config.update(values)
def test_config_file():
with NamedTemporaryFile('r+') as cf:
cf.write('[custom_section]\ncustom_val = 5\n')
cf.flush()
cf.seek(0)
config = SimulationConfig(cf.name)
assert config.getint('custom_section', 'custom_val') == 5
def test_config_add_module_object():
class ValidModuleModel(ModuleModel):
name = 'ValidModule'
config = SimulationConfig()
config.add_module(ValidModuleModel)
assert len(config.modules) == 1
assert isinstance(config.modules[0], ValidModuleModel)
def upload_config(self, simulation_id: str,
simulation_config: SimulationConfig):
client = self.client
with NamedTemporaryFile('w') as f:
simulation_config.write(f)
f.flush()
client.uploadFileToFolder(simulation_id,
f.name,
filename='config.ini')
def execute_simulation(self, name, config, folder=None):
target_time = config.get('simulation', {}).get('run_time', 50)
user, token = self.getCurrentUser(returnToken=True)
folder_model = Folder()
job_model = Job()
if folder is None:
folder = folder_model.findOne(
{'parentId': user['_id'], 'name': 'Public', 'parentCollection': 'user'}
)
if folder is None:
raise RestException('Could not find the user\'s "public" folder.')
simulation_model = Simulation()
simulation = simulation_model.createSimulation(
folder,
name,
config,
user,
True,
)
girder_config = GirderConfig(
api=GIRDER_API, token=str(token['_id']), folder=str(folder['_id'])
)
simulation_config = SimulationConfig(NLI_CONFIG_FILE, config)
# TODO: This would be better stored as a dict, but it's easier once we change the
# config object format.
simulation_config_file = StringIO()
simulation_config.write(simulation_config_file)
job = job_model.createJob(
title='NLI Simulation',
type=NLI_JOB_TYPE,
kwargs={
'girder_config': attr.asdict(girder_config),
'simulation_config': simulation_config_file.getvalue(),
'config': config,
'simulation_id': simulation['_id'],
},
user=user,
)
simulation['nli']['job_id'] = job['_id']
simulation_model.save(simulation)
run_simulation.delay(
name=name,
girder_config=girder_config,
simulation_config=simulation_config,
target_time=target_time,
job=job,
simulation_id=simulation['_id'],
)
return job
def test_config_multiple():
config = SimulationConfig(
{'custom_section': {
'custom_val_1': 5,
'custom_val_2': 10
}},
{'custom_section': {
'custom_val_1': 15
}},
)
# Configs should merge, with granular overwrites
assert config.getint('custom_section', 'custom_val_1') == 15
assert config.getint('custom_section', 'custom_val_2') == 10
def load(cls, arg: Union[str, bytes, PurePath, IO[bytes]]) -> 'State':
"""Load a pickled state from either a path, a file, or blob of bytes."""
from nlisim.config import SimulationConfig # prevent circular imports
if isinstance(arg, bytes):
arg = BytesIO(arg)
with H5File(arg, 'r') as hf:
time = hf.attrs['time']
grid = RectangularGrid.load(hf)
with StringIO(hf.attrs['config']) as cf:
config = SimulationConfig(cf)
state = cls(time=time, grid=grid, config=config)
for module in config.modules:
group = hf.get(module.name)
if group is None:
raise ValueError(
f'File contains no group for {module.name}')
try:
module_state = module.StateClass.load_state(state, group)
except Exception:
print(f'Error loading state for {module.name}')
raise
state._extra[module.name] = module_state
return state
def config():
yield SimulationConfig({
'simulation': {
'modules': 'nlisim.modules.fungus.Fungus',
'nx': 20,
'ny': 40,
'nz': 20,
'dx': 20,
'dy': 40,
'dz': 20,
'validate': True,
}
})
def config():
yield SimulationConfig(
{
'simulation': {
'modules': 'nlisim.oldmodules.fungus.Fungus',
'nx': 20,
'ny': 40,
'nz': 20,
'dx': 20,
'dy': 40,
'dz': 20,
'voxel_volume': 6.4e-11,
'space_volume': 6.4e-11 * 20 * 40 * 20,
'geometry_path': 'geometry.hdf5',
'validate': True,
}
}
)
def run_iterator(config: SimulationConfig,
target_time: float) -> Iterator[Tuple[State, Status]]:
"""Initialize and advance a simulation to the target time.
This method is a convenience method to automate running the
methods above that will be sufficient for most use cases. It
will:
1. Construct a new state object
2. Initialize the state object (yielding the result)
3. Advance the simulation by single time steps (yielding the result)
4. Finalize the simulation (yielding the result)
"""
attr.set_run_validators(config.getboolean('simulation', 'validate'))
state = initialize(State.create(config))
yield state, Status.initialize
for state in advance(state, target_time):
yield state, Status.time_step
yield finalize(state), Status.finalize
def base_config():
yield SimulationConfig()
def main(ctx: click.Context, config_files: Tuple[Path]) -> None:
ctx.obj = {'config': SimulationConfig(*config_files)}
def simulation_runner(
*,
config,
parent_folder,
job_model: Job,
run_name,
target_time,
token,
user,
experiment=None,
):
simulation_model = Simulation()
simulation = simulation_model.createSimulation(
parentFolder=parent_folder,
name=run_name,
config=config,
creator=user,
version=nlisim_version,
public=True,
experiment=experiment,
)
# if this is to be part of an experiment, let the experiment know about it
if experiment is not None:
experiment['nli']['component_simulations'].append(simulation['_id'])
experiment['nli']['per_sim_progress'][str(simulation['_id'])] = 0.0
experiment['nli']['per_sim_status'][str(
simulation['_id'])] = JobStatus.INACTIVE
experiment_model = Experiment()
experiment_model.save(experiment)
girder_config = GirderConfig(api=GIRDER_API,
token=str(token['_id']),
folder=str(parent_folder['_id']))
simulation_config = SimulationConfig(NLI_CONFIG_FILE, config)
# TODO: This would be better stored as a dict, but it's easier once we change the
# config object format.
simulation_config_file = StringIO()
simulation_config.write(simulation_config_file)
job = job_model.createJob(
title='NLI Simulation',
type=NLI_JOB_TYPE,
kwargs={
'girder_config': attr.asdict(girder_config),
'simulation_config': simulation_config_file.getvalue(),
'config': config,
'simulation_id': simulation['_id'],
'in_experiment': (experiment is not None),
'experiment_id': None if experiment is None else experiment['_id'],
},
user=user,
)
simulation['nli']['job_id'] = job['_id']
simulation_model.save(simulation)
run_simulation.delay(
name=run_name,
girder_config=girder_config,
simulation_config=simulation_config,
target_time=target_time,
job=job,
simulation_id=simulation['_id'],
)
return job, simulation
def test_config_dict():
config = SimulationConfig({'custom_section': {'custom_val': 5}})
assert config.getint('custom_section', 'custom_val') == 5
def test_config_add_module_string():
config = SimulationConfig()
config.add_module('nlisim.modules.fungus.Fungus')
assert len(config.modules) == 1
assert isinstance(config.modules[0], ModuleModel)
def test_config_stream():
with StringIO('[custom_section]\ncustom_val = 5\n') as cf:
config = SimulationConfig(cf)
assert config.getint('custom_section', 'custom_val') == 5
