Direct measure calibration step

direct_measure_calibration_step

Attributes

Classes

DirectMeasures

DirectMeasures(
    root_directory: str | Path = root_directory,
    directory_naming_method: DirectoryNamingMethod = NUMBERED,
    working_directory: str | Path = working_directory,
)

Bases: BaseAnalysisTool

A calibration step to identify material properties based on direct measures on experimental data.

A step means that the best measures are searched to match model outputs against N test results for a single load case.

Examples:

>>> from vimseo.tools.example_tool import MyTool
>>> tool = MyTool()
>>> tool.execute()
>>> print(tool.result)
# The result can be saved on disk.
>>> tool.save_results()
# Optionnaly, the current options of the tool can be saved on disk.
>>> tool.result.save_metadata_to_disk()
# The result saved on disk can be loaded.
>>> results = BaseTool.load_results(tool.working_directory /
>>> 'Tool_result.pickle')
# Then, the tool can plot the result. Note that the :meth:`plot_results` method
# takes the result as input. In the future, this method will be moved from the
# tools to a post processor class.
>>> tool.plot_results(results, save=True, show=False)

TODO allow passing pydantic model

Parameters:

• root_directory (str | Path, default: root_directory ) –

  The description is missing.

• directory_naming_method (DirectoryNamingMethod, default: NUMBERED ) –

  The description is missing.

• working_directory (str | Path, default: working_directory ) –

  The description is missing.

Source code in src/vimseo/tools/calibration/direct_measure_calibration_step.py

def __init__(
    self,
    root_directory: str | Path = config.root_directory,
    directory_naming_method: DirectoryNamingMethod = DirectoryNamingMethod.NUMBERED,
    working_directory: str | Path = config.working_directory,
):
    super().__init__(
        root_directory=root_directory,
        directory_naming_method=directory_naming_method,
        working_directory=working_directory,
    )
    self.result = DirectMeasuresResult()

Attributes

grammar property

grammar

The validation grammar.

option_names property

option_names

The names of the options that can be passed to execute().

options property

options

The options of the tool.

results instance-attribute

results: BaseResult | None

The results of the tool.

Functions

execute

execute(
    inputs: DirectMeasuresInputs | None = None,
    settings: DirectMeasuresSettings | None = None,
    **options
) -> DirectMeasuresResult

The user-defined treatment called by :meth:execute.

Parameters:

• options –

  The options of the execution.

Source code in src/vimseo/tools/calibration/direct_measure_calibration_step.py

@BaseCompositeTool.validate
def execute(
    self,
    inputs: DirectMeasuresInputs | None = None,
    settings: DirectMeasuresSettings | None = None,
    **options,
) -> DirectMeasuresResult:

    reference_data = options["reference_data"]
    measures = defaultdict(list)

    for measure_name, measure_settings in options[
        "direct_measure_settings"
    ].items():
        for sample_id in range(reference_data.shape[0]):
            values = vstack([
                reference_data.get_view(
                    variable_names=[
                        measure_settings["x_name"],
                    ]
                ).to_numpy()[sample_id],
                reference_data.get_view(
                    variable_names=[
                        measure_settings["y_name"],
                    ]
                ).to_numpy()[sample_id],
            ]).T
            curve = Curve({
                measure_settings["x_name"]: values[:, 0],
                measure_settings["y_name"]: values[:, 1],
            })
            measures[measure_name].append(
                DirectMeasureFactory()
                .create(measure_settings["measure_name"])
                .compute(curve)
            )
        measures[measure_name] = array(measures[measure_name])

    self.result.direct_measures = measures
    self.result.mean_direct_measures = {
        name: mean(measure) for name, measure in measures.items()
    }

load_options_from_metadata

load_options_from_metadata(
    file_path: str | Path | None = None,
)

Load a result of a tool from the disk.

Parameters:

• file_path (str | Path | None, default: None ) –

  The path to the file.

Source code in src/vimseo/tools/base_tool.py

def load_options_from_metadata(self, file_path: str | Path | None = None):
    """Load a result of a tool from the disk.

    Args:
        file_path: The path to the file.
    """
    file_path = (
        self._working_directory / f"{self.result.__class__.__name__}_metadata.json"
        if file_path is None
        else file_path
    )
    with Path(file_path).open() as f:
        loaded_metadata = json.load(f)
        if ToolResultMetadata._OPTIONS_KEY not in loaded_metadata:
            msg = f"Loaded options must contain the key '{ToolResultMetadata._OPTIONS_KEY}'"
            raise KeyError(msg)
        loaded_options = loaded_metadata[ToolResultMetadata._OPTIONS_KEY]
        if self._has_check_options:
            self._check_options(**loaded_options)
        self._options.update(loaded_options)

load_results classmethod

load_results(path: Path)

Load a result of a tool from the disk.

For a JSON file, only SpaceToolResult is supported. This method must be called from class SpaceTool. JSON format for tool results is deprecated.

Parameters:

• path (Path) –

  The path to the file.

• tool_name –

  The name of the tool associated with the result under stored

Source code in src/vimseo/tools/base_tool.py

@classmethod
def load_results(cls, path: Path):
    """Load a result of a tool from the disk.

    For a `JSON` file, only `SpaceToolResult` is supported.
    This method must be called from class `SpaceTool`.
    `JSON` format for tool results is deprecated.

    Args:
        path: The path to the file.
        tool_name: The name of the tool associated with the result under stored
        in ``path``.
    """
    import h5py

    path = Path(path)
    if path.suffix == ".hdf5":
        class_name = ""
        with h5py.File(path, "r") as f:
            class_name = f.attrs["__class__"]
        tmp_result = ToolResultsFactory().create(class_name)
        return type(tmp_result).from_hdf5(path)
    # TODO remove support for json
    if path.suffix == ".json":
        if cls.__name__ == "BaseTool":
            msg = (
                "Loading tool result from JSON format requires to call "
                "load_results from the tool class associated with the result stored "
                "in the JSON file."
            )
            raise ValueError(msg)
        LOGGER.warning("Loading tool results from JSON format is deprecated.")
        io = IOFactory().create(f"{cls.__name__}FileIO")
        return io.read(
            file_name=path,
        )
    if path.suffix == ".pickle":
        with Path(path).open("rb") as f:
            return pickle.load(f)

    msg = f"Unknow file format {path.suffix}. Supported formats are {cls._RESULT_FORMATS}"
    raise ValueError(msg)

plot_results abstractmethod

plot_results(
    result: BaseResult,
    directory_path: str | Path = "",
    save=False,
    show=True,
    **options
) -> Mapping[str, Figure]

Plot criteria for a given variable name.

Parameters:

• result (BaseResult) –

  The result of the tool.

• directory_path (str | Path, default: '' ) –

  The path under which the plots are saved.

• save –

  Whether to save the plot on disk.

• show –

  Whether to show the plot.

• options –

  The options of the plot.

Source code in src/vimseo/tools/base_tool.py

@abstractmethod
def plot_results(
    self,
    result: BaseResult,
    directory_path: str | Path = "",
    save=False,
    show=True,
    **options,
) -> Mapping[str, Figure]:
    """Plot criteria for a given variable name.

    Args:
        result: The result of the tool.
        directory_path: The path under which the plots are saved.
        save: Whether to save the plot on disk.
        show: Whether to show the plot.
        options: The options of the plot.
    """

save_results

save_results(
    prefix: str = "", file_format: str = "hdf5"
) -> None

Save the results of the tool on disk. The file path is BaseTool.working_directory / {filename}_result.{file_format}.

Args: prefix: The prefix of the filename result.

Parameters:

• prefix (str, default: '' ) –

  The description is missing.

• file_format (str, default: 'hdf5' ) –

  The description is missing.

Source code in src/vimseo/tools/base_composite_tool.py

def save_results(self, prefix: str = "", file_format: str = "hdf5") -> None:
    super().save_results(prefix, file_format=file_format)
    for tool in self._subtools.values():
        tool.save_results(prefix, file_format=file_format)

set_plot

set_plot(class_name, **options) -> None

Set the type of plot to show the results of this tool.

Parameters:

• class_name –

  The name of the plot class.

• **options –

  The options of the plot constructor.

Source code in src/vimseo/tools/base_tool.py

def set_plot(self, class_name, **options) -> None:
    """Set the type of plot to show the results of this tool.

    Args:
        class_name: The name of the plot class.
        **options: The options of the plot constructor.
    """
    if self._plot_factory:
        self._plot = self._plot_factory.create(class_name, **options)
    self._plot_class = class_name