Yaml config files

.gitignore

@@ -3,8 +3,6 @@
 *.pyc
 Untitled.ipynb
 .coverage
-Configuration/
-Experimental_Results/
 */test.ipynb
 
 # These are generated folders for cache

docs/source/requirements.txt

@@ -14,4 +14,5 @@ f4enix >= 0.8.1
 sphinx
 esbonio
 myst-parser
-sphinx_rtd_theme
+sphinx_rtd_theme
+pyyaml

docs/source/usage/configuration.rst

@@ -193,25 +193,35 @@ Computational benchmark post-processing configuration
 It is possible to control (to some extent) the post-processing of each benchmark via its 
 specific configuration file. These files are located in the ``<JADE_root>\Configuration\Benchmarks_Configuration``
 folder and their name must be identical to the one used in the ``File Name`` field in the main configuration file
-(using the .xlsx extension instead of the .i). These files are available only for computational benchmarks,
+(using the .yaml extension instead of the .i). These files are available only for computational benchmarks,
 since the high degree of customization needed for an experimental benchmark makes quite difficult to 
 standardize them. While computational benchmarks can be added to the JADE suite without the need for additional
 coding, this is not true also for experimental one.
 
-The files contain two main sheets, that respectively regulate the Excel and the Word/PDF (i.e., Atlas) post-processing output.
+The files contain two main sections, that respectively regulate the Excel and the Word/PDF (i.e., Atlas) post-processing output.
 
 Excel
 -----
 
-.. image:: ../img/conf/excelbench.png
-    :width: 600
+.. codeblock:: yaml
+
+    # Example of an extract from a benchmark configuration file, Excel section
+    Excel:
+        4.0:
+            cut_y: 20.0
+            identifier: 4
+            x: Energy
+            x_name: Energy [MeV]
+            y: Cells
+            y_name: Cell
+
 
-This sheet regulates the Excel output derived from the benchmark. It consists of a table where each row regulates
-the output of a single tally present in the MCNP input.
+This section regulates the Excel output derived from the benchmark. Each entry 
+corresponds to a different tally present in the input file (tally number).
 
 Hereinafter a description of the available fields is reported.
 
-Tally
+identifier
     tally number according to MCNP input file.
 x, y
     select the binnings to be used for the presentation of the excel results of the specific tally. Clearly,
@@ -254,10 +264,10 @@ x, y
         If a 1D FMESH is defined in the MCNP input, JADE will automatically transform it to a "binned" tally and handle it
         as any other tally using the ``Cor A``, ``Cor B`` or ``Cor C`` field.
 
-x name, y name
+x_name, y_name
     These will be the names associated to the **x** and **y** axis printed in the excel file.
 
-cut Y
+cut_y
     The idea behind JADE is to produce outputs that are easy to investigate simply by scrolling and concentrate on the
     main results highlighted through colors. Having a high number of bins both in the x and y axis may cause a problem
     in this sense, forcing the user to scroll on both axis. For this reason, a maximum number of columns can be set to
@@ -267,30 +277,37 @@ cut Y
 Atlas
 -----
 
-.. image:: ../img/conf/atlasbench.png
-    :width: 600
+.. codeblock:: yaml
+
+    # Example of an extract from a benchmark configuration file, Atlas section
+    Atlas:
+        4:
+            identifier: 4
+            plot_type: Binned graph
+            quantity: Neutron Flux
+            unit: '#/cm^2'
 
 This sheet regulates the Atlas output (Word) derived from the benchmark. It consists of a table where each row regulates
 the output of a single tally present in the input.
 Hereinafter a description of the available fields is reported.
 
-Tally
+identifier
     tally number according to input file.
-Quantity
-    Physical quantity that will be plotted on the y-axis of the plot. For the x-axis the one specified in the Excel sheet
+quantity
+    Physical quantity that will be plotted on the y-axis of the plot. For the x-axis the one specified in the excel section
     under **x** will be considered. The quantity selected for plotting will always be the tallied quantity.
 
     .. important::
-        when two binnings are specified in the Excel sheet, a different plot for each of the **y** bins will be produced.
+        when two binnings are specified in the Excel section, a different plot for each of the **y** bins will be produced.
         For example, let's consider a neutron flux tally binned both in energy (selected as **x**) and cells (selected as **y**).
         Then, a plot showing the neutron flux as a function of energy will be produced for each cell. On the contrary, if the cell
         binning is assigned to **x** and the energy one to **y**, a plot showing the neutron flux as a function of the cell would
         be produced for each energy interval.
-Unit
+unit
     Unit associated to the Quantity.
-<Graph type>
-    Different columns can be added where it can be specified if a plot in the style indicated by the column name
-    should be generated (``true``) or not (``false``). The available plot styles are *Binned graph*, *Ratio Graph*,
+plot_type
+    The type of plot that will be produced.
+    The available plot styles are *Binned graph*, *Ratio Graph*,
     *Experimental points* and *Grouped bars*.
 
     .. seealso::

jade/configuration.py

@@ -21,14 +21,36 @@
 You should have received a copy of the GNU General Public License
 along with JADE.  If not, see <http://www.gnu.org/licenses/>.
 """
+
+from __future__ import annotations
+
 import datetime
 import logging
 import os
 import sys
+from dataclasses import dataclass
+from enum import Enum
 
 import pandas as pd
+import yaml
 
 from jade.exceptions import fatal_exception
+from jade.plotter import PlotType
+
+
+class BinningType(Enum):
+    ENERGY = "Energy"
+    CELLS = "Cells"
+    TIME = "Time"
+    TALLY = "tally"
+    DIR = "Dir"
+    USER = "User"
+    SEGMENTS = "Segments"
+    MULTIPLIER = "Multiplier"
+    COSINE = "Cosine"
+    CORA = "Cor A"
+    CORB = "Cor B"
+    CORC = "Cor C"
 
 
 class Configuration:
@@ -208,3 +230,145 @@
         except KeyError:
             name = suffix
         return name
+
+
+@dataclass
+class ComputationalConfig:
+    """Configuration for a computational benchmark.
+
+    Attributes
+    ----------
+    excel_options : dict[int, ExcelOptions]
+        Options for the Excel benchmark.
+    atlas_options : dict[int, AtlasOptions]
+        Options for the Atlas benchmark.
+    """
+
+    excel_options: dict[int, ExcelOptions]
+    atlas_options: dict[int, AtlasOptions]
+
+    @classmethod
+    def from_yaml(cls, file: str | os.PathLike) -> ComputationalConfig:
+        """Build the configuration for a computational benchmark from a yaml file.
+
+        Parameters
+        ----------
+        file : str | os.PathLike
+            path to the yaml file.
+
+        Returns
+        -------
+        ComputationalConfig
+            The configuration for the computational benchmark.
+        """
+        with open(file) as f:
+            cfg = yaml.safe_load(f)
+
+        atlas_options = {}
+        for key, value in cfg["Atlas"].items():
+            atlas_options[int(key)] = AtlasOptions(**value)
+
+        excel_options = {}
+        for key, value in cfg["Excel"].items():
+            excel_options[int(key)] = ExcelOptions(**value)
+
+        return cls(excel_options=excel_options, atlas_options=atlas_options)
+
+
+@dataclass
+class ExcelOptions:
+    """Dataclass storing options for the Excel benchmark.
+
+    Attributes
+    ----------
+    identifier : int
+        Identifier of the tally.
+    x : BinningType | list[BinningType]
+        Tally dataframe column name to use for x axis. If a list, two binnings are
+        combined together to form a single binning. The only valid combination is
+        Cells-Segments for the moment.
+    x_name : str
+        X axis label.
+    y : BinningType | list[BinningType]
+        Tally dataframe column name to use for y axis. If a list, two binnings are
+        combined together to form a single binning. The only valid combination is
+        Cells-Segments for the moment.
+    y_name : str
+        Y axis label.
+
+    Raises
+    ------
+    ValueError
+        If an invalid BinningType is provided.
+    """
+
+    identifier: int  # identifier of the tally
+    x: BinningType | list[BinningType]  # tally dataframe column name to use for x axis
+    x_name: str  # x label
+    y: BinningType | list[BinningType]  # tally dataframe column name to use for y axis
+    y_name: str  # y label
+    cut_y: int | None = (
+        None  # max number of columns, after that the DF is split and goes to next line
+    )
+
+    def __post_init__(self):
+        # enforce that the binning type is a valid one, try to convert if possible
+        for attribute in [self.x, self.y]:
+            if type(attribute) is str:
+                split = attribute.split("-")
+                if len(split) > 1:
+                    attribute = []
+                    for bintype in split:
+                        try:
+                            attribute.append(BinningType(bintype))
+                        except ValueError:
+                            raise ValueError(f"Invalid binning type: {bintype}")
+                else:
+                    try:
+                        attribute = BinningType(attribute)
+                    except ValueError:
+                        raise ValueError(f"Invalid binning type: {attribute}")
+        # try:
+        #     self.x = BinningType(self.x)
+        # except ValueError:
+        #     raise ValueError(f"Invalid binning type for x: {self.x}")
+        # try:
+        #     self.y = BinningType(self.y)
+        # except ValueError:
+        #     raise ValueError(f"Invalid binning type for y: {self.y}")
+
+
+@dataclass
+class AtlasOptions:
+    """
+    AtlasOptions is a configuration data class for specifying options related to plotting
+    in the Atlas application.
+
+    Attributes
+    ----------
+    identifier : int
+        Identifier of the tally.
+    plot_type : PlotType
+        Type of plot.
+    quantity : str, optional
+        Quantity plotted (goes on the y axis of plots). Default is None.
+    unit : str, optional
+        Unit of the quantity. Default is None.
+
+    Raises
+    ------
+    ValueError
+        if an invalid PlotType is provided.
+    """
+
+    identifier: int  # identifier of the tally
+    plot_type: PlotType  # type of plot
+    quantity: str | None = None  # quantity plotted (goes on the y axis of plots)
+    unit: str | None = None  # unit of the quantity
+
+    def __post_init__(self):
+        # enforce that the plot type is a valid one
+        try:
+            self.plot_type = PlotType(self.plot_type)
+        except ValueError:
+            raise ValueError(f"Invalid plot type: {self.plot_type}")