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

Added extror from logs and namelist

Browse Source
This commit is contained in:
Noe Brucy
2019-11-13 17:33:15 +01:00
parent 3986b1cdf4
commit ea6f9b6bdd
4 changed files with 563 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files
plotter.py
+237 -105
View File
@@ -15,9 +15,10 @@ import matplotlib.patches as mpatches
from matplotlib.collections import PatchCollection
from functools import partial
from numpy.polynomial.polynomial import polyfit
from scipy.ndimage.filters import gaussian_filter1d
from pp_params import *
from postprocessor import Rule, BaseProcessor
from postprocessor import *
P.rcParams['image.cmap']='plasma'
@@ -29,18 +30,12 @@ P.rcParams.update(tex_params)
class PlotRule(Rule):
def plot(self, arg):
return self.process_fn(arg)
def plot(self, save, arg, **kwargs):
self.postproc.save = save
return self.process_fn(arg, **kwargs)
def is_valid(self, arg):
save = self.postproc.save
valid = True
for dep in self.dependencies:
if not arg is None:
valid = valid and dep + '_' + str(arg) in save
else:
valid = valid and dep in save
return arg in self.args_ok and valid and self.is_valid_add(arg)
return arg in self.args_ok and self.is_valid_add(arg)
class Plotter(BaseProcessor):
"""
@@ -55,81 +50,139 @@ class Plotter(BaseProcessor):
G = 1. # Gravitational constant
def __init__(self, filename=None, path_out='.', num=None, pp_params=Params()):
def __init__(self, path, runs, nums, path_out=None, pp_params=default_params(), tag=None):
self.pp_params = pp_params
if type(pp_params) == str:
self.pp_params = load_params(pp_params)
else :
self.pp_params = pp_params
if tag is not None:
self.pp_params.out.tag = tag
# Determining output directory
if path_out is None:
if filename is None:
self.path_out='.'
else:
self.path_out = os.path.dirname(filename)
if (path_out is None):
self.path_out = path
else:
self.path_out = path_out
# Find HDF5 file
if filename is None:
if not pp_params.out.tag == '':
tag_name = '_' + pp_params.out.tag
else :
tag_name = ''
self.filename = (self.path_out + '/postproc_' +
tag_name + format(num,'05') + '.h5')
else:
self.filename = filename
# Get postprocesor objets for each run
self.pp_runs = dict()
if not type(nums) == dict:
nums_tmp = nums
nums = dict()
for run in runs:
nums[run] = nums_tmp
for run in runs:
path_run = path + '/' + run
path_out_run = path_out + '/' + run
self.pp_runs[run] = dict()
for num in nums[run]:
self.pp_runs[run][num] = PostProcessor(path_run, num, path_out_run, pp_params)
# Get comparator object
self.comp = Comparator(path, runs, nums, path_out, pp_params)
# save infos
self.runs = runs
self.nums = nums
self.log_id = "[plot {}] ".format(self.pp_params.out.tag)
self.def_rules()
def plot(self, to_plot_list, args=[None], overwrite=False):
"""
Plot the data in to_plot_list and save them
"""
self.process(to_plot_list, args, overwrite, False)
def _process_single(self, name, rule, arg, overwrite=False, just_done=[], **kwargs):
# Solve dependencies
for dep in rule.dependencies:
if dep in self.comp.rules:
if type(rule.dependencies) == dict:
self.comp.process([dep], [rule.dependencies[dep]],
self.overwrite_dep)
else:
self.comp.process([dep], [arg], self.overwrite_dep, self.overwrite_dep)
else:
for run in self.runs:
for i, num in enumerate(self.nums[run]):
if type(rule.dependencies) == dict:
dep_arg = rule.dependencies[dep]
self.pp_runs[run][num].process([dep], [dep_arg],
self.overwrite_dep)
else:
self.pp_runs[run][num].process([dep], [arg],
self.overwrite_dep,
self.overwrite_dep)
def _process_single(self, name, rule, arg, overwrite=False, overwrite_dep=False, just_done=[]):
done = self._plot_rule(name, rule, arg, overwrite)
return []
# Process rule
done = self._process_rule(name, rule, arg, overwrite, just_done, **kwargs)
return just_done + [done]
def _plot_rule(self, name, rule, arg, overwrite):
def _process_rule(self, name, rule, arg, overwrite=False, just_done=[], **kwargs):
if not arg is None:
name_full = rule.group + '/' + name + '_' + str(arg)
name_full = name + '_' + str(arg)
else:
name_full = rule.group + '/' + name
name_full = name
if rule.is_valid(arg):
plot_filename = self._find_filename(name_full)
if overwrite or not os.path.exists(plot_filename):
rule.plot(arg)
P.tight_layout(pad=1)
P.savefig(plot_filename)
P.close()
self._log("{} plotted".format(name_full), "SUCCESS")
if rule.kind == 'classic':
for run in self.runs:
for i, num in enumerate(self.nums[run]):
plot_filename = self._find_filename(name_full, run, num)
save = tables.open_file(self.pp_runs[run][num].filename)
try:
self._plot_rule(rule, save, arg, plot_filename, overwrite, **kwargs)
finally:
save.close()
else:
self._log("Plot {} is already done, skipping...".format(name_full))
if rule.kind == 'series' and len(self.runs) == 1:
run = self.runs[0]
plot_filename = self._find_filename(name_full, run)
else:
plot_filename = self._find_filename(name_full)
save = tables.open_file(self.comp.filename, 'r')
try :
self._plot_rule(rule, save, arg, plot_filename, overwrite, **kwargs)
finally:
save.close()
else:
self._log("{} is not valid in this context".format(name_full), "ERROR")
def _plot_rule(self, rule, save, arg, plot_filename, overwrite, **kwargs):
if overwrite or not os.path.exists(plot_filename):
if not self.pp_params.out.interactive:
P.figure()
rule.plot(save, arg, **kwargs)
P.tight_layout(pad=1)
if not self.pp_params.out.interactive:
P.savefig(plot_filename)
P.close()
self._log("{} plotted".format(plot_filename), "SUCCESS")
else:
self._log("{} plotted".format(os.path.basename(plot_filename)), "SUCCESS")
else:
self._log("Plot {} is already done, skipping...".format(plot_filename))
def _find_filename(self, name_full):
def _find_filename(self, name_full, run=None, num=None):
if not self.pp_params.out.tag == '':
tag_name = '_' + self.pp_params.out.tag
else :
tag_name = ''
if 'num' in self.save.root._v_attrs:
num = self.save.root._v_attrs.num
return (self.path_out + '/' + name_full +
if not run is None and not num is None:
return (self.path_out + '/' + run + '/' + name_full +
tag_name + '_' + format(num,'05') +
self.pp_params.plot.out_ext)
elif not run is None:
return (self.path_out + '/' + run + '/'
+ name_full + tag_name + self.pp_params.plot.out_ext)
else:
return self.path_out + '/' + name_full + tag_name + self.pp_params.plot.out_ext
def _plot_map(self, name, ax_los, label=None, cmap='plasma', vmin=None, vmax=None, overlays=[]):
P.figure()
ax_h = self._axes_h[ax_los]
ax_v = self._axes_v[ax_los]
im_extent = self.save.root.maps._v_attrs.im_extent
@@ -201,8 +254,8 @@ class Plotter(BaseProcessor):
P.quiverkey(Q, 0.6, 0.98, max_v,
r'$'+str(max_v)[0:4]+'$ (code)', labelpos='E', coordinates='figure')
def _plot_radial(self, name, ax_los='z', label=None, xlog=False, ylog=False):
P.figure()
def _plot_radial(self, name, label=None, xlog=False, ylog=False):
radial_bins = self.save.get_node('/radial/radial_bins_' + ax_los).read()
bin_centers = 0.5 * (radial_bins[1:] + radial_bins[:-1])
mean_bin = self.save.get_node('/radial/{}_{}'.format(name, ax_los)).read()
@@ -220,7 +273,7 @@ class Plotter(BaseProcessor):
P.ylabel(label)
def _plot_hist(self, name, ax_los='z', label=None, ylog=False):
P.figure()
pdf = self.save.get_node('/hist/' + name + '_' + ax_los)
values, centers = pdf.read()
width = centers[1] - centers[0]
@@ -236,106 +289,185 @@ class Plotter(BaseProcessor):
P.ylim([None, 1.])
def _plot(self, name_x, name_y, xlabel=None, ylabel=None, linearfit=False):
P.figure()
def _plot(self, name_x, name_y, xlabel=None, ylabel=None,
xunit=None, yunit=None,
linearfit=False, smooth=0,
nml_key=None, runs=None, **kwargs):
node_x = self.save.get_node(name_x)
node_y = self.save.get_node(name_y)
if xlabel is None:
if 'label' in node_x:
xlabel = name_x._vattrs.label
if 'label' in node_x._v_attrs:
xlabel = node_x._v_attrs.label
else:
xlabel = name_x
xlabel = os.path.basename(name_x)
if ylabel is None:
if 'label' in node_y:
ylabel = name_y._vattrs.label
if 'label' in node_y._v_attrs:
ylabel = node_y._v_attrs.label
else:
ylabel = name_y
ylabel = os.path.basename(name_y)
x = node_x.read()
if node_y._v_attrs.CLASS == 'ARRAY':
y = node_y.read()
P.plot(x, y, fmt='*')
if 'unit' in node_x._v_attrs:
xunit_old = node_x._v_attrs.unit
else:
y = node_y.mean.read()
yerr = node_y.std.read()
P.errorbar(x, y, yerr=y, fmt='*')
xunit_old = cst.none
if 'unit' in node_y._v_attrs:
yunit_old = node_y._v_attrs.unit
else:
yunit_old = cst.none
if xunit is None:
xunit = xunit_old
if yunit is None:
yunit = yunit_old
xlabel = xlabel + unit_str(xunit)
ylabel = ylabel + unit_str(yunit)
P.xlabel(xlabel)
P.ylabel(ylabel)
P.grid()
if node_y._v_attrs.CLASS == 'ARRAY':
x = node_x.read() * xunit_old.express(xunit)
y = node_y.read() * yunit_old.express(yunit)
if smooth > 0:
y = gaussian_filter1d(y, sigma=smooth)
yerr = None
P.plot(x, y, fmt='*', **kwargs)
elif 'mean' in node_y:
x = node_x.read() * xunit_old.express(xunit)
y = node_y.mean.read() * yunit_old.express(yunit)
if smooth > 0:
y = gaussian_filter1d(y, sigma=smooth)
yerr = node_y.std.read() * yunit_old.express(yunit)
P.errorbar(x, y, yerr=yerr, fmt='*', **kwargs)
else:
yerr = None
if runs is None:
runs = self.runs
for run in runs:
x_run, y_run = node_x[run], node_y[run]
x = x_run.read() * xunit_old.express(xunit)
y = y_run.read() * yunit_old.express(yunit)
if smooth > 0:
y = gaussian_filter1d(y, sigma=smooth)
if nml_key is None:
label_run = r"{}".format(self.save.root._v_attrs.attrs[y_run.name].label)
else:
prop_name = os.path.basename(nml_key)
prop_value = self.comp.get_nml(nml_key, run)
label_run = r"{} = {}".format(prop_name, prop_value)
P.plot(x, y, label=label_run, **kwargs)
P.legend()
if linearfit:
if node_y._v_attrs.CLASS == 'ARRAY':
(a, b, rho, _, stderr) = linregress(node_x.read(), node_y.read())
_overlay_linearfit(x, y, yerr)
def _overlay_linearfit(x, y, yerr=None):
if yerr is None:
(a, b, rho, _, stderr) = linregress(x, y)
else:
c = polyfit(node_x.read(), node_y.mean.read(), 1,
w = [1.0 / ty for ty in node_y.std.read()], full=False)
c = polyfit(x, y, 1,
w = [1.0 / ty for ty in yerr], full=False)
b, a = c[0], c[1]
P.plot(x, a*y + b, '--', linewidth=1.5)
P.grid()
def def_rules(self):
self.rules = {
'coldens' : PlotRule(self, lambda ax_los:
self._plot_map('coldens', ax_los, label=r'$\Sigma$ (code)', vmin=0.01, vmax=100),
"Column density", ['/maps/coldens']),
self._plot_map('coldens', ax_los,
label=r'$\Sigma$ (code)', vmin=0.01, vmax=100),
"Column density", dependencies=['coldens']),
'rho' : PlotRule(self, lambda ax_los:
self._plot_map('rho', ax_los, label=r'$\rho$ (code)'),
"Density slice", ['/maps/rho']),
"Density slice", dependencies=['rho']),
'coldens_l' : PlotRule(self, lambda ax_los:
self._plot_map('coldens', ax_los, label=r'$\Sigma$ (code)',
vmin=0.01, vmax=100, overlays=[self._overlay_levels]),
"Column density", ['/maps/coldens', '/maps/levels']),
self._plot_map('coldens', ax_los,
label=r'$\Sigma$ (code)',
vmin=0.01, vmax=100,
overlays=[self._overlay_levels]),
"Column density",
dependencies=['coldens', 'levels']),
'rho_v' : PlotRule(self, lambda ax_los:
self._plot_map('rho', ax_los, label=r'$\rho$ (code)',
overlays=[self._overlay_speed]),
"Density slice", ['/maps/rho', '/maps/speed_h', '/maps/speed_v']),
self._plot_map('rho', ax_los, label=r'$\rho$ (code)',
overlays=[self._overlay_speed]),
"Density slice",
dependencies= ['rho', 'speed_h', 'speed_v']),
'jeans_ratio' : PlotRule(self, lambda ax_los:
self._plot_map('jeans_ratio', ax_los, vmin=0.1, vmax=100,
cmap='RdBu_r',
overlays=[self._overlay_levels]),
"Jeans' lenght divided by the max resolution",
dependencies=['/maps/jeans_ratio', '/maps/levels']),
dependencies=['jeans_ratio', 'levels']),
'Q' : PlotRule(self, lambda ax_los:
self._plot_map('rho', ax_los, label=r'$Q$', vmin=0.01, vmax=100, cmap='RdBu_r'),
self._plot_map('rho', ax_los, label=r'$Q$',
vmin=0.01, vmax=100, cmap='RdBu_r'),
"Toomre Q parameter for a Keplerian disk",
dependencies=['/maps/Q'], args_ok=['z'])
dependencies=['Q'], args_ok=['z'])
}
averageables = ['coldens', 'rho', 'T', 'Q']
for name in averageables:
self.rules['rad_' + name] = PlotRule(self, partial(self._plot_radial, 'rad_avg_' + name,
label=name, xlog=True, ylog=True),
self.rules['rad_' + name] = PlotRule(self,
partial(self._plot_radial,
'rad_avg_' + name,
label=name,
xlog=True, ylog=True),
"Azimuthal average of {}".format(name),
dependencies=['/radial/radial_bins', '/radial/rad_avg_' + name],
dependencies=['radial_bins', 'rad_avg_' + name],
args_ok=['z'])
self.rules['fluct_' + name] = PlotRule(self, partial(self._plot_map, 'fluct_' + name,
vmin=0.01, vmax=100, cmap='RdBu_r',
label='{}/avg({})'.format(name, name)),
"Fluctuation wrt to average of {}".format(name),
dependencies=['/maps/fluct_' + name],
args_ok=['z'])
self.rules['fluct_' + name] = PlotRule(self,
partial(self._plot_map, 'fluct_' + name,
vmin=0.01, vmax=100, cmap='RdBu_r',
label='{}/avg({})'.format(name, name)),
"Fluctuation wrt to average of {}".format(name),
dependencies=['fluct_' + name],
args_ok=['z'])
self.rules['pdf_' + name] = PlotRule(self, partial(self._plot_hist, 'pdf_' + name, ylog=True,
label='{}/avg({})'.format(name, name)),
"Probability density function of {} fluctuations".format(name),
dependencies=['/hist/pdf_' + name],
dependencies=['pdf_' + name],
args_ok=['z'])
self.rules.update({
'kappa_beta' : PlotRule(self, partial(self._plot, '/comp/beta', '/comp/avg_pdf_slope_coldens',
'kappa_beta' : PlotRule(self, partial(self._plot,
'/comp/beta',
'/comp/avg_pdf_slope_coldens',
linearfit=True),
args_ok=[None], dependencies=['/comp/beta', '/comp/avg_pdf_slope_coldens']),
'sink_mass' : PlotRule(self, partial(self._plot, '/series/time', '/series/sinks_mass',
linearfit=True),
args_ok=[None], dependencies=['/series/time', '/series/sinks_mass'])
args_ok=[None], kind='comp',
dependencies=['beta', 'avg_pdf_slope_coldens']),
'sink_mass' : PlotRule(self, partial(self._plot,
'/series/sinks_from_log/time',
'/series/sinks_from_log/mass_sink',
ylabel="Mass of sinks",
xunit=cst.Myr,
yunit=cst.Msun),
args_ok=[None], kind='series',
dependencies=['sinks_from_log']),
'assfr' : PlotRule(self, partial(self._plot,
'/series/sfr_from_log/time',
'/series/sfr_from_log/sfr',
ylabel="Averaged surfacic SFR",
xunit=cst.Myr,
yunit=cst.ssfr),
args_ok=[None], kind='series',
dependencies=['sfr_from_log']),
'issfr' : PlotRule(self, partial(self._plot,
'/series/sinks_from_log/time',
'/series/sinks_from_log/issfr',
ylabel="Surfacic SFR",
xunit=cst.Myr,
yunit=cst.ssfr),
args_ok=[None], kind='series',
dependencies=['issfr'])
})