def get_time(path, time=None, datahier = None):
if time is not None:
time = "{:.10f}".format(time)
from pyphare.pharesee.hierarchy import hierarchy_from
datahier = hierarchy_from(h5_filename=path+"/EM_E.h5", time=time, hier=datahier)
datahier = hierarchy_from(h5_filename=path+"/EM_B.h5", time=time, hier=datahier)
return datahier
def main():
config()
simulator = Simulator(gv.sim)
simulator.initialize()
simulator.run()
if cpp.mpi_rank() == 0:
b = hierarchy_from(h5_filename="phare_outputs/EM_B.h5")
plot(b)
def _test_dump_diags(self, dim, **simInput):
test_id = self.ddt_test_id()
for key in ["cells", "dl", "boundary_types"]:
simInput[key] = [simInput[key] for d in range(dim)]
for interp in range(1, 4):
local_out = f"{out}_dim{dim}_interp{interp}_mpi_n_{cpp.mpi_size()}_id{test_id}"
simInput["diag_options"]["options"]["dir"] = local_out
simulation = ph.Simulation(**simInput)
self.assertTrue(len(simulation.cells) == dim)
dump_all_diags(setup_model().populations)
self.simulator = Simulator(
simulation).initialize().advance().reset()
self.assertTrue(
any([
diagInfo.quantity.endswith("tags")
for diagInfo in ph.global_vars.sim.diagnostics
]))
checks = 0
found = 0
for diagInfo in ph.global_vars.sim.diagnostics:
h5_filepath = os.path.join(local_out,
h5_filename_from(diagInfo))
self.assertTrue(os.path.exists(h5_filepath))
h5_file = h5py.File(h5_filepath, "r")
self.assertTrue("0.0000000000"
in h5_file[h5_time_grp_key]) # init dump
n_patches = len(
list(h5_file[h5_time_grp_key]["0.0000000000"]
["pl0"].keys()))
if h5_filepath.endswith("tags.h5"):
found = 1
hier = hierarchy_from(h5_filename=h5_filepath)
patches = hier.level(0).patches
tag_found = 0
for patch in patches:
self.assertTrue(len(patch.patch_datas.items()))
for qty_name, pd in patch.patch_datas.items():
self.assertTrue((pd.dataset[:] >= 0).all())
self.assertTrue((pd.dataset[:] < 2).all())
tag_found |= (pd.dataset[:] == 1).any()
checks += 1
self.assertEqual(found, 1)
self.assertEqual(tag_found, 1)
self.assertEqual(checks, n_patches)
self.simulator = None
ph.global_vars.sim = None
def _test_dump_diags(self, dim, **simInput):
test_id = self.ddt_test_id()
# configure simulation dim sized values
for key in ["cells", "dl", "boundary_types"]:
simInput[key] = [simInput[key] for d in range(dim)]
b0 = [[10 for i in range(dim)], [19 for i in range(dim)]]
simInput["refinement_boxes"] = {"L0": {"B0": b0}}
for interp in range(1, 4):
print("_test_dump_diags dim/interp:{}/{}".format(dim, interp))
local_out = f"{out}_dim{dim}_interp{interp}_mpi_n_{cpp.mpi_size()}_id{test_id}"
simInput["diag_options"]["options"]["dir"] = local_out
simulation = ph.Simulation(**simInput)
self.assertTrue(len(simulation.cells) == dim)
dump_all_diags(setup_model().populations)
self.simulator = Simulator(simulation).initialize().advance()
for diagInfo in ph.global_vars.sim.diagnostics:
# diagInfo.quantity starts with a / this interferes with os.path.join, hence [1:]
h5_filename = os.path.join(local_out, (diagInfo.quantity + ".h5").replace('/', '_')[1:])
print("h5_filename", h5_filename)
h5_file = h5py.File(h5_filename, "r")
self.assertTrue("t0.000000" in h5_file) # init dump
self.assertTrue("t0.000100" in h5_file)
self.assertTrue("pl1" in h5_file["t0.000100"])
self.assertFalse("pl0" in h5_file["t0.000100"])
self.assertTrue("t0.001000" in h5_file) # advance dump
# SEE https://github.com/PHAREHUB/PHARE/issues/275
if dim == 1: # REMOVE WHEN PHARESEE SUPPORTS 2D
self.assertTrue(os.path.exists(h5_filename))
hier = hierarchy_from(h5_filename=h5_filename)
if h5_filename.endswith("domain.h5"):
for patch in hier.level(0).patches:
for qty_name, pd in patch.patch_datas.items():
splits = pd.dataset.split(ph.global_vars.sim)
self.assertTrue(splits.size() == pd.dataset.size() * 2)
print("splits.iCell", splits.iCells)
print("splits.delta", splits.deltas)
print("splits.weight", splits.weights)
print("splits.charge", splits.charges)
print("splits.v", splits.v)
self.simulator = None
ph.global_vars.sim = None
def test_hierarchy_timestamp_cadence(self, refinement_boxes):
dim = refinement_boxes["L0"]["B0"].ndim
time_step = .001
# time_step_nbr chosen to force diagnostics dumping double imprecision cadence calculations accuracy testing
time_step_nbr = 101
final_time = time_step * time_step_nbr
for trailing in [0, 1]: # 1 = skip init dumps
for i in [2, 3]:
simInput = simArgs.copy()
diag_outputs = f"phare_outputs_hierarchy_timestamp_cadence_{dim}_{self.ddt_test_id()}_{i}"
simInput["diag_options"]["options"]["dir"] = diag_outputs
simInput["time_step_nbr"] = time_step_nbr
ph.global_vars.sim = None
simulation = ph.Simulation(**simInput)
setup_model(10)
timestamps = np.arange(0, final_time, time_step * i)[trailing:]
for quantity in ["B"]:
ElectromagDiagnostics(
quantity=quantity,
write_timestamps=timestamps,
compute_timestamps=timestamps,
flush_every=ElectromagDiagnostics.h5_flush_never,
)
Simulator(simulation).run()
for diagInfo in simulation.diagnostics:
h5_filename = os.path.join(diag_outputs,
h5_filename_from(diagInfo))
self.assertTrue(os.path.exists(h5_filename))
hier = hierarchy_from(h5_filename=h5_filename)
time_hier_keys = list(hier.time_hier.keys())
self.assertEqual(len(time_hier_keys), len(timestamps))
for i, timestamp in enumerate(time_hier_keys):
self.assertEqual(hier.format_timestamp(timestamps[i]),
timestamp)
def getHierarchy(self,
interp_order,
refinement_boxes,
qty,
nbr_part_per_cell=100,
diag_outputs="phare_outputs",
density=lambda x: 0.3 + 1. / np.cosh((x - 6) / 4.)**2,
beam=False,
smallest_patch_size=10,
largest_patch_size=10,
cells=120,
dl=0.1):
from pyphare.pharein import global_vars
global_vars.sim = None
startMPI()
Simulation(smallest_patch_size=smallest_patch_size,
largest_patch_size=largest_patch_size,
time_step_nbr=30000,
final_time=30.,
boundary_types="periodic",
cells=cells,
dl=dl,
interp_order=interp_order,
refinement_boxes=refinement_boxes,
diag_options={
"format": "phareh5",
"options": {
"dir": diag_outputs,
"mode": "overwrite"
}
})
def beam_density(x):
return np.zeros_like(x) + 0.3
def by(x):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
return 0.1 * np.cos(2 * np.pi * x / L[0])
def bz(x):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
return 0.1 * np.sin(2 * np.pi * x / L[0])
def bx(x):
return 1.
def vx(x):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
return 0.1 * np.cos(2 * np.pi * x / L[0]) + 0.2
def vy(x):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
return 0.1 * np.cos(2 * np.pi * x / L[0])
def vz(x):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
return 0.1 * np.sin(2 * np.pi * x / L[0])
def vthx(x):
return 0.01 + np.zeros_like(x)
def vthy(x):
return 0.01 + np.zeros_like(x)
def vthz(x):
return 0.01 + np.zeros_like(x)
if beam:
MaxwellianFluidModel(bx=bx,
by=by,
bz=bz,
protons={
"charge": 1,
"density": density,
"vbulkx": vx,
"vbulky": vy,
"vbulkz": vz,
"vthx": vthx,
"vthy": vthy,
"vthz": vthz,
"nbr_part_per_cell": nbr_part_per_cell,
"init": {
"seed": 1337
}
},
beam={
"charge": 1,
"density": beam_density,
"vbulkx": vx,
"vbulky": vy,
"vbulkz": vz,
"vthx": vthx,
"vthy": vthy,
"vthz": vthz,
"nbr_part_per_cell": nbr_part_per_cell,
"init": {
"seed": 1337
}
})
else:
MaxwellianFluidModel(bx=bx,
by=by,
bz=bz,
protons={
"charge": 1,
"density": density,
"vbulkx": vx,
"vbulky": vy,
"vbulkz": vz,
"vthx": vthx,
"vthy": vthy,
"vthz": vthz,
"nbr_part_per_cell": nbr_part_per_cell,
"init": {
"seed": 1337
}
})
ElectronModel(closure="isothermal", Te=0.12)
for quantity in ["E", "B"]:
ElectromagDiagnostics(quantity=quantity,
write_timestamps=np.zeros(1),
compute_timestamps=np.zeros(1))
for quantity in ["density", "bulkVelocity"]:
FluidDiagnostics(quantity=quantity,
write_timestamps=np.zeros(1),
compute_timestamps=np.zeros(1))
poplist = ["protons", "beam"] if beam else ["protons"]
for pop in poplist:
for quantity in ["density", "flux"]:
FluidDiagnostics(quantity=quantity,
write_timestamps=np.zeros(1),
compute_timestamps=np.zeros(1),
population_name=pop)
for quantity in ['domain', 'levelGhost', 'patchGhost']:
ParticleDiagnostics(quantity=quantity,
compute_timestamps=np.zeros(1),
write_timestamps=np.zeros(1),
population_name=pop)
simulator = Simulator(global_vars.sim)
simulator.initialize()
if qty == "b":
b_hier = hierarchy_from(h5_filename=diag_outputs + "/EM_B.h5")
return b_hier
is_particle_type = qty == "particles" or qty == "particles_patch_ghost"
if is_particle_type:
particle_hier = None
if qty == "particles":
particle_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_domain.h5")
particle_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_levelGhost.h5",
hier=particle_hier)
if is_particle_type:
particle_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_patchGhost.h5",
hier=particle_hier)
if qty == "particles":
merge_particles(particle_hier)
if is_particle_type:
return particle_hier
if qty == "moments":
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_density.h5")
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_bulkVelocity.h5",
hier=mom_hier)
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_density.h5",
hier=mom_hier)
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_flux.h5",
hier=mom_hier)
if beam:
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_beam_density.h5",
hier=mom_hier)
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_beam_flux.h5",
hier=mom_hier)
return mom_hier
def getHierarchy(self,
interp_order,
refinement_boxes,
qty,
diag_outputs,
nbr_part_per_cell=100,
density=_density,
extra_diag_options={},
beam=False,
time_step_nbr=1,
smallest_patch_size=None,
largest_patch_size=10,
cells=120,
dl=0.1,
ndim=1):
diag_outputs = f"phare_outputs/init/{diag_outputs}"
from pyphare.pharein import global_vars
global_vars.sim = None
if smallest_patch_size is None:
from pyphare.pharein.simulation import check_patch_size
_, smallest_patch_size = check_patch_size(
ndim, interp_order=interp_order, cells=cells)
extra_diag_options["mode"] = "overwrite"
extra_diag_options["dir"] = diag_outputs
self.register_diag_dir_for_cleanup(diag_outputs)
Simulation(
smallest_patch_size=smallest_patch_size,
largest_patch_size=largest_patch_size,
time_step_nbr=time_step_nbr,
final_time=30.,
boundary_types=["periodic"] * ndim,
cells=[cells] * ndim,
dl=[dl] * ndim,
interp_order=interp_order,
refinement_boxes=refinement_boxes,
diag_options={
"format": "phareh5",
"options": extra_diag_options
},
strict=True,
)
def beam_density(*xyz):
return np.zeros_like(xyz[0]) + 0.3
def bx(*xyz):
return 1.
def by(*xyz):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
_ = lambda i: 0.1 * np.cos(2 * np.pi * xyz[i] / L[i])
return np.asarray([_(i) for i, v in enumerate(xyz)]).prod(axis=0)
def bz(*xyz):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
_ = lambda i: 0.1 * np.sin(2 * np.pi * xyz[i] / L[i])
return np.asarray([_(i) for i, v in enumerate(xyz)]).prod(axis=0)
def vx(*xyz):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
_ = lambda i: 0.1 * np.cos(2 * np.pi * xyz[i] / L[i])
return np.asarray([_(i) for i, v in enumerate(xyz)]).prod(axis=0)
def vy(*xyz):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
_ = lambda i: 0.1 * np.cos(2 * np.pi * xyz[i] / L[i])
return np.asarray([_(i) for i, v in enumerate(xyz)]).prod(axis=0)
def vz(*xyz):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
_ = lambda i: 0.1 * np.sin(2 * np.pi * xyz[i] / L[i])
return np.asarray([_(i) for i, v in enumerate(xyz)]).prod(axis=0)
def vth(*xyz):
return 0.01 + np.zeros_like(xyz[0])
def vthx(*xyz):
return vth(*xyz)
def vthy(*xyz):
return vth(*xyz)
def vthz(*xyz):
return vth(*xyz)
if beam:
MaxwellianFluidModel(bx=bx,
by=by,
bz=bz,
protons={
"charge": 1,
"density": density,
"vbulkx": vx,
"vbulky": vy,
"vbulkz": vz,
"vthx": vthx,
"vthy": vthy,
"vthz": vthz,
"nbr_part_per_cell": nbr_part_per_cell,
"init": {
"seed": 1337
}
},
beam={
"charge": 1,
"density": beam_density,
"vbulkx": vx,
"vbulky": vy,
"vbulkz": vz,
"vthx": vthx,
"vthy": vthy,
"vthz": vthz,
"nbr_part_per_cell": nbr_part_per_cell,
"init": {
"seed": 1337
}
})
else:
MaxwellianFluidModel(bx=bx,
by=by,
bz=bz,
protons={
"charge": 1,
"density": density,
"vbulkx": vx,
"vbulky": vy,
"vbulkz": vz,
"vthx": vthx,
"vthy": vthy,
"vthz": vthz,
"nbr_part_per_cell": nbr_part_per_cell,
"init": {
"seed": 1337
}
})
ElectronModel(closure="isothermal", Te=0.12)
for quantity in ["E", "B"]:
ElectromagDiagnostics(quantity=quantity,
write_timestamps=np.zeros(time_step_nbr),
compute_timestamps=np.zeros(time_step_nbr))
for quantity in ["density", "bulkVelocity"]:
FluidDiagnostics(quantity=quantity,
write_timestamps=np.zeros(time_step_nbr),
compute_timestamps=np.zeros(time_step_nbr))
poplist = ["protons", "beam"] if beam else ["protons"]
for pop in poplist:
for quantity in ["density", "flux"]:
FluidDiagnostics(quantity=quantity,
write_timestamps=np.zeros(time_step_nbr),
compute_timestamps=np.zeros(time_step_nbr),
population_name=pop)
for quantity in ['domain', 'levelGhost', 'patchGhost']:
ParticleDiagnostics(quantity=quantity,
compute_timestamps=np.zeros(time_step_nbr),
write_timestamps=np.zeros(time_step_nbr),
population_name=pop)
Simulator(global_vars.sim).initialize().reset()
eb_hier = None
if qty in ["e", "eb"]:
eb_hier = hierarchy_from(h5_filename=diag_outputs + "/EM_E.h5",
hier=eb_hier)
if qty in ["b", "eb"]:
eb_hier = hierarchy_from(h5_filename=diag_outputs + "/EM_B.h5",
hier=eb_hier)
if qty in ["e", "b", "eb"]:
return eb_hier
is_particle_type = qty == "particles" or qty == "particles_patch_ghost"
if is_particle_type:
particle_hier = None
if qty == "particles":
particle_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_domain.h5")
particle_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_levelGhost.h5",
hier=particle_hier)
if is_particle_type:
particle_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_patchGhost.h5",
hier=particle_hier)
if qty == "particles":
merge_particles(particle_hier)
if is_particle_type:
return particle_hier
if qty == "moments":
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_density.h5")
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_bulkVelocity.h5",
hier=mom_hier)
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_density.h5",
hier=mom_hier)
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_flux.h5",
hier=mom_hier)
if beam:
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_beam_density.h5",
hier=mom_hier)
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_beam_flux.h5",
hier=mom_hier)
return mom_hier
def getHierarchy(self,
interp_order,
refinement_boxes,
qty,
diag_outputs,
nbr_part_per_cell=100,
density=_density,
smallest_patch_size=None,
largest_patch_size=20,
cells=120,
time_step=0.001,
model_init={},
dl=0.2,
extra_diag_options={},
time_step_nbr=1,
timestamps=None,
ndim=1,
block_merging_particles=False):
diag_outputs = f"phare_outputs/advance/{diag_outputs}"
from pyphare.pharein import global_vars
global_vars.sim = None
if smallest_patch_size is None:
from pyphare.pharein.simulation import check_patch_size
_, smallest_patch_size = check_patch_size(
ndim, interp_order=interp_order, cells=cells)
extra_diag_options["mode"] = "overwrite"
extra_diag_options["dir"] = diag_outputs
self.register_diag_dir_for_cleanup(diag_outputs)
Simulation(
smallest_patch_size=smallest_patch_size,
largest_patch_size=largest_patch_size,
time_step_nbr=time_step_nbr,
time_step=time_step,
boundary_types=["periodic"] * ndim,
cells=np_array_ify(cells, ndim),
dl=np_array_ify(dl, ndim),
interp_order=interp_order,
refinement_boxes=refinement_boxes,
diag_options={
"format": "phareh5",
"options": extra_diag_options
},
strict=True,
)
def S(x, x0, l):
return 0.5 * (1 + np.tanh((x - x0) / l))
def bx(*xyz):
return 1.
def by(*xyz):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
_ = lambda i: 0.1 * np.cos(2 * np.pi * xyz[i] / L[i])
return np.asarray([_(i) for i, v in enumerate(xyz)]).prod(axis=0)
def bz(*xyz):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
_ = lambda i: 0.1 * np.cos(2 * np.pi * xyz[i] / L[i])
return np.asarray([_(i) for i, v in enumerate(xyz)]).prod(axis=0)
def vx(*xyz):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
_ = lambda i: 0.1 * np.cos(2 * np.pi * xyz[i] / L[i])
return np.asarray([_(i) for i, v in enumerate(xyz)]).prod(axis=0)
def vy(*xyz):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
_ = lambda i: 0.1 * np.cos(2 * np.pi * xyz[i] / L[i])
return np.asarray([_(i) for i, v in enumerate(xyz)]).prod(axis=0)
def vz(*xyz):
from pyphare.pharein.global_vars import sim
L = sim.simulation_domain()
_ = lambda i: 0.1 * np.cos(2 * np.pi * xyz[i] / L[i])
return np.asarray([_(i) for i, v in enumerate(xyz)]).prod(axis=0)
def vth(*xyz):
return 0.01 + np.zeros_like(xyz[0])
def vthx(*xyz):
return vth(*xyz)
def vthy(*xyz):
return vth(*xyz)
def vthz(*xyz):
return vth(*xyz)
MaxwellianFluidModel(bx=bx,
by=by,
bz=bz,
protons={
"charge": 1,
"density": density,
"vbulkx": vx,
"vbulky": vy,
"vbulkz": vz,
"vthx": vthx,
"vthy": vthy,
"vthz": vthz,
"nbr_part_per_cell": nbr_part_per_cell,
"init": model_init,
})
ElectronModel(closure="isothermal", Te=0.12)
if timestamps is None:
timestamps = all_timestamps(global_vars.sim)
for quantity in ["E", "B"]:
ElectromagDiagnostics(quantity=quantity,
write_timestamps=timestamps,
compute_timestamps=timestamps)
for quantity in ["density", "bulkVelocity"]:
FluidDiagnostics(quantity=quantity,
write_timestamps=timestamps,
compute_timestamps=timestamps)
poplist = ["protons"]
for pop in poplist:
for quantity in ["density", "flux"]:
FluidDiagnostics(quantity=quantity,
write_timestamps=timestamps,
compute_timestamps=timestamps,
population_name=pop)
for quantity in ['domain', 'levelGhost', 'patchGhost']:
ParticleDiagnostics(quantity=quantity,
compute_timestamps=timestamps,
write_timestamps=timestamps,
population_name=pop)
Simulator(global_vars.sim).run()
eb_hier = None
if qty in ["e", "eb", "fields"]:
eb_hier = hierarchy_from(h5_filename=diag_outputs + "/EM_E.h5",
hier=eb_hier)
if qty in ["b", "eb", "fields"]:
eb_hier = hierarchy_from(h5_filename=diag_outputs + "/EM_B.h5",
hier=eb_hier)
if qty in ["e", "b", "eb"]:
return eb_hier
is_particle_type = qty == "particles" or qty == "particles_patch_ghost"
if is_particle_type:
particle_hier = None
if qty == "particles":
particle_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_domain.h5")
particle_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_levelGhost.h5",
hier=particle_hier)
if is_particle_type:
particle_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_patchGhost.h5",
hier=particle_hier)
if not block_merging_particles and qty == "particles":
merge_particles(particle_hier)
if is_particle_type:
return particle_hier
if qty == "moments" or qty == "fields":
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_density.h5",
hier=eb_hier)
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_bulkVelocity.h5",
hier=mom_hier)
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_density.h5",
hier=mom_hier)
mom_hier = hierarchy_from(h5_filename=diag_outputs +
"/ions_pop_protons_flux.h5",
hier=mom_hier)
return mom_hier
def get_time(path, time):
if time is not None:
time = "{:.10f}".format(time)
from pyphare.pharesee.hierarchy import hierarchy_from
return hierarchy_from(h5_filename=path + "/ions_pop_protons_domain.h5",
time=time)
def _test_dump_diags(self, dim, **simInput):
test_id = self.ddt_test_id()
# configure simulation dim sized values
for key in ["cells", "dl", "boundary_types"]:
simInput[key] = [simInput[key] for d in range(dim)]
b0 = [[10 for i in range(dim)], [19 for i in range(dim)]]
simInput["refinement_boxes"] = {"L0": {"B0": b0}}
py_attrs = [
f"{dep}_version" for dep in ["samrai", "highfive", "pybind"]
]
py_attrs += ["git_hash"]
for interp in range(1, 4):
print("test_dump_diags dim/interp:{}/{}".format(dim, interp))
local_out = f"{out}_dim{dim}_interp{interp}_mpi_n_{cpp.mpi_size()}_id{test_id}"
simInput["diag_options"]["options"]["dir"] = local_out
simulation = ph.Simulation(**simInput)
self.assertTrue(len(simulation.cells) == dim)
dump_all_diags(setup_model().populations)
self.simulator = Simulator(
simulation).initialize().advance().reset()
refined_particle_nbr = simulation.refined_particle_nbr
self.assertTrue(
any([
diagInfo.quantity.endswith("domain")
for diagInfo in ph.global_vars.sim.diagnostics
]))
particle_files = 0
for diagInfo in ph.global_vars.sim.diagnostics:
h5_filepath = os.path.join(local_out,
h5_filename_from(diagInfo))
self.assertTrue(os.path.exists(h5_filepath))
h5_file = h5py.File(h5_filepath, "r")
self.assertTrue("0.0000000000"
in h5_file[h5_time_grp_key]) # init dump
self.assertTrue(
"0.0010000000"
in h5_file[h5_time_grp_key]) # first advance dump
h5_py_attrs = h5_file["py_attrs"].attrs.keys()
for py_attr in py_attrs:
self.assertIn(py_attr, h5_py_attrs)
hier = hierarchy_from(h5_filename=h5_filepath)
if h5_filepath.endswith("domain.h5"):
particle_files += 1
self.assertTrue("pop_mass" in h5_file.attrs)
if "protons" in h5_filepath:
self.assertTrue(h5_file.attrs["pop_mass"] == 1)
elif "alpha" in h5_filepath:
self.assertTrue(h5_file.attrs["pop_mass"] == 4)
else:
raise RuntimeError("Unknown population")
self.assertGreater(len(hier.level(0).patches), 0)
for patch in hier.level(0).patches:
self.assertTrue(len(patch.patch_datas.items()))
for qty_name, pd in patch.patch_datas.items():
splits = pd.dataset.split(ph.global_vars.sim)
self.assertTrue(splits.size() > 0)
self.assertTrue(pd.dataset.size() > 0)
self.assertTrue(
splits.size() == pd.dataset.size() *
refined_particle_nbr)
self.assertEqual(particle_files,
ph.global_vars.sim.model.nbr_populations())
self.simulator = None
ph.global_vars.sim = None
def getHierarchy(self, interp_order, refinement_boxes, qty, nbr_part_per_cell=100,
diag_outputs="phare_outputs",
smallest_patch_size=5, largest_patch_size=20,
cells=120, time_step=0.001, model_init={},
dl=0.1, extra_diag_options={}, time_step_nbr=1, timestamps=None):
from pyphare.pharein import global_vars
global_vars.sim = None
startMPI()
extra_diag_options["mode"] = "overwrite"
extra_diag_options["dir"] = diag_outputs
Simulation(
smallest_patch_size=smallest_patch_size,
largest_patch_size=largest_patch_size,
time_step_nbr=time_step_nbr,
time_step=time_step,
boundary_types="periodic",
cells=cells,
dl=dl,
interp_order=interp_order,
refinement_boxes=refinement_boxes,
diag_options={"format": "phareh5",
"options": extra_diag_options}
)
def density(x):
return 1.
def S(x,x0,l):
return 0.5*(1+np.tanh((x-x0)/l))
def bx(x):
return 1.
def by(x):
L = global_vars.sim.simulation_domain()[0]
v1=-1
v2=1.
return v1 + (v2-v1)*(S(x,L*0.25,1) -S(x, L*0.75, 1))
def bz(x):
return 0.5
def b2(x):
return bx(x)**2 + by(x)**2 + bz(x)**2
def T(x):
K = 1
return 1/density(x)*(K - b2(x)*0.5)
def vx(x):
return 0.
def vy(x):
return 0.
def vz(x):
return 0.
def vthx(x):
return T(x)
def vthy(x):
return T(x)
def vthz(x):
return T(x)
MaxwellianFluidModel(bx=bx, by=by, bz=bz,
protons={"charge": 1,
"density": density,
"vbulkx": vx, "vbulky": vy, "vbulkz": vz,
"vthx": vthx, "vthy": vthy, "vthz": vthz,
"nbr_part_per_cell": nbr_part_per_cell,
"init": model_init})
ElectronModel(closure="isothermal", Te=0.12)
if timestamps is None:
timestamps = np.arange(0, global_vars.sim.final_time + global_vars.sim.time_step, global_vars.sim.time_step)
for quantity in ["E", "B"]:
ElectromagDiagnostics(
quantity=quantity,
write_timestamps=timestamps,
compute_timestamps=timestamps
)
for quantity in ["density", "bulkVelocity"]:
FluidDiagnostics(
quantity=quantity,
write_timestamps=timestamps,
compute_timestamps=timestamps
)
poplist = ["protons"]
for pop in poplist:
for quantity in ["density", "flux"]:
FluidDiagnostics(quantity=quantity,
write_timestamps=timestamps,
compute_timestamps=timestamps,
population_name=pop)
for quantity in ['domain', 'levelGhost', 'patchGhost']:
ParticleDiagnostics(quantity=quantity,
compute_timestamps=timestamps,
write_timestamps=timestamps,
population_name=pop)
Simulator(global_vars.sim).initialize().run()
eb_hier = None
if qty in ["e", "eb"]:
eb_hier = hierarchy_from(h5_filename=diag_outputs+"/EM_E.h5", hier=eb_hier)
if qty in ["b", "eb"]:
eb_hier = hierarchy_from(h5_filename=diag_outputs+"/EM_B.h5", hier=eb_hier)
if qty in ["e", "b", "eb"]:
return eb_hier
is_particle_type = qty == "particles" or qty == "particles_patch_ghost"
if is_particle_type:
particle_hier = None
if qty == "particles":
particle_hier = hierarchy_from(h5_filename=diag_outputs+"/ions_pop_protons_domain.h5")
particle_hier = hierarchy_from(h5_filename=diag_outputs+"/ions_pop_protons_levelGhost.h5", hier=particle_hier)
if is_particle_type:
particle_hier = hierarchy_from(h5_filename=diag_outputs+"/ions_pop_protons_patchGhost.h5", hier=particle_hier)
if qty == "particles":
merge_particles(particle_hier)
if is_particle_type:
return particle_hier
if qty == "moments":
mom_hier = hierarchy_from(h5_filename=diag_outputs+"/ions_density.h5")
mom_hier = hierarchy_from(h5_filename=diag_outputs+"/ions_bulkVelocity.h5", hier=mom_hier)
mom_hier = hierarchy_from(h5_filename=diag_outputs+"/ions_pop_protons_density.h5", hier=mom_hier)
mom_hier = hierarchy_from(h5_filename=diag_outputs+"/ions_pop_protons_flux.h5", hier=mom_hier)
return mom_hier