import glob
import os
import numpy as np
from pyphare.core.phare_utilities import listify, refinement_ratio
from pyphare.logger import getLogger
from pyphare.pharesee.hierarchy import ScalarField, VectorField, hierarchy_from
from pyphare.pharesee.hierarchy.fromh5 import pop_attribute_from_h5
from pyphare.pharesee.hierarchy.hierarchy_utils import (
compute_hier_from,
flat_finest_field,
)
from .utils import (
_compute_current,
_compute_divB,
_compute_pop_pressure,
_compute_pressure,
_compute_to_primal,
_get_rank,
make_interpolator,
)
logger = getLogger(__name__)
quantities_per_file = {
"EM_B": "B",
"EM_E": "E",
"ions_bulkVelocity": "Vi",
"ions_charge_flux": "CF",
"ions_charge_density": "Ni",
"ions_mass_density": "rho",
"particle_count": "nppc",
"mhd_rho": "mhd_rho",
"mhd_V": "mhd_V",
"mhd_P": "mhd_P",
"mhd_rhoV": "mhd_rhoV",
"mhd_Etot": "mhd_Etot",
}
[docs]
class Run:
def __init__(self, path, default_time=None):
self.path = path
self.default_time_ = default_time
self.available_diags = glob.glob(os.path.join(self.path, "*.h5"))
def _get_hierarchy(self, times, filename, hier=None, **kwargs):
from pyphare.core.box import Box
times = listify(times)
times = [f"{t:.10f}" for t in times]
if "selection_box" in kwargs and isinstance(kwargs["selection_box"], tuple):
lower = kwargs["selection_box"][:2]
upper = kwargs["selection_box"][2:]
kwargs["selection_box"] = Box(lower, upper)
def _get_hier(h):
return hierarchy_from(
h5_filename=os.path.join(self.path, filename),
times=times,
hier=h,
**kwargs,
)
return _get_hier(hier)
# TODO maybe transform that so multiple times can be accepted
def _get(self, hierarchy, time, merged, interp):
"""
if merged=True, will return an interpolator and a tuple of 1d arrays
with the coordinates of the finest grid where the interpolator
can be calculated (that is the return of flat_finest_field)
"""
if merged:
domain = self.GetDomainSize()
dl = self.GetDl(hierarchy.finest_level(time))
# assumes all qties in the hierarchy have the same ghost width
# so take the first patch data of the first patch of the first level....
nbrGhosts = next(
iter(hierarchy.level(0).patches[0].patch_datas.values())
).ghosts_nbr
merged_qties = {}
for qty in hierarchy.quantities():
data, coords = flat_finest_field(hierarchy, qty, time=time)
merged_qties[qty] = make_interpolator(
data, coords, interp, domain, dl, qty, nbrGhosts
)
return merged_qties
else:
return hierarchy
[docs]
def GetB(self, time, merged=False, interp="nearest", all_primal=True, **kwargs):
if merged:
all_primal = False
hier = self._get_hierarchy(time, "EM_B.h5", **kwargs)
if not all_primal:
return self._get(hier, time, merged, interp)
h = compute_hier_from(_compute_to_primal, hier, x="Bx", y="By", z="Bz")
return VectorField.FROM(h)
[docs]
def GetE(self, time, merged=False, interp="nearest", all_primal=True, **kwargs):
if merged:
all_primal = False
hier = self._get_hierarchy(time, "EM_E.h5", **kwargs)
if not all_primal:
return self._get(hier, time, merged, interp)
h = compute_hier_from(_compute_to_primal, hier, x="Ex", y="Ey", z="Ez")
return VectorField.FROM(h)
[docs]
def GetMassDensity(self, time, merged=False, interp="nearest", **kwargs):
hier = self._get_hierarchy(time, "ions_mass_density.h5", **kwargs)
return ScalarField.FROM(self._get(hier, time, merged, interp))
[docs]
def GetNi(self, time, merged=False, interp="nearest", **kwargs):
hier = self._get_hierarchy(time, "ions_charge_density.h5", **kwargs)
return ScalarField.FROM(self._get(hier, time, merged, interp))
[docs]
def GetN(self, time, pop_name, merged=False, interp="nearest", **kwargs):
hier = self._get_hierarchy(time, f"ions_pop_{pop_name}_density.h5", **kwargs)
return ScalarField.FROM(self._get(hier, time, merged, interp))
[docs]
def GetVi(self, time, merged=False, interp="nearest", **kwargs):
hier = self._get_hierarchy(time, "ions_bulkVelocity.h5", **kwargs)
return VectorField.FROM(self._get(hier, time, merged, interp))
[docs]
def GetChargeFlux(self, time, merged=False, interp="nearest", **kwargs):
hier = self._get_hierarchy(time, "ions_charge_flux.h5", **kwargs)
return VectorField.FROM(self._get(hier, time, merged, interp))
[docs]
def GetFlux(self, time, pop_name, merged=False, interp="nearest", **kwargs):
hier = self._get_hierarchy(time, f"ions_pop_{pop_name}_flux.h5", **kwargs)
return VectorField.FROM(self._get(hier, time, merged, interp))
[docs]
def GetPressure(self, time, pop_name, merged=False, interp="nearest", **kwargs):
M = self._get_hierarchy(
time, f"ions_pop_{pop_name}_momentum_tensor.h5", **kwargs
)
V = self.GetFlux(time, pop_name, **kwargs)
N = self.GetN(time, pop_name, **kwargs)
P = compute_hier_from(
_compute_pop_pressure,
(M, V, N),
popname=pop_name,
mass=self.GetMass(pop_name, **kwargs),
)
return self._get(P, time, merged, interp) # should later be a TensorField
[docs]
def GetPi(self, time, merged=False, interp="nearest", **kwargs):
M = self._get_hierarchy(time, "ions_momentum_tensor.h5", **kwargs)
massDensity = self.GetMassDensity(time, **kwargs)
Vi = self._get_hierarchy(time, "ions_bulkVelocity.h5", **kwargs)
Pi = compute_hier_from(_compute_pressure, (M, massDensity, Vi))
return self._get(Pi, time, merged, interp) # should later be a TensorField
[docs]
def GetPe(self, time, merged=False, interp="nearest", all_primal=True):
hier = self._get_hierarchy(time, "ions_charge_density.h5")
Te = hier.sim.electrons.closure.Te
if not all_primal:
return Te * self._get(hier, time, merged, interp)
h = compute_hier_from(_compute_to_primal, hier, scalar="rho")
return ScalarField.FROM(h) * Te
[docs]
def GetJ(self, time, merged=False, interp="nearest", all_primal=True, **kwargs):
if merged:
all_primal = False
B = self.GetB(time, all_primal=False, **kwargs)
J = compute_hier_from(_compute_current, B)
if not all_primal:
return self._get(J, time, merged, interp)
h = compute_hier_from(_compute_to_primal, J, x="Jx", y="Jy", z="Jz")
return VectorField.FROM(h)
[docs]
def GetDivB(self, time, merged=False, interp="nearest", **kwargs):
B = self.GetB(time, all_primal=False, **kwargs)
db = compute_hier_from(_compute_divB, B)
return ScalarField.FROM(self._get(db, time, merged, interp))
[docs]
def GetMHDrho(
self, time, merged=False, interp="nearest", all_primal=True, **kwargs
):
if merged:
all_primal = False
hier = self._get_hierarchy(time, "mhd_rho.h5", **kwargs)
if not all_primal:
return self._get(hier, time, merged, interp)
h = compute_hier_from(_compute_to_primal, hier, value="mhdRho")
return ScalarField.FROM(h)
[docs]
def GetMHDV(self, time, merged=False, interp="nearest", all_primal=True, **kwargs):
if merged:
all_primal = False
hier = self._get_hierarchy(time, "mhd_V.h5", **kwargs)
if not all_primal:
return self._get(hier, time, merged, interp)
h = compute_hier_from(_compute_to_primal, hier, x="mhdVx", y="mhdVy", z="mhdVz")
return VectorField.FROM(h)
[docs]
def GetMHDP(self, time, merged=False, interp="nearest", all_primal=True, **kwargs):
if merged:
all_primal = False
hier = self._get_hierarchy(time, "mhd_P.h5", **kwargs)
if not all_primal:
return self._get(hier, time, merged, interp)
h = compute_hier_from(_compute_to_primal, hier, value="mhdP")
return ScalarField.FROM(h)
[docs]
def GetMHDrhoV(
self, time, merged=False, interp="nearest", all_primal=True, **kwargs
):
if merged:
all_primal = False
hier = self._get_hierarchy(time, "mhd_rhoV.h5", **kwargs)
if not all_primal:
return self._get(hier, time, merged, interp)
h = compute_hier_from(
_compute_to_primal, hier, x="mhdRhoVx", y="mhdRhoVy", z="mhdRhoVz"
)
return VectorField.FROM(h)
[docs]
def GetMHDEtot(
self, time, merged=False, interp="nearest", all_primal=True, **kwargs
):
if merged:
all_primal = False
hier = self._get_hierarchy(time, "mhd_Etot.h5", **kwargs)
if not all_primal:
return self._get(hier, time, merged, interp)
h = compute_hier_from(_compute_to_primal, hier, value="mhdEtot")
return ScalarField.FROM(h)
[docs]
def GetMagneticFlux(
self, time, interp="nearest", xn=None, yn=None, Xn=None, Yn=None
):
hier = self._get_hierarchy(time, "EM_B.h5")
# Reuse grids if provided, otherwise generate them
if xn is None or yn is None or Xn is None or Yn is None:
domain = self.GetDomainSize()
dl = self.GetDl(hier.finest_level(time))
xn = np.arange(0, domain[0] + dl[0], dl[0])
yn = np.arange(0, domain[1] + dl[1], dl[1])
Xn, Yn = np.meshgrid(xn, yn, indexing="ij")
merged_B = self._get(hier, time, merged=True, interp=interp)
bx_interp = merged_B["Bx"][0]
by_interp = merged_B["By"][0]
bx = bx_interp(Xn, Yn)
by = by_interp(Xn, Yn)
from scipy.integrate import cumulative_trapezoid
Az_x0 = -cumulative_trapezoid(by[:, 0], xn, initial=0)
Az = cumulative_trapezoid(bx, yn, axis=1, initial=0)
Az += Az_x0[:, np.newaxis]
return Az, (xn, yn)
[docs]
def FindPrimaryXPoint(self, Az, xn, yn):
dAz_dx = np.gradient(Az, xn, axis=0)
dAz_dy = np.gradient(Az, yn, axis=1)
grad_mag = np.sqrt(dAz_dx**2 + dAz_dy**2)
threshold = np.percentile(grad_mag, 5)
d2Az_dx2 = np.gradient(dAz_dx, xn, axis=0)
d2Az_dy2 = np.gradient(dAz_dy, yn, axis=1)
d2Az_dxdy = np.gradient(dAz_dx, yn, axis=1)
det_hessian = d2Az_dx2 * d2Az_dy2 - d2Az_dxdy**2
candidates = (grad_mag < threshold) & (det_hessian < 0)
det_hessian_masked = np.where(candidates, det_hessian, np.inf)
idx = np.unravel_index(np.argmin(det_hessian_masked), Az.shape)
return xn[idx[0]], yn[idx[1]], idx
[docs]
def GetReconnectionRate(self, times, interp="nearest"):
domain = self.GetDomainSize()
hier = self._get_hierarchy(times[0], "EM_B.h5")
dl = self.GetDl(hier.finest_level(times[0]))
xn = np.arange(0, domain[0] + dl[0], dl[0])
yn = np.arange(0, domain[1] + dl[1], dl[1])
Xn, Yn = np.meshgrid(xn, yn, indexing="ij")
flux_at_xpoint = []
xpoint_trajectory = []
for t in times:
Az, _ = self.GetMagneticFlux(t, interp=interp, xn=xn, yn=yn, Xn=Xn, Yn=Yn)
x_xp, y_xp, idx = self.FindPrimaryXPoint(Az, xn, yn)
xpoint_trajectory.append([x_xp, y_xp])
flux_at_xpoint.append(Az[idx])
flux_at_xpoint = np.array(flux_at_xpoint)
xpoint_trajectory = np.array(xpoint_trajectory)
dt = np.diff(times)
rates = np.diff(flux_at_xpoint) / dt
times_centered = (times[:-1] + times[1:]) / 2
return times_centered, rates, flux_at_xpoint, xpoint_trajectory
[docs]
def GetRanks(self, time, merged=False, interp="nearest", **kwargs):
"""
returns a hierarchy of MPI ranks
takes the information from magnetic field diagnostics arbitrarily
this fails if the magnetic field is not written and could at some point
be replace by a search of any available diag at the requested time.
"""
B = self.GetB(time, all_primal=False, **kwargs)
ranks = compute_hier_from(_get_rank, B)
return ScalarField.FROM(self._get(ranks, time, merged, interp))
[docs]
def GetParticles(self, time, pop_name, hier=None, **kwargs):
def filename(name):
return f"ions_pop_{name}_domain.h5"
if isinstance(pop_name, (list, tuple)):
for pop in pop_name:
hier = self._get_hierarchy(time, filename(pop), hier=hier, **kwargs)
return hier
return self._get_hierarchy(time, filename(pop_name), hier=hier, **kwargs)
[docs]
def GetParticleCount(self, time, **kwargs):
c = self._get_hierarchy(time, "particle_count.h5", **kwargs)
return c
[docs]
def GetMass(self, pop_name, **kwargs):
return pop_attribute_from_h5(self.path, pop_name, "pop_mass")
[docs]
def GetCharge(self, pop_name, **kwargs):
return pop_attribute_from_h5(self.path, pop_name, "pop_charge")
[docs]
def GetDomainSize(self, **kwargs):
import h5py
data_file = h5py.File(
self.available_diags[0], "r"
) # That is the first file in th available diags
root_cell_width = np.asarray(data_file.attrs["cell_width"])
return (data_file.attrs["domain_box"] + 1) * root_cell_width
[docs]
def GetDl(self, level=0):
"""
gives the ndarray containing the grid sizes for the given level
:param level: the level at which get the associated grid size
"""
import h5py
if level < 0:
raise ValueError(f"Run::GetDl: level must be >= 0, got {level}")
with h5py.File(self.available_diags[0], "r") as data_file:
root_cell_width = np.asarray(data_file.attrs["cell_width"])
return root_cell_width / refinement_ratio**level
[docs]
def all_times(self):
import h5py
files = self.available_diags
ts = {}
for file in files:
basename = os.path.basename(file).split(".")[0]
ff = h5py.File(file)
time_keys = ff["t"].keys()
time = np.zeros(len(time_keys))
for it, t in enumerate(time_keys):
time[it] = float(t)
ts[quantities_per_file.get(basename, basename)] = time
ff.close()
return ts
[docs]
def times(self, qty):
return self.all_times()[qty]