def main():
global MODFUNCS
parser = argparse.ArgumentParser()
parser.add_argument(
"scan_dir",
type=Path,
help="directory of the scan containing the file scan.pickle",
)
parser.add_argument(
"-f",
"--file",
type=Path,
default=Path("propagate") / "propagate.h5/natpop",
help="relative path within each simulation",
)
parser.add_argument("-d", "--dof", type=int, default=1, help="degree of freedom")
parser.add_argument("-n", "--node", type=int, default=1, help="node")
parser.add_argument(
"-e",
"--extension",
type=str,
default=".pdf",
help="file extensions for the plots",
)
parser.add_argument("-o", "--output", type=str, help="name of the output directory")
plot.add_argparse_2d_args(parser)
args = parser.parse_args()
if not args.output:
args.output = f"natpop_{args.dof}_{args.node}"
def apply_args(fig: Figure, ax: Axes, parameters: Parameters):
del parameters
plot.apply_2d_args(ax, fig, args)
MODFUNCS = [apply_args] + MODFUNCS
load_scan(args.scan_dir).plot_foreach(
args.output,
partial(
plot_natpop,
file_path=args.file,
dof=args.dof,
node=args.node,
extension=args.extension,
),
)
def scan_plot_energy(
scan_dir: Union[Path, str],
propagation: str = "propagate",
extensions: List[str] = [".png"],
**kwargs,
):
scan_dir = make_path(scan_dir)
plotting_args = PlotArgs2D.from_dict(kwargs)
selection = load_scan(scan_dir)
def plot_func(index, path, parameters):
del path
del parameters
time, _, energy, _ = read_output_hdf5(
scan_dir / "by_index" / str(index) / propagation / "propagate.h5",
"output",
)
fig, axis = plt.subplots(1, 1)
plot_energy(axis, time, energy)
return fig, [axis]
yield doit_plot_individual(
selection,
"energy",
[str(Path(propagation) / "propagate.h5")],
plot_func,
plotting_args,
extensions,
decorator_funcs=kwargs.get("decorator_funcs", []),
)
def action_collect_values(scan_dir: Path, targets):
selection = load_scan(scan_dir)
variables = selection.get_variable_names()
def helper(index, path, parameters):
return (
[parameters[variable] for variable in variables],
fetch_func(index, path, parameters),
)
parameters = []
values_lst = []
for param, val in selection.foreach(helper, parallel=False):
if val is not None:
parameters.append(param)
values_lst.append(val)
else:
LOGGER.warning("cannot fetch value(s) for parameters: %s",
str(param))
parameters = numpy.array(parameters, dtype=object)
values = numpy.array(values_lst, dtype=object)
if len(values.shape) == 1:
values = values.reshape((len(values), 1))
elif len(values.shape) == 2:
pass
else:
raise RuntimeError(f"Invalid dimensions {len(values.shape)}")
data = numpy.c_[parameters, values]
header = [variable for variable in variables
] + [f"value{i}" for i in range(values.shape[1])]
Path(targets[0]).parent.mkdir(parents=True, exist_ok=True)
numpy.savetxt(targets[0], data, header=" ".join(header))
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"scan_dir",
type=str,
help="directory of the scan containing the file scan.pickle",
)
parser.add_argument(
"-f",
"--file",
type=Path,
default=Path("propagate") / "output",
help="relative path within each simulation",
)
parser.add_argument(
"-e",
"--extension",
type=str,
default=".pdf",
help="file extensions for the plots",
)
parser.add_argument(
"-o",
"--output",
type=Path,
default="energy",
help="name of the output directory",
)
plot.add_argparse_2d_args(parser)
args = parser.parse_args()
def apply_args(fig: Figure, ax: Axes, parameters: Parameters):
del parameters
plot.apply_2d_args(ax, fig, args)
load_scan(args.scan_dir).plot_foreach(
args.output,
partial(
plot_energy,
file_path=args.file,
modfunc=apply_args,
extension=args.extension,
),
)
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"scan_dir",
type=Path,
help="directory of the scan containing the file scan.pickle",
)
parser.add_argument(
"expval",
type=Path,
help="relative path to expval within each simulation",
)
parser.add_argument(
"-e",
"--extension",
type=str,
default=".pdf",
help="file extensions for the plots",
)
parser.add_argument("-o",
"--output",
type=str,
help="name of the output directory")
plot.add_argparse_2d_args(parser)
args = parser.parse_args()
if not args.output:
args.output = "_".join(args.expval.with_suffix("").parts)
def apply_args(fig: Figure, ax: Axes, parameters: Parameters):
del parameters
plot.apply_2d_args(ax, fig, args)
load_scan(args.scan_dir).plot_foreach(
args.output,
partial(
plot_expval,
file_path=args.expval,
modfunc=apply_args,
extension=args.extension,
),
)
def action(scan_dir, input_files, targets):
variables, values = load_scan(scan_dir).get_variable_values()
with h5py.File(targets[0], "w") as fptr:
max_depletion = []
max_entropy = []
max_last_orbital = []
for input_file in input_files:
time, data = read_natpop_hdf5(
input_file,
"natpop",
node=self.node,
dof=self.dof,
)
del time
entropy = compute_entropy(data)
max_depletion.append((1 - data[:, 0]).max())
max_entropy.append(entropy.max())
max_last_orbital.append(data[:, -1].max())
dset = fptr.create_dataset(
"max_depletion",
(len(max_depletion), ),
dtype=numpy.float64,
)
dset[:] = max_depletion
dset = fptr.create_dataset(
"max_entropy",
(len(max_entropy), ),
dtype=numpy.float64,
)
dset[:] = max_entropy
dset = fptr.create_dataset(
"max_last_orbital",
(len(max_last_orbital), ),
dtype=numpy.float64,
)
dset[:] = max_last_orbital
grp = fptr.create_group("variables")
for var in variables:
dset = grp.create_dataset(
var,
values[var].shape,
dtype=values[var].dtype,
)
dset[:] = values[var]
def scan_plot_entropy(
scan_dir: Union[Path, str],
propagation: str = "propagate",
node: int = 1,
dof: int = 1,
extensions: List[str] = [
".png",
],
**kwargs,
):
scan_dir = make_path(scan_dir)
plotting_args = PlotArgs2D.from_dict(kwargs)
selection = load_scan(scan_dir)
def plot_func(index, path, parameters):
del path
del parameters
data = read_natpop(
str(scan_dir / "by_index" / str(index) / propagation /
"propagate.h5") + "/natpop",
node=node,
dof=dof,
)
entropy = compute_entropy(data[1])
fig, axis = plt.subplots(1, 1)
plot_entropy(axis, data[0], entropy)
return fig, [axis]
return doit_plot_individual(
selection,
"entropy",
[str(Path(propagation) / "propagate.h5")],
plot_func,
plotting_args,
extensions,
decorator_funcs=kwargs.get("decorator_funcs", []),
)
def scan_plot_gpop(
scan_dir: Union[Path, str],
propagation: str = "propagate",
dof: int = 1,
extensions: List[str] = [
".png",
],
**kwargs,
):
scan_dir = make_path(scan_dir)
plot_name = kwargs.get("plot_name", f"gpop_{dof}")
plotting_args = PlotArgs2D.from_dict(kwargs)
plotting_args.grid = kwargs.get("grid", False)
selection = load_scan(scan_dir)
def plot_func(index, path, parameters):
del path
del parameters
time, grid, density = read_gpop(
str(scan_dir / "by_index" / str(index) / propagation /
"propagate.h5") + "/gpop",
dof=dof,
)
fig, axis = plt.subplots(1, 1)
plot_gpop(axis, time, grid, density)
return fig, [axis]
yield doit_plot_individual(
selection,
plot_name,
[str(Path(propagation) / "propagate.h5")],
plot_func,
plotting_args,
extensions,
decorator_funcs=kwargs.get("decorator_funcs", []),
)
def scan_plot_expval(
scan_dir: Union[Path, str],
expval: Union[Path, str],
extensions: List[str] = [
".png",
],
**kwargs,
):
scan_dir = make_path(scan_dir)
expval = make_path(expval)
kwargs["coefficient"] = kwargs.get("coefficient", 1.0)
plotting_args = PlotArgs2D.from_dict(kwargs)
selection = load_scan(scan_dir)
def plot_func(index, path, parameters):
del path
del parameters
data = read_expval_hdf5(
str((scan_dir / "by_index" / str(index) /
expval).with_suffix(".exp.h5")), )
fig, axis = plt.subplots(1, 1)
plot_expval(axis, *data, **kwargs)
return fig, [axis]
return doit_plot_individual(
selection,
f"expval_{str(expval)}".replace("/", "_"),
[str(expval.with_suffix(".exp.h5"))],
plot_func,
plotting_args,
extensions,
decorator_funcs=kwargs.get("decorator_funcs", []),
extra_args={"coefficient": kwargs["coefficient"]},
)
def __call__(self) -> Dict[str, Any]:
pickle_obj = [self.node, self.dof, self.missing_ok]
pickle_path = self.output_file.with_suffix(".pickle")
pickle_path.parent.mkdir(parents=True, exist_ok=True)
with open(pickle_path, "wb") as fptr:
pickle.dump(pickle_obj, fptr, protocol=3)
def action(scan_dir, input_files, targets):
variables, values = load_scan(scan_dir).get_variable_values()
with h5py.File(targets[0], "w") as fptr:
max_depletion = []
max_entropy = []
max_last_orbital = []
for input_file in input_files:
time, data = read_natpop_hdf5(
input_file,
"natpop",
node=self.node,
dof=self.dof,
)
del time
entropy = compute_entropy(data)
max_depletion.append((1 - data[:, 0]).max())
max_entropy.append(entropy.max())
max_last_orbital.append(data[:, -1].max())
dset = fptr.create_dataset(
"max_depletion",
(len(max_depletion), ),
dtype=numpy.float64,
)
dset[:] = max_depletion
dset = fptr.create_dataset(
"max_entropy",
(len(max_entropy), ),
dtype=numpy.float64,
)
dset[:] = max_entropy
dset = fptr.create_dataset(
"max_last_orbital",
(len(max_last_orbital), ),
dtype=numpy.float64,
)
dset[:] = max_last_orbital
grp = fptr.create_group("variables")
for var in variables:
dset = grp.create_dataset(
var,
values[var].shape,
dtype=values[var].dtype,
)
dset[:] = values[var]
scan_name_sanitized = self.scan_dir.name.replace("=", "_")
scan = load_scan(self.scan_dir)
input_files = [
self.scan_dir / "by_index" / str(i) / self.propagation /
"propagate.h5" for i, _ in scan.parameters
]
yield {
"name":
"{}:natpop:{}_{}:{}:default_analysis".format(
self.propagation,
self.node,
self.dof,
scan_name_sanitized,
),
"file_dep": [pickle_path] + input_files,
"targets": [self.output_file],
"actions": [(action, [self.scan_dir, input_files])],
}
def collect_values(
scan_dir: Union[Path, str],
data_files: List[Union[Path, str]],
output_file: Union[Path, str],
fetch_func,
missing_ok: bool = True,
):
scan_dir = make_path(scan_dir)
data_files = [make_path(p) for p in data_files]
output_file = make_path(output_file)
selection = load_scan(scan_dir)
file_deps = []
for data_file in data_files:
for i, _ in selection.parameters:
p = scan_dir / "by_index" / str(i) / data_file
if missing_ok and p.exists():
file_deps.append(p)
def action_collect_values(scan_dir: Path, targets):
selection = load_scan(scan_dir)
variables = selection.get_variable_names()
def helper(index, path, parameters):
return (
[parameters[variable] for variable in variables],
fetch_func(index, path, parameters),
)
parameters = []
values_lst = []
for param, val in selection.foreach(helper, parallel=False):
if val is not None:
parameters.append(param)
values_lst.append(val)
else:
LOGGER.warning("cannot fetch value(s) for parameters: %s",
str(param))
parameters = numpy.array(parameters, dtype=object)
values = numpy.array(values_lst, dtype=object)
if len(values.shape) == 1:
values = values.reshape((len(values), 1))
elif len(values.shape) == 2:
pass
else:
raise RuntimeError(f"Invalid dimensions {len(values.shape)}")
data = numpy.c_[parameters, values]
header = [variable for variable in variables
] + [f"value{i}" for i in range(values.shape[1])]
Path(targets[0]).parent.mkdir(parents=True, exist_ok=True)
numpy.savetxt(targets[0], data, header=" ".join(header))
yield {
"name":
"{}:collect_values:{}".format(
str(scan_dir.name),
str(output_file.with_suffix("")),
).replace("=", "_").replace("/", "_"),
"targets": [str(output_file)],
"file_dep":
file_deps,
"clean":
True,
"actions": [(action_collect_values, [scan_dir])],
}
