noe/pipeline
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Organize in submodules

Browse Source
This commit is contained in:
Noe Brucy
2022-10-07 11:20:04 +02:00
parent 1f3b0762c9
commit 0d90179292
32 changed files with 231 additions and 510 deletions
Download Patch File Download Diff File Expand all files Collapse all files
__init__.py
View File
__pycache__/comparator.cpython-37.pyc
BIN
View File
Binary file not shown.
aggregator.py
+1 -1
View File
@@ -4,7 +4,7 @@ import numpy as np
from functools import partial
from baseprocessor import Rule
import snapshotprocessor
from mypool import MyPool
from utils.mypool import MyPool
try:
from mpi4py.futures import MPIPoolExecutor
baseprocessor.py
+13 -3
View File
@@ -10,11 +10,11 @@ from functools import partial
import numpy as np
import tables
from tables import HDF5ExtError
from tables import HDF5ExtError, NoSuchNodeError
from tables.registry import class_name_dict
from params import default_params, load_params
from units import U
from utils.params import default_params, load_params
from utils.units import U
import sys
import traceback
@@ -44,6 +44,7 @@ class Rule:
return self.process_fn(arg, **kwargs)
else:
return self.process_fn(**kwargs)
class BaseProcessor:
"""
Base class for processors, should not be instanciated
@@ -292,8 +293,17 @@ class HDF5Container(BaseProcessor):
)
else:
value = node.read()
if isinstance(unit, dict):
name = os.path.basename(node_name)
if name in unit:
unit = unit[name]
else:
unit = None
if not (unit is None or unit_old is None or unit_old == U.none):
value = value * unit_old.express(unit)
except NoSuchNodeError:
self.logger.error(f"The value {node_name} is node available", stack_info=True)
raise
finally:
if not open_before:
self.close()
fragdisk/__init__.py
View File
gui.py → fragdisk/gui.py
+1 -1
View File
@@ -17,7 +17,7 @@ from scipy.stats import linregress
from skimage.draw import line
from snapshotprocessor import SnapshotProcessor
from params import default_params
from utils.params import default_params
class DraggablePoint:
galactica/__init__.py
View File
fragdisk_galactica.py → galactica/fragdisk_galactica.py
View File
ismfeed_galactica.py → galactica/ismfeed_galactica.py
View File
ramses_astrophysix.py → galactica/ramses_astrophysix.py
View File
galturb/__init__.py
View File
galaxy.py → galturb/galaxy.py
View File
sectors_extraction.py → galturb/sectors_extraction.py
View File
ism.py
-101
View File
@@ -1,101 +0,0 @@
# coding: utf-8
import numpy as np
import pandas as pd
from plotter import U
import snapshotprocessor
mp = 1.4 * 1.66 * 10 ** (-24) * U.g
z0 = 150 * U.pc
sink_header = [
"Id",
"M",
"dmf",
"x",
"y",
"z",
"vx",
"vy",
"vz",
"rot_period",
"lx",
"ly",
"lz",
"acc_rate",
"acc_lum",
"age",
"int_lum",
"Teff",
]
def convert_coldens_s(n0):
return (np.sqrt(2 * np.pi) * mp * z0 * (n0 * U.cm ** (-3))).express(U.coldens)
convert_coldens = np.vectorize(convert_coldens_s)
def get_dispersion(dset, name):
"""
Compute dispersion from dset[name]
"""
vel = dset[name]
mass = dset["mass"]
mass_tot = np.sum(mass)
if mass_tot > 0:
mean = np.sum(mass * vel) / mass_tot
return np.sqrt(np.sum(mass * (vel - mean) ** 2) / mass_tot)
else:
return 0
def get_sinks(pp):
csv_name = f"{pp.path}/output_{pp.num:05}/sink_{pp.num:05}.csv"
return pd.read_csv(csv_name, header=None, names=sink_header)
def analyze_box(pp):
pp.cells["mass"] = snapshotprocessor.mass_func(pp.cells)
coldens = pp.get_value("/maps/coldens_z", unit=U.coldens)
sinks = get_sinks(pp)
sinks["mass"] = sinks.M
res = {}
dirs = ["x", "y", "z"]
res["time"] = pp.info["time"] * pp.info["unit_time"].express(U.Myr)
for i, dir in enumerate(dirs):
pp.cells[f"v{dir}"] = pp.cells["vel"][:, i]
res[f"sigma_{dir}"] = get_dispersion(pp.cells, f"v{dir}") * pp.info[
"unit_velocity"
].express(U.km_s)
res[f"sigma_sinks_{dir}"] = get_dispersion(sinks, f"v{dir}") * pp.info[
"unit_velocity"
].express(U.km_s)
res["coldens_mean"] = np.mean(coldens)
res["n0"] = pp.get_nml("cloud_params/dens0")
res["mass"] = np.sum(
pp.cells["mass"]
* (pp.info["unit_density"] * pp.info["unit_length"] ** 3).express(U.Msun)
)
res["coldens_initial"] = convert_coldens_s(res["n0"])
res["mass_initial"] = res["coldens_initial"] * 1e6
res["coldens_mean"] = np.mean(coldens)
res["coldens_beam"] = res["mass"] / (pp.info["unit_length"].express(U.pc)) ** 2
res["nsink"] = sinks.M.count()
res["mass_sink"] = np.sum(sinks.M)
return res
def load_wrapper(pp, fun):
"""
Wrapper to load_unload data and map function
"""
pp.load_cells(keys=["pos", "vel", "dx", "rho"])
pp.coldens("z")
res = fun(pp)
pp.unload_cells()
return res
def allinone(pp):
return load_wrapper(pp, analyze_box)
ismfeed/__init__.py
View File
ismfeed.py → ismfeed/ismfeed.py
View File
pipeline.py
+1 -1
View File
@@ -9,7 +9,7 @@ import numpy as np
from plotter import Plotter, plt
from snapshotprocessor import SnapshotProcessor, get_time
from studyprocessor import StudyProcessor
from params import default_params, load_params
from utils.params import default_params, load_params
fake_pp = SnapshotProcessor()
plotter.py
+8 -16
View File
@@ -36,12 +36,11 @@ except ModuleNotFoundError:
print("WARNING: no movie support (missing module moviepy)")
from mpl_toolkits.axes_grid1.inset_locator import inset_axes
import pspec_read
from baseprocessor import Rule, BaseProcessor
from aggregator import Aggregator
from studyprocessor import StudyProcessor
from run_selector import RunSelector
from units import U, unit_str, convert_exp
from runselector import RunSelector
from utils.units import U, unit_str, convert_exp
try:
import lic
@@ -56,7 +55,7 @@ from astrophysix.simdm.experiment import (
ParameterVisibility,
Simulation,
)
from ramses_astrophysix import ramses
from galactica.ramses_astrophysix import ramses
filetype_from_ext = {ext: ft for ft in FileType for ext in ft.extension_list}
@@ -270,6 +269,7 @@ class Plotter(Aggregator, BaseProcessor):
self.nums,
self.path_out,
self.params,
tag=tag,
unit_time=unit_time,
selector=self.selector,
)
@@ -1434,15 +1434,6 @@ class Plotter(Aggregator, BaseProcessor):
if subname_y:
hdf5_y.close()
def _pspec(self, name, **kwargs):
"""
Plot power spectrum (wrapper around pspec_read)
"""
del kwargs["run"]
file_pspec = self.current_processor.get_value("/hdf5/pspec")
num = self.current_processor.num
getattr(pspec_read, "pspec_" + name)(file_pspec, ".", num, **kwargs)
def _overlay_fit(self, x, y, yerr=None, kind="linear", label=None, **kwargs):
"""
Add an overlay : fit a curve, linear or powerlaw
@@ -1527,7 +1518,7 @@ class Plotter(Aggregator, BaseProcessor):
This is where rules are defined
"""
self.rules = {
"plot_arrays": PlotRule(lambda arg, **kwargs: self._plot(*arg, **kwargs), kind="comp"
"plot_comp": PlotRule(lambda arg, **kwargs: self._plot(*arg, **kwargs), kind="comp"
),
"plot_run": PlotRule(lambda arg, **kwargs: self._plot(*arg, **kwargs), kind="run"
),
@@ -1674,7 +1665,6 @@ class Plotter(Aggregator, BaseProcessor):
"Density profile",
dependencies=["axis", "rho_prof"],
),
"pspec": PlotRule(self, self._pspec, dependencies={"pspec": None}),
"sbeta": PlotRule(
partial(
self._plot,
@@ -1965,13 +1955,15 @@ class Plotter(Aggregator, BaseProcessor):
self._gen_from_log("fine_step_from_log", name)
for name in ["time", "dt", "a", "mem_cells", "mem_parts"]:
self._gen_from_log("fine_step_from_log", name_y=name, name_x="fine_step")
self._gen_from_log("SN_momentum_from_log", name_x="time", name_y="SN_momentum")
# Dict of overlays
self.overlays = {
"g": partial(self._overlay_vector, "g"),
"B": self._overlay_B,
"vel": self._overlay_speed,
"speed": self._overlay_speed,
"speed": self._overlay_speed,
"levels": self._overlay_levels,
"contour": self._overlay_contour,
"particles": self._overlay_particles,
pspec_read.py
-374
View File
@@ -1,374 +0,0 @@
from builtins import str
import matplotlib.pyplot as P
import numpy as np
import tables as T
################################################################
# 3D
################################################################
def pspec_rho(file, path_out, num, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d3/rho")
kbins = h5f.get_node(group, "kbins").read()
pspec = h5f.get_node(group, "pspec").read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = (k ** 2) * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^2 \mathcal{P}(\rho)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_rho_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_rho_" + format(num, "05") + ".jpeg")
def pspec_B(file, path_out, num, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d3/B")
kbins = h5f.get_node(group, "kbins").read()
pspec = h5f.get_node(group, "pspec").read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = k ** 2 * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^2 \mathcal{P}(B)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_B_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_B_" + format(num, "05") + ".jpeg")
def pspec_v(file, path_out, num, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d3/v")
kbins = h5f.get_node(group, "kbins").read()
pspec = h5f.get_node(group, "pspec").read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = k ** 4 * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^4 \mathcal{P}(v)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_v_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_v_" + format(num, "05") + ".jpeg")
def pspec_vz(file, path_out, num, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d3/vz")
kbins = h5f.get_node(group, "kbins").read()
pspec = h5f.get_node(group, "pspec").read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = k ** 4 * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^4 \mathcal{P}(vz)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_vz_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_vz_" + format(num, "05") + ".jpeg")
def pspec_cos(file, path_out, num, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d3/cos_vB")
kbins = h5f.get_node(group, "kbins").read()
pspec = h5f.get_node(group, "pspec").read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = k ** 2 * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^2 \mathcal{P}(\cos(\vec{v}.\vec{B}))$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_cos_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_cos_" + format(num, "05") + ".jpeg")
def pspec_logrho(file, path_out, num, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d3/logrho")
kbins = h5f.get_node(group, "kbins").read()
pspec = h5f.get_node(group, "pspec").read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = k ** 2 * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^2 \mathcal{P}(\log(\rho))$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_logrho_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_logrho_" + format(num, "05") + ".jpeg")
def pspec_kr(file, path_out, num, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d3/kr")
kbins = h5f.get_node(group, "kbins").read()
pspec = h5f.get_node(group, "pspec").read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = (k ** 4) * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^4 \mathcal{P}(\rho^{1/3}v)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_kr_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_kr_" + format(num, "05") + ".jpeg")
def pspec_vc(file, path_out, num, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d3/vc")
kbins = h5f.get_node(group, "kbins").read()
pspec = h5f.get_node(group, "pspec").read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = (k ** 4) * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^4 \mathcal{P}(v_c)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_vc_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_vc_" + format(num, "05") + ".jpeg")
def pspec_vs(file, path_out, num, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d3/vs")
kbins = h5f.get_node(group, "kbins").read()
pspec = h5f.get_node(group, "pspec").read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = (k ** 4) * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^4 \mathcal{P}(v_s)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_vs_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_vs_" + format(num, "05") + ".jpeg")
###################################################################
# 2D
###################################################################
def pspec_rho_2D(file, path_out, num, plan, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d2/rho")
kbins = h5f.get_node(group, "kbins_" + str(plan)).read()
pspec = h5f.get_node(group, "pspec_" + str(plan)).read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = (k ** 1) * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k \mathcal{P}(\rho)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_rho_2D_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_rho_2D_" + format(num, "05") + ".jpeg")
def pspec_B_2D(file, path_out, num, plan, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d2/B")
kbins = h5f.get_node(group, "kbins_" + str(plan)).read()
pspec = h5f.get_node(group, "pspec_" + str(plan)).read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = k ** 1 * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k \mathcal{P}(B)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_B_2D_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_B_2D_" + format(num, "05") + ".jpeg")
def pspec_v_2D(file, path_out, num, plan, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d2/v")
kbins = h5f.get_node(group, "kbins_" + str(plan)).read()
pspec = h5f.get_node(group, "pspec_" + str(plan)).read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = k ** 3 * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^3 \mathcal{P}(v)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_v_2D_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_v_2D_" + format(num, "05") + ".jpeg")
def pspec_vz_2D(file, path_out, num, plan, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d2/vz")
kbins = h5f.get_node(group, "kbins_" + str(plan)).read()
pspec = h5f.get_node(group, "pspec_" + str(plan)).read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = k ** 3 * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^3 \mathcal{P}(v_z)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_vz_2D_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_vz_2D_" + format(num, "05") + ".jpeg")
def pspec_cos_2D(file, path_out, num, plan, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d2/cos_vB")
kbins = h5f.get_node(group, "kbins_" + str(plan)).read()
pspec = h5f.get_node(group, "pspec_" + str(plan)).read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = k * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k \mathcal{P}(\cos(\vec{v}.\vec{B}))$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_cos_2D_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_cos_2D_" + format(num, "05") + ".jpeg")
def pspec_logrho_2D(file, path_out, num, plan, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d2/logrho")
kbins = h5f.get_node(group, "kbins_" + str(plan)).read()
pspec = h5f.get_node(group, "pspec_" + str(plan)).read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = k * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k \mathcal{P}(\log(\rho))$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_logrho_2D_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_logrho_2D_" + format(num, "05") + ".jpeg")
def pspec_kr_2D(file, path_out, num, plan, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d2/kr")
kbins = h5f.get_node(group, "kbins_" + str(plan)).read()
pspec = h5f.get_node(group, "pspec_" + str(plan)).read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = (k ** 3) * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^3 \mathcal{P}(\rho^{1/3}v)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_kr_2D_" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_kr_2D_" + format(num, "05") + ".jpeg")
def pspec_vc_2D(file, path_out, num, plan, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d2/vc")
kbins = h5f.get_node(group, "kbins_" + str(plan)).read()
pspec = h5f.get_node(group, "pspec_" + str(plan)).read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = (k ** 3) * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^3 \mathcal{P}(v_c)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_vc_2D" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_vc_2D" + format(num, "05") + ".jpeg")
def pspec_vs_2D(file, path_out, num, plan, color="r", save=False, **kwargs):
h5f = T.open_file(file, mode="r")
group = h5f.get_node("/out_" + format(num, "05") + "/d2/vs")
kbins = h5f.get_node(group, "kbins_" + str(plan)).read()
pspec = h5f.get_node(group, "pspec_" + str(plan)).read()
h5f.close()
k = np.sqrt(kbins[1:] * kbins[:-1])
pspec = (k ** 3) * pspec
if save:
P.figure(figsize=(8, 8))
P.xlabel(r"$k$", fontsize=12)
P.ylabel(r"$k^3 \mathcal{P}(v_s)$", fontsize=12)
P.loglog(k, pspec, "-", color=color, **kwargs)
if save:
P.savefig(path_out + "pspec_vs_2D" + format(num, "05") + ".ps")
P.savefig(path_out + "pspec_vs_2D" + format(num, "05") + ".jpeg")
run_selector.py → runselector.py
View File
scripts/__init__.py
View File
pspec_new.py → scripts/pspec.py
View File
select_snapshot.py
+1 -1
View File
@@ -5,7 +5,7 @@
Select snaphots with a criterion
"""
from run_selector import RunSelector
from runselector import RunSelector
from plotter import Plotter, U
import os
snapshotprocessor.py
+8 -8
View File
@@ -34,10 +34,10 @@ from pymses.sources.hop.hop import HOP
from fil_finder import FilFinder2D
from scipy import fft
import pspec_new
from scripts import pspec as pspec
from units import U
from utils.units import U
from baseprocessor import (
HDF5Container,
Rule,
@@ -48,7 +48,7 @@ from baseprocessor import (
oct_vect_getter,
)
from run_selector import RunSelector
from runselector import RunSelector
# Getters
@@ -212,10 +212,10 @@ def pspec(map2D):
# Compute fft
fmap = fft.fft2(map2D)
# Compute the power map from the fft
pmap = pspec_new.pcube(fmap)
pmap = pspec.pcube(fmap)
# Use the power map and the fft to compute the powerspectrum
# This is typically an histogram of k weighted by the fourier transform value
pspec, kbins, pspec2, fbins = pspec_new.pspectrum(pmap, kmap, kbins, 1, 0)
pspec, kbins, pspec2, fbins = pspec.pspectrum(pmap, kmap, kbins, 1, 0)
# Return bin center and power spectrum
return 0.5 * (kbins[1:] + kbins[:-1]), pspec
@@ -1434,10 +1434,10 @@ class SnapshotProcessor(HDF5Container):
return {key: df[key].values for key in df}
def _pspec(self, overwrite_file=False, **kwargs):
def pspec(self, overwrite_file=False, **kwargs):
outfile = self.pspec_filename
if overwrite_file or not os.path.exists(self.pspec_filename):
pspec_new.pspec(repo=self.path, iouts=[self.num], outfile=outfile, **kwargs)
pspec.pspec(repo=self.path, iouts=[self.num], outfile=outfile, **kwargs)
return np.array([self.pspec_filename])
def _write_particles(self):
@@ -1754,7 +1754,7 @@ class SnapshotProcessor(HDF5Container):
"vz_gas": "unit_velocity",
},
),
"pspec": Rule(self._pspec, "Power spectrum", "/hdf5"),
"pspec": Rule(self.pspec, "Power spectrum", "/hdf5"),
"write_particles": Rule(self._write_particles, "Particles file", "/hdf5"
),
"write_cells": Rule(self._write_cells, "Cells file", "/hdf5"),
studyprocessor.py
+37 -3
View File
@@ -12,9 +12,9 @@ from scipy.stats import linregress
from baseprocessor import Rule, HDF5Container
from aggregator import Aggregator
from snapshotprocessor import SnapshotProcessor
from run_selector import RunSelector
from params import default_params
from units import U
from runselector import RunSelector
from utils.params import default_params
from utils.units import U
class StudyProcessor(Aggregator, HDF5Container):
@@ -452,6 +452,31 @@ class StudyProcessor(Aggregator, HDF5Container):
series["turb_energy"][run].append(np.nan)
return series
def _extract_SN_Mom_from_log(self, series, log_filename, run):
cmd_grep = f"grep -e 'SN momentum' -e 'Fine step' {log_filename}"
content = os.popen(cmd_grep).readlines()
block_err = []
time = 0
for i in range(0, len(content)):
try:
if content[i][1:5] == "Fine":
data = content[i].replace("=", " ").split()
time = np.float(data[4])
elif content[i][1:3] == "SN" :
series["time"][run].append(time)
series["SN_momentum"][run].append(np.float(content[i].split()[-1]))
else:
raise ValueError("Wrong start of line")
except (AssertionError, ValueError, IndexError):
block_err.append(i)
if len(block_err) > 0:
self.logger.warning(
f"Error encountered in parsing {log_filename} (grepped blocks {block_err})"
)
return series
def get_logs(self, run):
glob_str = f"{self.path}/{run}/{self.params.input.log_prefix}*"
logs = glob.glob(glob_str)
@@ -815,6 +840,15 @@ class StudyProcessor(Aggregator, HDF5Container):
"id": U.none,
},
),
"SN_momentum_from_log": Rule(
partial(self._from_log, ["time", "SN_momentum"], self._extract_SN_Mom_from_log),
group="/series",
unit={"time": "unit_time", "SN_momentum" : {"unit_mass" : 1, "unit_velocity" : 1}},
description={
"time": "Time",
"SN_momentum": "Injected momentum",
},
),
"turb_power": Rule(
self._turb_power,
group="/series/rms_from_log",
turbox/__init__.py
View File
turbox/turbox.py
+160
View File
@@ -0,0 +1,160 @@
"""
Toolbox for the TURBOX project (simulation part).
By Noé Brucy and Corentin Le Yuehlic, 2022
Compute and plot eta_d, from the slope of the logdensity power spectrum
"""
import numpy as np
from plotter import U
from baseprocessor import Rule
from matplotlib import pyplot as plt
import pandas as pd
import tables
from scipy.stats import linregress
def get_pspec(pp, field:str, dim:int=3):
"""Read power spectruù
Parameters
----------
pp : SnapshotProcessor
field : str
field to get
dim : int, optional
dimension (2 or 3), by default 3
Returns
-------
tupple (np.array, np.array)
wave number and correponding powers
"""
h5file = tables.File(pp.pspec_filename)
path = f"/out_{pp.num:05}/d{dim}/{field}"
node = h5file.get_node(path)
kbins = node.kbins.read()
pspec = node.pspec.read()
h5file.close()
k = (kbins[:-1] + kbins[1:]) / 2
return k, pspec
span_resolution = {
256: (0.8, 1.1),
512: (0.5, 1.7),
1024: (0.4, 1.7)
}
def get_slope(pp, field:str, resol:int, plotdebug:bool=False):
"""Get the slope of the Power specturm using linear regression in the selected range
Parameters
----------
pp : Snapshotprocessor
field : str
field name
resol : int
resolution (number of cells on 1 side of the simulation cube)
Returns
-------
tuple (float, float)
Slope, square value of the correlation coefficient
"""
# Trustworthy span od the power spectrum in log10(k) as a function of the resolution
logkmin, logkmax = span_resolution[resol]
k, power = get_pspec(pp, field)
logk, logpower = np.log10(k), np.log10(power)
mask = (logk >= logkmin) & (logk < logkmax)
results = linregress(logk[mask], logpower[mask])
if plotdebug:
plt.figure()
plt.plot(logk, logpower)
plt.plot(logk[mask], results.slope*logk[mask]+ results.intercept, lw=3, ls=":", color="k")
pp.logger.info(f"Fit results in get_slope({field}, {resol}): slope:{results.slope:.2f}, b:{results.intercept:.2f}, R2:{results.rvalue**2:.2f}")
if results.rvalue**2 < 0.8:
pp.logger.warning(f"Bad fit in get_slope({field}, {resol}) with {logkmin} <= logk < {logkmax}")
pp.logger.warning(f"log(k) is \n {logk[mask]}")
pp.logger.warning(f"log(power) is \n {logpower[mask]}")
return results.slope, results.intercept, results.rvalue**2
def build_suite(pl, redo=False, cs0=0.28834810480560674):
"""Compute an array of parameter for each run in the Plotter pl
Parameters
----------
pl : Plotter
redo : bool, optional
redo the comptutation of the velocity dispersion, by default False
cs0 : float, optional
Sound speed in the simulations, by default 0.28834810480560674
Returns
-------
pd.Dataframe
dataframe with the properties of the simulation
"""
df = dict()
df["snapshots"] = pl.nums.values()
df["n0"] = pl.study.get_nml("galbox_params/dens0").values()
df["turbinit"] = pl.study.get_nml("galbox_params/turb").values()
df["solver"] = pl.study.get_nml("hydro_params/riemann").values()
df["slope"] = pl.study.get_nml("hydro_params/slope_type").values()
df["res"] = pl.study.get_nml("amr_params/levelmin").values()
df["frms"] = pl.study.get_nml("turb_params/turb_rms").values()
df["seed"] = pl.study.get_nml("turb_params/turb_seed").values()
df["comp"] = pl.study.get_nml("turb_params/comp_frac").values()
df["L"] = pl.study.get_nml("amr_params/boxlen").values()
df["T_turb"] = (np.array(list(pl.study.get_nml("turb_params/turb_T").values()))
* pl.study.info["unit_time"].express(U.Myr))
df = pd.DataFrame(df, index=pl.runs)
if redo:
pl.study.avg_time_sigma("x", overwrite_dep=False)
pl.study.avg_time_sigma("y", overwrite_dep=False)
pl.study.avg_time_sigma("z", overwrite_dep=False)
pl.study.time(overwrite=True)
for ax in ["x", "y", "z"]:
df[f"sigma_{ax}"] = np.array(list(map(
lambda x : x.T[0],
[pl.study.get_value(f"/series/time_sigma_{ax}",
unit=U.km_s)[run] for run in pl.runs])))
df["sigma_all"] = df[f"sigma_x"]**2 + df[f"sigma_y"]**2 + df[f"sigma_z"]**2
df["sigma_all"] = list(map(np.sqrt, df["sigma_all"].values))
df["Mach_all"] = list(map(lambda v: v/cs0, df["sigma_all"].values))
df["time"] = list(map(lambda x : x.T[0],
[pl.study.get_value(f"/series/time", unit=U.Myr)[run]
for run in pl.runs]))
df["sigma"] = list(map(lambda l: np.mean(l), df["sigma_all"].values))
df["Mach"] = df["sigma"] / cs0
df["turnover"] = (df["L"] * U.pc.express(U.km) / (2 * df["sigma"]))* U.s.express(U.Myr)
return df
def rho_pdf(pp):
pp.load_cells()
rho = pp.cells["rho"] * pp.info["unit_density"].express(U.H_cc)
rho_0 = np.mean(rho)
print(rho_0)
s = np.log(rho/rho_0)
values, edges = np.histogram(s, bins=300, range=(-15, 11),
density=True)
pp.unload_cells()
centers = 0.5 * (edges[1:] + edges[:-1])
return (np.stack([values, centers]), {"logbins": True})
rule_pdf=Rule(rho_pdf, "Density PDF", name="rho_pdf", group="/hist")
def apply_rule_pdf(pp):
return pp.process(rule_pdf, pp, overwrite=True)
utils/__init__.py
View File
line_annotation.py → utils/line_annotation.py
View File
mypool.py → utils/mypool.py
View File
params.py → utils/params.py
+1 -1
View File
@@ -33,7 +33,7 @@ def params_from_file(filename):
def default_params():
return params_from_file(_dir_path + "/params.yml")
return params_from_file(_dir_path + "/../params.yml")
def load_params(filename):
units.py → utils/units.py
View File