From b23ffc68de47a384d229b28b8f3536dd66b8a57c Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Thu, 6 Aug 2026 11:03:25 +0200 Subject: [PATCH 01/14] Port over fmudesign source code Examples folder containing xlsx files was leftout --- src/ert/config/fmudesign/__init__.py | 16 + src/ert/config/fmudesign/_designsummary.py | 116 + src/ert/config/fmudesign/_excel_to_dict.py | 768 ++ src/ert/config/fmudesign/config_validation.py | 86 + src/ert/config/fmudesign/create_design.py | 996 ++ .../config/fmudesign/design_distributions.py | 387 + .../examples/ex1_onebyone_rms_repeat.xlsx | Bin 0 -> 14686 bytes .../fmudesign/examples/ex2_correlations.xlsx | Bin 0 -> 26420 bytes .../config/fmudesign/examples/ex2_doe1.xlsx | Bin 0 -> 4985 bytes .../fmudesign/examples/ex3_velocities.xlsx | Bin 0 -> 16802 bytes .../examples/ex4_background_parameters.xlsx | Bin 0 -> 23728 bytes .../config/fmudesign/examples/ex4_doe1.xlsx | Bin 0 -> 4985 bytes .../examples/ex5_single_reference.xlsx | Bin 0 -> 17137 bytes .../ex6_singlereference_and_seed.xlsx | Bin 0 -> 17328 bytes .../examples/ex7_background_no_seed.xlsx | Bin 0 -> 25277 bytes .../config/fmudesign/examples/ex7_doe1.xlsx | Bin 0 -> 4985 bytes .../examples/ex8_mc_with_correls.xlsx | Bin 0 -> 23478 bytes .../examples/fmudesign_ex_montecarlo.xlsx | Bin 0 -> 24097 bytes .../examples/fmudesign_ex_onebyone.xlsx | Bin 0 -> 16138 bytes src/ert/config/fmudesign/fmudesignrunner.py | 356 + src/ert/config/fmudesign/quality_report.py | 629 ++ src/ert/config/fmudesign/utils.py | 216 + .../unit_tests/config/fmudesign/__init__.py | 0 .../config/fmudesign/data/README.md | 4 + .../fmudesign/data/config/correlations.xlsx | Bin 0 -> 4723 bytes .../data/config/design_input_background.xlsx | Bin 0 -> 31540 bytes .../design_input_background_extseeds.xlsx | Bin 0 -> 30231 bytes .../design_input_background_no_seed.xlsx | Bin 0 -> 30300 bytes .../config/design_input_corr_discrete.xlsx | Bin 0 -> 24025 bytes .../config/design_input_default_no_seed.xlsx | Bin 0 -> 22182 bytes .../data/config/design_input_example1.xlsx | Bin 0 -> 16773 bytes .../data/config/design_input_example2.xlsx | Bin 0 -> 25192 bytes .../design_input_example_velocities.xlsx | Bin 0 -> 21899 bytes .../design_input_many_correlations.xlsx | Bin 0 -> 18882 bytes .../config/design_input_mc_with_correls.xlsx | Bin 0 -> 28694 bytes .../design_input_multiple_dependencies.xlsx | Bin 0 -> 27793 bytes .../data/config/design_input_onebyone.xlsx | Bin 0 -> 30495 bytes .../config/design_input_singlereference.xlsx | Bin 0 -> 22183 bytes ...design_input_singlereference_and_seed.xlsx | Bin 0 -> 22326 bytes .../config/fmudesign/data/config/doe1.xlsx | Bin 0 -> 4985 bytes .../data/config/generateddesignmatrix.xlsx | Bin 0 -> 14985 bytes .../config/fmudesign/data/config/seeds.csv | 100 + .../config/fmudesign/data/config/seeds.txt | 5 + .../config/fmudesign/data/config/seeds.xlsx | Bin 0 -> 5208 bytes .../fmudesign/data/distributions/design.csv | 111 + .../fmudesign/data/distributions/design.xlsx | Bin 0 -> 14391 bytes .../data/distributions/designsummary.csv | 8 + .../design_output_mc_with_correls.json | 9023 +++++++++++++++++ .../config/fmudesign/test_create_design.py | 685 ++ .../config/fmudesign/test_designmatrix.py | 154 + .../config/fmudesign/test_designsummary.py | 53 + .../config/fmudesign/test_excel_to_dict.py | 249 + .../config/fmudesign/test_use_cases.py | 224 + 53 files changed, 14186 insertions(+) create mode 100644 src/ert/config/fmudesign/__init__.py create mode 100644 src/ert/config/fmudesign/_designsummary.py create mode 100644 src/ert/config/fmudesign/_excel_to_dict.py create mode 100644 src/ert/config/fmudesign/config_validation.py create mode 100644 src/ert/config/fmudesign/create_design.py create mode 100644 src/ert/config/fmudesign/design_distributions.py create mode 100644 src/ert/config/fmudesign/examples/ex1_onebyone_rms_repeat.xlsx create mode 100644 src/ert/config/fmudesign/examples/ex2_correlations.xlsx create mode 100644 src/ert/config/fmudesign/examples/ex2_doe1.xlsx create mode 100644 src/ert/config/fmudesign/examples/ex3_velocities.xlsx create mode 100644 src/ert/config/fmudesign/examples/ex4_background_parameters.xlsx create mode 100644 src/ert/config/fmudesign/examples/ex4_doe1.xlsx create mode 100644 src/ert/config/fmudesign/examples/ex5_single_reference.xlsx create mode 100644 src/ert/config/fmudesign/examples/ex6_singlereference_and_seed.xlsx create mode 100644 src/ert/config/fmudesign/examples/ex7_background_no_seed.xlsx create mode 100644 src/ert/config/fmudesign/examples/ex7_doe1.xlsx create mode 100644 src/ert/config/fmudesign/examples/ex8_mc_with_correls.xlsx create mode 100644 src/ert/config/fmudesign/examples/fmudesign_ex_montecarlo.xlsx create mode 100644 src/ert/config/fmudesign/examples/fmudesign_ex_onebyone.xlsx create mode 100644 src/ert/config/fmudesign/fmudesignrunner.py create mode 100644 src/ert/config/fmudesign/quality_report.py create mode 100644 src/ert/config/fmudesign/utils.py create mode 100644 tests/ert/unit_tests/config/fmudesign/__init__.py create mode 100644 tests/ert/unit_tests/config/fmudesign/data/README.md create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/correlations.xlsx create mode 100755 tests/ert/unit_tests/config/fmudesign/data/config/design_input_background.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/design_input_background_extseeds.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/design_input_background_no_seed.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/design_input_corr_discrete.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/design_input_default_no_seed.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/design_input_example1.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/design_input_example2.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/design_input_example_velocities.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/design_input_many_correlations.xlsx create mode 100755 tests/ert/unit_tests/config/fmudesign/data/config/design_input_mc_with_correls.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/design_input_multiple_dependencies.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/design_input_onebyone.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/design_input_singlereference.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/design_input_singlereference_and_seed.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/doe1.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/generateddesignmatrix.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/seeds.csv create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/seeds.txt create mode 100644 tests/ert/unit_tests/config/fmudesign/data/config/seeds.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/distributions/design.csv create mode 100755 tests/ert/unit_tests/config/fmudesign/data/distributions/design.xlsx create mode 100644 tests/ert/unit_tests/config/fmudesign/data/distributions/designsummary.csv create mode 100644 tests/ert/unit_tests/config/fmudesign/snapshots/test_create_design/test_generate_full_mc_snapshot/design_output_mc_with_correls.json create mode 100644 tests/ert/unit_tests/config/fmudesign/test_create_design.py create mode 100644 tests/ert/unit_tests/config/fmudesign/test_designmatrix.py create mode 100644 tests/ert/unit_tests/config/fmudesign/test_designsummary.py create mode 100644 tests/ert/unit_tests/config/fmudesign/test_excel_to_dict.py create mode 100644 tests/ert/unit_tests/config/fmudesign/test_use_cases.py diff --git a/src/ert/config/fmudesign/__init__.py b/src/ert/config/fmudesign/__init__.py new file mode 100644 index 00000000000..ef5fe374476 --- /dev/null +++ b/src/ert/config/fmudesign/__init__.py @@ -0,0 +1,16 @@ +""" +Used for pre and processing of ert sensitivities, such as +setting up design matrix to run single sensitivities with ERT. +Output of this module can be used in custom standalone applications. +""" + +from semeio.fmudesign._designsummary import summarize_design +from semeio.fmudesign._excel_to_dict import excel_to_dict, inputdict_to_yaml +from semeio.fmudesign.create_design import DesignMatrix + +__all__ = [ + "DesignMatrix", + "excel_to_dict", + "inputdict_to_yaml", + "summarize_design", +] diff --git a/src/ert/config/fmudesign/_designsummary.py b/src/ert/config/fmudesign/_designsummary.py new file mode 100644 index 00000000000..4cbe754325b --- /dev/null +++ b/src/ert/config/fmudesign/_designsummary.py @@ -0,0 +1,116 @@ +"""Module for summarizing design set up for one by one sensitivities""" + +import pandas as pd + + +def _get_sensitivity_type(senscase: str) -> str: + """Determine sensitivity type based on the case name""" + sensitivity_types = {"p10_p90": "mc", "ref": "ref"} + return sensitivity_types.get(senscase.lower(), "scalar") + + +def summarize_design(filename: str, sheetname: str = "DesignSheet01") -> pd.DataFrame: + """ + Summarizes the design set up for one by one sensitivities + specified in a design matrix on standard fmu format. + + Args: + filename (str): Name of excel or csv file containing designmatrix + for one by one sensitivities on standard FMU format. + sheetname (str): Name of sheet in excel workbook which + contains the designmatrix (only for excel input). Defaults to + 'DesignSheet01'. + + Returns: + pd.DataFrame: Summary of sensitivities, + corresponding realisation numbers, + senstype('mc' or 'scalar') + and senscase (name of high and low cases). + Each row represents one sensitivity + with 1-2 cases (low/high). + Column names are ['sensno', 'sensname', + 'senstype', 'casename1', 'startreal1', 'endreal1', + 'casename2', 'startreal2', 'endreal2'] + + Example: + >> from semeio.fmudesign import summarize_design + >> designname = 'design_filename.xlsx' + >> designsheet = 'DesignSheet01' + >> designtable = summarize_design(designname, designsheet) + + """ + + # Read design matrix + if str(filename).endswith(".xlsx"): + # Drop empty rows or columns that have been read in + # due to having background colour/formatting + dgn = ( + pd.read_excel(filename, sheetname, engine="openpyxl") + .dropna(axis=0, how="all") + .loc[:, lambda df: ~df.columns.str.contains("^Unnamed")] + ) + elif str(filename).endswith(".csv"): + dgn = pd.read_csv(filename) + else: + raise ValueError( + "Design matrix must be on Excel or csv format" + " and filename must end with .xlsx or .csv" + ) + + # Initialize results DataFrame with same columns + designsummary = pd.DataFrame( + columns=[ + "sensno", + "sensname", + "senstype", + "casename1", + "startreal1", + "endreal1", + "casename2", + "startreal2", + "endreal2", + ] + ) + + # Get unique sensitivity names in order of appearance + sensnames = dgn["SENSNAME"].unique() + + for sensno, sensname in enumerate(sensnames): + sens_group = dgn[dgn["SENSNAME"] == sensname].copy() + # Get cases in order of appearance + cases = ( + sens_group.drop_duplicates("SENSCASE")[["SENSCASE"]].to_numpy().flatten() + ) + + # First case + case1_data = sens_group[sens_group["SENSCASE"] == cases[0]] + casename1 = cases[0] + startreal1 = case1_data["REAL"].min() + endreal1 = case1_data["REAL"].max() + + # Handle second case if it exists + if len(cases) > 1: + case2_data = sens_group[sens_group["SENSCASE"] == cases[1]] + casename2 = cases[1] + startreal2 = case2_data["REAL"].min() + endreal2 = case2_data["REAL"].max() + else: + casename2 = None + startreal2 = None + endreal2 = None + + senstype = _get_sensitivity_type(cases[0]) + # Add row to results + designsummary.loc[sensno] = [ + sensno, + sensname, + senstype, + casename1, + startreal1, + endreal1, + casename2, + startreal2, + endreal2, + ] + + return designsummary diff --git a/src/ert/config/fmudesign/_excel_to_dict.py b/src/ert/config/fmudesign/_excel_to_dict.py new file mode 100644 index 00000000000..3c48bed499f --- /dev/null +++ b/src/ert/config/fmudesign/_excel_to_dict.py @@ -0,0 +1,768 @@ +"""This module contains functions for reading Excel config files. +These are converted to a dict-of-dicts representation, then they are used +by the DesignMatrix class to generate design matrices. +""" + +import collections +import contextlib +import math +from collections import Counter +from collections.abc import Hashable, Sequence +from pathlib import Path +from typing import Any, cast + +import numpy as np +import openpyxl +import pandas as pd +import yaml + +from semeio.fmudesign.design_distributions import read_correlations +from semeio.fmudesign.utils import seeds_from_extern + + +def excel_to_dict( + input_filename: str, + *, + gen_input_sheet: str = "general_input", + design_input_sheet: str = "designinput", + default_val_sheet: str = "defaultvalues", +) -> dict[str, Any]: + """Read excel file with input to design setup + + Args: + input_filename (str): Name of excel input file + gen_input_sheet (str): Sheet name for general input + design_input_sheet (str): Sheet name for design input + default_val_sheet (str): Sheet name for default input + + Returns: + dict on format for DesignMatrix.generate + """ + # To be backwards compatible, we do not change the input arg names + general_input_sheet = gen_input_sheet + default_values_sheet = default_val_sheet + + # Find sheets + _assert_no_merged_cells(input_filename) + xlsx = openpyxl.load_workbook(input_filename, read_only=True, keep_links=False) + general_input_sheet = find_sheet(general_input_sheet, names=xlsx.sheetnames) + design_input_sheet = find_sheet(design_input_sheet, names=xlsx.sheetnames) + default_values_sheet = find_sheet(default_values_sheet, names=xlsx.sheetnames) + + generalinput = ( + pd.read_excel( + input_filename, + general_input_sheet, + header=None, + index_col=0, + engine="openpyxl", + ) + .dropna(axis=0, how="all") + .dropna(axis=1, how="all") + .loc[:, 1] + .to_dict() + ) + + if (design_type := generalinput.get("designtype")) != "onebyone": + raise ValueError( + "Generation of DesignMatrix only implemented " + f"for type 'onebyone', not {design_type}" + ) + + return _excel_to_dict_onebyone( + input_filename=input_filename, + general_input_sheet=general_input_sheet, + design_input_sheet=design_input_sheet, + default_values_sheet=default_values_sheet, + ) + + +def inputdict_to_yaml(inputdict: dict[str, Any], filename: str) -> None: + """Write inputdict to yaml format + + Args: + inputdict (dict) + filename (str): name of output file + """ + with Path(filename).open("w", encoding="utf-8") as stream: + yaml.dump(inputdict, stream) + + +def find_sheet(name: str, names: list[str]) -> str: + """Search for Excel sheets with a soft matching. Raises ValueError if zero + or more than one match is found. + + Examples: + >>> find_sheet('general_input', ['generalinput', 'designinput', 'defaultinput']) + 'generalinput' + >>> find_sheet('variable_input', ['generalinput', 'designinput', 'defaultinput']) + Traceback (most recent call last): + ... + ValueError: No match for variable_input: ['generalinput', 'designinput', 'defaultinput'] + """ # noqa: E501 + + def sanitize(inputstring: str) -> str: + return inputstring.lower().strip().replace("_", "") + + found = [name_i for name_i in names if sanitize(name) == sanitize(name_i)] + if len(found) > 1: + raise ValueError(f"More than one match for {name}: {found}") + if len(found) == 0: + raise ValueError(f"No match for {name}: {names}") + return found[0] + + +def _check_designinput(dsgn_input: pd.DataFrame) -> None: + """Checks for valid input in designinput sheet""" + # Filter out rows where sensname has no value + valid_sensnames = dsgn_input["sensname"].dropna() + duplicated_mask = valid_sensnames.duplicated() + + if duplicated_mask.any(): + # Find the first duplicate to include in error message + duplicate_name = valid_sensnames[duplicated_mask].iloc[0] + raise ValueError( + f"sensname '{duplicate_name}' was found on more than one row in " + "designinput sheet. Two sensitivities can not share the same sensname. " + "Please correct this and rerun" + ) + + # Check for duplicate parameter names within each sensname + for sensname, df_sensname in dsgn_input.ffill().groupby("sensname"): + param_names = list(df_sensname["param_name"]) + try: + _raise_if_duplicates(param_names) + except ValueError as e: + raise ValueError(f"Duplicate param names in {sensname}\n{e}") from e + + +def _check_for_mixed_sensitivities(sens_name: str, sens_group: pd.DataFrame) -> None: + """Checks for valid input in designinput sheet. A sensitivity cannot contain + two different sensitivity types""" + + unique_types = sens_group["type"].dropna().unique() + if len(unique_types) > 1: + raise ValueError( + f"The sensitivity with sensname '{sens_name}' in designinput sheet " + "contains more than one sensitivity type. For each sensname all parameters " + "must be specified using the same type (seed, scenario, dist, ref, " + "background, extern)" + ) + + +def resolve_path(input_filename: str, reference: str | None) -> str | None: + """The path `input_filename` is an Excel sheet, and `reference` is a cell + value that *might* be a reference to another file. Resolve the path to + `reference` and return. If no such file exists, return `reference`. + """ + # The reference is None, so just return it back + if reference is None: + return reference + + # It's a string but not a reference to another file + if not str(reference).endswith(("xlsx", "csv")): + return reference + + # If the reference is e.g. 'C:/Users/USER/files/doe1.xlsx' + reference_path = Path(reference) + if reference_path.is_absolute() and reference_path.exists(): + return str(reference_path.resolve()) + + # If the reference is e.g. 'doe1.xlsx' + full_path = Path(input_filename).parent / reference_path + if full_path.exists(): + return str(full_path.resolve()) + + if reference_path.exists(): + return str(reference_path.resolve()) + + raise ValueError(f"Failed to resolve path for file: {reference}") + + +def _excel_to_dict_onebyone( + input_filename: str, + *, + general_input_sheet: str, + design_input_sheet: str, + default_values_sheet: str, +) -> dict[str, Any]: + """Reads configuration from Excel file for a onebyone design matrix. + + Args: + input_filename (str): Name of excel workbook + general_input_sheet (str): name of general input sheet + design_input_sheet (str): name of design input sheet + default_values_sheet (str): name of default value sheet + + Returns: + dict on format for DesignMatrix.generate + """ + output: dict[str, Any] = { + "input_file": input_filename + } # This is the config that we read and return + + # Read the general input sheet to a dictionary + generalinput = ( + pd.read_excel( + input_filename, + general_input_sheet, + header=None, + engine="openpyxl", + ) + .dropna(axis=0, how="all") + .dropna(axis=1, how="all") + .set_index(0) + .loc[:, 1] + .to_dict() + ) + + def parse_value(value: object) -> object: + if pd.isna(value): # type: ignore[call-overload] + return None + if isinstance(value, str): + return value.strip() + return value + + # Convert NaN values to None and strip other values + generalinput = { + str(key).strip(): parse_value(value) for (key, value) in generalinput.items() + } + + # Check that there are no wrong keys or typos, e.g. 'repets' + ALLOWED_KEYS = { + "designtype", + "repeats", + "correlation_iterations", + "distribution_seed", + "rms_seeds", + "background", + } + extra_keys = set(generalinput.keys()) - set(ALLOWED_KEYS) + if extra_keys: + msg = ( + "In the general input sheet, the following parameter(s) are not" + f"recognized and cannot be parsed:\n{extra_keys!r}\n" + f"Allowed keys:{ALLOWED_KEYS!r}" + ) + raise LookupError(msg) + + # Copy keys over if they exist + keys = ["designtype", "repeats", "correlation_iterations", "distribution_seed"] + for key in keys: + if key not in generalinput: + continue + output[key] = generalinput[key] + + # Copy the 'rms_seeds' key over. It is called 'seeds' further down in + # the code for historical reasons. + key = "seeds" + with contextlib.suppress(KeyError): + output[key] = generalinput["rms_seeds"] + + # If 'seeds' / 'rms_seed' is a file, then read it + if key in output: + maybe_path = resolve_path(input_filename, output[key]) + if isinstance(maybe_path, str) and Path(maybe_path).exists(): + output[key] = seeds_from_extern(maybe_path) + + # If 'background' is a file, then read it + key = "background" + output[key] = {} + try: + value = str(generalinput[key]) + if value.endswith(("csv", "xlsx")): + output[key]["extern"] = resolve_path(input_filename, value) + else: + output[key] = _read_background(input_filename, value) + except KeyError: + output[key] = None + except ValueError: + output[key] = generalinput[key] + + output["defaultvalues"] = _read_defaultvalues(input_filename, default_values_sheet) + + output["sensitivities"] = {} + designinput = ( + pd.read_excel(input_filename, design_input_sheet, engine="openpyxl") + .dropna(axis=0, how="all") + .loc[:, lambda df: ~df.columns.astype(str).str.contains("^Unnamed")] + ) + + # Strip strings in column 'sensname' while preserving NaN values + designinput = designinput.assign(sensname=lambda df: df["sensname"].str.strip()) + + _check_designinput(designinput) + + designinput["sensname"] = designinput["sensname"].ffill() + + if "decimals" in designinput: + # Convert to numeric, then filter for integers + numeric_decimals = pd.to_numeric(designinput["decimals"], errors="coerce") + mask = numeric_decimals.notna() & (numeric_decimals % 1 == 0) + + valid_decimals = designinput[mask] + output["decimals"] = { + row.param_name: int(cast("float", row.decimals)) + for row in valid_decimals.itertuples() + } + + grouped = designinput.groupby("sensname", sort=False) + + # Read each sensitivity + for sensname, group in grouped: + _check_for_mixed_sensitivities( + str(sensname), + group, + ) + + sensdict: dict[str, Any] = {} + + sens_type = group["type"].iloc[0] + if sens_type in {"ref", "background"}: + sensdict["senstype"] = sens_type + + elif sens_type == "seed": + sensdict["seedname"] = "RMS_SEED" + sensdict["senstype"] = sens_type + if _has_value(group["param_name"].iloc[0]): + sensdict["parameters"] = _read_constants(group) + else: + sensdict["parameters"] = None + + elif sens_type == "scenario": + sensdict = _read_scenario_sensitivity(group) + sensdict["senstype"] = sens_type + + elif sens_type == "dist": + sensdict["senstype"] = sens_type + sensdict["parameters"] = _read_dist_sensitivity(group) + sensdict["correlations"] = None + if "corr_sheet" in group: + sensdict["correlations"] = _read_correlations(group, input_filename) + + elif sens_type == "extern": + sensdict["extern_file"] = resolve_path( + input_filename, str(group["extern_file"].iloc[0]) + ) + sensdict["senstype"] = sens_type + sensdict["parameters"] = list(group["param_name"]) + + else: + raise ValueError( + f"Sensitivity {sensname} does not have a valid sensitivity type" + ) + + if "numreal" in group and _has_value(group["numreal"].iloc[0]): + # Using default number of realisations: + # 'repeats' from general_input sheet + sensdict["numreal"] = int(group["numreal"].iloc[0]) + + # If this sensitivity has dependencies, then get them from sheet + sensdict["dependencies"] = {} + if "dependencies" in group: + # Get all dependencies in this sensitivity + valid_deps = group[group["dependencies"].notna()] + dependencies_dict = {} + + # For each dependency, get the mapping + for row in valid_deps.itertuples(): + dependencies_dict[row.param_name] = _read_dependencies( + filename=input_filename, + sheetname=str(row.dependencies), + from_parameter=str(row.param_name), + ) + sensdict["dependencies"] = dependencies_dict + + # Add this sensitivity to the sensitivities + output["sensitivities"][str(sensname)] = sensdict + + return output + + +def _read_defaultvalues(filename: str, sheetname: str) -> dict[str, Any]: + """Reads defaultvalues, also used as values for + reference/base case + + Args: + filename (str): Name of excel file + sheetname (string): name of defaultsheet + + Returns: + dict with defaultvalues (parameter, value) + """ + default_df = ( + pd.read_excel(filename, sheetname, header=0, index_col=0, engine="openpyxl") + .dropna(axis=0, how="all") + # Drop all unnamed columns from the df + .loc[:, lambda df: ~df.columns.astype(str).str.contains("^Unnamed")] + ) + + if default_df.empty: + return {} + + # Strip leading/trailing spaces from parameter names such that + # for example " PARAM" and "PARAM" are treated as duplicates. + default_df.index = default_df.index.str.strip() + + # Check for duplicates and raise error if found + duplicates = default_df.index.duplicated(keep=False) + if duplicates.any(): + duplicate_names = default_df.index[duplicates].unique() + raise ValueError( + f"Duplicate parameter names found in sheet '{sheetname}': " + f"{', '.join(duplicate_names)}. All parameter names must be unique." + ) + + return {str(k): v for k, v in default_df.iloc[:, 0].to_dict().items()} + + +def _read_dependencies( + *, filename: str, sheetname: str, from_parameter: str +) -> dict[str, Any]: + """Reads parameters that are set from other parameters + + Args: + filename(str): name of excel file + sheetname (string): name of dependency sheet + from_parameter (string): parameter name to map from + + Returns: + dict with design parameter, dependent parameters + and values + """ + depend_dict: dict[str, Any] = {} + depend_df = ( + pd.read_excel(filename, sheetname, dtype=str, na_values="", engine="openpyxl") + .dropna(axis=0, how="all") + .loc[:, lambda df: ~df.columns.astype(str).str.contains("^Unnamed")] + ) + + if from_parameter in depend_df: + depend_dict["from_values"] = depend_df[from_parameter].tolist() + depend_dict["to_params"] = {} + for key in depend_df: + if key != from_parameter: + depend_dict["to_params"][key] = depend_df[key].tolist() + else: + raise ValueError( + f"Parameter {from_parameter} specified to have derived parameters, " + f"but the sheet specifying the dependencies {sheetname} does " + "not contain the input parameter. " + ) + return depend_dict + + +def _read_background(inp_filename: str, bck_sheet: str) -> dict[str, Any]: + """Reads excel sheet with background parameters and distributions + + Args: + inp_filename (str): name of Excel workbook + bck_sheet (str): name of sheet with background parameters + + Returns: + dict with parameter names and distributions + """ + backdict: dict[str, Any] = {} + paramdict: dict[str, Any] = {} + bck_input = ( + pd.read_excel(inp_filename, bck_sheet, engine="openpyxl") + .dropna(axis=0, how="all") + .loc[:, lambda df: ~df.columns.astype(str).str.contains("^Unnamed")] + ) + + backdict["correlations"] = None + if "corr_sheet" in bck_input: + backdict["correlations"] = _read_correlations(bck_input, inp_filename) + + if "dist_param1" not in bck_input.columns.to_numpy(): + bck_input["dist_param1"] = float("NaN") + if "dist_param2" not in bck_input.columns.to_numpy(): + bck_input["dist_param2"] = float("NaN") + if "dist_param3" not in bck_input.columns.to_numpy(): + bck_input["dist_param3"] = float("NaN") + if "dist_param4" not in bck_input.columns.to_numpy(): + bck_input["dist_param4"] = float("NaN") + + for row in bck_input.itertuples(): + if not _has_value(row.param_name): + raise ValueError( + "Background parameters specified " + "where one line has empty parameter " + "name " + ) + if not _has_value(row.dist_param1): + raise ValueError( + f"Parameter {row.param_name} has been input " + "in background sheet but with empty " + "first distribution parameter " + ) + if not _has_value(row.dist_param2) and _has_value(row.dist_param3): + raise ValueError( + f"Parameter {row.param_name} has been input in " + "background sheet with " + 'value for "dist_param3" while ' + '"dist_param2" is empty. This is not ' + "allowed" + ) + if not _has_value(row.dist_param3) and _has_value(row.dist_param4): + raise ValueError( + f"Parameter {row.param_name} has been input in " + "background sheet with " + 'value for "dist_param4" while ' + '"dist_param3" is empty. This is not ' + "allowed" + ) + distparams = [ + item + for item in [ + row.dist_param1, + row.dist_param2, + row.dist_param3, + row.dist_param4, + ] + if _has_value(item) + ] + if "corr_sheet" in bck_input: + corrsheet = None if not _has_value(row.corr_sheet) else row.corr_sheet + else: + corrsheet = None + paramdict[str(row.param_name)] = [str(row.dist_name), distparams, corrsheet] + backdict["parameters"] = paramdict + + if "decimals" in bck_input: + decimals: dict[str, Any] = {} + for row in bck_input.itertuples(): + if _has_value(row.decimals) and _is_int(row.decimals): # type: ignore[arg-type] + decimals[row.param_name] = int(row.decimals) # type: ignore[arg-type, index] + backdict["decimals"] = decimals + + return backdict + + +def _read_scenario_sensitivity(sensgroup: pd.DataFrame) -> dict[str, Any]: + """Reads parameters and values + for scenario sensitivities + """ + sdict: dict[str, Any] = {} + sdict["cases"] = {} + casedict1: dict[str, Any] = {} + casedict2: dict[str, Any] = {} + + if not _has_value(sensgroup["senscase1"].iloc[0]): + raise ValueError( + "Sensitivity {} has been input " + "as a scenario sensitivity, but " + "without a name in senscase1 column.".format(sensgroup["sensname"].iloc[0]) + ) + + for row in sensgroup.itertuples(): + if not _has_value(row.param_name): + raise ValueError( + f"Scenario sensitivity {row.sensname} specified " + "where one line has empty parameter " + "name " + ) + if not _has_value(row.value1): + raise ValueError( + f"Parameter {row.param_name} has been input " + 'as type "scenario" but with empty ' + "value in value1 column " + ) + casedict1[str(row.param_name)] = row.value1 + + if _has_value(sensgroup["senscase2"].iloc[0]): + for row in sensgroup.itertuples(): + if not _has_value(row.value2): + raise ValueError( + "Sensitivity {} has been input " + "with a name in senscase2 column " + "but without a value for parameter {} " + "in value2 column.".format( + sensgroup["sensname"].iloc[0], row.param_name + ) + ) + casedict2[str(row.param_name)] = row.value2 + sdict["cases"][str(sensgroup["senscase1"].iloc[0])] = casedict1 + sdict["cases"][str(sensgroup["senscase2"].iloc[0])] = casedict2 + else: + for row in sensgroup.itertuples(): + if _has_value(row.value2): + raise ValueError( + "Sensitivity {} has been input " + "with a value for parameter {} " + "in value2 column " + "but without a name for the scenario " + "in senscase2 column.".format( + sensgroup["sensname"].iloc[0], row.param_name + ) + ) + sdict["cases"][str(sensgroup["senscase1"].iloc[0])] = casedict1 + return sdict + + +def _read_constants(sensgroup: pd.DataFrame) -> dict[str, Any]: + """Reads constants to be used together with + seed sensitivity""" + if "dist_param1" not in sensgroup.columns.to_numpy(): + sensgroup["dist_param1"] = float("NaN") + paramdict: dict[str, Any] = {} + for row in sensgroup.itertuples(): + if not _has_value(row.dist_param1): + raise ValueError( + f"Parameter name {row.param_name} has been input " + 'in a sensitivity of type "seed". \n' + f"If {row.param_name} was meant to be the name of " + "the seed parameter, this is " + "unfortunately not allowed. " + "The seed parameter name is standardised " + "to RMS_SEED and should not be specified.\n " + "If you instead meant to specify a constant " + "value for another parameter in the seed " + 'sensitivity, please remember "const" in ' + 'dist_name and a value in "dist_param1". ' + ) + distparams = row.dist_param1 + paramdict[str(row.param_name)] = [str(row.dist_name), distparams] + return paramdict + + +def _read_dist_sensitivity(sensgroup: pd.DataFrame) -> dict[str, Any]: + """Reads parameters and distributions + for monte carlo sensitivities + """ + if "dist_param1" not in sensgroup.columns.to_numpy(): + sensgroup["dist_param1"] = float("NaN") + if "dist_param2" not in sensgroup.columns.to_numpy(): + sensgroup["dist_param2"] = float("NaN") + if "dist_param3" not in sensgroup.columns.to_numpy(): + sensgroup["dist_param3"] = float("NaN") + if "dist_param4" not in sensgroup.columns.to_numpy(): + sensgroup["dist_param4"] = float("NaN") + paramdict: dict[str, Any] = {} + for row in sensgroup.itertuples(): + if not _has_value(row.param_name): + raise ValueError( + f"Dist sensitivity {row.sensname} specified " + "where one line has empty parameter " + "name " + ) + if not _has_value(row.dist_param1): + raise ValueError( + f"Parameter {row.param_name} has been input " + 'as type "dist" but with empty ' + "first distribution parameter " + ) + if not _has_value(row.dist_param2) and _has_value(row.dist_param3): + raise ValueError( + f"Parameter {row.param_name} has been input with " + 'value for "dist_param3" while ' + '"dist_param2" is empty. This is not ' + "allowed" + ) + if not _has_value(row.dist_param3) and _has_value(row.dist_param4): + raise ValueError( + f"Parameter {row.param_name} has been input with " + 'value for "dist_param4" while ' + '"dist_param3" is empty. This is not ' + "allowed" + ) + distparams = [ + item + for item in [ + row.dist_param1, + row.dist_param2, + row.dist_param3, + row.dist_param4, + ] + if _has_value(item) + ] + if "corr_sheet" in sensgroup: + corrsheet = None if not _has_value(row.corr_sheet) else row.corr_sheet + else: + corrsheet = None + paramdict[str(row.param_name)] = [str(row.dist_name), distparams, corrsheet] + + return paramdict + + +def _read_correlations( + sensgroup: pd.DataFrame, inputfile: str +) -> dict[str, Any] | None: + """Parse correlation information from a sensitivity group.""" + + # No correlation sheet column exists + if "corr_sheet" not in sensgroup.columns: + return None + + # The column exists, but it is all blank + if sensgroup["corr_sheet"].dropna().empty: + return None + + correlations: dict[str, Any] = {"inputfile": inputfile} + + # Create a mapping 'corr_to_params' like: + # {'corr1': ['var_A', 'var_B', ...], ...} + corr_to_params = collections.defaultdict(list) + for _, row in sensgroup.iterrows(): + if not _has_value(row["corr_sheet"]): + continue + corr_to_params[row["corr_sheet"]].append(row["param_name"]) + + # Open the correlation sheet and peek at it + # We want to verify that if variables ['A', 'B'] point to the corr sheet, + # then exactly those variables are also defined in the sheet + for corr_sheet, parameters in corr_to_params.items(): + df_corr = read_correlations(excel_filename=inputfile, corr_sheet=corr_sheet) + if set(df_corr.columns) != set(parameters): + sensname = sensgroup["sensname"].iloc[0] + msg = f"Mismatch between parameters in sensitivity group {sensname!r} " + msg += f"pointing to\ncorrelation sheet {corr_sheet!r} and " + msg += "parameters specified in that correlation sheet.\n" + msg += f"Parameters in sensitivity group: {sorted(set(parameters))}\n" + msg += f"Parameters in correlation sheet: {sorted(set(df_corr.columns))}\n" + msg += "These parameters must be specified one-to-one." + raise ValueError(msg) + + correlations["sheetnames"] = list(set(corr_to_params.keys())) + + return correlations + + +def _has_value(value: Any) -> bool: # noqa: ANN401 + """Returns False only if the argument is np.nan""" + try: + return not np.isnan(value) + except TypeError: + return True + + +def _is_int(teststring: str) -> bool: + """Test if string is a finite integer""" + try: + if not np.isnan(int(teststring)): + return math.isclose((float(teststring) % 1), 0, abs_tol=1e-14) + return False # It was a "number", but it was NaN. + except ValueError: + return False + + +def _raise_if_duplicates(container: Sequence[Hashable]) -> None: + """Raises a descriptive error if there are duplicates in the container.""" + duplicates = {k: v for (k, v) in Counter(container).items() if v > 1} + if duplicates: + raise ValueError(f"Duplicates with counts: {duplicates}") + + +def _assert_no_merged_cells(input_filename: str) -> None: + """Raises an exception if any merged cells exist, else returns None.""" + + workbook = openpyxl.load_workbook(input_filename) + for sheet_name in workbook.sheetnames: + worksheet = workbook[sheet_name] + merged_ranges = list(worksheet.merged_cells.ranges) + if merged_ranges: + raise Exception( + "Merged cells are not allowed. Found merged cell in " + f"{input_filename} at sheet '{sheet_name}'.\n" + f"Found {len(merged_ranges)} merged cell range(s): {merged_ranges}" + ) diff --git a/src/ert/config/fmudesign/config_validation.py b/src/ert/config/fmudesign/config_validation.py new file mode 100644 index 00000000000..7c8dd6a8743 --- /dev/null +++ b/src/ert/config/fmudesign/config_validation.py @@ -0,0 +1,86 @@ +""" +Module for validation of config (typically read from Excel). +""" + +import copy +import numbers +from typing import Any + + +def validate_configuration( + config: dict[str, Any], verbosity: int = 0 +) -> dict[str, Any]: + """Main function for config validation. + + This function is responsible for: + - Checking that required keys exist + - Checking that values are set to valid types + - Setting default values if keys are not set + + """ + config = copy.deepcopy(config) + + if config["designtype"] != "onebyone": + raise ValueError( + "Generation of DesignMatrix only implemented for type 'onebyone', " + f"not {config['designtype']}" + ) + + if "repeats" not in config: + raise LookupError('"repeats" must be specified in general input sheet') + + key = "correlation_iterations" + if key not in config: + if verbosity > 0: + print(f"{key!r} not set in general input sheet. Setting to default 0.") + print(" - When set to 0, Iman Conover is used to induce correlations.") + print( + " - When set to a positive integer N, Iman Conover is followed by N iterations\n" # noqa: E501 + " of random permutations (swaps). This leads to results that are never worse, and often better.\n" # noqa: E501 + " It is especially useful for skewed distributions like lognormal and high dimensional problems." # noqa: E501 + ) + print( + f" If desired correlation does not match observed, try setting {key!r}=999 or higher." # noqa: E501 + ) + config[key] = 0 + else: + try: + config[key] = int(config[key]) + except (ValueError, TypeError) as err: + raise ValueError( + f"{key!r} must be a non-negative integer, got: {config[key]}" + ) from err + + key = "distribution_seed" + if key not in config: + raise ValueError( + "You did not specify a value for 'distribution_seed', which is used to " + "seed the random number generator that draws from distributions in Monte " + "Carlo sensitivities.\n" + "- Specify a number (e.g. a 6 digit integer) to seed the random number " + "generator and obtain reproducible results.\n" + "- Specify None if you do not want to seed the random number generator. " + "Your analysis will not be reproducible." + ) + if not (isinstance(config[key], numbers.Integral) or (config[key] is None)): + raise ValueError( + f"{key!r} must be a non-negative integer or None, got: {config[key]}" + ) + + # 'seeds' here is 'rms_seeds' in the input. It can be either: + # - 'default' => gives seed numbers 1000, 1001, 1002, ... + # - 'None' => seed number not added + # - a path to a file + key = "seeds" + if key not in config: + msg = '"rms_seeds" must be specified in general input sheet\n' + msg += ' - Set to "None", "default" or path to a file.' + raise LookupError(msg) + is_default = config[key] == "default" + is_none = config[key] is None + is_list = isinstance(config[key], list) and config[key] + if not any([is_default, is_none, is_list]): + msg = f"'rms_seeds' must be 'None', 'default' or a list, got: {config[key]}" + raise ValueError(msg) + + return config diff --git a/src/ert/config/fmudesign/create_design.py b/src/ert/config/fmudesign/create_design.py new file mode 100644 index 00000000000..fabdc022db9 --- /dev/null +++ b/src/ert/config/fmudesign/create_design.py @@ -0,0 +1,996 @@ +"""Module for generating design matrices that can be run by DESIGN2PARAMS +and DESIGN_KW in FMU/ERT. + + +A DesignMatrix is a "God-object" that contains information about all info +used to generate design matrices, including one or several Sensitivities. + + +""" + +from __future__ import annotations + +import copy +from datetime import datetime +from pathlib import Path +from typing import TYPE_CHECKING, Any, cast + +import numpy as np +import pandas as pd +import probabilit + +import semeio +from semeio.fmudesign import design_distributions as design_dist +from semeio.fmudesign._excel_to_dict import _raise_if_duplicates +from semeio.fmudesign.config_validation import validate_configuration +from semeio.fmudesign.quality_report import QualityReporter, print_corrmat +from semeio.fmudesign.utils import ( + find_max_realisations, + map_dependencies, + parameters_from_extern, + printwarning, + to_numeric_safe, +) + +if TYPE_CHECKING: + from collections.abc import Hashable, Sequence + + +class DesignMatrix: + """Class for design matrix in FMU. Can contain a onebyone design + or a full montecarlo design. + + Attributes: + designvalues (pd.DataFrame): design matrix on standard fmu format + contains columns 'REAL' (realization number), and if a onebyone + design, also columns 'SENSNAME' and 'SENSCASE' + defaultvalues (dict): default values for design + backgroundvalues (pd.DataFrame): Used when background parameters are + not constant. Either a set is sampled from specified distributions + or they are read from a file. + """ + + def __init__(self, verbosity: int = 0, output_dir: Path | None = None) -> None: + """ + Placeholders for: + designvalues: dataframe with parameters that varies + defaultvalues: dictionary of default/base case values + backgroundvalues: dataframe with background parameters + seedvalues: list of seed values + verbosity: how much information to print + output_dir: where to write debugging output and QC plots + + """ + self.designvalues: pd.DataFrame + self.defaultvalues: dict[Hashable, Any] = {} + self.backgroundvalues: pd.DataFrame | None = None + self.seedvalues: list[int] | None = None + self.verbosity: int = verbosity + self.output_dir: Path | None = output_dir + + def reset(self) -> None: + """Resets DesignMatrix to empty. Necessary iin case method generate + is used several times for same instance of DesignMatrix""" + self.designvalues = pd.DataFrame() + self.defaultvalues = {} + self.backgroundvalues = None + self.seedvalues = None + + def generate(self, inputdict: dict[str, Any]) -> None: + """Generating design matrix from input dictionary in specific + format. Adding default values and background values if existing. + Looping through sensitivities and adding them to designvalues. + + Args: + inputdict (dict): input parameters for design + """ + inputdict = validate_configuration(inputdict, verbosity=self.verbosity) + + self.reset() # Emptying if regenerating matrix + self.rng = np.random.default_rng(seed=inputdict.get("distribution_seed")) + self.defaultvalues = inputdict["defaultvalues"] + + # Reading or generating rms seed values + max_reals = find_max_realisations(inputdict) + self.seedvalues = DesignMatrix.create_rms_seeds(inputdict["seeds"], max_reals) + + # If background values used - read or generate + if "background" in inputdict: + self.add_background( + back_dict=inputdict["background"], + max_values=max_reals, + correlation_iterations=inputdict.get("correlation_iterations", 0), + ) + + sensitivity: Sensitivity + + self.designvalues["SENSNAME"] = None + self.designvalues["SENSCASE"] = None + + for key in inputdict["sensitivities"]: + sens = inputdict["sensitivities"][key] + + # Numer of realization (rows) to use for each sensitivity + size = sens["numreal"] if "numreal" in sens else inputdict["repeats"] + + print(f" Generating sensitivity : {key}") + + if sens["senstype"] == "ref": + sensitivity = SingleRealisationReference(key, verbosity=self.verbosity) + sensitivity.generate(size=size) + sensitivity.map_dependencies(sens.get("dependencies", {})) + self._add_sensitivity(sensitivity) + elif sens["senstype"] == "background": + sensitivity = BackgroundSensitivity(key, verbosity=self.verbosity) + sensitivity.generate(size=size) + sensitivity.map_dependencies(sens.get("dependencies", {})) + self._add_sensitivity(sensitivity) + elif sens["senstype"] == "seed": + sensitivity = SeedSensitivity(key, verbosity=self.verbosity) + sensitivity.generate( + size=size, + seedname=sens["seedname"], + seedvalues=self.seedvalues, + parameters=sens["parameters"], + ) + sensitivity.map_dependencies(sens.get("dependencies", {})) + + self._add_sensitivity(sensitivity) + elif sens["senstype"] == "scenario": + sensitivity = ScenarioSensitivity(key, verbosity=self.verbosity) + for casekey in sens["cases"]: + case = sens["cases"][casekey] + temp_case = ScenarioSensitivityCase(casekey) + temp_case.generate( + size=size, + parameters=case, + seedvalues=self.seedvalues, + ) + sensitivity.add_case(temp_case) + sensitivity.map_dependencies(sens.get("dependencies", {})) + + self._add_sensitivity(sensitivity) + elif sens["senstype"] == "dist": + sensitivity = MonteCarloSensitivity(key, verbosity=self.verbosity) + sensitivity.generate( + size=size, + parameters=sens["parameters"], + seedvalues=self.seedvalues, + corrdict=sens["correlations"], + rng=self.rng, + correlation_iterations=inputdict.get("correlation_iterations", 0), + ) + sensitivity.map_dependencies(sens.get("dependencies", {})) + + self._add_sensitivity(sensitivity) + + elif sens["senstype"] == "extern": + sensitivity = ExternSensitivity(key, verbosity=self.verbosity) + sensitivity.generate( + size=size, + filename=sens["extern_file"], + parameters=sens["parameters"], + seedvalues=self.seedvalues, + ) + sensitivity.map_dependencies(sens.get("dependencies", {})) + + self._add_sensitivity(sensitivity) + + else: + raise ValueError(f"Unknown sensitivity type: {sens['senstype']!r}") + + # MonteCarloSensitivity is special - it can produce debugging outputs + is_montecarlo = isinstance(sensitivity, MonteCarloSensitivity) + if is_montecarlo and self.verbosity > 0: + sensitivity = cast("MonteCarloSensitivity", sensitivity) + quality_reporter = QualityReporter( + df=sensitivity.sensvalues, variables=sens["parameters"] + ) + + # Print to terminal + quality_reporter.print_numeric() + quality_reporter.print_discrete() + for corr_name, df_corr in sensitivity.correlation_dfs_.items(): + quality_reporter.print_correlation(corr_name, df_corr) + + if is_montecarlo and self.verbosity > 1 and self.output_dir is not None: + sensitivity = cast("MonteCarloSensitivity", sensitivity) + output_dir = self.output_dir / key + quality_reporter.plot_columns(output_dir=output_dir) + + # Correlations + for corr_name, df_corr in sensitivity.correlation_dfs_.items(): + # Always plot heatmaps + quality_reporter.plot_correlation_heatmap( + corr_name, df_corr, output_dir=output_dir, show=False + ) + + # Only plot pairgrid for small correlations + if len(df_corr) <= 6: + quality_reporter.plot_correlation( + corr_name, df_corr, output_dir=output_dir, show=False + ) + + # Once all sensitivities have been added, complete the work + if "background" in inputdict: + self._fill_with_background_values() + self._fill_with_defaultvalues() + + # Round columns in `self.designvalues` to desired precision + self._set_decimals(inputdict) + + # Create REAL column (realization number) + self.designvalues = self.designvalues.assign(REAL=lambda df: np.arange(len(df))) + + # Re-order columns + start_cols = ["REAL", "SENSNAME", "SENSCASE", "RMS_SEED"] + self.designvalues = self.designvalues[ + [col for col in start_cols if col in self.designvalues] + + [col for col in self.designvalues if col not in start_cols] + ] + + # Make all values numerical if possible + self.designvalues = self.designvalues.map(to_numeric_safe) + + def to_xlsx( + self, + filename: str, + designsheet: str = "DesignSheet01", + defaultsheet: str = "DefaultValues", + ) -> None: + """Writing design matrix to excel workfbook on standard fmu format + to be used in FMU/ERT by DESIGN2PARAMS and DESIGN_KW + + Args: + filename (str): output filename (extension .xlsx) + designsheet (str): name of excel sheet containing design matrix + (optional, defaults to 'DesignSheet01') + defaultsheet (str): name of excel sheet containing default + values (optional, defaults to 'DefaultValues') + """ + # Create folder for output file + Path(filename).parent.mkdir(exist_ok=True, parents=True) + + if not filename.endswith(".xlsx"): + filename += ".xlsx" + print(f"Warning: Missing .xlsx suffix. Changed to: {filename}") + + with pd.ExcelWriter(filename, engine="openpyxl") as writer: + self.designvalues.to_excel( + writer, sheet_name=designsheet, index=False, header=True + ) + # Default values + defaults = pd.DataFrame( + data=list(self.defaultvalues.items()), + columns=["defaultparameters", "defaultvalue"], + ) + defaults.to_excel( + writer, sheet_name=defaultsheet, index=False, header=False + ) + + version_info = pd.DataFrame( + { + "Description": ["Created using semeio version:", "Created on:"], + "Value": [ + semeio.__version__, + datetime.now() + .astimezone() + .isoformat(sep=" ", timespec="seconds"), + ], + } + ) + version_info.to_excel(writer, sheet_name="Metadata", index=False) + + print( + f"Design matrix of shape {self.designvalues.shape} written to: {filename!r}" + ) + + @staticmethod + def create_rms_seeds(seeds: list | str | None, max_reals: int) -> list | None: + """Create RMS seems from 'seeds' argument. + + Args: + seeds: Seed configuration. Can be: + - None: returns None + - "default": Generates sequential seeds 1001, 1002, 1003, ... + - list of seeds, e.g. [1, 2, 3] + max_reals: Maximum number of seed values to generate or load + + Examples + -------- + >>> DesignMatrix.create_rms_seeds([1, 2, 3], max_reals=5) + Provided number of seed values (3) in external file is lower than the maximum number of realisations (5). + Seeds will be repeated, e.g. [1, 2, 3] => [1, 2, 3, 1, 2, ...] + [1, 2, 3, 1, 2] + """ # noqa: E501 + if seeds is None: + return None + + if seeds == "default": + return [item + 1000 for item in range(max_reals)] + + if isinstance(seeds, list): + if max_reals > len(seeds): + print( + f"Provided number of seed values ({len(seeds)}) in external file " + f"is lower than the maximum number of realisations ({max_reals}).\n" + " Seeds will be repeated, e.g. [1, 2, 3] => [1, 2, 3, 1, 2, ...]" + ) + + return [seeds[item % len(seeds)] for item in range(max_reals)] + + # Raise if none of the cases above apply. We do this because if we did not we + # would return None, which is a valid case in itself. + raise ValueError(f"Must be None, 'default' or list: {seeds=}") + + def add_background( + self, + back_dict: dict[str, Any] | None, + max_values: int, + correlation_iterations: int = 0, + ) -> None: + """Adding background as specified in dictionary. + Either from external file or from distributions in background + dictionary + + Args: + back_dict (dict): how to generate background values + max_values (int): number of background values to generate + correlation_iterations (int): Number of permutations performed + on samples after Iman-Conover in an attempt to match observed + correlation to desired correlation as well as possible. + """ + if back_dict is None: + self.backgroundvalues = None + elif "extern" in back_dict: + print(f"Reading background values from: {back_dict['extern']}") + self.backgroundvalues = parameters_from_extern(back_dict["extern"]) + elif "parameters" in back_dict: + print("Generating background values from distributions.") + self._add_dist_background( + back_dict=back_dict, + size=max_values, + correlation_iterations=correlation_iterations, + ) + + def background_to_excel( + self, filename: str, backgroundsheet: str = "Background" + ) -> None: + """Writing background values to an Excel spreadsheet + + Args: + filename (str): output filename (extension .xlsx) + backgroundsheet (str): name of excel sheet + """ + if self.backgroundvalues is None: + raise ValueError("No background values available to write to Excel") + + xlsxwriter = pd.ExcelWriter(filename, engine="openpyxl") + self.backgroundvalues.to_excel( + xlsxwriter, sheet_name=backgroundsheet, index=False, header=True + ) + xlsxwriter.close() + print(f"Backgroundvalues written to {filename}") + + def _add_sensitivity( + self, + sensitivity: Sensitivity, + ) -> None: + """Adding a sensitivity to the design + + Args: + sensitivity of class Scenario, MonteCarlo or Extern + """ + existing_values = self.designvalues + new_values = sensitivity.sensvalues + self.designvalues = pd.concat([existing_values, new_values]) + + def _fill_with_background_values(self) -> None: + """Substituting NaNs with background values if existing. + background values not in design are added as separate columns + """ + if self.backgroundvalues is None: + return + + grouped = self.designvalues.groupby(["SENSNAME", "SENSCASE"], sort=False) + result_values = pd.DataFrame() + for sensname, case_ in grouped: + temp_df = case_.reset_index() + temp_df = temp_df.fillna(self.backgroundvalues) + for key in self.backgroundvalues.columns: + if key not in case_: + temp_df[key] = self.backgroundvalues[key] + if len(temp_df) > len(self.backgroundvalues): + raise ValueError( + "Provided number of background values " + f"{len(self.backgroundvalues)} is smaller than number" + f" of realisations for sensitivity {sensname}" + ) + elif len(temp_df) > len(self.backgroundvalues): + print( + "Provided number of background values " + f"({len(self.backgroundvalues)}) is smaller than number" + f" of realisations for sensitivity {sensname}" + f" and parameter {key}. " + "Will be filled with default values." + ) + existing_values = result_values.copy() + result_values = pd.concat([existing_values, temp_df]) + + result_values = result_values.drop(["index"], axis=1) + self.designvalues = result_values + + def _fill_with_defaultvalues(self) -> None: + """Filling NaNs with default values""" + for key in self.designvalues.columns: + if key in self.defaultvalues: + self.designvalues[key] = self.designvalues[key].fillna( + self.defaultvalues[key] + ) + elif key not in {"REAL", "SENSNAME", "SENSCASE", "RMS_SEED"}: + raise LookupError(f"No defaultvalues given for parameter {key} ") + + def _add_dist_background( + self, + back_dict: dict[str, Any], + size: int, + correlation_iterations: int, + ) -> None: + """Drawing background values from distributions + specified in dictionary + + Args: + back_dict (dict): parameters and distributions + size (int): Number of samples to generate + correlation_iterations (int): Number of permutations performed + on samples after Iman-Conover in an attempt to match observed + correlation to desired correlation as well as possible. + """ + + mc_background = MonteCarloSensitivity("background") + mc_background.generate( + size=size, + parameters=back_dict["parameters"], + seedvalues=None, + corrdict=back_dict["correlations"], + rng=self.rng, + correlation_iterations=correlation_iterations, + ) + mc_backgroundvalues = mc_background.sensvalues.copy() + quality_reporter = QualityReporter( + df=mc_backgroundvalues, variables=back_dict["parameters"] + ) + + # Print info to terminal + if self.verbosity > 0: + quality_reporter.print_numeric() + quality_reporter.print_discrete() + for corr_name, df_corr in mc_background.correlation_dfs_.items(): + quality_reporter.print_correlation(corr_name, df_corr) + + # Write plots to disk + if self.verbosity > 0 and self.output_dir is not None: + output_dir = self.output_dir / mc_background.sensname + quality_reporter.plot_columns(output_dir=output_dir) + + # Correlations + for corr_name, df_corr in mc_background.correlation_dfs_.items(): + quality_reporter.plot_correlation( + corr_name, df_corr, output_dir=output_dir, show=False + ) + + # Rounding of background values as specified + if "decimals" in back_dict: + for key in back_dict["decimals"]: + if design_dist.is_number(mc_backgroundvalues[key].iloc[0]): + mc_backgroundvalues[key] = ( + mc_backgroundvalues[key] + .astype(float) + .round(int(back_dict["decimals"][key])) + ) + else: + raise ValueError("Cannot round a string parameter") + self.backgroundvalues = mc_backgroundvalues.copy() + + def _set_decimals(self, inputdict: dict[str, Any]) -> None: + """Round to specified number of decimals. + + Args: + inputdict (dictionary): input diction that might have a sub-dict + with key "decimals". This sub-dict has + (key, value)s are (param, decimals) + """ + inputdict = copy.deepcopy(inputdict) + + # No decimal information => Nothing to do. + if not inputdict.get("decimals", {}): + return + + # If there are dependencies (derived params) that are copies, + # like TO := copy(FROM), then the new TO column must be rounded too. + for sensdict in inputdict["sensitivities"].values(): + if not sensdict["dependencies"]: + continue + for from_param, from_dict in sensdict["dependencies"].items(): + for to_param in from_dict["to_params"]: + if not inputdict["decimals"].get(from_param, None): + continue + inputdict["decimals"][to_param] = inputdict["decimals"].get( + from_param, "" + ) + + # Round each column + dict_decimals = inputdict["decimals"] + for key in self.designvalues.columns: + if key in dict_decimals: + if design_dist.is_number(self.designvalues[key].iloc[0]): + self.designvalues[key] = ( + self.designvalues[key] + .astype(float) + .round(int(dict_decimals[key])) + ) + else: + raise ValueError(f"Cannot round a string parameter {key}") + + +class Sensitivity: + sensvalues: pd.DataFrame + + def __init__(self, sensname: str, verbosity: int = 0) -> None: + """ + Args: + sensname (str): Name of sensitivity. Defines SENSNAME in design matrix. + verbosity (int): How much information to print. Non-negative integer. + """ + self.sensname: str = sensname + self.verbosity: int = verbosity + + def map_dependencies(self, dependencies: dict[str, Any]) -> Sensitivity: + """Map the dependencies, mutating the dataframe `self.sensvalues`.""" + verbose = self.verbosity > 0 # Because the function takes a boolean + self.sensvalues: pd.DataFrame = map_dependencies( + self.sensvalues, dependencies=dependencies, verbose=verbose + ) + return self + + +class SeedSensitivity(Sensitivity): + """ + A seed sensitivity is normally the reference for one by one sensitivities, + which all other sensitivities are compared to. All parameters will be at + their default values. Only the RMS_SEED will be varying. + + It contains a list of seeds to be repeated for each sensitivity + The parameter name is hardcoded to RMS_SEED + It will be assigned the sensname 'p10_p90' which will be written to + the SENSCASE column in the output. + + Attributes: + sensname (str): name of sensitivity + sensvalues (pd.DataFrame): design values for the sensitivity + + """ + + def generate( + self, + size: int, + seedname: str, + seedvalues: Sequence[int] | None, + parameters: dict[str, Any] | None, + ) -> None: + """Generates parameter values for a seed sensitivity + + Args: + size (int): number of rows to generate + seedname (str): name of seed parameter to add + seedvalues (list): list of integer seedvalues + parameters (dict): parameter names and + distributions or values. + """ + if seedvalues is None: + msg = ( + "Seed values must be set when running sensitivity type 'seed'. " + f"Got seed: {seedvalues}" + ) + raise ValueError(msg) + + self.sensvalues = pd.DataFrame(index=range(size)) + self.sensvalues[seedname] = seedvalues[0:size] + + if parameters is not None: + for key in parameters: + dist_name = parameters[key][0].lower() + constant = parameters[key][1] + if dist_name != "const": + raise ValueError( + 'A sensitivity of type "seed" can only have ' + "additional parameters where dist_name is " + f'"const". Check sensitivity {self.sensname}"' + ) + self.sensvalues[key] = constant + + self.sensvalues["SENSNAME"] = self.sensname + self.sensvalues["SENSCASE"] = "p10_p90" + + +class SingleRealisationReference(Sensitivity): + """ + The class is used in set-ups where one wants a single realisation + containing only default values as a reference, but the realisation + itself is not included in a sensitivity. + Typically used when RMS_SEED is not a parameter. + SENSCASE will be set to 'ref' in design matrix, to flag that it should be + excluded as a sensitivity in the plot. + + Attributes: + sensname (str): name of sensitivity + sensvalues (pd.DataFrame): design values for the sensitivity + + """ + + def generate( + self, + size: int, + ) -> None: + """Generates realisation number only + + Args: + realnums (list): list of integers with realization numbers + """ + self.sensvalues = pd.DataFrame(index=range(size)) + self.sensvalues["SENSNAME"] = self.sensname + self.sensvalues["SENSCASE"] = "ref" + + +class BackgroundSensitivity(Sensitivity): + """ + The class is used in set-ups where one sensitivities + are run on top of varying background parameters. + Typically used when RMS_SEED is not a parameter, so the reference + for tornadoplots will be the realisations with all parameters + at their default values except the background parameters. + SENSCASE will be set to 'p10_p90' in design matrix. + + Attributes: + sensname (str): name of sensitivity + sensvalues (pd.DataFrame): design values for the sensitivity + + """ + + def generate(self, size: int) -> None: + """Generates realisation number only + + Args: + size (int): number of rows to generate + """ + self.sensvalues = pd.DataFrame(index=range(size)) + self.sensvalues["SENSNAME"] = self.sensname + self.sensvalues["SENSCASE"] = "p10_p90" + + +class ScenarioSensitivity(Sensitivity): + """Each design can contain one or several single sensitivities of type + Seed, MonteCarlo or Scenario. + Each ScenarioSensitivity can contain 1-2 ScenarioSensitivityCases. + + The ScenarioSensitivity class is used for sensitivities where all + realizatons in a ScenarioSensitivityCase have identical values + but one or more parameter has a different values from the other + ScenarioSensitivityCase. + + Exception is the seed value and the special case where + varying background parameters are specified. Then these are varying + within the case. + + Attributes: + case1 (ScenarioSensitivityCase): first case, e.g. 'low case' + case2 (ScenarioSensitivityCase): second case, e.g. 'high case' + sensvalues (pd.DataFrame): design values for the sensitivity, containing + 1-2 cases + """ + + case1: ScenarioSensitivityCase | None = None + case2: ScenarioSensitivityCase | None = None + + def add_case(self, senscase: ScenarioSensitivityCase) -> None: + """ + Adds a ScenarioSensitivityCase instance + to a ScenarioSensitivity object. + + Args: + senscase (ScenarioSensitivityCase): + Equals SENSCASE in design matrix. + """ + if self.case1 is not None: # Case 1 has been read, this is case2 + if senscase.sensvalues is not None and "SENSCASE" in senscase.sensvalues: + self.case2 = senscase + senscase.sensvalues["SENSNAME"] = self.sensname + self.sensvalues = pd.concat( + [self.sensvalues, senscase.sensvalues], sort=True + ) + elif senscase.sensvalues is not None and "SENSCASE" in senscase.sensvalues: + self.case1 = senscase + self.sensvalues = senscase.sensvalues.copy() + self.sensvalues["SENSNAME"] = self.sensname + + +class ScenarioSensitivityCase(Sensitivity): + """Each ScenarioSensitivity can contain one or + two ScenarioSensitivityCases. + + The 1-2 cases are typically 'low' and 'high' cases for one or + a set of parameters, where all realisatons in + the case have identical values except the seed value + and in special cases specified background values which may + vary within the case. + + One or two ScenarioSensitivityCase instances can be added to each + ScenarioSensitivity object. + + Attributes: + sensname (str): name of the sensitivity case, + equals SENSCASE in design matrix. + sensvalues (pd.DataFrame): parameters and values + for the sensitivity with realisation numbers as index. + + """ + + def generate( + self, + size: int, + parameters: dict[str, Any], + seedvalues: Sequence[int] | None, + ) -> None: + """Generate sensvalues for the ScenarioSensitivityCase + + Args: + size (int): number of rows to generate + parameters (dict): + dictionary with parameter names and values + seeds (str): default or None + """ + + self.sensvalues = pd.DataFrame( + columns=list(parameters.keys()), index=range(size) + ) + for key, value in parameters.items(): + self.sensvalues[key] = value + self.sensvalues["SENSCASE"] = self.sensname + + if seedvalues: + self.sensvalues["RMS_SEED"] = seedvalues[:size] + + +class MonteCarloSensitivity(Sensitivity): + """ + For a MonteCarloSensitivity one or several parameters + are drawn from specified distributions with or without correlations. + A MonteCarloSensitivity can only contain + one case, where the name SENSCASE is automatically set to 'p10_p90' in the + design matrix to flag that p10_p90 should be calculated in TornadoPlot. + + Attributes: + sensname (str): name for the sensitivity. + Equals SENSNAME in design matrix. + sensvalues (pd.DataFrame): parameters and values for the sensitivity + with realisation numbers as index. + """ + + def generate( + self, + *, + size: int, + parameters: dict[str, Any], + seedvalues: Sequence[int] | None, + corrdict: dict[str, Any] | None, + rng: np.random.Generator, + correlation_iterations: int = 0, + ) -> None: + """Generates parameter values by drawing from defined distributions. + + Args: + size (int): number of rows to generate + parameters (dict): dictionary of parameters and distributions + values (list): a list of seed values or None + corrdict (dict): Configuration for correlated parameters. Contains: + - 'inputfile': Name of Excel file with correlation matrices + - 'sheetnames': List of sheet names, where each sheet contains a + correlation matrix. If None, parameters are treated as uncorrelated. + rng (numpy.random.Generator): Random number generator instance + correlation_iterations (int): Number of permutations performed + on samples after Iman-Conover in an attempt to match observed + correlation to desired correlation as well as possible. + """ + self.sensvalues = pd.DataFrame( + columns=list(parameters.keys()), index=range(size) + ) + self.correlation_dfs_ = {} # Store correlation matrices (dataframes) + + if size < 0: + raise ValueError(f"Got < 0 samples ({size=})") + + distr_by_name = {} + for param_name, (dist_name, dist_params, _) in parameters.items(): + # Convert to a probabilit Distribution object + distr = design_dist.to_probabilit( + distname=dist_name, dist_parameters=dist_params + ) + distr_by_name[param_name] = distr + + # Create a dummy NoOp node for sampling each parent distribution + expression = probabilit.modeling.NoOp(*distr_by_name.values()) + + if corrdict: + # Create an iterator over correlation groups from the main sheet + df_params = ( + pd.DataFrame.from_dict( + parameters, + orient="index", + columns=["dist_name", "dist_params", "corr_sheet"], + ) + .reset_index() + .rename(columns={"index": "param_name"}) + .assign(corr_sheet=lambda df: df.corr_sheet.fillna("nocorr")) + ) + + corr_groups = dict(iter(df_params.groupby("corr_sheet"))) + corr_groups.pop("nocorr", None) + + for corr_group_name, corr_group in corr_groups.items(): + corr_group_name = cast("str", corr_group_name) + + # Skip nocorr + if corr_group_name == "nocorr": + continue + + # A single correlation - print warning and skip it + if len(corr_group) == 1: + printwarning(corr_group_name) + continue + + # Read correlation matrix and convert it to a proper matrix + df_correlations = design_dist.read_correlations( + excel_filename=corrdict["inputfile"], corr_sheet=corr_group_name + ) + multivariate_parameters = df_correlations.index.tolist() + correlations = df_correlations.to_numpy() + + if self.verbosity == 0: + print( + f"Sampling {len(multivariate_parameters)} parameters", + f"in correlation group {corr_group_name!r}", + ) + else: + print( + f"Sampling {len(multivariate_parameters)} parameters", + f"in correlation group {corr_group_name!r}: " + f"{multivariate_parameters}", + ) + + # Get the nearest correlation matrix + nearest = probabilit.correlation.nearest_correlation_matrix( + correlations, weights=None, eps=1e-6, verbose=False + ) + if not np.allclose(correlations, nearest): + print( + f"\nWarning: Correlation matrix {corr_group_name!r} " + "is inconsistent" + ) + print("Requirements:") + print(" - All diagonal elements must be 1") + print(" - All elements must be between -1 and 1") + print(" - The matrix must be positive semi-definite") + print("\nInput correlation matrix:") + print_corrmat(df_correlations) + df_correlations = pd.DataFrame( + nearest, + index=df_correlations.index, + columns=df_correlations.columns, + ) + print("\nAdjusted to nearest consistent correlation matrix:") + print_corrmat(df_correlations) + + corrvars = [distr_by_name[name] for name in multivariate_parameters] + expression.correlate(*corrvars, corr_mat=df_correlations.to_numpy()) + self.correlation_dfs_[corr_group_name] = df_correlations + + # Either do ImanConover followed by Permutation, or simply ImanConover + if correlation_iterations > 0: + correlator = probabilit.correlation.Composite( + iterations=correlation_iterations, + correlation_type="pearson", + random_state=rng, + verbose=False, + ) + else: + correlator = probabilit.correlation.ImanConover() + + # Sample the dummy node - this samples every parent and populates "samples_" + expression.sample( + size=size, random_state=rng, method="lhs", correlator=correlator + ) + + for distr_name, distr_obj in distr_by_name.items(): + samples = distr_obj.samples_ + is_numeric = issubclass(samples.dtype.type, np.number) + if is_numeric and not np.all(np.isfinite(distr_obj.samples_)): + raise ValueError( + f"Sampling produced non-finite values in {distr_name}={distr_obj}\n" + "Please review the parameters in the distribution." + ) + + # Discrete distributions are handled in a special way. We map them + # to Uniform distributions, sample in [0, 1), then map those samples + # back to the categorical values AFTER sampling. This is so that we + # can "induce correlations" between categorical values. + if hasattr(distr_obj, "_values"): + probabilities = getattr(distr_obj, "_probabilities", None) + samples = design_dist.quantiles_to_values( + quantiles=samples, + values=distr_obj._values, + probabilities=probabilities, + ) + + self.sensvalues = self.sensvalues.assign(**{distr_name: samples}) + + if self.sensname != "background": + self.sensvalues["SENSNAME"] = self.sensname + self.sensvalues["SENSCASE"] = "p10_p90" + if "RMS_SEED" not in self.sensvalues and seedvalues: + self.sensvalues["RMS_SEED"] = seedvalues[:size] + + null_columns = self.sensvalues.isna().any(axis=0) + if null_columns.any(): + cols_w_null = list(null_columns.loc[lambda ser: ser].index) + raise ValueError(f"Found NaN values in columns: {cols_w_null}") + + +class ExternSensitivity(Sensitivity): + """ + Used when reading parameter values from a file + Assumed to be used with monte carlo type sensitivities and + will hence write 'p10_p90' as SENSCASE in output designmatrix + + Attributes: + sensname (str): Name of sensitivity. + Defines SENSNAME in design matrix + sensvalues (pd.DataFrame): design values for the sensitivity + + """ + + def generate( + self, + size: int, + filename: str, + parameters: list[str], + seedvalues: Sequence[int] | None, + ) -> None: + """Reads parameter values for a monte carlo sensitivity + from file + + Args: + size (int): number of samples to generate + filename (str): file to read values from + parameters (list): list with parameter names + seeds (str): default or None + """ + _raise_if_duplicates(parameters) + self.sensvalues = pd.DataFrame(columns=parameters, index=range(size)) + extern_values = parameters_from_extern(filename) + if size > len(extern_values): + raise ValueError( + f"Number of realisations {size} specified for " + f"sensitivity {self.sensname} is larger than rows in " + f"file {filename}" + ) + for param in parameters: + if param in extern_values: + self.sensvalues[param] = list(extern_values[param][:size]) + else: + raise ValueError(f"Parameter {param} not in external file") + + self.sensvalues["SENSNAME"] = self.sensname + self.sensvalues["SENSCASE"] = "p10_p90" + + if seedvalues: + self.sensvalues["RMS_SEED"] = seedvalues[:size] diff --git a/src/ert/config/fmudesign/design_distributions.py b/src/ert/config/fmudesign/design_distributions.py new file mode 100644 index 00000000000..c317f4fb50c --- /dev/null +++ b/src/ert/config/fmudesign/design_distributions.py @@ -0,0 +1,387 @@ +"""Module for random sampling of parameter values from distributions.""" + +from collections.abc import Sequence +from typing import Any + +import numpy as np +import numpy.typing as npt +import pandas as pd +import probabilit +from scipy import stats + + +def validate_params(distname: str, parameters: list[str]) -> list[float]: + """Common parameter validation for all distributions. + + Example: + >>> validate_params('normal', ['0', '-3.14', '1e10']) + [0.0, -3.14, 10000000000.0] + >>> validate_params('normal', ['inf']) + Traceback (most recent call last): + ... + ValueError: Parameter 1 in distribution normal is not finite: inf + """ + new_parameters: list[float] = [] + + for i, parameter in enumerate(parameters): + try: + new_parameters.append(float(parameter)) + except (ValueError, TypeError) as e: + raise ValueError( + f"Parameter {i + 1} in distribution {distname} not " + f"convertible to number: {parameter}" + ) from e + + if not np.isfinite(new_parameters[i]): + raise ValueError( + f"Parameter {i + 1} in distribution {distname} " + f"is not finite: {parameter}" + ) + + return new_parameters + + +def quantiles_to_values( + *, + quantiles: npt.NDArray[Any], + values: npt.NDArray[Any], + probabilities: npt.NDArray[Any] | None = None, +) -> npt.NDArray[Any]: + """Maps quantiles to values (which can be categorical or not). + + Assume values = [A, B, C], then probabilities = [1, 1, 1] = [1/3, 1/3, 1/3], + first we bin the interval [0, 1) into segments matching the probabilities: + - A: [0, 1/3) + - B: [1/3, 2/3) + - C: [2/3, 1) + Then we map the quantiles into the ranges back onto the original values. + + Examples + -------- + >>> values = np.array(["A", "B", "C"]) + >>> quantiles = np.array([0, 1/3, 0.5, 0.8]) + >>> quantiles_to_values(quantiles=quantiles, values=values) + array(['A', 'B', 'B', 'C'], dtype='>> probabilities = np.array([0.2, 0.3, 0.5]) + >>> quantiles = (np.arange(1, 10)) / 10 + >>> quantiles_to_values(quantiles=quantiles, values=values, + ... probabilities=probabilities) # [0.1, 0.2, ...] + array(['A', 'B', 'B', 'B', 'C', 'C', 'C', 'C', 'C'], dtype='= 0) + + # Create bin edges + edges = np.cumsum([0, *list(probabilities)]) + # Map to bin indices, then back onto the original values + bin_indices = np.digitize(quantiles, edges, right=False) - 1 + return values[bin_indices] + + +def to_probabilit( + distname: str, + dist_parameters: Sequence[str], +) -> probabilit.modeling.AbstractDistribution: + """ + Prepare scipy distributions with parameters + Args: + distname (str): distribution name 'normal', 'lognormal', 'triang', + 'uniform', 'logunif', 'discrete', 'pert', 'beta' + dist_parameters (list): list with parameters for distribution + Returns: + array with sampled values + """ + + distname = distname.lower().strip() + + # A discrete variable is a distribution over categoricals, e.g. ('A', 'B', 'C') + # with weights (0.5, 0.3, 0.2). The way we deal with them is that we sample uniform + # values, then assign the interval [0, 0.5) to A, [0.5, 0.8) to B and [0.8, 1) to C. + # This means that we can "correlate" these variables, in the sense that if their + # underlying Uniforms are correlated, then the categorical values will often match + # too. To accomplish all of this we assign _values and _probabilities to the + # distribution instances below. This "correlation" only exists in a narrow specific + # sense of course. + + if distname.startswith("disc"): + if len(dist_parameters) == 1: + values_str = str(dist_parameters[0]) + values = [v.strip() for v in values_str.split(",")] + distr = probabilit.Distribution("uniform") + distr._values = np.array(values) + return distr + values_str, probabilities_str = map(str, dist_parameters) + values = [v.strip() for v in values_str.split(",")] + probabilities = [float(v.strip()) for v in probabilities_str.split(",")] + if len(values) != len(probabilities): + raise ValueError( + "Length mismatch for discrete distribution, " + f"dist_param1 has length {len(values)}, " + f"but dist_param2 has length {len(probabilities)}. " + "dist_param1 and dist_param2 must have the same numer of " + "entries for discrete distributions." + ) + distr = probabilit.Distribution("uniform") + distr._values = np.array(values) + distr._probabilities = np.array(probabilities) + return distr + + # Special case for constant + if distname.startswith("const"): + return probabilit.Constant(dist_parameters[0]) + + # Convert parameters + parameters: list[float] = validate_params( + distname=distname, parameters=list(dist_parameters) + ) + + match (distname, parameters): + # ================== NORMAL ================== + + case [_, (p10, p90)] if distname.startswith("normal_p10_p90"): + # We use the equations + # p10 = mu - z*sigma and p90 = mu + z*sigma + # to find mu and sigma + z_score = stats.norm.ppf(0.9) + mean = (p10 + p90) / 2 + std = (p90 - p10) / (2 * z_score) + return probabilit.distributions.Normal(mean=mean, std=std) + + case [_, (p10, p90, low, high)] if distname.startswith("normal_p10_p90"): + z_score = stats.norm.ppf(0.9) + mean = (p10 + p90) / 2 + std = (p90 - p10) / (2 * z_score) + return probabilit.distributions.TruncatedNormal( + mean=mean, std=std, low=low, high=high + ) + + case [_, (mean, std)] if distname.startswith("norm"): + return probabilit.distributions.Normal(mean=mean, std=std) + + case [_, (mean, std, low, high)] if distname.startswith("norm"): + return probabilit.distributions.TruncatedNormal( + mean=mean, std=std, low=low, high=high + ) + + case [_, parameters] if distname.startswith("norm"): + raise ValueError( + f"Normal must have 2 or 4 parameters, got: " + f"{len(parameters)} ({parameters})" + ) + + # ================== LOGNORMAL ================== + + case [_, (mu, sigma)] if distname.startswith("logn"): + return probabilit.distributions.Lognormal.from_log_params( + mu=mu, sigma=sigma + ) + + case [_, (mu, sigma, low, high)] if distname.startswith("logn"): + # (mu, sigma) are defined in log-space, but (low, high) + # are defined on exp-space + return probabilit.modeling.Exp( + probabilit.distributions.TruncatedNormal( + mu, sigma, low=np.log(low), high=np.log(high) + ) + ) + + case [_, parameters] if distname.startswith("logn"): + raise ValueError( + f"Lognormal must have 2 or 4 parameters, got: " + f"{len(parameters)} ({parameters})" + ) + + # ================== UNIFORM ================== + + case [_, (p10, p90)] if distname.startswith("uniform_p10_p90"): + length = (p90 - p10) / 0.8 + minimum = p10 - 0.1 * length + maximum = p90 + 0.1 * length + return probabilit.distributions.Uniform(minimum=minimum, maximum=maximum) + + case [_, (minimum, maximum)] if distname.startswith("unif"): + return probabilit.distributions.Uniform(minimum=minimum, maximum=maximum) + + case [_, parameters] if distname.startswith("unif"): + raise ValueError( + f"Uniform must have 2 parameters, got: {len(parameters)} ({parameters})" + ) + + # ================== TRIANGULAR ================== + + case [_, (low, mode, high)] if distname.startswith("triangular_p10_p90"): + return probabilit.distributions.Triangular( + low=low, mode=mode, high=high, low_perc=0.1, high_perc=0.9 + ) + + case [_, (minimum, mode, maximum)] if distname.startswith("triang"): + return probabilit.distributions.Triangular( + low=minimum, mode=mode, high=maximum, low_perc=0.0, high_perc=1.0 + ) + + case [_, parameters] if distname.startswith("triang"): + raise ValueError( + f"Triangular must have 3 parameters, got: " + f"{len(parameters)} ({parameters})" + ) + + # ================== BETA ================== + + case [_, (a, b)] if distname.startswith("beta"): + # Defaults to probabilit.Distribution("beta", a=a, b=b, loc=0, scale=1) + return probabilit.Distribution("beta", a=a, b=b) + + case [_, (a, b, low, high)] if distname.startswith("beta"): + loc = low + scale = high - low + return probabilit.Distribution("beta", a=a, b=b, loc=loc, scale=scale) + + case [_, parameters] if distname.startswith("beta"): + raise ValueError( + f"Beta must have 2 or 4 parameters, got: " + f"{len(parameters)} ({parameters})" + ) + + # ================== PERT ================== + + case [_, (low, mode, high)] if distname.startswith("pert_p10_p90"): + return probabilit.distributions.PERT( + low=low, mode=mode, high=high, low_perc=0.1, high_perc=0.9 + ) + + case [_, (low, mode, high, scale)] if distname.startswith("pert_p10_p90"): + return probabilit.distributions.PERT( + low=low, mode=mode, high=high, low_perc=0.1, high_perc=0.9, gamma=scale + ) + + case [_, (minimum, mode, maximum)] if distname.startswith("pert"): + return probabilit.distributions.PERT( + low=minimum, mode=mode, high=maximum, low_perc=0.0, high_perc=1.0 + ) + + case [_, (minimum, mode, maximum, scale)] if distname.startswith("pert"): + return probabilit.distributions.PERT( + low=minimum, + mode=mode, + high=maximum, + low_perc=0.0, + high_perc=1.0, + gamma=scale, + ) + + case [_, parameters] if distname.startswith("pert"): + raise ValueError( + f"PERT must have 3 or 4 parameters, got: " + f"{len(parameters)} ({parameters})" + ) + + # ================== LOGUNIFORM ================== + + case [_, (low, high)] if distname.startswith("logunif"): + return probabilit.Distribution("loguniform", low, high) + + case [_, parameters] if distname.startswith("logunif"): + raise ValueError( + f"Loguniform must have 2 parameters, got: " + f"{len(parameters)} ({parameters})" + ) + + case [distname, parameters]: + raise ValueError(f"Invalid combination of {distname=} and {parameters=}.") + + +def is_number(teststring: str) -> bool: + """Test if a string can be parsed as a float""" + try: + return not np.isnan(float(teststring)) + except ValueError: + return False + + +def read_correlations(excel_filename: str, corr_sheet: str) -> pd.DataFrame: + """Read a correlation matrix from an Excel sheet. + + The sheet must have rows/columns with variable names. They must match. + The upper-triangular part must be empty strings. The lower triangular part + must be specified. + + Args: + excel_filename (str): name of Excel file containing correlation matrix + corr_sheet (str): name of sheet containing correlation matrix + + Returns: + pd.DataFrame: Dataframe with correlations, parameter names + as column and index + """ + if not str(excel_filename).endswith(".xlsx"): + raise ValueError( + "Correlation matrix filename should be on Excel format and end with .xlsx" + ) + + correlations = ( + pd.read_excel( + excel_filename, + sheet_name=corr_sheet, + index_col=0, + # A user reported failures when a single space ' ' was present + # in the upper triangular part. Therefore we add spaces as NaN too. + na_values=[" " * i for i in range(10)], + engine="openpyxl", + ) + .dropna(axis=0, how="all") + # Remove any 'Unnamed' columns that Excel/pandas may have automatically added. + .loc[:, lambda df: ~df.columns.str.contains("^Unnamed")] + # Remove whitespace + .rename(columns=str.strip) + .rename(index=str.strip) + ) + + if list(correlations.index) != list(correlations.columns): + msg = ( + "Mismatch between column and index in correlation " + f"matrix sheet: {corr_sheet!r}\n" + f"Column: {correlations.columns.tolist()}\n" + f"Index : {correlations.index.tolist()}\n" + "These values must match exactly. Please fix sheet " + f"{corr_sheet!r} in file {excel_filename!r}." + ) + raise ValueError(msg) + + arr = correlations.to_numpy(copy=True) + upper_idx = np.triu_indices_from(arr, k=1) + lower_idx = np.tril_indices_from(arr, k=0) # Include diag + lower_entries = arr[lower_idx] + + if not np.all(np.isnan(arr[upper_idx])): + raise ValueError( + "All upper-triangular elements in matrix in " + f"corr sheet {corr_sheet} must be blank." + ) + + if not np.all(np.isfinite(lower_entries)): + raise ValueError( + "All lower-triangular elements in matrix in " + f"corr sheet {corr_sheet} must be specified." + ) + + if np.any((lower_entries < -1) | (lower_entries > 1)): + raise ValueError( + "All lower-triangular elements in matrix in " + f"corr sheet {corr_sheet} must be between -1 and 1." + ) + + # Build symmetric matrix from lower triangle + np.nan_to_num(arr, copy=False, nan=0.0) + mat = arr + arr.T + np.fill_diagonal(mat, 1.0) + return pd.DataFrame(mat, index=correlations.index, columns=correlations.columns) diff --git a/src/ert/config/fmudesign/examples/ex1_onebyone_rms_repeat.xlsx b/src/ert/config/fmudesign/examples/ex1_onebyone_rms_repeat.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..3d2c57813d3c90032c79db849fb883bc74d983fc GIT binary patch literal 14686 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 literal 0 HcmV?d00001 diff --git a/src/ert/config/fmudesign/examples/ex2_correlations.xlsx b/src/ert/config/fmudesign/examples/ex2_correlations.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..2dd52e6b214ae899a70d55d09910ec56ee22074b GIT binary patch literal 26420 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 z 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 M5qM^3^y{zx10<|)_y7O^ literal 0 HcmV?d00001 diff --git a/src/ert/config/fmudesign/examples/ex2_doe1.xlsx b/src/ert/config/fmudesign/examples/ex2_doe1.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..f89741402f1b932e8d71342ae7aba5b3d25ad8f9 GIT binary patch literal 4985 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 Zd=+J&!P5l*fCm120k8dAcz^!&zW`Uu++zR$ literal 0 HcmV?d00001 diff --git a/src/ert/config/fmudesign/examples/ex4_background_parameters.xlsx b/src/ert/config/fmudesign/examples/ex4_background_parameters.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..89a93e47c5e73acb28bb0cae6aea16772567ea91 GIT binary patch literal 23728 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 Z=&K+N4p=ULfKUKG(}3MS4FAth{|f>NLDB#K literal 0 HcmV?d00001 diff --git a/src/ert/config/fmudesign/examples/ex6_singlereference_and_seed.xlsx b/src/ert/config/fmudesign/examples/ex6_singlereference_and_seed.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..b48d6ee1b25165482e8b050a0a223ca43ee842e3 GIT binary patch literal 17328 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 S=K+F*;rB-PDE!br-~I+>i*Tm^ literal 0 HcmV?d00001 diff --git a/src/ert/config/fmudesign/examples/fmudesign_ex_montecarlo.xlsx b/src/ert/config/fmudesign/examples/fmudesign_ex_montecarlo.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..5b19a475982a834a91df044a9cc197328d9f3284 GIT binary patch literal 24097 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 F{{iAJbmjm6 literal 0 HcmV?d00001 diff --git a/src/ert/config/fmudesign/examples/fmudesign_ex_onebyone.xlsx b/src/ert/config/fmudesign/examples/fmudesign_ex_onebyone.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..24b085c684d018c50589793eab014d65e6dd561c GIT binary patch literal 16138 zcmbVz1yo(jvMs^gHMqOm#)5lrg1fszkf6cc-JRg>?(Ps=gS!X)ko*2SIeGVA>S(&$dtX~yC-Oiuau=ZtCcuDj_U{JO=Y4OLZ<OH zhW^kltA_54!)vFp@K~@6Vp2#6ggYk#=+pJ#gio=<`-zDtO^rKtHhNd!qb(jqNVM&^~P-qSC^RExDzMcK<+F}j$du~69nrwC>6tY& zobfRAU;~}hzW~IB>D__V8v9jL7u?dD{kG9l>4*?CC$9qsYHfcUlD?hGM7efWbGF23 zadh~u@}#efwhX-Qu^U4y*Rs_$wN}osdyh4AQqtlP`;Dkx%#tsMuQa&5`zNAMekV%b z(cZz@@{Oz7X(?+T226;vhYw);xazWsusWzLTt^i>32w^4EMMzPi?LO2R+RnsCJm;S zrV}1Lk7L-9J?G-=vn7~2_1EDLZ79fzj2{udt~eb_d*{IIaFl@-Fq#yCUv5*neiD#3 z#GDP6TIU4MW3&U$A|oxW#QSb&r3{^AW^p8on@IsJVnQ}hnZL}3pT$TbYAJL)B#ET; zdw>n7S~&s<*jiluLinTYFeZ#UNtKkhMlOgQFOyIJsYP120^`LL!EH&)MsQG$aoPcZ zO^Rz8(rlZP?p7D3fVOqYNz2GP(IU9!TR3)P?ZOV&+enyO9xNTG$U+e5=V>Br$Sw+V zWdJmKkt!Xhv>taJvP*irE=>qXj+!ED{#W*kLH=n5kp4CU)^>(({JYB!zxp*|%OzUW zY0*{<+>C^RoNS|)uMlEjifvsfp)Jjl`xB4!R3b21{YujL(eS>7c3dZV4N`3?5mTTn zQ1rZCWHF`d7{&$~bf{sKjv=jXFucwLO|w{IcFWvZp*h$hG=n#Dw7(szu(>%}@AorS z#Sz$40Zu#B!(i2f12m;j&nmQaKrpg~w;@hcauY%fxhuN<<-7I#zbxo>z(J?e|=8m5zNX|)CnRHvh<*)$~2 zstGiM28`hfM|J$;yM`76yIR}kaX$agmr9#iJKso|Z#q{zDKiuCQ~R+>tjjp{UZgQ1 z1O)_`h6V%SQ8>e;^AF(`hu+s^|MXW~M!z z>XZ|VKA=B^>-%i+0Tcx8G)kSjPSi6%Nk<>{R=%ndU^e!JFTqMpCMUcoR~pS;P&UM*wPqPcOrUTW-Wwo!?~2A*kFiYnAaMI2Le zrM6PIv*mao6>(l@pD1nHEEUnjUmE|{1hk^5pff;Iq3Bw~Ml=}Yp3u_`l*#pmps&xW9XES*4^)doKTv3=^ zvsWfvx8h}p`lIn|X7CZ+3R6+qGNTzVu)ECoL=bYQRLWZ; zO+pF1@MN!t^{^(uIqp#BdIB>!!!$NZorLQ_kn06Vr+y{6vcsy4=9>c6&B7Ko^Dk`y z52oiN?*XH%s&Btq@bH8}<|y(+2lYn5t-D*uemE%*FjH$!fu)oOS)pmD)X~xx8u4() z5zgs#M!n7ssaS*QF4jF&@MJh5RTdYJs%X&o7`?_q6waBqmOZ?do#oOVpx2ngw$gWG zmg3#A_uhNC$ul9@)8zCg{@ZdxyFz4Sdi6{$(0_`kaQ|9v_6{xd8{Etpc!08>I4S!82hZ-8 zCqQ1o^7p|dchvXV1X75d3ifAxY;b|fBz(@yth}^4?cq|yxV2DQG}Nk=x}eeQB>su!bG{;8=aNm8(TM_xBwZBHrCFBEN}z~r z#waZzJ4lkDXbZZ1x~N2g>Cey&6SztK4!bd4fUYQAfxI z*|%UI8)Ljp+K33Vz*lGrcD`5@;1l){_*5k!2-M_?LCzBhZ14vM6rH0__>6mJhiAlp^#aY@l$w>#YSt70Sbv#OIAr8(zRd4;KeR5# zCvN>x422m{MGxAyFGX|Eq^T#LF~^QEPUCV~oi`hlYjUQYKIW6B(@P3~e1Jh?_R`;B zBIeT(WPs%DRj`Na0!{YY^ZU}=Wy0-(~|2y85CCN}P6| zZv+Zb6Ed;{F+!XQ(PoWsikD&OVk;Y#4&!q4O$@k5!aDdMiVwBEz&}%e7(#Z&QGA}-QU`!2T8NB2$+^Rb$4XEbZH^Jso|m@HN6Y&I>?y1INy z!Rg&5fO{m!CR!;({>*K0Tj+{T2pgwUqWd1Q-U$O3cc=vRVNSYCc>AkSNcDivZUdsK71@RP)runizOPUD= zVA^_A4LP5R^=fDz*tltGZ+N<7UQj{#eV7>bzQh(=?!HiSM^YKf>u0FLr~wL!?~|*` zct%`#m>jbv18c}NP5w8IpNM4Fm8VP@p;Y^HgAWUj?T7UM^48svArD%mMUYK{@=^h_ zz|ofcoi)ArmI|RIy8r?Iik7M|xG%`U1lGLHoQyWH;C<~ko_>acgS>*D5N_8DoS-@Yyqh@ugQ&??ej~i7n)yH@^`NY~r3;+5qc7*4F z+ks2?Rui;HwbaHK;vLnh#(dqURmJbV!tSYCbC#oxN^6#m{u*N-vplV_gx}J?G0WL3 zh97Pz**o%Fo3W-B1QR=6Ln<~BJ379PQn+Rd-+H*V75Xv@sbtPAlZVu(l95wZtkaJs z`t&3hhTMPN;u=;_B)Sfu3d0OD3xoFV$eaS~a~pn2UsHP4s1L{fKK2ap7KHU*Qt~9g zfPlc1|0xK+J%PQZNcz^6mWEai_Ka_Fc=Xfo>!y#`a!ZX)h1dfj>A@nrsRFN-O9#xt zADO%BgRYE>6s*`7i_ddyey{r!O-I`7LI7nK`VIxPk!v^&OJX|4F;6!rJeJjzB@_ZF zbFf4)Uo7X8{qk8CblWdVK>e#}4S%q-(P@5CDHTh)*Ckw@+`c=HIP#E0321MfNH2rYt&q5$5ol4xa}>o_z8qOdU{32^G{K%2aYE zzkD$9)Lj^*?XJ~j&#sAs3~4NkU3DnVVQWMUx4~wIr50E3gpejv3<<^Bg@;-}&RL+` z$)3dfs6ad6J^HgnfEqcym$=X+Y$Ec)tmx5SRfssXigDS(EDmb4_7>U`R&by@sZwN& z1&ll^*E#u4HseLJc`!b<|0r~gf-9p&)VLvsbjslL$;M_GVu6v(8ybvxM%Lu^;PJly zI)T1`VSDS!1=C*_)!+8z^ptmL8Rq6;n@$A@^N?RG2pP1RHnlKP(uc`r+<)mv!?gQ> zcA8teQ{pGG3Jt!4IaYvs8PG>Lg``#Ug_kp>g#<}mru@FS&aidb%jkU(qR2wCQ7)LM z74$JSk=3Yv5(W$c%Q;^%b@JQI`0j!$*yN73N_zd9y2(-?@8e9#NJ{fm7{#)ZW=$2h z;ca^cj~^Y{*ygS=c5ULz%kN=a z>z=(baxYVWRZ7Sfdd0yj7mMwpaTNmaP79G)>&y51pTJ?VAm_y6?G+4ZzW=m{mMZAq zh_GHN%6b-PmCV{6k!Vv768ZM2#r?h7d>5yNGVIfj4czpiP)%xRJ?XW*2|5O@c62!4 z4WNKUae9oYa*?wTMQ9Dn_=#Eq)@3ctH7)JOFJLTnWs_fug~)f`L*~SNCQg*cSXH5w z04Zf65kVDhwQShNgVEpbEuAEt1$)P=+eodwrL}~l0WB3*OKu8GDSnbb23vs$uZdX( zq@0Pal)MrJ!YhYYMBn5Mxf^E2j8_H4GWJH++pmLFIn zk~7M8`&)x9m{x-9rd^p#1WF6M^n26PHQq(oTx}o5Z0*i#3f2jR@qZqLrA>rxph;WL zhgVxpF>)#Ith|Ps)KuFS?_8U1tIGE#&t^UO2{IcMR9M@KK3J8XvlxXTNv&#RKf_(Q zD!$_MyurY`(BOl@?Qo!#&*g}##~}?ty`W$=_7!-)FiKM{lFEA1odHSc5^auXU~M^#rPqx=hI^(5WC%HDyd5rti3zu zz)4wegLy@`uIXKhAVVpz>@j@8a#4HM=^g1ts2o)XppYiW;gY7fa3O%!LJ4FGVwwhM zNq|um*+6>C4hc}WYU?g=RA|pDj)MlAeEg9>5(Ls+Sp51O5l)h*K2P|}4l!$M@y!jH_FY?~X`}qnO zFobc5a?2GM8J&}4G}y}_!(Dnom86S3ARv|&G2s|Q2=+6X6M{DBHk*29VyC{erY?A{+NmKD14y;GC$LXjd}1k%3%!YjF9z#C;a&MPU_##c(xL#u0z$4OxqIT>FrBvB8*~m1 z=%9N}UT7E$afl4x#B3gI@>s*0cMrQr{{C>AzU#suOy8|YNF`75`7=Ro>R5M4f>bdCnF?gsruYZa=9efxz z-Fg{@teIF_%vPpThEckOr#50ePhNpz-TqVUBz=IYGSWZ|;lq^ErEpY}mNk%X4!>9v&c zn*GSr{!?%#{;T3)Z(?ZZVEMDDi90-kNafgq`n(<_EUs`06w@ms7>-a{u~SDMCp$63eB=CDvVw{ zQLJf+JqQf3CPscf{G25Qbj1iYa5LQG?V34rtm!?jom|dAc-3@6>K$Gz*|9`}dC0S7 ze-Mskoae4OOD>9%QciQ0^I@3$5)TzZ#=KJo=*%lxyJY8%w*G+^Ed43{;~%7~oG?=@ zH8L5~`$?v96{;IQaNh_Ksg29)c)i_%f2=eABO$-`zJEhV%KtSX+bkeHA`3W*_Jn+X^nRi7#Z^d#1FQTg`Ow^`1;+#@>wnULd@M(Y1FA(;PTh5T9@ zzo=+c)wE9mpt`SVcb;jbSljeD6$J63cp9)BI~lD(4lpW&st|HXc|J*qK@v_%<3(>1 zdUtQ67rT{#@^6jv$~4-(D;&~cWIXmZe4i<%lZ+;Va=A3$TQI;vg@a+5+70}11Vc6{ zqrfvPgYaGs_gx1#l&m7kWuUDKD~{42QtGA|kfdxRHAJ8^BU!R;!_t>0`Lgq1ri{u_@#(P^j-lz^ztY!Up2_Gtiy7s&>Ej2G6_X;qHCs0qgYe>Co87MJocE#6<0*;)g&c zvo2mN=dxV=9L}y?u))*R{!b`n;0Y9x?5gh|gC~=|dUo$(Czgv5iWv`LJcH%x!Fg2` z5D(gbz^nN7oNs{)@cZynt=02xr3P}hq~ht)0q3qGX4rpJAh1JZz4J5RW`t22OZD|7 zjca)4A{}7*9_mM#_+tlim^NZMUNnGQxQa)cb8WW1n1Xhf%)@)PiDvtoun}w;Yy{$S zCSsVmT+D&o#6>(~8h{&SIuOeB9ZiZKeMYr<*g^XuqMg*8FvxI!7;8wAe&B2iaxU~* zH7Y*25euY9n>kloA@aEam`Shrl!H)D&`#<+UKNpb2iUf+CONS_2`Bba1@Q;m7$2o; zYqdpgI%+dKgyd9eSQ&0=qj5$_1=*{ix#WU7^1-Ob(cpV)KkY)EnhBav%gL#h()8hL zoGfFQR+IGw>+(HYVHt|1W5}=G$E~foX8!gl=XHJo`1-@F8kI6hRzG|0|a?v`= zyxfilBQ+aQate(1du0czQdVVx2Y%tIC*2Y?x}TSf>YnJwbKxel>y~RFL zI*kL2NlucPdn!SzCWz=+4SG+jz^djpm+g9x2GY=ta|qSp7EIOL!W)1a6QaUxPXgZW zRH0p36^&HFggv_9?3r`mH`=8TjJixwAhWW+XB9}V_@+F1{_C!!2T zHlm$E!tIQzdpN1lvtThOCgdWdMk=qhZ*nYKBz?m|CntSL?C~2QA%DOAYh4U^OT( zJ?5BVn{N$ufW75)fI7P-?f9g$VXmzX{HRRxuB{EUVQ7=-_U*TuG+*4IY=9+`)`!zW zH4Hmdf8G3DFZ2mVlhC! zQYkChyX2!iCE8&)8;8W|i#kt7aoL3m34=oc!CXneSz} zh~xbq4~~k)O~$YWe<%jKOmCb4hEQDk0O^m~*#+EDyQ$M{7j!}f=kjHQ)E>$Y%Niko z==ckR_G7FB)(RR)tQSoLnJkN%*t+*s)6vWJLar$ZNONd{`zQiIRlujiuDg8zpF}H; zPhD39PU`%^ctGg*90WrioxuG+;V2mRrpTjU_yCeuFoJcWRbi6~BEFZdm!0o@zi|2B z>#NL(<_hBzlJP90;vVwAx$Z1E8T{PrXMsoDe3lffq_?LFW1@TKI^a=>po+HUnz;lS z0Q)J?is5Lipr12(@W$pY05>Hgc>FG(zxzZkO%6IEq+C??XmDUKmmdquxs{%cQ8JJr znE4}kO#fg6z3}~0qHZOvK`upnoepy3F8i4f`**6Q5P8HS4R60>P3Aa1h-#*s5U*ME zc41@{qnQy`x(Xt?16M3lCjjDCXbqSe4%V{|Qo9LGVTs|o$yI5jQ!-PG90o{OG~tGo z`v3?T+lwytTUdvT& zfY^Fkj_6Q+tvmeFt0Y_e;279cvt$~5FASYB1X9>cd?@_#@Uxgil^&KQys%y1AmR1S zD0VdS{zE~q3l|X@+LsN{n2B4+aj^U^&1daAG;5mo=~IFFJ)q<;FMP2tA0DVzV15=# z2-H9TY0y5(AKr69Dr!YT7X=kU1;hyqK$|8GS!SAvBi7-6q6zG_!BY&hTO-sMp4SP? z&g5uBaZx}j!wn>XHO(xSP%DN%hH8gKkgN%i<@x{;{Mjn6Kg5W*C3r`kLT*o-?pypK zV5oTgKsfc&^LstC=m@DNcrSBED?zMTh~dd`d6?%)diE0V&hOEM4IZc}Z>0z!W% zSc_C5+L6l#H|-B{hf-C2>UGhzDASHkgtv5h~;<4bCZwY>@2EPx|r_f23FF;UAKrTpL;4BgSxUh z-4BaiEF?zsGMGSka6T`nE((GySk(gIddQXx`+0ICX_HP37vr_OO~Od59RcnGhA*8bxV*ty)Z+TvizV?auUb)-mnPOO=hultUM;~ z^X$HRSI6;_FfdK2oCRW)tc!;~<&d%vSucVS>L`Mq9M_#iGE z7wVgx>-lrhcCFtmo7dxHGctSd4;OA!hNWp`6&?bF#O`StM2^s15s4ti;aTL9ceeaG z(00bftSA9Sb(?-MA$8z&`h|#2poEsb;0sNvrZ7cGq;d{eWKS8VXaakelKgA1EUdAa z$pftJP6)|%KgQzAd?fOud+~E~qF$ ztx_uev|)-!vt`fNV1Gp51D@sNS8j>$YP7yKWe8q3qs8qX#1<{%ScDM`D>$u~9@^U| zD>#FHBuTpym83J1INAqdObwJQP6#lStk>T z99xbE7^{knq8&o86x|;*hlT*TkNB<>(-!kzHD?9@vG)TA5K!2w{^>ufe*QxMVRq-Czku*A@38g6j(NKmgxv9Js?Z za2$-Y^}XEu7!UXGM+`OIvFjKWy`p zYMjXpp)&fQpy}SL1C6X6MgF_-cvNl>#7ov!4YA>Cb{&<3REh3M43yNBuvj|WKJ ziHXK;7O16B(=Jeny&*i4^zwn-yPXf=%gF7U)}0YX4DcV{^|KYv#*+W;`wfx z)HYd#d3K(oZ(}F|N6bx}BZv-ieno!(ru=ZWd=nXeQm1h-Vs}F|l3$0MW05h8JAmhX zo;o+h36F{3V9ZPK15Hj^HYicH5wl)HB7p*mss4rhYjn zjB@4uLGakowDrXP`#WxqnC>u*q%ZHK*Mpm63Jm#ygXci3zkf-i^Y=Hh)_J~WwH<3S zf_DX+e5<}G03Tj4^X7a+9zmzJ<58vARX%rEJ@hsF*_E~@hFwap5^A+70T(uc@Yq3G zc4OhsCS+X&qYY-=xGX0*E!54}ApuA;*Uz#*zb0(j^V10}UR^GE!skqfQIeh-N`)6q zHlRx^{&r4nQ_X)!nAR`u%$JSz93?+)?kcA>%~-zgqE#JoksRitnYLToKvCYCIA5~+ zBVn0cGQXSj@^U5tBd-ldLAxctO)I>}lUs%-obKVLkp9KIb)w%_>y{~j1*snoR<97&is!XLCNIMa{V|6PsYMc^Bv@9P?kX@wG{m4D?06J2Y4;o`QkLx7iEDL|D?B z_B&7CBYmp@38`|Z?qVllPw78*WI6RD8F+W(qWt~yY*SZp%cd)}Rs*kw(FB`aR+!`H zhMVRIH?k?GjT?6VaZS6I___}JBD0>2Vg#5n_6W{lJ{Z}FHY>HfcU>~H1rC>Zb-{S> z6P53AimR7(BLB-sMaZ(ie!6I%BcEU0;@P$OtM?z6+b9R2HQFUPY-Z44DR!YTJL$0y zm9=WULvaZQlb?eC*dB~v_dRo`hMOh>>5osTpW-?3^ER23+j`|9j~ z_BKKJXv0CR?Fw0VMh=|OFU*1q%)=4o9FFiRVqFVEa3XDoI_Q_a6;DG?=Z|-~C!F$x z@dQIyT8-p1D-nll@uGBE2L6?H9Y8VE>-0_s1$1H) z1MCj`+IX++gc8kZmxFGJG>s2GUBDLXNz9uPmYO?(;^j zFBMJO1?WLE5fx)9nn^^x$`i#%qwCHZzbwAnVV*KiixwHEeBtm3WNO*6Oy|lj!334a zmbFhrRjrdjUql3uiad$Ao5)=N!61q*X0AkR+!?(`%kCA70dSep!#X}JWign~5i{SH zt|GIKR5eR_!TNqNFzhMva%WXMKe(i^VW6bt#N&*BJT+!6KnTh;@=+u@$>?h$+&&h; z&p7IpK9B z^5-qtRX+yBqIH~ROV5*Xly!V%x<(2V$u;rPOw7p=!+pezcV8T_l<2zq3~ijS!nztM z1L5X8BnkZHBs(L*8JgxQMpAY@tg%bIbJ+mt#E1Y zYb>Xv+=09_fb%?x-_9v>Ca@PgTprXe`U)WCv-u@`N`-aRPoy7fy?S02{Y*MB!EOnQ zu^qa%8h>LK2zQ zDH%V*E%|81VQy;ip{N#fP%KzYI~cn9h0zk_f?2HsQSKDnbv@G>mSkC)+P68{!aAv? z1J1=G5zK5~`~`de1#qH(O=w{66mgp$=o%E>kSt4F!J7#(G(VG&W?=>3N8C%3i2dgt z(sx~RV_nU32&hRtj;3an%ZfS$`7<9TqGkqpCH1rrElwavy2;Kbw}-{Wk_EgInc&Ah z);h`n~InRItWci4DUn*vx9*cIvn(74!T$C75!L@T6mE#tEZNOKmQ6FFJyMgq?}PTdhTfiw@X(lqP{ zDIg0KcJ+b~E^((GB0n?VqG;iOS>P7)*^cs)EeLpjH@V3hIY3KD@S$}?{;0=Zb|syk zCGiOK05|R!1v=dUM|^}HS`J;4-dMPN>;Mn7Wz}98~0@4kq#x;u_+C- zHlk!!hTW%p`w@vM2Uo1*x$V@wd*&4OXh~!rMfnS1B1e6< z6aZ(7IpDNg7vPu!5@fqQ22LVkjLaL^BOZY7gSkmAf+#blYqN6}14w;e5q=`b>#zk9 zq>G6kg*mQ4&zW?JURROU5==Y zIzN5hx3$Dy$scf=62Ylb&&ZQTs z@wCux(^A(OFTzyW2o9+nuF|BkF2fDu!#HsB_c}XxKhAr6)g?^7vgY?5mLUb2#C&AK zEJ+mePPKYeF=5aL4l*-tLc`jD*M8GYDCMw=C4~f~PXx?{)N^g4&=O{hSAp#%mW0}I zmrZ1ikvtkpw7CXh0dnp160p#)MaFyE;Y{)NeM`0O^+o}aLt`X z!G1UHJooU;8W6pjcXIu*qC+E61yaJ6^v zOhxNs<<67iYbeCr@t%A#Xtby;>oq-093dQc>uH9ybH^CU_lri~uUsb23&Ew&pn`uR z02V3O3<%#2-JvI@<%dz*LuaI*{Up*V-CQl&YsyyBDyGV8qM10A0$5r!@S*cEwnHDE$@L zEo+s?`Dg@3tqZ5EGMY7QRmc;_XzJk@87Pgt^9^~4cwWe7C~(V5N_||ci!tN@ccRw2 zU67my*UKL4B(CVa$MJ)Gb`^wO;0$`O=gopJ>Ru+oPrj^*vl6+}f*098=dUfi9^Vnj ztqXO+#Z;b#MqUY${|q+Rqtb$lVnz&lC+w@NR1)Zm3cX)QfJdMZB=}s zavmuV(!t08koMIFg5QS=8)P?Ssk0TqtYyW~>9NUzEFV!RP6tk)r&c0Mmd1wx7 z#ka^q+R1H>yrvbcoQDy!o8v*F2Ngn>-;N>Sb=-FaW` z91*{N(S=w^6-@>j*ZBA?2H{R(i-MTjSicdHWDUdGeUG~CUrJmDm?!A(uQ@st#XkiI z)PL=R_9nV^h6V}_c5j>ETYes={Hp#2AiA%WW9~HuO*yGsye8<806s5`V6t9dcci|V z0it+}I1KIkYp&cCOBkBq!LPIf+&Fk+9D?D-_)c>j{sJ?rqbc(R#&D4eZSz(<)*pD+ zQXgmeKJK})tWLHpC|G=;c~0z2^eSiqSog)|ht!3ck%XMj$ZR_soOSAL&R1A%p+Y_Y zkV(xK*^P}))k79pGru^QuD0-66L3ATPS0)xeBK?^L%-Hj!e|Ucq0&mp5rW1xL+250 zbu#6hERhOPRnKhqX1<(FZx>qULt(VVn(L!OzGiZe0WpdZ`i}O^bI!YZGGrZLYUP?U zKU0~bay72WM2Q3gS8V~APCb4putE=t9M*)3F+e~?H+P=s3S0_ZpdG@47=h+1y6*Nv z@m?|t)-nDaMn%zGJ$=s$B@I{}?R(V~3VZ=&83d$Mry!q0a7$k>Pa3^f&5RDM0-QG4 zPf8mc?Y?U5di@}S;O)pF2exYRS^Wfg3rb%61jU=Fp`IKP%-a=fHw;m0R1*@}hfKtu zZnl1r+{f2bY-^nO<$JfUd2oSEclR6w@DckS>UFQ)!eRGJ za`<+;{nysg$(-W&!>I8mILb z1kLakAD|ta9pV%d0>OHP3b;@{uiI1c;vqqh9tP3~a|!3~1jLM5sUjg7hmq=hT{cbl z97%k8T@}AT&GJozS}G{D_p3}VPNL4mV&3L5P7+8JolVP)YWWm(g|!#jqi&gU1#UsqSzC4Mw*PJlPC8#w%~04tICH{jXH7qt2x?UW&&@7}gvy2M&Z%vaCahW#hcdh6R# z7qqr=cokP_E4tVi+H1Z!)@Zz@Ocw*H|LGIjuoWD2CSxCv)}3t;*=B9gvG=FBh%3|{ z&(nP%QUH>{yYjkP_qAP~0;##NABq@*pxjjEO{Uc5`B0d;c}(3__cQI5sRaqGInpmH z@5pNAbl67)Z7@Q!2KenqNU|QHWdtEjmyL|Hh0?!YzzTH z>c!ocOoG)@MLOV5EP2M?X=K6Jr*l1amoz$ObExZfl|3ofN@%M#a(g{`KN(V+Bev3y zhvJOYs1PyfvW{%;#kVnRoZraQe#Y2>;pI3jIjud=bwJUpGVJ2mduF>P2{ksZ z^>cFZa_}KN(>)PX`{;fB=CtQ9j$_6^`wrlVoI@HuR?ziX-qfq_^ks}R`TzLzqkFpX>k7<ds||E4cXUh@V~A9Y83nv;P?Ki zx6Zb|#?=(Ue(tqlq|Fr&HTl9D9p;s<{v;L(L`P2G$ zArA3h|MTlr0mgsd^FOJP{sjD8$ntl3N+=vMfp{p{1fH( zr>(cr!Cxc)Rb}={^nWTO{0a1XR`z$GFoypG^y^XWPoUp7p|>RNuTjSG3+R8ObbliJ i9^C#ONgx6LcI%Rr1bcN&ARv_2FW^^azu Create example/demo configuration file for the user + $ fmudesign run => Run a configuration file and produce design matrix + +Without arguments (init / run), the CLI will execute 'run' to be backwards +compatible. For more information, look at the code or execute + + $ fmudesign --help + +""" + +import argparse +import dataclasses +import functools +import shutil +import sys +import traceback +import warnings +from argparse import ArgumentParser, Namespace, _SubParsersAction +from importlib.resources import as_file, files +from pathlib import Path + +from packaging.version import Version + +import semeio +from semeio.fmudesign import DesignMatrix, excel_to_dict + + +@dataclasses.dataclass +class Example: + # Examples used in the 'fmudesign init' subcommand + + filename: str + description: str + # Auxiliary files that the main file depend on (external params, seeds, etc.) + other_files: list[str] = dataclasses.field(default_factory=list) + + +EXAMPLES = [ + Example( + "fmudesign_ex_montecarlo.xlsx", + description=( + "Shows all statistical parameter distributions, " + "how to correlate samples, etc." + ), + ), + Example( + "fmudesign_ex_onebyone.xlsx", + description="The example file used in fmu-coursedocs. Extensively documented.", + ), + Example( + "ex1_onebyone_rms_repeat.xlsx", + description="One by one sensitivities with repeating RMS seeds", + ), + Example( + "ex2_correlations.xlsx", + description=( + "Sensitivities with group of (correlated) parameters " + "sampled from distributions" + ), + other_files=["ex2_doe1.xlsx"], + ), + Example( + "ex3_velocities.xlsx", + description="Testing different velocity models with uncertainty", + ), + Example( + "ex4_background_parameters.xlsx", + description="Sensitivities with background parameters", + other_files=["ex4_doe1.xlsx"], + ), + Example( + "ex5_single_reference.xlsx", + description="Sensitivities with a single reference realisation", + ), + Example( + "ex6_singlereference_and_seed.xlsx", + description=( + "Sensitivities with a single reference realisation and seed sensitivity" + ), + ), + Example( + "ex7_background_no_seed.xlsx", + description="Sensitivities with background but without RMS seed", + other_files=["ex7_doe1.xlsx"], + ), + Example("ex8_mc_with_correls.xlsx", description="Full Monte Carlo sensitivity"), +] + + +def get_parser() -> tuple[ArgumentParser, _SubParsersAction]: + """Create argument parser and return (parser, subparsers).""" + + # =============== MAIN PARSER =============== + parser = argparse.ArgumentParser( + description="Generates design matrices to be used with ERT", + epilog=( + f""" +example usage: + $ fmudesign --help + $ fmudesign init --help + $ fmudesign run --help + $ fmudesign init {next(iter(EXAMPLES)).filename} + $ fmudesign run {next(iter(EXAMPLES)).filename} output_example.xlsx + +getting help: + - Documentation: https://equinor.github.io/fmu-tools/fmudesign.html + - Issue tracker: https://github.com/equinor/semeio/issues""" + ), + formatter_class=argparse.RawDescriptionHelpFormatter, + add_help=False, + ) + + parser.add_argument( + "-v", + "--version", + action="version", + version=f"fmudesign {Version(semeio.__version__)}", + ) + parser.add_argument( + "-h", "--help", action="help", help="Show this help message and exit" + ) + subparsers = parser.add_subparsers(dest="command", help="Available subcommands") + + # =============== SUBCOMMAND: run =============== + description = "Generate a design matrix from a config file." + epilog = """example usage: + $ fmudesign --help + $ fmudesign run input_config_example.xlsx + $ fmudesign run input_config_example.xlsx output_example.xlsx """ + + parser_run = subparsers.add_parser( + "run", + help=description, + formatter_class=argparse.RawDescriptionHelpFormatter, + add_help=False, + epilog=epilog, + description=description, + ) + + parser_run.add_argument( + "-h", "--help", action="help", help="Show this help message and exit" + ) + parser_run.add_argument( + "config", + type=str, + help="Input design matrix filename in Excel format", + ) + parser_run.add_argument( + "destination", + type=str, + nargs="?", + help=( + "Destination filename for design matrix " + "(default: generateddesignmatrix.xlsx)" + ), + default="generateddesignmatrix.xlsx", + ) + parser_run.add_argument( + "--designinput", + type=str, + help=( + "Alternative sheetname for the worksheet designinput (default: designinput)" + ), + default="designinput", + ) + parser_run.add_argument( + "--defaultvalues", + type=str, + help=( + "Alternative sheetname for worksheet defaultvalues (default: defaultvalues)" + ), + default="defaultvalues", + ) + parser_run.add_argument( + "--general_input", + type=str, + help=( + "Alternative sheetname for the worksheet general_input" + "(default: general_input)" + ), + default="general_input", + ) + parser_run.add_argument( + "-v", + "--verbose", + action="count", + help=( + "Verbosity of terminal output and plotting, " + "run with increased verbosity level -v -v to include more information" + ), + default=0, + ) + func = functools.partial(subcommand_run, parser=parser_run) + parser_run.set_defaults(func=func) + + # =============== SUBCOMMAND: init =============== + description = "Initialize a demo file to get started with fmudesign." + epilog = "available demo files:\n" + ljust = max(len(f.filename) for f in EXAMPLES) + for example in EXAMPLES: + epilog += f" - {example.filename.ljust(ljust)} : {example.description}\n" + + ex_filename = next(iter(EXAMPLES)).filename + epilog += "\nexample usage:\n" + epilog += f" $ fmudesign init {ex_filename}\n" + epilog += f" $ fmudesign run {ex_filename}" + + parser_init = subparsers.add_parser( + "init", + help=description, + formatter_class=argparse.RawDescriptionHelpFormatter, + add_help=False, + epilog=epilog, + description=description, + ) + parser_init.add_argument( + "-h", "--help", action="help", help="Show this help message and exit" + ) + parser_init.add_argument( + "file", type=str, nargs="?", help="Name of demo file to create." + ) + + func = functools.partial(subcommand_init, parser=parser_init) + parser_init.set_defaults(func=func) + + return parser, subparsers + + +def subcommand_run(args: Namespace, parser: ArgumentParser) -> None: + """Handles the 'run' subcommand.""" + + # Check if defaults were changed + for sheet in ["designinput", "defaultvalues", "general_input"]: + default = parser.get_default(sheet) + custom = getattr(args, sheet) + if default != custom: + print(f"Worksheet changed from default: {default!r} -> {custom!r}") + + # Check existence of config file + if not Path(args.config).is_file(): + raise OSError(f"Input file {args.config} does not exist") + + # Check if destination exists + if Path(args.config).resolve() == Path(args.destination).resolve(): + raise OSError( + f'Identical name "{args.config}" have been provided for the input' + "file and the output file" + ) + + # Parse Excel config file to dict-of-dict configuration + print(f"Reading file: {args.config!r}") + config = excel_to_dict( + args.config, + gen_input_sheet=args.general_input, + design_input_sheet=args.designinput, + default_val_sheet=args.defaultvalues, + ) + + # If destination is 'analysis/generateddesignmatrix.xlsx', then plots + # will be saved to 'analysis/generateddesignmatrix//.png' + output_dir = Path(args.destination).parent / Path(args.destination).stem + design = DesignMatrix(verbosity=args.verbose, output_dir=output_dir) + + design.generate(config) + design.to_xlsx(args.destination) + + +def subcommand_init(args: Namespace, parser: ArgumentParser) -> None: + """Handles the 'init' subcommand.""" + EXAMPLES_DIR = files("semeio.fmudesign.examples") + + # Verify that all examples in EXAMPLES_DIR exist on disk + for example in EXAMPLES: + assert (EXAMPLES_DIR / example.filename).is_file() + + # No files were provided + if not args.file: + parser.print_help() + sys.exit(0) + + filename = args.file.strip() + valid_names = {ex.filename for ex in EXAMPLES} + if filename not in valid_names: + print(f"Error on {filename!r}. Not found among: {valid_names}") + sys.exit(1) + + if Path(filename).exists(): + print(f"Error on {filename!r}. Already exists.") + sys.exit(1) + + with as_file(EXAMPLES_DIR / filename) as source_path: + shutil.copy(source_path, filename) + print(f"Created file {filename!r}.") + + examples_by_filename = {example.filename: example for example in EXAMPLES} + for other_file in examples_by_filename[filename].other_files: + with as_file(EXAMPLES_DIR / other_file) as source_path: + shutil.copy(source_path, other_file) + print(f" Created auxiliary file {other_file!r}.") + + sys.exit(0) + + +def main() -> None: + """semeio.fmudesign is a command line utility for generating design matrices + + Wrapper for the the semeio.fmudesign module""" + warnings.filterwarnings("ignore", category=DeprecationWarning) + warnings.filterwarnings("ignore", category=FutureWarning) + + parser, _subparsers = get_parser() + + # Backwards compatibility. If not a known command, assume "run" + valid_cmds = ("run", "init", "-h", "--help", "-v", "--version") + if len(sys.argv) > 1 and sys.argv[1] not in valid_cmds: + sys.argv.insert(1, "run") + + args = parser.parse_args() + + # No subcommand was provided + if not hasattr(args, "func"): + parser.print_help() + sys.exit(0) + + try: + args.func(args) + except Exception: # noqa: BLE001 + traceback.print_exc() + print( + "\n \n", + "fmudesign failed. Read the error message above and fix the input file.\n", + " - Documentation: https://equinor.github.io/fmu-tools/fmudesign.html\n", + " - Course docs: https://fmu-docs.equinor.com/docs/fmu-coursedocs/fmu-howto/sensitivities/index.html \n", # noqa: E501 + " - Issues/feature requests: https://github.com/equinor/semeio/issues\n", + "If you believe this error is a bug or are unable to fix it, create an issue or contact the scout team \n", # noqa: E501 + ) + sys.exit(1) # Exit with a non-zero status code (required for smoke tests!) + + print( + "\n", + f"Thank you for using fmudesign {Version(semeio.__version__).base_version}\n", + " - Documentation: https://equinor.github.io/fmu-tools/fmudesign.html\n", + " - Course docs: https://fmu-docs.equinor.com/docs/fmu-coursedocs/fmu-howto/sensitivities/index.html\n", + " - Issues/feature requests: https://github.com/equinor/semeio/issues\n", + ) + + +if __name__ == "__main__": + main() diff --git a/src/ert/config/fmudesign/quality_report.py b/src/ert/config/fmudesign/quality_report.py new file mode 100644 index 00000000000..4f792aad0fe --- /dev/null +++ b/src/ert/config/fmudesign/quality_report.py @@ -0,0 +1,629 @@ +import copy +import math +from pathlib import Path +from typing import TYPE_CHECKING, Any, cast + +import matplotlib.pyplot as plt +import numpy as np +import numpy.typing as npt +import pandas as pd +import scipy as sp +import seaborn as sns +from probabilit.correlation import ( + nearest_correlation_matrix, +) + +from semeio.fmudesign.design_distributions import to_probabilit + +if TYPE_CHECKING: + from matplotlib.patches import Rectangle + +COLORS = list(plt.rcParams["axes.prop_cycle"].by_key()["color"]) + + +class QualityReporter: + """This class is responsible for quality reporting a dataframe with samples. + It has methods to print statistical outputs and save figures to disk. + + Examples + >>> import pandas as pd + >>> df = pd.DataFrame({"a": [2, 4, 2, 3, 4, 3, 2, 3, 4, 5], + ... "b": [2, 4, 2, 4, 2, 4, 2, 3, 2, 3], + ... "c": list("asdfsdfsdf")}) + >>> variables = {"a": ["Normal",[0, 1]], "b": ["Expon",[1]], "c":["Discrete"]} + >>> quality_reporter = QualityReporter(df, variables=variables) + >>> quality_reporter.print_numeric() + ================ CONTINUOUS PARAMETERS ================ + mean std min 10% 50% 90% max + a 3.2 1.032796 2.0 2.0 3.0 4.1 5.0 + b 2.8 0.918937 2.0 2.0 2.5 4.0 4.0 + >>> quality_reporter.print_discrete() + ================ DISCRETE PARAMETERS ================ + | c | proportion | + |:----|-------------:| + | s | 0.3 | + | d | 0.3 | + | f | 0.3 | + | a | 0.1 | + """ + + def __init__(self, df: pd.DataFrame, variables: dict[str, list[Any]]) -> None: + """Initialize QualityReporter with dataframe and variable descriptions. + + Args: + df: DataFrame containing the samples + variables: Dictionary mapping variable names to their + distribution descriptions + e.g., {"COST": ["normal", [0.0, 1.0]]} + """ + self.df: pd.DataFrame = df.loc[:, list(variables.keys())] + self.variables: dict[str, list[Any]] = copy.deepcopy(variables) + assert not self.df.empty + + def print_numeric(self) -> None: + """Print statistics for all numerical columns.""" + df_numeric = self.df.select_dtypes(include="number") + if df_numeric.empty: + return + + print("=" * 16, "CONTINUOUS PARAMETERS", "=" * 16) + + with pd.option_context( + "display.max_rows", None, "display.max_columns", None, "display.width", None + ): + print( + df_numeric.describe(percentiles=[0.1, 0.5, 0.9]).T.drop( + columns=["count"] + ) + ) + + def print_discrete(self) -> None: + """Print statistics for all discrete (non-numerical) columns.""" + df_non_numeric = self.df.select_dtypes(exclude="number") + if df_non_numeric.empty: + return + + print("=" * 16, "DISCRETE PARAMETERS", "=" * 16) + + for column in df_non_numeric.columns: + print(self.df[column].value_counts(normalize=True).round(3).to_markdown()) + + @staticmethod + def _create_output_dir(output_dir: Path | None) -> Path | None: + if output_dir is not None: + output_dir = Path(output_dir) + output_dir.mkdir(parents=True, exist_ok=True) + return output_dir + return None + + def plot_columns(self, output_dir: Path | None = None) -> None: + """Loop through all columns and plot them, saving to disk if + `output_dir` is given and exists. + + Args: + output_dir: Optional directory path to save plots. If None, plots + are not saved to disk. + """ + df_numeric = self.df.select_dtypes(include="number") + df_non_numeric = self.df.select_dtypes(exclude="number") + + print("=" * 16, "GENERATING VARIABLE PLOTS", "=" * 16) + + # Create output directory if specified + output_path = self._create_output_dir(output_dir) + + # Plot numeric columns + for column in df_numeric.columns: + # We do not plot constant distributions + if self.variables[column][0].lower().startswith("const"): + continue + + fig, _ax = self.plot_numeric( + series=self.df[column], + var_name=column, + var_description=self.variables[column], + ) + + if output_path is not None: + filename = output_path / f"{column}.png" + fig.savefig(filename, dpi=200) + print(f" - Saved variable: {filename}") + + plt.close(fig) + + # Plot discrete columns + for column in df_non_numeric.columns: + fig, _ax = self.plot_discrete( + series=self.df[column], + var_name=column, + var_description=self.variables[column], + ) + + if output_path is not None: + filename = output_path / f"{column}.png" + fig.savefig(filename, dpi=200) + print(f" - Saved file: {filename}") + + plt.close(fig) + + @staticmethod + def plot_numeric( + series: pd.Series, var_name: str, var_description: list[Any] + ) -> tuple[plt.Figure, plt.Axes]: + """Create a plot for a single numeric column, returning (fig, ax). + + Args: + series: Pandas series containing the numeric data + var_name: Name of the variable + var_description: Description of the variable distribution + + Returns: + Tuple of (matplotlib Figure, matplotlib Axes) + """ + fig, ax = plt.subplots(figsize=(6, 4)) + bins = max(int(math.sqrt(len(series))), 10) + sns.histplot(data=series, stat="density", bins=bins, ax=ax) + sns.kdeplot(series, ax=ax, color="blue", label="KDE") + + # Create string to describe distiribution + var_string = ( + f"{var_description[0]}~(" + + ", ".join( + f"dist_param{i + 1}={v}" for i, v in enumerate(var_description[1]) + ) + + ")" + ) + + ax.set_title(f"{var_name}\n{var_string}", fontsize=7) + + # Add plot of expected PDF + dist_name, dist_parameters = var_description[:2] + + try: + dist = to_probabilit(dist_name, dist_parameters) + x = np.linspace(series.min(), series.max(), 1000) + pdf = dist.to_scipy().pdf(x) + ax.plot(x, pdf, color="red", lw=2, ls="--", label="expected PDF") + except AttributeError: + print(f" - Plot warning: PDF not plotted for {var_name}") + + # Add rugplot + ax.scatter( + series.to_numpy(), + np.zeros(len(series)), + marker="|", + color=COLORS[1], + alpha=0.8, + ) + + # Add average and quantiles to the plot + mean = series.mean() + ax.axvline( + x=mean, + color="black", + ls="-", + alpha=0.8, + label=f"mean={mean:.2e}", + ) + + quantiles = [0.1, 0.5, 0.9] + for q in quantiles: + quantile_value = series.quantile(q=q) + P_label = f"{q * 100:.0f}".zfill(2) # e.g. 0.05 => '05' + ax.axvline( + x=quantile_value, + color="black", + ls="--", + alpha=0.8, + label=f"P{P_label}={quantile_value:.2e}", + ) + + ax.grid(visible=True, ls="--", alpha=0.5) + ax.legend(loc="upper left", bbox_to_anchor=(1.05, 1), fontsize=7) + fig.tight_layout() + + return fig, ax + + @staticmethod + def plot_discrete( + series: pd.Series, var_name: str, var_description: list[Any] + ) -> tuple[plt.Figure, plt.Axes]: + """Create a plot for a single discrete column, returning (fig, ax). + + Args: + series: Pandas series containing the discrete data + var_name: Name of the variable + var_description: Description of the variable distribution + + Returns: + Tuple of (matplotlib Figure, matplotlib Axes) + """ + fig, ax = plt.subplots(figsize=(6, 4)) + + # Calculate normalized proportions + proportions = series.value_counts(normalize=True) + value_counts = series.value_counts(normalize=False) + + # Create DataFrame for seaborn + plot_data = pd.DataFrame( + {var_name: proportions.index, "proportion": proportions.to_numpy()} + ).sort_values(by=var_name) + + # Use seaborn barplot with normalized values + sns.barplot(data=plot_data, x=var_name, y="proportion", ax=ax) + + # Create string to describe distiribution + var_string = ( + f"{var_description[0]}~(" + + ", ".join( + f"dist_param{i + 1}={v}" for i, v in enumerate(var_description[1]) + ) + + ")" + ) + + ax.set_title(f"{var_name}\n{var_string}", fontsize=7) + ax.set_ylabel("Proportion") + + # Add percentage labels on bars + for _proportion, count, p in zip( + proportions, value_counts, ax.patches, strict=False + ): + rect = cast("Rectangle", p) + # assert math.isclose(_proportion, rect.get_height()) + percentage = f"{rect.get_height():.1%} (n={count:.0f})" + ax.annotate( + percentage, + (rect.get_x() + rect.get_width() / 2.0, rect.get_height()), + ha="center", + va="bottom", + fontsize=9, + ) + + ax.grid(visible=True, ls="--", alpha=0.5, axis="y") + ax.tick_params(axis="x", rotation=0) + fig.tight_layout() + + return fig, ax + + def print_correlation(self, corr_name: str, df_corr: pd.DataFrame) -> None: + """Print information about desired and achieved correlation matrices. + + Args: + corr_name: Name of the correlation group + df_corr: DataFrame containing the desired correlation matrix + """ + corr_arr = df_corr.to_numpy() + assert np.allclose(corr_arr, corr_arr.T) + assert df_corr.shape[0] == df_corr.shape[1] + + # Get lower triangular indices + idx_low_triang = np.tril_indices_from(corr_arr, k=-1) + corr = self.df[df_corr.columns].select_dtypes(include="number").corr() + # Do not print if only a single variable remains + if corr.shape[1] == 1: + return + + print( + "=" * 16, + f"CORRELATION_GROUP {corr_name!r} (num variables: {len(df_corr.columns)})", + "=" * 16, + ) + + if len(df_corr) <= 12: + print("Desired correlation:") + print_corrmat(df_corr) + else: + print("Skipping printing desired correlation. Matrix too large.") + + nearest_corr = nearest_correlation_matrix( + corr_arr, weights=None, eps=1e-6, verbose=False + ) + diffs = nearest_corr[idx_low_triang] - corr_arr[idx_low_triang] + corr_rmse = np.sqrt(np.mean(diffs**2)) + + if corr_rmse > 1e-2: + print(f"The desired correlation matrix is not valid => {corr_rmse=:.2f}") + print("Closest valid correlation matrix (used as target):") + df_nearest_corr = pd.DataFrame( + nearest_corr, columns=df_corr.columns, index=df_corr.index + ) + print_corrmat(df_nearest_corr) + else: + print("The desired correlation matrix is valid") + + # No correlation in samples (e.g. discrete variables) + if corr.empty: + return + + if len(corr) <= 12: + print("Observed (Pearson) correlation in samples:") + print_corrmat(corr) + else: + print("Skipping printing observed (Pearson) correlation. Matrix too large.") + + # Difference between achieved corr in samples and target + diffs = corr.to_numpy()[idx_low_triang] - nearest_corr[idx_low_triang] + corr_rmse = np.sqrt(np.mean(diffs**2)) + print( + "Distance metrics between target correlation matrix " + "and empirical correlation matrix" + ) + print(f" - Root Mean Squared Error (RMSE): {corr_rmse:.6f}") + + if corr_rmse > 0.05: + print( + "Target correlation matrix and empirical correlation achieved", + " in data does not match well\n" + "This is natural with few samples, or very high/low desired correlations, " # noqa: E501 + "or distributions that are far from\nnormal (e.g. lognormal)." + " Setting 'correlation_iterations' to 999 in the general input sheet might help.", # noqa: E501 + ) + + def plot_correlation( + self, + corr_name: str, + df_corr: pd.DataFrame, + *, + output_dir: Path | None = None, + show: bool, + ) -> None: + """Plot correlation group of variables. + + Args: + corr_name: Name of the correlation group + df_corr: DataFrame containing the correlation structure to plot + output_dir: Optional directory path to save plots + show: Whether or not to show the matplotlib figure + """ + # Short circuit this case, as there is nothing to do + if (not show) and (output_dir is None): + return + + def corrfunc( + x: npt.NDArray[np.float64], + y: npt.NDArray[np.float64], + **kwargs: Any, # noqa: ANN401 + ) -> None: + # Add correlations and grid to plots + r, _ = sp.stats.pearsonr(x, y) + ax = plt.gca() + ax.annotate( + r"$\rho=$" + f"{r:.2f}", + xy=(0.05, 0.95), + xycoords=ax.transAxes, + ) + ax.grid(visible=True, ls="--", alpha=0.5) + + def add_grid(*args: Any, **kwargs: Any) -> None: # noqa: ANN401 + ax = plt.gca() + ax.grid(visible=True, ls="--", alpha=0.5) + + df = self.df[df_corr.columns].select_dtypes(include="number") + + # Only plot if two or more variables remain + if df.shape[1] <= 1: + return + + pairgrid = sns.PairGrid(df) + + pairgrid.map_upper(sns.kdeplot) + pairgrid.map_upper(add_grid) + bins = max(int(math.sqrt(len(df))), 30) + pairgrid.map_diag(sns.histplot, bins=bins, kde=True) + + pairgrid.map_lower(sns.scatterplot, s=10, alpha=0.6) + pairgrid.map_lower(corrfunc) + + # Add rugplots to diagonal plots + for i, var in enumerate(df.columns): + pairgrid.diag_axes[i].scatter( # type: ignore[index] + df[var].to_numpy(), + np.zeros(len(df)), + marker="|", + color="black", + alpha=0.5, + ) + + output_path = self._create_output_dir(output_dir) + if output_path is not None: + filename = output_path / f"{corr_name}.png" + pairgrid.savefig(filename, dpi=200) + print(f" - Saved correlation: {filename}") + + if show: + plt.show() + + plt.close(pairgrid.fig) + + def plot_correlation_heatmap( + self, + corr_name: str, + df_corr: pd.DataFrame, + *, + output_dir: Path | None = None, + show: bool, + ) -> None: + """Plot correlation heapmap of group of variables. + + Args: + corr_name: Name of the correlation group + df_corr: DataFrame containing the correlation structure to plot + output_dir: Optional directory path to save plots + show: Whether or not to show the matplotlib figure + """ + # Short circuit this case, as there is nothing to do + if (not show) and (output_dir is None): + return + + df = self.df[df_corr.columns].select_dtypes(include="number") + + # Only plot if two or more variables remain + if df.shape[1] <= 1: + return + + correlation_matrix = df.corr() + n_vars = len(correlation_matrix) + + # Roughly try to create a figure of a good size + size = 3 + n_vars * 0.15 + fig, ax = plt.subplots(1, 1, figsize=(size, size)) + + # Custom annotation + arr = correlation_matrix.to_numpy() + annot_arr = np.empty_like(arr, dtype=object) + for (i, j), value in np.ndenumerate(arr): + annot_arr[i, j] = "1" if i == j else f"{value:.2f}".replace("0.", ".") + annot_matrix = pd.DataFrame( + annot_arr, + index=correlation_matrix.index, + columns=correlation_matrix.columns, + ) + + # Based on a linear regression + annot_fontsize = max(8 - 0.115 * n_vars, 2) + sns.heatmap( + correlation_matrix, + annot=annot_matrix, + fmt="", + cmap="coolwarm", + center=0, + square=True, + linewidths=0.5, + cbar_kws={"shrink": 0.75}, + vmin=-1, + vmax=1, + ax=ax, + annot_kws={"size": annot_fontsize}, + ) + ax.set_title(f"Observed correlation: {corr_name}", fontsize=11) + + # Rotate labels + ax.set_xticklabels(ax.get_xticklabels(), rotation=90, ha="center", va="top") + ax.set_yticklabels(ax.get_yticklabels(), rotation=0) + ax.tick_params(axis="both", which="major", labelsize=6) + plt.subplots_adjust(bottom=0.15) + + fig.tight_layout() + + output_path = self._create_output_dir(output_dir) + if output_path is not None: + filename = output_path / f"{corr_name}_heatmap.png" + fig.savefig(filename, dpi=200) + print(f" - Saved correlation heatmap: {filename}") + + if show: + plt.show() + + plt.close(fig) + + +def print_corrmat(df_corrmat: pd.DataFrame) -> None: + """Print a correlation matrix. + + Example: + >>> values = np.array([[ 1, -0, 0.9], + ... [ -0, 1, 0], + ... [0.9, 0, 1]]) + >>> vars_ = ['OWC1', 'OWC2', 'OWC3'] + >>> df_corrmat = pd.DataFrame(values, index=vars_, columns=vars_) + >>> print_corrmat(df_corrmat) + | | (1) | (2) | (3) | + |:---------|------:|------:|------:| + | (1) OWC1 | 1.00 | | | + | (2) OWC2 | 0.00 | 1.00 | | + | (3) OWC3 | 0.90 | 0.00 | 1.00 | + """ + values = df_corrmat.to_numpy(copy=True) + assert np.allclose(values, values.T) + # Make slightly negative values positive + mask = np.isclose(values, 0) + values[mask] = np.abs(values[mask]) + df_corrmat = pd.DataFrame( + values, index=df_corrmat.index, columns=df_corrmat.columns + ) + + # Compress columns into integers so we can show more on the screen + assert list(df_corrmat.columns) == list(df_corrmat.index) + varnames = list(df_corrmat.columns) + df_corrmat = df_corrmat.set_axis( + [f"({i})" for i, _ in enumerate(varnames, 1)], axis=1 + ) + df_corrmat = df_corrmat.set_axis( + [f"({i}) {varname}" for i, varname in enumerate(varnames, 1)], axis=0 + ) + + # Remove upper triangular part for prettier printing + def formatter(x: float) -> str: + return np.format_float_positional(x, precision=2, unique=True, min_digits=2) + + mask = np.triu(np.ones_like(df_corrmat, dtype=bool), k=1) + df_display = df_corrmat.astype(float).map(formatter) + df_display[mask] = "" + print( + df_display.to_markdown( + floatfmt=".2f", + disable_numparse=True, + numalign="right", + stralign="right", + colalign=("left",), + ) + ) + + +if __name__ == "__main__": + # Testing an experimenting with this class is easier with an example, + # rather than trying to formally test the design of output plots + # using units tests and the like. Therefore an example is included. + + # Create sample data + rng = np.random.default_rng(42) + n_samples = 500 + + # Generate correlated data + mean = [0, 0] + cov = [[1, 0.7], [0.7, 1]] + correlated_data = rng.multivariate_normal(mean, cov, n_samples) + + df = pd.DataFrame( + { + "COST": correlated_data[:, 0] * 100 + 1000, + "EFFICIENCY": correlated_data[:, 1] * 0.1 + 0.8, + "MATERIAL": rng.choice( + ["Steel", "Aluminum", "Titanium"], n_samples, p=[0.5, 0.3, 0.2] + ), + } + ) + + variables: dict[str, list[Any]] = { + "COST": ["Normal", [1000, 100]], + "EFFICIENCY": ["Normal", [0.8, 0.1]], + "MATERIAL": ["Discrete", ["Steel", "Aluminum", "Titanium"]], + } + + # Create QualityReporter + quality_reporter = QualityReporter(df, variables) + + # 1. Plot all columns + quality_reporter.plot_columns() + + # 2. Plot individual numeric variable + fig, ax = quality_reporter.plot_numeric(df["COST"], "COST", variables["COST"]) + plt.show() + plt.close(fig) + + # 3. Plot individual discrete variable + fig, ax = quality_reporter.plot_discrete( + df["MATERIAL"], "MATERIAL", variables["MATERIAL"] + ) + plt.show() + plt.close(fig) + + # 4. Correlation analysis and plotting + correlation_matrix = pd.DataFrame( + [[1.0, 0.7], [0.7, 1.0]], + index=["COST", "EFFICIENCY"], + columns=["COST", "EFFICIENCY"], + ) + + quality_reporter.print_correlation("corr1", correlation_matrix) + quality_reporter.plot_correlation("corr1", correlation_matrix, show=True) diff --git a/src/ert/config/fmudesign/utils.py b/src/ert/config/fmudesign/utils.py new file mode 100644 index 00000000000..f35ab20635d --- /dev/null +++ b/src/ert/config/fmudesign/utils.py @@ -0,0 +1,216 @@ +""" +Module for utility functions that do not belong elsewhere. +""" + +from typing import Any + +import pandas as pd + + +def parameters_from_extern(filename: str) -> pd.DataFrame: + """Read parameter values or background values + from specified file. Format either Excel ('xlsx') + or csv. + + Args: + filename (str): name of file + """ + if str(filename).endswith(".xlsx"): + return ( + pd.read_excel(filename, engine="openpyxl") + .dropna(axis=0, how="all") + .loc[:, lambda df: ~df.columns.str.contains("^Unnamed")] + ) + + if str(filename).endswith(".csv"): + return pd.read_csv(filename) + + raise ValueError( + "External file with parameter values should " + "be on Excel or csv format " + "and end with .xlsx or .csv" + ) + + +def seeds_from_extern(filename: str) -> list[int]: + """Read parameter values or background values + from specified file. Format either Excel ('xlsx') + or csv. + + Args: + filename (str): name of file + """ + if str(filename).endswith(".xlsx"): + df_seeds = ( + pd.read_excel(filename, header=None, engine="openpyxl") + .dropna(axis=0, how="all") + .dropna(axis=1, how="all") + ) + return df_seeds.iloc[:, 0].tolist() + + if str(filename).endswith(".csv") or str(filename).endswith(".txt"): + df_seeds = pd.read_csv(filename, header=None) + return df_seeds.iloc[:, 0].tolist() + + raise ValueError( + "External file with seed values should " + "be on Excel or csv format " + "and end with .xlsx .csv or .txt" + ) + + +def find_max_realisations(config: dict[str, Any]) -> int: + """Finds the maximum number of realisations over all sensitivity cases.""" + max_reals = config.get("repeats", 0) + for sens_info in config["sensitivities"].values(): + max_reals = max(sens_info.get("numreal", 0), max_reals) + assert max_reals > 0 + return max_reals + + +def printwarning(corr_group_name: str) -> None: + print( + "#######################################################\n" + "semeio.fmudesign Warning: \n" + "Using designinput sheets where " + "corr_sheet is only specified for one parameter " + "will cause non-correlated parameters .\n" + f"ONLY ONE PARAMETER WAS SPECIFIED TO USE CORR_SHEET {corr_group_name}\n" + "\n" + "Note change in how correlated parameters are specified \n" + "from fmudeisgn version 1.0.1 in August 2019 :\n" + "Name of correlation sheet must be specified for each " + "parameter in correlation matrix. \n" + "This to enable use of several correlation sheets. " + "This also means non-correlated parameters do not " + "have to be included in correlation matrix. \n " + "See documentation: \n" + "https://equinor.github.io/fmu-tools/" + "fmudesign.html#create-design-matrix-for-" + "one-by-one-sensitivities\n" + "\n" + "####################################################\n" + ) + + +def to_numeric_safe(val: float | str) -> int | float | str: + """Convert all values that CAN be converted to numeric. Retain the rest. + This used to be pd.to_numeric(..., errors='ignore'), but was deprecated. + + Examples + -------- + >>> df = pd.DataFrame({'a': ['cat', '3.5', '-1', 0, 'dog']}) + >>> df.map(to_numeric_safe).a.values + array(['cat', np.float64(3.5), np.int64(-1), 0, 'dog'], dtype=object) + + >>> [to_numeric_safe(e) for e in [5, '3', 'dog']] + [5, np.int64(3), 'dog'] + + """ + assert not isinstance(val, pd.Series | pd.DataFrame | list) + try: + return pd.to_numeric(val) # noq + except (ValueError, TypeError): + return val + + +def map_dependencies( + df: pd.DataFrame, *, dependencies: dict[str, Any], verbose: bool = False +) -> pd.DataFrame: + """Return a new copy of `df` with dependencies mapped. + + Examples + -------- + >>> df = pd.DataFrame({'a': [1, 2, 3, 4], 'b': ['A', 'B', 'C', 'D']}) + >>> dependencies = {'a': {'from_values': [1, 2, 3, 4], + ... 'to_params':{'c': [1, 4, 9, 16]}}} + >>> map_dependencies(df, dependencies=dependencies) + a b c + 0 1 A 1 + 1 2 B 4 + 2 3 C 9 + 3 4 D 16 + + A messy mix of numbers and strings: + + >>> df = pd.DataFrame({'a': ['1', '2', 3, 4], 'b': ['A', 'B', 'C', 'D']}) + >>> dependencies = {'a': {'from_values': ['1', 2, '3', 4], + ... 'to_params':{'c': [1, 4, 9, '16']}}} + >>> map_dependencies(df, dependencies=dependencies) + a b c + 0 1 A 1 + 1 2 B 4 + 2 3 C 9 + 3 4 D 16 + + If no `to_params` are given, then the `from` column is copied: + + >>> dependencies = {'a': {'from_values': ['1', 2, '3', 4], + ... 'to_params':{'c': [1, 4, 9, '16'], + ... 'd': []}}} + >>> map_dependencies(df, dependencies=dependencies) + a b c d + 0 1 A 1 1 + 1 2 B 4 2 + 2 3 C 9 3 + 3 4 D 16 4 + """ + + df = df.copy() + for from_param, from_dict in dependencies.items(): + # No column to map from + if from_param not in df.columns: + continue + + from_values = from_dict["from_values"] + from_values = [to_numeric_safe(value) for value in from_values] + + for to_param, to_values_ in from_dict["to_params"].items(): + to_values = [to_numeric_safe(value) for value in to_values_] + + # No values to map to => to_param = copy(from_param) + if not to_values: + df = df.assign(**{to_param: df[from_param].map(to_numeric_safe)}) + if verbose: + print(f"Copied {from_param!r} to {to_param!r}") + continue + + if len(from_values) != len(to_values): + msg = ( + f"Mapping dependencies {from_param!r} to {to_param!r} failed.\n" + f"Length mismatch.\nMapping from values: {from_values!r}" + f"\nMapping to values: {to_values!r}" + ) + raise ValueError(msg) + + # At this point we have a mapping 'from_param' - > 'to_param' + # defined elementwise by values of 'from_values' -> 'to_values' + mapping = dict(zip(from_values, to_values, strict=False)) + + # Check that every value will be mapped + not_mapped = set(df[from_param].map(to_numeric_safe)) - set(from_values) + if not_mapped: + msg = ( + f"Mapping dependencies {from_param!r} to {to_param!r} using " + f"mapping:\n{mapping!r}\n failed. The following values could " + f"not be mapped:\n{not_mapped!r}" + ) + raise ValueError(msg) + + df = df.assign( + **{ + # Bind loop variables as default args to the lambda + to_param: lambda df, from_param=from_param, mapping=mapping: ( + df[from_param].map(to_numeric_safe).map(mapping) + ) + } + ) + if verbose: + print( + f"Mapping dependency. From {from_param!r} " + f"to {to_param!r} using map:" + ) + for from_, to_ in mapping.items(): + print(f" {from_} => {to_}") + + return df diff --git a/tests/ert/unit_tests/config/fmudesign/__init__.py b/tests/ert/unit_tests/config/fmudesign/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/ert/unit_tests/config/fmudesign/data/README.md b/tests/ert/unit_tests/config/fmudesign/data/README.md new file mode 100644 index 00000000000..ed51a76fcf1 --- /dev/null +++ b/tests/ert/unit_tests/config/fmudesign/data/README.md @@ -0,0 +1,4 @@ +Testdata for tornadoplots from one by one sensitivities (design matrix) +distributions: contains design matrix on fmu standard format in excel and .csv format +results: contains in place volumes exported from RMS in fmu standard csv format +config: contains yaml config files for add_webviz_tornado_onebyone.py diff --git a/tests/ert/unit_tests/config/fmudesign/data/config/correlations.xlsx b/tests/ert/unit_tests/config/fmudesign/data/config/correlations.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..6504ee445b34bc61bf2caf39781c46e5ec40db19 GIT binary patch literal 4723 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 literal 0 HcmV?d00001 diff --git a/tests/ert/unit_tests/config/fmudesign/data/config/design_input_background_extseeds.xlsx b/tests/ert/unit_tests/config/fmudesign/data/config/design_input_background_extseeds.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..39d6dba411359b539eaa7d14fe0073a997c2006e GIT binary patch literal 30231 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 BU;O|8 literal 0 HcmV?d00001 diff --git a/tests/ert/unit_tests/config/fmudesign/data/config/design_input_corr_discrete.xlsx b/tests/ert/unit_tests/config/fmudesign/data/config/design_input_corr_discrete.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..353c69d5c033177f2a4c695a148eb313e1c95fa7 GIT binary patch literal 24025 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 literal 0 HcmV?d00001 diff --git a/tests/ert/unit_tests/config/fmudesign/data/config/design_input_default_no_seed.xlsx b/tests/ert/unit_tests/config/fmudesign/data/config/design_input_default_no_seed.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..0882adea074f968cae64fde775d3b62d5dcdb257 GIT binary patch literal 22182 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

|vi^R&e7q}~rr0C*Clz!`@T+i;6dt+8 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 z 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 literal 0 HcmV?d00001 diff --git a/tests/ert/unit_tests/config/fmudesign/data/config/design_input_mc_with_correls.xlsx b/tests/ert/unit_tests/config/fmudesign/data/config/design_input_mc_with_correls.xlsx new file mode 100755 index 0000000000000000000000000000000000000000..7b895070b66e77596f0608974b053b0def05f1bd GIT binary patch literal 28694 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 W;6aUzP*8NBA2E=#)?j@5>Hh$5dJY=^ literal 0 HcmV?d00001 diff --git a/tests/ert/unit_tests/config/fmudesign/data/config/design_input_multiple_dependencies.xlsx b/tests/ert/unit_tests/config/fmudesign/data/config/design_input_multiple_dependencies.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..4c1d13de8a65e3498c9d7b82497c3e1049a341d7 GIT binary patch literal 27793 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 literal 0 HcmV?d00001 diff --git a/tests/ert/unit_tests/config/fmudesign/data/config/design_input_onebyone.xlsx b/tests/ert/unit_tests/config/fmudesign/data/config/design_input_onebyone.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..7331fc219dd495cefef7d3827ca175ddac81cb94 GIT binary patch literal 30495 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

^HSo4q^@37+ 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 I+5sRQ03tbNhX4Qo literal 0 HcmV?d00001 diff --git a/tests/ert/unit_tests/config/fmudesign/data/config/design_input_singlereference_and_seed.xlsx b/tests/ert/unit_tests/config/fmudesign/data/config/design_input_singlereference_and_seed.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..569616f805609a25e68a39f7fe5cc95ace87b9ef GIT binary patch literal 22326 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 z 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 n0izL)?sU|a5VH1LzDU}k?VkOpM!3IOo{zN*~s literal 0 HcmV?d00001 diff --git a/tests/ert/unit_tests/config/fmudesign/data/config/doe1.xlsx b/tests/ert/unit_tests/config/fmudesign/data/config/doe1.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..f89741402f1b932e8d71342ae7aba5b3d25ad8f9 GIT binary patch literal 4985 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 Pks$iOX}5s$_OJf|aSl+) literal 0 HcmV?d00001 diff --git a/tests/ert/unit_tests/config/fmudesign/data/config/seeds.csv b/tests/ert/unit_tests/config/fmudesign/data/config/seeds.csv new file mode 100644 index 00000000000..3248aef51fa --- /dev/null +++ b/tests/ert/unit_tests/config/fmudesign/data/config/seeds.csv @@ -0,0 +1,100 @@ +2000 +2001 +2002 +2003 +2004 +2005 +2006 +2007 +2008 +2009 +2010 +2011 +2012 +2013 +2014 +2015 +2016 +2017 +2018 +2019 +2020 +2021 +2022 +2023 +2024 +2025 +2026 +2027 +2028 +2029 +2030 +2031 +2032 +2033 +2034 +2035 +2036 +2037 +2038 +2039 +2040 +2041 +2042 +2043 +2044 +2045 +2046 +2047 +2048 +2049 +2050 +2051 +2052 +2053 +2054 +2055 +2056 +2057 +2058 +2059 +2060 +2061 +2062 +2063 +2064 +2065 +2066 +2067 +2068 +2069 +2070 +2071 +2072 +2073 +2074 +2075 +2076 +2077 +2078 +2079 +2080 +2081 +2082 +2083 +2084 +2085 +2086 +2087 +2088 +2089 +2090 +2091 +2092 +2093 +2094 +2095 +2096 +2097 +2098 +2099 diff --git a/tests/ert/unit_tests/config/fmudesign/data/config/seeds.txt b/tests/ert/unit_tests/config/fmudesign/data/config/seeds.txt new file mode 100644 index 00000000000..42c8e73d5a1 --- /dev/null +++ b/tests/ert/unit_tests/config/fmudesign/data/config/seeds.txt @@ -0,0 +1,5 @@ +2000 +2001 +2002 +2003 +2004 diff --git a/tests/ert/unit_tests/config/fmudesign/data/config/seeds.xlsx b/tests/ert/unit_tests/config/fmudesign/data/config/seeds.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..f948116f4a428862647141b11293e8f17ce20784 GIT binary patch literal 5208 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 HwAKFrmv!cs literal 0 HcmV?d00001 diff --git a/tests/ert/unit_tests/config/fmudesign/data/distributions/design.csv b/tests/ert/unit_tests/config/fmudesign/data/distributions/design.csv new file mode 100644 index 00000000000..ce2afa4d9b9 --- /dev/null +++ b/tests/ert/unit_tests/config/fmudesign/data/distributions/design.csv @@ -0,0 +1,111 @@ +REAL,SENSNAME,SENSCASE,RMS_SEED,COHIBA_MODE,RAND_VEL_MODEL,OWCAEAST,GP2FILL,FAULTSEAL,RELP_GO +0,rms_seed,P10_P90,1000,PREDICTION,0,2603,0.5,0.5,0.5 +1,rms_seed,P10_P90,1001,PREDICTION,0,2603,0.5,0.5,0.5 +2,rms_seed,P10_P90,1002,PREDICTION,0,2603,0.5,0.5,0.5 +3,rms_seed,P10_P90,1003,PREDICTION,0,2603,0.5,0.5,0.5 +4,rms_seed,P10_P90,1004,PREDICTION,0,2603,0.5,0.5,0.5 +5,rms_seed,P10_P90,1005,PREDICTION,0,2603,0.5,0.5,0.5 +6,rms_seed,P10_P90,1006,PREDICTION,0,2603,0.5,0.5,0.5 +7,rms_seed,P10_P90,1007,PREDICTION,0,2603,0.5,0.5,0.5 +8,rms_seed,P10_P90,1008,PREDICTION,0,2603,0.5,0.5,0.5 +9,rms_seed,P10_P90,1009,PREDICTION,0,2603,0.5,0.5,0.5 +10,hum_seed,P10_P90,1000,SIMULATION,0,2603,0.5,0.5,0.5 +11,hum_seed,P10_P90,1001,SIMULATION,0,2603,0.5,0.5,0.5 +12,hum_seed,P10_P90,1002,SIMULATION,0,2603,0.5,0.5,0.5 +13,hum_seed,P10_P90,1003,SIMULATION,0,2603,0.5,0.5,0.5 +14,hum_seed,P10_P90,1004,SIMULATION,0,2603,0.5,0.5,0.5 +15,hum_seed,P10_P90,1005,SIMULATION,0,2603,0.5,0.5,0.5 +16,hum_seed,P10_P90,1006,SIMULATION,0,2603,0.5,0.5,0.5 +17,hum_seed,P10_P90,1007,SIMULATION,0,2603,0.5,0.5,0.5 +18,hum_seed,P10_P90,1008,SIMULATION,0,2603,0.5,0.5,0.5 +19,hum_seed,P10_P90,1009,SIMULATION,0,2603,0.5,0.5,0.5 +20,velmodel,alternative,1000,PREDICTION,1,2603,0.5,0.5,0.5 +21,velmodel,alternative,1001,PREDICTION,1,2603,0.5,0.5,0.5 +22,velmodel,alternative,1002,PREDICTION,1,2603,0.5,0.5,0.5 +23,velmodel,alternative,1003,PREDICTION,1,2603,0.5,0.5,0.5 +24,velmodel,alternative,1004,PREDICTION,1,2603,0.5,0.5,0.5 +25,velmodel,alternative,1005,PREDICTION,1,2603,0.5,0.5,0.5 +26,velmodel,alternative,1006,PREDICTION,1,2603,0.5,0.5,0.5 +27,velmodel,alternative,1007,PREDICTION,1,2603,0.5,0.5,0.5 +28,velmodel,alternative,1008,PREDICTION,1,2603,0.5,0.5,0.5 +29,velmodel,alternative,1009,PREDICTION,1,2603,0.5,0.5,0.5 +30,owc_aeast,shallow,1000,PREDICTION,0,2596,0.5,0.5,0.5 +31,owc_aeast,shallow,1001,PREDICTION,0,2596,0.5,0.5,0.5 +32,owc_aeast,shallow,1002,PREDICTION,0,2596,0.5,0.5,0.5 +33,owc_aeast,shallow,1003,PREDICTION,0,2596,0.5,0.5,0.5 +34,owc_aeast,shallow,1004,PREDICTION,0,2596,0.5,0.5,0.5 +35,owc_aeast,shallow,1005,PREDICTION,0,2596,0.5,0.5,0.5 +36,owc_aeast,shallow,1006,PREDICTION,0,2596,0.5,0.5,0.5 +37,owc_aeast,shallow,1007,PREDICTION,0,2596,0.5,0.5,0.5 +38,owc_aeast,shallow,1008,PREDICTION,0,2596,0.5,0.5,0.5 +39,owc_aeast,shallow,1009,PREDICTION,0,2596,0.5,0.5,0.5 +40,owc_aeast,deep,1000,PREDICTION,0,2610,0.5,0.5,0.5 +41,owc_aeast,deep,1001,PREDICTION,0,2610,0.5,0.5,0.5 +42,owc_aeast,deep,1002,PREDICTION,0,2610,0.5,0.5,0.5 +43,owc_aeast,deep,1003,PREDICTION,0,2610,0.5,0.5,0.5 +44,owc_aeast,deep,1004,PREDICTION,0,2610,0.5,0.5,0.5 +45,owc_aeast,deep,1005,PREDICTION,0,2610,0.5,0.5,0.5 +46,owc_aeast,deep,1006,PREDICTION,0,2610,0.5,0.5,0.5 +47,owc_aeast,deep,1007,PREDICTION,0,2610,0.5,0.5,0.5 +48,owc_aeast,deep,1008,PREDICTION,0,2610,0.5,0.5,0.5 +49,owc_aeast,deep,1009,PREDICTION,0,2610,0.5,0.5,0.5 +50,gas_fraction,no_fill,1000,PREDICTION,0,2603,0,0.5,0.5 +51,gas_fraction,no_fill,1001,PREDICTION,0,2603,0,0.5,0.5 +52,gas_fraction,no_fill,1002,PREDICTION,0,2603,0,0.5,0.5 +53,gas_fraction,no_fill,1003,PREDICTION,0,2603,0,0.5,0.5 +54,gas_fraction,no_fill,1004,PREDICTION,0,2603,0,0.5,0.5 +55,gas_fraction,no_fill,1005,PREDICTION,0,2603,0,0.5,0.5 +56,gas_fraction,no_fill,1006,PREDICTION,0,2603,0,0.5,0.5 +57,gas_fraction,no_fill,1007,PREDICTION,0,2603,0,0.5,0.5 +58,gas_fraction,no_fill,1008,PREDICTION,0,2603,0,0.5,0.5 +59,gas_fraction,no_fill,1009,PREDICTION,0,2603,0,0.5,0.5 +60,gas_fraction,filled,1000,PREDICTION,0,2603,1,0.5,0.5 +61,gas_fraction,filled,1001,PREDICTION,0,2603,1,0.5,0.5 +62,gas_fraction,filled,1002,PREDICTION,0,2603,1,0.5,0.5 +63,gas_fraction,filled,1003,PREDICTION,0,2603,1,0.5,0.5 +64,gas_fraction,filled,1004,PREDICTION,0,2603,1,0.5,0.5 +65,gas_fraction,filled,1005,PREDICTION,0,2603,1,0.5,0.5 +66,gas_fraction,filled,1006,PREDICTION,0,2603,1,0.5,0.5 +67,gas_fraction,filled,1007,PREDICTION,0,2603,1,0.5,0.5 +68,gas_fraction,filled,1008,PREDICTION,0,2603,1,0.5,0.5 +69,gas_fraction,filled,1009,PREDICTION,0,2603,1,0.5,0.5 +70,fault_seal,open,1000,PREDICTION,0,2603,0.5,0,0.5 +71,fault_seal,open,1001,PREDICTION,0,2603,0.5,0,0.5 +72,fault_seal,open,1002,PREDICTION,0,2603,0.5,0,0.5 +73,fault_seal,open,1003,PREDICTION,0,2603,0.5,0,0.5 +74,fault_seal,open,1004,PREDICTION,0,2603,0.5,0,0.5 +75,fault_seal,open,1005,PREDICTION,0,2603,0.5,0,0.5 +76,fault_seal,open,1006,PREDICTION,0,2603,0.5,0,0.5 +77,fault_seal,open,1007,PREDICTION,0,2603,0.5,0,0.5 +78,fault_seal,open,1008,PREDICTION,0,2603,0.5,0,0.5 +79,fault_seal,open,1009,PREDICTION,0,2603,0.5,0,0.5 +80,fault_seal,tight,1000,PREDICTION,0,2603,0.5,1,0.5 +81,fault_seal,tight,1001,PREDICTION,0,2603,0.5,1,0.5 +82,fault_seal,tight,1002,PREDICTION,0,2603,0.5,1,0.5 +83,fault_seal,tight,1003,PREDICTION,0,2603,0.5,1,0.5 +84,fault_seal,tight,1004,PREDICTION,0,2603,0.5,1,0.5 +85,fault_seal,tight,1005,PREDICTION,0,2603,0.5,1,0.5 +86,fault_seal,tight,1006,PREDICTION,0,2603,0.5,1,0.5 +87,fault_seal,tight,1007,PREDICTION,0,2603,0.5,1,0.5 +88,fault_seal,tight,1008,PREDICTION,0,2603,0.5,1,0.5 +89,fault_seal,tight,1009,PREDICTION,0,2603,0.5,1,0.5 +90,relp_go,lc,1000,PREDICTION,0,2603,0.5,0.5,0 +91,relp_go,lc,1001,PREDICTION,0,2603,0.5,0.5,0 +92,relp_go,lc,1002,PREDICTION,0,2603,0.5,0.5,0 +93,relp_go,lc,1003,PREDICTION,0,2603,0.5,0.5,0 +94,relp_go,lc,1004,PREDICTION,0,2603,0.5,0.5,0 +95,relp_go,lc,1005,PREDICTION,0,2603,0.5,0.5,0 +96,relp_go,lc,1006,PREDICTION,0,2603,0.5,0.5,0 +97,relp_go,lc,1007,PREDICTION,0,2603,0.5,0.5,0 +98,relp_go,lc,1008,PREDICTION,0,2603,0.5,0.5,0 +99,relp_go,lc,1009,PREDICTION,0,2603,0.5,0.5,0 +100,relp_go,hc,1000,PREDICTION,0,2603,0.5,0.5,1 +101,relp_go,hc,1001,PREDICTION,0,2603,0.5,0.5,1 +102,relp_go,hc,1002,PREDICTION,0,2603,0.5,0.5,1 +103,relp_go,hc,1003,PREDICTION,0,2603,0.5,0.5,1 +104,relp_go,hc,1004,PREDICTION,0,2603,0.5,0.5,1 +105,relp_go,hc,1005,PREDICTION,0,2603,0.5,0.5,1 +106,relp_go,hc,1006,PREDICTION,0,2603,0.5,0.5,1 +107,relp_go,hc,1007,PREDICTION,0,2603,0.5,0.5,1 +108,relp_go,hc,1008,PREDICTION,0,2603,0.5,0.5,1 +109,relp_go,hc,1009,PREDICTION,0,2603,0.5,0.5,1 diff --git a/tests/ert/unit_tests/config/fmudesign/data/distributions/design.xlsx b/tests/ert/unit_tests/config/fmudesign/data/distributions/design.xlsx new file mode 100755 index 0000000000000000000000000000000000000000..cf3cba873313255b6812f6b91ba964921746e339 GIT binary patch literal 14391 zcmc(G1yG&M(k7nZgy0e+5ZnnGAOs8UZo!=c2X_tb?(Tu$?(QVG6P)1gw&#%V`;+_K zy?3j&wrVF;@V=zy>7MSVd*(ooj5st52E_B{&mkJ-}ZJ>d<4Ff&+Yf02M zF=!?<|3kN+2p5MMOhNt1=78_XAKg3?h8}d-6B%*s++2K~s}<%x3m0`i9cC9uT0}QI z4@waU5(X5h(S(HE;kaa{qg?LdH=8LBzaCK%BSY02D4OUpKO>H^gsi}4oY9c&P|@OA z{gg{k@2|h8@8WBrsSW+8|MMcC@M6h$={8i!|I#DMso&-YZs~KlvC>E%K_G@bqbXs39WYT>ivPKd@r|rzdqP-);$*v ze`t!5+#WQZY#XI8=7W$CfA-w4$h&qKv}|rD2+;d~ats)*3sNwcH!wOGMHpf}C`^Atw=z4J4eM{KI!*W)x1CDHpbny+$l9&r@k4Ap-(zn0 z3ITI?C8RkcloyLL;j{1#q&X-+oCOx~IP1G6E!sZGpbk4APepa(TAcH++g8P~(f|;}PK9#2ng|i5q=+pk}*o#_%R_wHG5g~EqcsK z1`iFH?T~)ZR8Jp{-td%+JfVtTS+`=gsi}F97%kOp4*4=A5=9-H0HP_Sy>|-%#;9z? zC!d^!f+9>x96tn8G+{k-w7cQA8K!O*{OX)KQws!SDY+NjUd_|4#0U0`pV&W2^Pq-?=!CBK?> zp_u6o9RPO2ItKTOi{Q)jQod*D&Mog9np;I}+r-4&=&|I5USUXAAAqP&R#Hg*-24zE zVC_%>`XaL9a5NZf5f;oA7GPWfM&V?fEhS!Peq_P>KlmW zNT4EskbS#KhOZaG(Hz5Hs(uO4BfI*&i!JIRAHWwLO7~gLo{}54|KjrYz3J59X^vK; zV@UgZ#h47nx|vWN#-k>ex&|M+M$=c;6;bJBL@&SGQItV4L>*KcZduo8bor9}IEyr- zsn6l3*uAiSuNl8ll1C0b_d0LR9?p1PF~i>9*F&ebg^18H%O#PiFYx&=Fd>3vbj(wC z`3pVsv$O51o2X+zS8~}VHMP`%1;5F_159Tkz zMEhE|kYEp4ZIo@#f!1H~Up<8J%R@HCIzR(`d0U`~rI8KTL9ua?;mM3>euwv%eV6nR zhS7_dIveQGLL1`m@d~jAp(u!PlXWTPA8tPs@tnyai!3`C_2`|3HBW0dmsz?_q(*VC z^K$g9RwzkQFmT%zcYKrX8}sY;gD1a6x!=TVzDa*q68cs&cPVo!VWqpqZt)~-``KG7 zPB+dkB_I}+$xtye~hOd zE><@E^qQ1Ep$get3w_;6%yD79=5m2_|BO~tEsulb6Gt045`9!uobMjLRYbFpHj`up z4)6D4=K!TElU|0n>Yc!Q>0(QVU1X;c{;{A4>@3p z?&XJOpBcYXNEoezysgMdLm+y@durzcm|`N9=L>NxjR-9Jq&`Av`v@>e2V)&`+(4%9 z!BFK{euNS@_5)iis-r1i2Xnn)$P%`#(9N+&rOUL}p&ioWR>B9ZRQ4U_vqfz)dRaZm zpA+`xZm45)NH}gPBVP5dWEXW%By<|_A9M@^i~%t8)b2f1sj1MD8oTkN_$+I_1^Yeg zfwhtv@!qR4pK}d(7}k|m#(P8svxX>vVB!pvS7`A6trUVc4NzX`0W2&GENyL=z>MjR z84j9fMC%1@sr;YQ#%55eFxW>bs`QiPj8W#FC8(^a5Q_^Zxt?!xS41ze$@I}ZLp0-k z7y`UoyY4KnEXzj=b%>?TtA_$sPxn~RobNhaKSX=?{bW@;ERdrJ+R-^S)Vlrpy7vXy zk8ZK*A-6<>a?8R_j&mN)V^&_-c+WwsRCs<*Fshn^sAhj z;12C9ZIN)bA?w}})Z>$i1S4gJRj%pBPC@tj_ZfL|gCE*)YQ|y*gu=He`J-M<0lR*b ziO@6;D89+djqhqd!aP;&yMNZE+P1=JALjTST>u-KBec;q1s+Cs0w}<2)bZzS}klxb)2@7rdqBp6X z!?ElAOX3iCRA(fl7O$R&Np^3yM(&xH!i6(x->Z-X;mvrW$q^cp93bhc4Ckd*7UxMH zQ{tE3nUm{po?~z=HnhCfPt+g1*GH{Nr#WWwUKC;#tL7)&&MvM`(FPF^%}Q7M&YD z$%}6cJHX&zJ}@(u-Pg|-K+LFw{cp^8{fimkT5Dr$U|?(WSMhy%dE&{h^H;<$LI?PS z!7DV=C_3&Fz`CFNTnltM$eAZHcmJq6S<6lx0E_zS-NDd7Z70U0Vz~YXA~-V`t0YMN zY;%?bskY-X&99l%*xj#0aL2`dKEwXlz{LNaD0`j}OCekh&Xh1|y=uw~cl;;!W)4?B zifWnx%_bkN%t(U%^z)-eKWNScf`^V83vSBd5-u~=<3Yr{Vs{l1rrbkDgp4yfV3K27 zOK;yJuHKm5{s#G5F2u2>D(Up`?L-sVGS!t0La;-Gt7CK9K+Dblucro_e{;x_E11D4 z)2u3KGtY+Be5q{Z*jI=N|8qPnCq%DT(vVf`Fh1jxS4R%yUcaNNA{-+N4Sc_$^O8jy~p)@$EB~JQwZhY@qkB1 z$79)pLA}wPYz~gNG-qG;fOIacl+SxXs*wnsa;Pm+GM#q~&IY4LmY zruGwcot_PzMn%6)t1>OP^VM_aH`LyS-D@1G*G9`{uTyrY410)R4uy8-UQ*3#Q)iG1 ztuBAV@z^43A>~w3>K~kQ?7i3uaaXdX+?g{prkGdYZ|Vp%*AP1^YsU~l?`7y% zh>0qqOwQl)8toAXd8r^*$W-7MLbS&X>$I_zq*CNs@u8QaH)coBjbY5DwE&_r@Q{Zk z&Vp1BQxd|j>Gzj3$PA{e3fa!J?-(x%B#x@}S02_(uRGc7JmuwQ85o!A`PBUIc=f)~0oDmIxc6FDt}`ijGsV9Kl7y@9!; zQ-qa}V3C|vAx7f(La$k&3I4PMH>Uutgj6Uug7#KQH}O?bL=;Dllab0x76Cp?iF0w_ zDb0HHSMSYAAav&_0SSDXx^I zcO64A!RM8A>f!P2QqaXluEmBa5G>^E@)KBvyu%ak+W|n&(yff(s~>M5Q^}SCV})GA zVg)%6_}L$hzhCuQzW9LnSO@Kade{H`h=ShrQ+vAYDA5JxCoWq!d3I=H14g$_xFqCI zkImIuqP1E4qi_B_d=AIbw0EcM`x)KeacLKj@|55ZDSTcXQ3&|(S+{?q1>xK;F7tD+ zIunk10|04ZR1g=-kNB_;L`RKy=73aed96k6PgcjUUvI*;*d9=>_uKjEuDnssHD|84 z*K40WF7F_6txvn(LVkVd*w$T&?pQuS)VQyHe1K5)SfM4j)Mu=NfL8XRxS%1hBFB;H z{lvO2s%wP__Z5j76&R0nNzPdJ99sD^#YHlum4V}wLj3wC%1;-9Se{k{@Q?_qPz z*u6R!{A4BS_mxa~PZ{(|27VRt`${TpF6yT#qRZ`*F}X_3(Z3<7qt>bw6nUUZiVzj{By zxI%h|)2XcYaa)dVr5V{)7jWAgbX&EBO`axY>3^cG`_JqS`!UkU>nlun2=P=+(EA zD;F{S@%NXyVQS4g&*hy*m=_DN8|G7J)TxegLl4SslhiaY^f$uo-uROe(7m7upfB2X zQL@#rw|tb-AuD{4A*NPi<nX9YRuNZN@)N`5m@uuMBi+?Z>MCzcjwZuMmPl%KVgoHv=fT z80ivQ#p^v8KtQ^?iCwqs=H0T}{rM#`5z%i3uvBwvg73Jhm;QMA&3|&;M%E&J<7QSA z$i|HD;1%{x++CLbBcY zc5l7qD?49mss-R6*#G*XY5`++GikoUIbnJ@esXcvULNyQ=u#5(OQkK>q!H@r#*O~; zkv#b}B>)i5-W`0hd7P;--56D*GQ7LF2{?>T-tX^rs_iJ9T(_?;3f|GIH@3Xkcde#N z+GRU!TosUgG#l5{_Mr8!pg&Sh*Gx&T2efc#(n(w0hIOfLP zT(vk>ds@1oS4%fsJ-#`2(d0@!$Tt@}w`B56PgCOIu1u9~_rkkh`EuTODMKS&Vw3&+ z#AbZ)Rfn{JW<07z26u{`co}so<}QjtC_ybO)#b!kyagE#1lWM)FGrvyX@N zS9_lVgHPdhYi_Gyo00%E`!9gG?BVm9C=V?f6PNb}mxJ9|DxG$XLPVP$_I0n~b`Kus zZ_FIT@Rl0W$UqxOctZC zXs_K4^beGVZZXd`4viYO6V3Y(tUneWhF4Cz&+hhYT%a{qf$@Ep=>0mY zK@?-1UBQ}Ji&4DH+#yZ2k@^f-D6dQ3lW~XKA(7rNp5O@%>8#HQjWq}Ggfv-4&T5ez zzBWQ0N;7T{-^3{9R`?P4MP1RZ7J%H|@UccZPXDWn-?GOFvooM@^N>4do7|MNcRhA6 zVU7L92u<`nh9Gac;Ac!qtXY*1>sildbIOUk5=ZQ0d(?fmtI9sqEma5Zv29*N??s^~ zH2av$8O=95T~cxkvM;+2m@6Ud(I97JUv#3>1n4KUzhmIn=~9CN?7Ka+#U$wo3L zCf2K%6Q2;o{i4%D426?T+Jj^M!l+o7afFm*Le9t|DSsd`(E~u~t6;)k7(OYu1-ge1ZN}w#PYvDFC9UAb<%@y$g5uMTn$+ zkKYeS;3-3>C)0pT4;=HGFU^9IG3B_1NTi-j)Vd+JpKbA`Xnd1@Bn``aM& zTJxm+#h#Q84!DHAVIPnh5EBJ{a()hLz_G=yAo)q`laWo0LTHZZc_4S~$!yJeAQ45R zH?&YuxekHM15aO73Kxyb15eo{<&8LuA`LZZSQZ>8i;XbTk}eCE3Zu|14K+h!g|0#E zs5KXDHIznPey&<^%3BE?FAAH4nz)Snp2QwbqwiH3td_3}}95;R^ca5$%>#`(y@?UTyfSp+|9PFQP;UKtLa=4?s zj$!|fCfR^vwg`4R%d+5OHmD_HAIEI!5&S*OWs9Dpu#zQoL`V7SO#z)H$}UIszT_MB znQljQNI(RClPu;I@&&?Cjh@(kJ{9TH`)FI4Qbb;(d{3Gly! z76@rTeDP8sm0(YILX%QoR|Za2L@|YHhUWcZuAhX2^H6^--%myJMuW+RM5)=`8I7OI zD+!~~o*$CZV6aKUJuc+fCc3o-H$U8>&iSVKYQ9NENr6FwrfAQFlkyhN6`)v2h!)r5 zuD3OcsPIWw2WzEvgp&zKg~T2}`37MJEDHubj%BheGYga&!!TLFX;A+>{&6)?&L@rH z)N2ncglZ~`KFwqVVCXhsu1kUqZHo1*jXH*7YEut%{KC`(LT82kEyU87%*6?ErxDar zVhDQxgyd(;sf&2Rx|&`s3=wXZ;7juuB= zmP}3g6=n+%Yt}(wwt#60eL@oMnh#kaobS)YI?9t8`4!|EP*^~VIIe+OQtH9)f&kF0 zTJ#=;?XQm!{1zGk5eAHuis-n-yhIG=xJ9~j{d`Gd#P#q+HYj!=jo{dA>#qID~09Z0qIf44@^=cbYD;vVC{gsF))SMXxRrJ*1IFYs}NrNY)G<0&$7HO zgCyfnc(l9jO8wI;z4ernQT<9UB}HB7F#Qe}G_Q(JMZ!bI238;r6ubdcX{aan`)c+P z1h6`zYZz*0=c-EO2k2n(!P8?_SpZzAucGEJ$OuxILwOAwSUws)S~KeT$CVPIu@`^B_ZrZt4$>VwS-_Y zByV_vrt@NKhJFZfKyi|%c-Dw>sL{q94=y1N^sA}i%O$$poNr;D*hdV&$!c;704YbY zFK72lL^-`kgj^~MYGof%=$Oy-ZSn|-wi%prQ)J2pnKwpkhXG1C<7KdYvJRQwK~Z~y zpAlBXVHc0k$~BhnP4V-ZJALhq@I4MizGt-jL_bwvv`=PA8cbrekLDiP^OTeiQc~k9 z3)5vm=`fMe@*gPj!#FuH=liLa*D>sXVyo+)Kxy_QjPxXok^%`5Bc;gi;o!u)w^#;& z?u9OsNul`R0Kj4)wQc=W>+2AJ-%@{rAy6^*;D7!tc0Gg!k~%GfTmtbcXn!5U3K+!2 zNp1~f>~b7T0p}>JloScYGsobR6m(9`w>|xZGg4BJ6!`_w^5_)L1VUGzh zF4+Eh39!p#`%#@Wc}JdkZj{dtawyMm&j+WifHMCHlI;mH0}PpWqY_bL%siQ|U!{j%izJa} zI8k>klfZ_+G*{8DFwt$2Z7nCJ&X%~N$3K@r%ov{}`vbHk%~5t44{plI zV&{kYiBeh2Y7~XTngr*`xrqsL*H{d;DVPddfc8NXPz9n(78BA;VZ$TOtul}=`oguAn+AdC-Nam*Phs8kbG>G|= zQ6S1yDZ}T2Xg3QA8Wf*?p?KxL(e6no1jKX0e?j^eo~y5qeFy2&(?|;4AEP}Ih-+X) zoWOdjQGXEl{}So1s`y8~1Z&{U(FnVQh*yI00M@-vF5d9p@&J@5Pt>6w?y)z)x*`$R zOo|2ZTer%99vQ?hFuMb4`f@Xyb*p;os@~Oz4|)+*Oyq8W*B@g~Z(~vrJURj{9RK6> zQzm-4@cl91vOlezNqtvtJE#_d#m2GfSixMSN8ZQG2KjQMTvH9j@SV-hnCs6^uJZD8 zl=_qwvmsB>VMzl;C!1PIopobdZmJ{M?jtuyb9;!96ewK^i7hZd_OYaaF^3$pkg`CB zC5zFRd~ww~DHm`gs|bc1H^Hg$tFGfpgUgoTJ6X6<(AlKMcwjtN@c*0CSh!Z>StjFu zT0)?4ue}Lp!tqcch_U}sO4OMB@*VSmrBF}uToo@SOqhI(V>%wrnXg5NQ#t~_KgoN- zc&0r!+M&f>{bfCuYRhgq+^eBNm0fvJoOfc@M-_?EGjMH)dAvH$y+sTlnvBoJdx6E? z&#z{JO4K8{YJ9m$2YIoo%sGVk=xd~r9oc5!`Vb}Xk@!zYr>A;5Du#Pe%+-M*uI7tV zB_GpwU+%Qh-_Eo}^N3lWFmJ)lLpXWa`H+0nT3@`G`5w)~2oUM-RRSyqrM!y;xS4x` zEI46)d=m3|5?j8RL38@F5*8I+veJOb=|sJHGXvoiv$}3Tk5U790)_ufAflp~-6!;vGOO&w5P&&+*QkBrV=1^pmGgi1LACpVBQgW#t~?tU%}tecgE>&Rc2P& zL3(W+3y>q?Io@G-uN$B+L~=I4aJ&Y32B#Flcx0F3&J{ZV%KR!X7+d ztnqhNro#r{7cEDj3N3n|Td2~t#_l?|G*D03$?}k-yV4gqJ9Uz(wemwrc`n&7m zR7+_?HTFjQdGD?6eao!ZX1gq1GIBy~CbO(2opuui7bF9oJrWZW1XkmU`TN(^Gw1TRX{| zk#eVMk#MIW+T3k@R9fKqx;c3;Kp&s8_?VWS&NEpR+K7MpXl8z?KX(5x{dLMNHGTib zx8PGnYxdUbo2(=c6O_B08o1%(woc{-PrW1inm@vmIndl&TcM8KKl}Rn%10F$#E&>K)6&m7zK6;_%)*Z(wz)ufYq+t()c4LNhXCW1QUG z`iJYKTe~7N)r0&@qVbrabLjrF%V2FoRri4YMZXA*HM}wNuYeQR+hiU6c0V%ri!e*k z0dkrFbiS>4a|?ZS;XB5csZldHNqH7z?lC*Tstw{zWZ$Yh55`g&W#5`?^b(N(sze%; zifl~!G_O;0e6PzbX$^a1+jVQQwtdn9wb*D4XC3yx5ZRFD)$yFal+*I~BwMJnK_Tl( ziSM69GIK?{mQB-$DJ-U_Ov$Qkd+FH|V`AQ%vYTdvB_d5sC(b`&FWBeo@f`b{ucs^s zwY`Eej3!RDj4W#<@i-_hM;23VB$&R**Q(Y?@2xedBE31=NBUBoz0T$nOXXkvz@~T&V z&a35Ou+^;k^mas5M0_L4H?}&HkH!*yNXm1+bK;&>c29ZHY}%0dV@!Tc7b{wEWVp<@ z`9(VCA_BlTZQM6K<>tAF*zmOK_aM$-X$AMLv*>!mHTgOBcQy!!k_>6cvlMpg*B0zT z--P!?9CAAA!YSTm!;pm?3Vv%F5scVkj=BBQQO%S~>uTP@^{7Bb zjuvCUFT9)1NRnvPIQ31A^%{k+4f=ZbNu9CQ(A{|GoL|LHZe_YD_}w+2LUGi>(CFf(TcS$$TJjm5#(8H_+gDNBf?8dS!P8z zlq{O;DI@0$JxhU`UbQ`|gjZ;;51R;lS=yUO!j)~cxij;@=sT`0Tq?iOS8GH4=A1+z ztE22vh*k`HXZ(8T>Cgzy`G!kPq$Q)%}jh^e&3s*?l$LPWp4UZmFNlrjP*Q zy=rf^2%jmt(<>H%yk*tfp%XZ!U9n2`#P1jx{pfgbTQ4d}bo08*VLFkvJnMPgJw}wF(#_-ndT3QoQuKUfwP&*5RB};omHG^?0XP<&sAT6|X(sSGdgSuguE#~4! zPm)gR*Bp$I2FqvR5nh)PL2X?;@+@qIqaM&bU?G*v%x7AyMBR8Aab+C(qtm#T15kIz-{<7QRvyf&HfFB4LUJ6BP`;%=~p zw?#&>X5y{z}q)O3ulq;%D+j-|f zlBlEaZQ{ousYb^VVYo>8Qai~Lq{#5oze_9+BIV$6Fdyf_|D{Mf>8zW1=n*>#SNKhW z;nf&S%h3Cz>gx@HJMGFv;?8bb9A>1UmWQ#ud9NW3cSOzo#@sJ}oXT^xFL5{UiMt+h zaRGdn3Yj$vLe{Txd%t{&KlXB^oj0vXGSx^Tdk`J`@mvO<9doM9TIH+?*1w6TJM*=kuQ@2@hVRFope@vrAOHtb%% z41BN@_}Fsw)OAKv#p^{62LaI#^4~TZ{9hZ5K2XO2+@{E2Z(%O@>zRoj^t>PU0|07S z?0v)xZb3JN^74)SD4*YA5nUtd5<;Nojj#85kIdHNe&ju+W^Pf^*gLP2HCG3=AC>o! zZqqSP?aDjr30(eaZ<4Tz$()sdYBVK4mh2*luw1K~cjroJ12$5sj}8Z;P1(=PDDkzd zPmZ}8QWR1-cN_Jx5apOo6_~mzCver0In%fUs6US1p^B&06Y1>Lw4%rbenq-6mlBeQ zKNi+N5tTvJn!%hU{mgH>c~Y6FatGMgFp4 zQj7rURw2r{cSE9Vfh?HuWHWdmB~@6lpY|+nne%uELo}qhtp~Bk;j<{|k6`oDzPCSs z?ZfhNN3?n;O%RD(B;<|2+N4)IS~{ifG|w03vvf?N8Wf`JDviWHCk`ZdZBtG1 zvruy^h7b5MJ5Ggj_!n6W^DmtrU~j%t=EtG?XuRb;aa1_jFD65*vu=v`8B-sZFJ{g2 z6OcWuNzJlLUsyDjtDbmYj;+7B?90Pv9PbtYQKqkU$tGZ6CUu-ldouEVGq29*!_S&t z>6vH-o^*0Lh2}6#R)^6chZpvv=y;LAAF#U}Y6XHMd2!AmY--$zKUA{WU%Wr_=PD_; zQ|lb?p_3Un?`UvteEV$j+q^aD&SQYuXRRv+*_qB@$U?<%jc|psourp?%KX$paCu7f z2%cqaLJzPBL2vSSg9<6(^0Y`lKTB~XaCx1gUaL}7nt2kJGcb~GlW_%Wt5?)2~a456`sE#Pz^?8tWHU|q0Ec(I=lvG-85X; zZZ&erV`Yuze)GpqC(_)Ts&&Seua%^l@_1_66%m6JYy&my>Vuli|8vhi>hGSizZ;rE z~ZPWqFz1c!e+ z=1KgKBEHSzRsP{i!smNWrwqANc)NhvT7L^b$Gcz+0}WGHrbbT#_F#w8XtrL#-E5KD z*icn3m0{N(d9X1H7k02g)b(uSA_&9nwXu+CvrrJ?+ammo7vl67W-kmkJs54%f-$DJ zO2lPmym2B30-Nas4Q6%I5aDl?B6`2tq+drrqH?v+j>Nc)l%N9ta>k7YaXi`gGIFZ#?`3}+R(_c2Y=*@wFQz^<3n&AJg z9zaiRnC)4!(V=4N&w(K&mgYHPMvA`PDz|Pp<;Jr?Z;Px%5HnBYi>#-%U?A8w3tPA* zsuKB;)Y8x!VUs=>Z@HG3vy}XxzPMkBfq0bfJzSWkNZ?ocTvY@ZfqNQFny8m-H%RO0 zw!&!QS+*s7s5f|}{G=4^_r%06d=ZWAj7Qx{Yhse7JXGX^y55@!Z;5YC3U}>o-CDD1 zN%qJxsQLM5;aCbcqx!5A)GnIWvVNX)e!KWU8qPI=%kw3!RY-tufoHuD@p^sX#tzqV zgsLxBZ&Tjp)*j}5#31+w_zbTmSapF3VpIq8e`C~35Tn!u0G76(c3y1-Co2OR&8G&% z*g;EBo2JmEtI)bdY(iN<5w#brVmzJPb^~zVOQj3dX#v7Ro7=ZVfr^-v&ANDK!N#aZ zDQH$|QWP2`ca*%pl1cQv&FdVk_;tJMgr&$?TLs!nEJpZpJaIWEz#)~8mX~e#wxe@PGb|{vIv581fq6L!D*sA1n;xmsZM%R@PAw1to90#nCVx=g7?^iM;)FlN)g9a#;-9x#zzy5K2QEm}KkxkfbM~JXEWkHk zeh&d~efs;x(BJo9{yF{6+XvuV7{A8_h=~9BPR2iR{_IBw-&OcMa6pY>Ae?`@x$sYf zKl_&d)eTb5{=JL+pR@mL@_qeVIq1n4)FBVj|9|Rq{wLs{J#OGmw%@}E;h%uNJB9y= z^5-Y>e?=JtZ4Uox*6-Hqf1><(>;iv^|2@&rvK;EKQ}7yx$O7oqI;V9pH6B2 z1p2c+f%moFW0>)OR`T~Q_s_|H<_)-n{T@Ut|J#BlBMu8nF$f4`&_7KO5xZEyZ~qGv C&nc?_ literal 0 HcmV?d00001 diff --git a/tests/ert/unit_tests/config/fmudesign/data/distributions/designsummary.csv b/tests/ert/unit_tests/config/fmudesign/data/distributions/designsummary.csv new file mode 100644 index 00000000000..abab7bae7b1 --- /dev/null +++ b/tests/ert/unit_tests/config/fmudesign/data/distributions/designsummary.csv @@ -0,0 +1,8 @@ +sensno,sensname,senstype,casename1,startreal1,endreal1,casename2,startreal2,endreal2 +0,rms_seed,mc,P10_P90,0,9,nan,nan,nan +1,hum_seed,mc,P10_P90,10,19,nan,nan,nan +2,velmodel,scalar,alternative,20,29,nan,nan,nan +3,owc_aeast,scalar,shallow,30,39,deep,40,49 +4,gas_fraction,scalar,no_fill,50,59,filled,60,69 +5,fault_seal,scalar,open,70,79,tight,80,89 +6,relp_go,scalar,lc,90,99,hc,100,109 diff --git a/tests/ert/unit_tests/config/fmudesign/snapshots/test_create_design/test_generate_full_mc_snapshot/design_output_mc_with_correls.json b/tests/ert/unit_tests/config/fmudesign/snapshots/test_create_design/test_generate_full_mc_snapshot/design_output_mc_with_correls.json new file mode 100644 index 00000000000..8e0162c15a5 --- /dev/null +++ b/tests/ert/unit_tests/config/fmudesign/snapshots/test_create_design/test_generate_full_mc_snapshot/design_output_mc_with_correls.json @@ -0,0 +1,9023 @@ +{ + "defaultvalues": { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 1, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.01, + "HUM_METHOD": "SIMPLE", + "HUM_MODE": "PREDICTION", + "INJ_UNC": 0, + "NTG1": 0.25, + "NTG2": 0.45, + "NTG6": 0.8, + "OWC1": 0.001, + "OWC2": 0.1, + "OWC3": 0.07, + "PARAM1": 0.035, + "PARAM2": 0.05, + "PARAM3": 0.02, + "RMS_SEED": 1000 + }, + "designvalues": [ + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.007, + "NTG1": 0.95, + "NTG2": 0.61, + "OWC1": 2547.0, + "OWC2": 2466.3, + "OWC3": 2427.0, + "PARAM1": 0.031, + "PARAM2": -0.96, + "PARAM3": 0.0, + "REAL": 0.0, + "RMS_SEED": 1000.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.84, + "NTG2": 0.64, + "OWC1": 2527.1, + "OWC2": 2463.9, + "OWC3": 2472.4, + "PARAM1": 0.036, + "PARAM2": 0.02, + "PARAM3": 0.0, + "REAL": 1.0, + "RMS_SEED": 1001.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.033, + "NTG1": 0.81, + "NTG2": 0.61, + "OWC1": 2511.9, + "OWC2": 2461.0, + "OWC3": 2480.7, + "PARAM1": 0.036, + "PARAM2": -0.62, + "PARAM3": 7036570000.0, + "REAL": 2.0, + "RMS_SEED": 1002.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.496, + "NTG1": 0.8, + "NTG2": 0.59, + "OWC1": 2502.9, + "OWC2": 2453.1, + "OWC3": 2483.3, + "PARAM1": 0.037, + "PARAM2": -0.22, + "PARAM3": 0.009, + "REAL": 3.0, + "RMS_SEED": 1003.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.026, + "NTG1": 0.95, + "NTG2": 0.57, + "OWC1": 2510.1, + "OWC2": 2458.8, + "OWC3": 2462.8, + "PARAM1": 0.031, + "PARAM2": 0.69, + "PARAM3": 0.0, + "REAL": 4.0, + "RMS_SEED": 1004.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.017, + "NTG1": 0.86, + "NTG2": 0.55, + "OWC1": 2530.9, + "OWC2": 2468.4, + "OWC3": 2453.7, + "PARAM1": 0.038, + "PARAM2": 0.04, + "PARAM3": 0.0, + "REAL": 5.0, + "RMS_SEED": 1005.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.176, + "NTG1": 0.84, + "NTG2": 0.56, + "OWC1": 2546.5, + "OWC2": 2475.4, + "OWC3": 2411.0, + "PARAM1": 0.028, + "PARAM2": -0.9, + "PARAM3": 3901990000.0, + "REAL": 6.0, + "RMS_SEED": 1006.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.013, + "NTG1": 0.82, + "NTG2": 0.62, + "OWC1": 2504.0, + "OWC2": 2474.1, + "OWC3": 2457.9, + "PARAM1": 0.038, + "PARAM2": 0.81, + "PARAM3": 0.023, + "REAL": 7.0, + "RMS_SEED": 1007.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.127, + "NTG1": 0.81, + "NTG2": 0.55, + "OWC1": 2514.0, + "OWC2": 2470.0, + "OWC3": 2448.4, + "PARAM1": 0.031, + "PARAM2": 0.82, + "PARAM3": 0.0, + "REAL": 8.0, + "RMS_SEED": 1008.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.082, + "NTG1": 0.92, + "NTG2": 0.64, + "OWC1": 2525.3, + "OWC2": 2478.2, + "OWC3": 2458.1, + "PARAM1": 0.039, + "PARAM2": 0.63, + "PARAM3": 110548.0, + "REAL": 9.0, + "RMS_SEED": 1009.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.081, + "NTG1": 0.79, + "NTG2": 0.58, + "OWC1": 2528.6, + "OWC2": 2472.0, + "OWC3": 2458.7, + "PARAM1": 0.034, + "PARAM2": -0.09, + "PARAM3": 51.206, + "REAL": 10.0, + "RMS_SEED": 1010.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.825, + "NTG1": 0.81, + "NTG2": 0.63, + "OWC1": 2523.3, + "OWC2": 2473.8, + "OWC3": 2439.5, + "PARAM1": 0.039, + "PARAM2": 0.63, + "PARAM3": 2731.64, + "REAL": 11.0, + "RMS_SEED": 1011.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.405, + "NTG1": 0.9, + "NTG2": 0.61, + "OWC1": 2519.4, + "OWC2": 2464.8, + "OWC3": 2438.9, + "PARAM1": 0.032, + "PARAM2": 0.6, + "PARAM3": 0.002, + "REAL": 12.0, + "RMS_SEED": 1012.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.559, + "NTG1": 0.84, + "NTG2": 0.6, + "OWC1": 2545.6, + "OWC2": 2491.1, + "OWC3": 2413.0, + "PARAM1": 0.04, + "PARAM2": -0.27, + "PARAM3": 1.991, + "REAL": 13.0, + "RMS_SEED": 1013.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.611, + "NTG1": 0.89, + "NTG2": 0.59, + "OWC1": 2539.7, + "OWC2": 2475.1, + "OWC3": 2445.4, + "PARAM1": 0.031, + "PARAM2": 0.31, + "PARAM3": 0.0, + "REAL": 14.0, + "RMS_SEED": 1014.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.005, + "NTG1": 0.85, + "NTG2": 0.63, + "OWC1": 2536.5, + "OWC2": 2466.9, + "OWC3": 2434.4, + "PARAM1": 0.041, + "PARAM2": 0.39, + "PARAM3": 71.14, + "REAL": 15.0, + "RMS_SEED": 1015.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.116, + "NTG1": 0.8, + "NTG2": 0.55, + "OWC1": 2524.0, + "OWC2": 2468.2, + "OWC3": 2437.4, + "PARAM1": 0.037, + "PARAM2": -0.47, + "PARAM3": 0.0, + "REAL": 16.0, + "RMS_SEED": 1016.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.92, + "NTG2": 0.58, + "OWC1": 2512.3, + "OWC2": 2480.0, + "OWC3": 2462.6, + "PARAM1": 0.032, + "PARAM2": 0.63, + "PARAM3": 0.0, + "REAL": 17.0, + "RMS_SEED": 1017.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.77, + "NTG2": 0.62, + "OWC1": 2531.4, + "OWC2": 2489.3, + "OWC3": 2413.6, + "PARAM1": 0.035, + "PARAM2": -0.35, + "PARAM3": 84.753, + "REAL": 18.0, + "RMS_SEED": 1018.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.038, + "NTG1": 0.82, + "NTG2": 0.61, + "OWC1": 2510.9, + "OWC2": 2458.1, + "OWC3": 2475.5, + "PARAM1": 0.036, + "PARAM2": -0.38, + "PARAM3": 0.013, + "REAL": 19.0, + "RMS_SEED": 1019.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.94, + "NTG2": 0.62, + "OWC1": 2547.3, + "OWC2": 2468.8, + "OWC3": 2444.3, + "PARAM1": 0.033, + "PARAM2": -0.76, + "PARAM3": 0.136, + "REAL": 20.0, + "RMS_SEED": 1020.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.784, + "NTG1": 0.78, + "NTG2": 0.62, + "OWC1": 2539.6, + "OWC2": 2492.5, + "OWC3": 2443.2, + "PARAM1": 0.038, + "PARAM2": 0.26, + "PARAM3": 0.105, + "REAL": 21.0, + "RMS_SEED": 1021.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.064, + "NTG1": 0.82, + "NTG2": 0.6, + "OWC1": 2541.9, + "OWC2": 2474.9, + "OWC3": 2427.5, + "PARAM1": 0.035, + "PARAM2": 0.85, + "PARAM3": 0.008, + "REAL": 22.0, + "RMS_SEED": 1022.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.089, + "NTG1": 0.93, + "NTG2": 0.58, + "OWC1": 2502.3, + "OWC2": 2446.7, + "OWC3": 2478.0, + "PARAM1": 0.04, + "PARAM2": 0.21, + "PARAM3": 0.0, + "REAL": 23.0, + "RMS_SEED": 1023.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.003, + "NTG1": 0.84, + "NTG2": 0.62, + "OWC1": 2525.4, + "OWC2": 2464.0, + "OWC3": 2475.6, + "PARAM1": 0.029, + "PARAM2": -0.97, + "PARAM3": 1.689, + "REAL": 24.0, + "RMS_SEED": 1024.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.004, + "NTG1": 0.9, + "NTG2": 0.55, + "OWC1": 2528.0, + "OWC2": 2462.4, + "OWC3": 2449.9, + "PARAM1": 0.036, + "PARAM2": 0.52, + "PARAM3": 27.378, + "REAL": 25.0, + "RMS_SEED": 1025.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.336, + "NTG1": 0.81, + "NTG2": 0.57, + "OWC1": 2522.5, + "OWC2": 2458.9, + "OWC3": 2460.4, + "PARAM1": 0.036, + "PARAM2": -0.83, + "PARAM3": 0.561, + "REAL": 26.0, + "RMS_SEED": 1026.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.076, + "NTG1": 0.79, + "NTG2": 0.56, + "OWC1": 2526.3, + "OWC2": 2481.0, + "OWC3": 2449.3, + "PARAM1": 0.036, + "PARAM2": -0.78, + "PARAM3": 1264310.0, + "REAL": 27.0, + "RMS_SEED": 1027.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.88, + "NTG2": 0.56, + "OWC1": 2507.8, + "OWC2": 2463.7, + "OWC3": 2436.8, + "PARAM1": 0.027, + "PARAM2": 0.08, + "PARAM3": 145.245, + "REAL": 28.0, + "RMS_SEED": 1028.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.003, + "NTG1": 0.92, + "NTG2": 0.57, + "OWC1": 2547.0, + "OWC2": 2484.2, + "OWC3": 2415.8, + "PARAM1": 0.038, + "PARAM2": 0.42, + "PARAM3": 73619800.0, + "REAL": 29.0, + "RMS_SEED": 1029.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.318, + "NTG1": 0.78, + "NTG2": 0.62, + "OWC1": 2503.0, + "OWC2": 2458.3, + "OWC3": 2488.3, + "PARAM1": 0.04, + "PARAM2": -0.92, + "PARAM3": 58244500.0, + "REAL": 30.0, + "RMS_SEED": 1030.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.003, + "NTG1": 0.93, + "NTG2": 0.56, + "OWC1": 2549.5, + "OWC2": 2490.2, + "OWC3": 2407.4, + "PARAM1": 0.035, + "PARAM2": -0.22, + "PARAM3": 61.275, + "REAL": 31.0, + "RMS_SEED": 1031.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.006, + "NTG1": 0.79, + "NTG2": 0.6, + "OWC1": 2506.5, + "OWC2": 2453.8, + "OWC3": 2463.5, + "PARAM1": 0.029, + "PARAM2": 0.62, + "PARAM3": 0.007, + "REAL": 32.0, + "RMS_SEED": 1032.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.007, + "NTG1": 0.86, + "NTG2": 0.57, + "OWC1": 2520.4, + "OWC2": 2467.2, + "OWC3": 2454.8, + "PARAM1": 0.038, + "PARAM2": 0.34, + "PARAM3": 0.0, + "REAL": 33.0, + "RMS_SEED": 1033.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.004, + "NTG1": 0.81, + "NTG2": 0.6, + "OWC1": 2516.3, + "OWC2": 2460.6, + "OWC3": 2459.7, + "PARAM1": 0.035, + "PARAM2": 0.72, + "PARAM3": 0.007, + "REAL": 34.0, + "RMS_SEED": 1034.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.017, + "NTG1": 0.79, + "NTG2": 0.62, + "OWC1": 2515.8, + "OWC2": 2454.0, + "OWC3": 2471.5, + "PARAM1": 0.035, + "PARAM2": 0.5, + "PARAM3": 0.0, + "REAL": 35.0, + "RMS_SEED": 1035.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.017, + "NTG1": 0.84, + "NTG2": 0.57, + "OWC1": 2547.7, + "OWC2": 2482.1, + "OWC3": 2415.4, + "PARAM1": 0.041, + "PARAM2": 0.11, + "PARAM3": 0.062, + "REAL": 36.0, + "RMS_SEED": 1036.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.715, + "NTG1": 0.82, + "NTG2": 0.61, + "OWC1": 2526.8, + "OWC2": 2442.1, + "OWC3": 2460.0, + "PARAM1": 0.044, + "PARAM2": 0.61, + "PARAM3": 1336400000.0, + "REAL": 37.0, + "RMS_SEED": 1037.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.011, + "NTG1": 0.89, + "NTG2": 0.6, + "OWC1": 2514.2, + "OWC2": 2454.1, + "OWC3": 2461.7, + "PARAM1": 0.038, + "PARAM2": -0.3, + "PARAM3": 0.0, + "REAL": 38.0, + "RMS_SEED": 1038.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.77, + "NTG2": 0.57, + "OWC1": 2508.4, + "OWC2": 2472.0, + "OWC3": 2448.0, + "PARAM1": 0.038, + "PARAM2": 0.68, + "PARAM3": 15.074, + "REAL": 39.0, + "RMS_SEED": 1039.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.011, + "NTG1": 0.77, + "NTG2": 0.58, + "OWC1": 2543.0, + "OWC2": 2470.1, + "OWC3": 2448.1, + "PARAM1": 0.042, + "PARAM2": -0.04, + "PARAM3": 763730000.0, + "REAL": 40.0, + "RMS_SEED": 1040.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.527, + "NTG1": 0.86, + "NTG2": 0.54, + "OWC1": 2520.7, + "OWC2": 2477.9, + "OWC3": 2435.6, + "PARAM1": 0.037, + "PARAM2": 0.15, + "PARAM3": 359967000.0, + "REAL": 41.0, + "RMS_SEED": 1041.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.006, + "NTG1": 0.85, + "NTG2": 0.6, + "OWC1": 2544.9, + "OWC2": 2483.9, + "OWC3": 2426.5, + "PARAM1": 0.036, + "PARAM2": -0.14, + "PARAM3": 49044.1, + "REAL": 42.0, + "RMS_SEED": 1042.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.134, + "NTG1": 0.98, + "NTG2": 0.63, + "OWC1": 2531.3, + "OWC2": 2473.4, + "OWC3": 2454.2, + "PARAM1": 0.039, + "PARAM2": 0.3, + "PARAM3": 1353.63, + "REAL": 43.0, + "RMS_SEED": 1043.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.96, + "NTG2": 0.56, + "OWC1": 2519.7, + "OWC2": 2471.7, + "OWC3": 2444.5, + "PARAM1": 0.031, + "PARAM2": -0.94, + "PARAM3": 5180.77, + "REAL": 44.0, + "RMS_SEED": 1044.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.275, + "NTG1": 0.98, + "NTG2": 0.59, + "OWC1": 2527.9, + "OWC2": 2481.3, + "OWC3": 2421.0, + "PARAM1": 0.035, + "PARAM2": -0.29, + "PARAM3": 0.001, + "REAL": 45.0, + "RMS_SEED": 1045.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.9, + "NTG1": 0.92, + "NTG2": 0.58, + "OWC1": 2548.4, + "OWC2": 2482.7, + "OWC3": 2417.4, + "PARAM1": 0.033, + "PARAM2": -0.46, + "PARAM3": 0.0, + "REAL": 46.0, + "RMS_SEED": 1046.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.121, + "NTG1": 0.85, + "NTG2": 0.54, + "OWC1": 2546.9, + "OWC2": 2495.1, + "OWC3": 2413.9, + "PARAM1": 0.04, + "PARAM2": 0.41, + "PARAM3": 0.427, + "REAL": 47.0, + "RMS_SEED": 1047.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.015, + "NTG1": 0.79, + "NTG2": 0.62, + "OWC1": 2537.4, + "OWC2": 2470.7, + "OWC3": 2434.3, + "PARAM1": 0.037, + "PARAM2": 0.09, + "PARAM3": 7.828, + "REAL": 48.0, + "RMS_SEED": 1048.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.013, + "NTG1": 0.81, + "NTG2": 0.55, + "OWC1": 2535.8, + "OWC2": 2474.4, + "OWC3": 2416.4, + "PARAM1": 0.038, + "PARAM2": -0.94, + "PARAM3": 0.272, + "REAL": 49.0, + "RMS_SEED": 1049.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.005, + "NTG1": 0.91, + "NTG2": 0.62, + "OWC1": 2520.9, + "OWC2": 2457.2, + "OWC3": 2429.0, + "PARAM1": 0.043, + "PARAM2": -0.07, + "PARAM3": 970939.0, + "REAL": 50.0, + "RMS_SEED": 1050.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.103, + "NTG1": 0.8, + "NTG2": 0.61, + "OWC1": 2540.0, + "OWC2": 2476.5, + "OWC3": 2426.7, + "PARAM1": 0.03, + "PARAM2": -0.05, + "PARAM3": 0.0, + "REAL": 51.0, + "RMS_SEED": 1051.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.283, + "NTG1": 0.82, + "NTG2": 0.58, + "OWC1": 2533.0, + "OWC2": 2457.5, + "OWC3": 2428.8, + "PARAM1": 0.039, + "PARAM2": 0.18, + "PARAM3": 9911890000.0, + "REAL": 52.0, + "RMS_SEED": 1052.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.169, + "NTG1": 0.87, + "NTG2": 0.56, + "OWC1": 2538.8, + "OWC2": 2437.1, + "OWC3": 2450.6, + "PARAM1": 0.04, + "PARAM2": -0.19, + "PARAM3": 0.003, + "REAL": 53.0, + "RMS_SEED": 1053.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.914, + "NTG1": 0.8, + "NTG2": 0.58, + "OWC1": 2507.0, + "OWC2": 2451.8, + "OWC3": 2481.5, + "PARAM1": 0.034, + "PARAM2": -0.25, + "PARAM3": 1145.09, + "REAL": 54.0, + "RMS_SEED": 1054.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.053, + "NTG1": 0.91, + "NTG2": 0.59, + "OWC1": 2539.4, + "OWC2": 2483.5, + "OWC3": 2420.3, + "PARAM1": 0.041, + "PARAM2": 0.15, + "PARAM3": 0.731, + "REAL": 55.0, + "RMS_SEED": 1055.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.332, + "NTG1": 0.88, + "NTG2": 0.6, + "OWC1": 2501.3, + "OWC2": 2460.2, + "OWC3": 2455.5, + "PARAM1": 0.03, + "PARAM2": 0.48, + "PARAM3": 0.0, + "REAL": 56.0, + "RMS_SEED": 1056.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.13, + "NTG1": 0.85, + "NTG2": 0.62, + "OWC1": 2539.0, + "OWC2": 2463.7, + "OWC3": 2443.5, + "PARAM1": 0.035, + "PARAM2": 0.45, + "PARAM3": 22762.8, + "REAL": 57.0, + "RMS_SEED": 1057.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.641, + "NTG1": 0.81, + "NTG2": 0.59, + "OWC1": 2518.4, + "OWC2": 2474.0, + "OWC3": 2429.4, + "PARAM1": 0.044, + "PARAM2": 0.81, + "PARAM3": 1423.78, + "REAL": 58.0, + "RMS_SEED": 1058.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.237, + "NTG1": 0.82, + "NTG2": 0.62, + "OWC1": 2502.7, + "OWC2": 2437.8, + "OWC3": 2493.9, + "PARAM1": 0.035, + "PARAM2": -0.37, + "PARAM3": 3.774, + "REAL": 59.0, + "RMS_SEED": 1059.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.316, + "NTG1": 0.78, + "NTG2": 0.61, + "OWC1": 2527.6, + "OWC2": 2493.2, + "OWC3": 2423.6, + "PARAM1": 0.032, + "PARAM2": -0.86, + "PARAM3": 1.259, + "REAL": 60.0, + "RMS_SEED": 1060.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.754, + "NTG1": 0.94, + "NTG2": 0.6, + "OWC1": 2500.6, + "OWC2": 2458.4, + "OWC3": 2465.4, + "PARAM1": 0.038, + "PARAM2": -0.02, + "PARAM3": 0.656, + "REAL": 61.0, + "RMS_SEED": 1061.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.015, + "NTG1": 0.78, + "NTG2": 0.61, + "OWC1": 2510.2, + "OWC2": 2477.9, + "OWC3": 2462.3, + "PARAM1": 0.034, + "PARAM2": 0.89, + "PARAM3": 0.374, + "REAL": 62.0, + "RMS_SEED": 1062.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.028, + "NTG1": 0.84, + "NTG2": 0.55, + "OWC1": 2534.1, + "OWC2": 2457.7, + "OWC3": 2447.9, + "PARAM1": 0.033, + "PARAM2": -0.3, + "PARAM3": 0.0, + "REAL": 63.0, + "RMS_SEED": 1063.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.91, + "NTG2": 0.61, + "OWC1": 2526.4, + "OWC2": 2458.2, + "OWC3": 2469.1, + "PARAM1": 0.033, + "PARAM2": 0.37, + "PARAM3": 7441.01, + "REAL": 64.0, + "RMS_SEED": 1064.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.031, + "NTG1": 0.9, + "NTG2": 0.62, + "OWC1": 2540.9, + "OWC2": 2443.1, + "OWC3": 2460.8, + "PARAM1": 0.036, + "PARAM2": -0.39, + "PARAM3": 889491.0, + "REAL": 65.0, + "RMS_SEED": 1065.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.064, + "NTG1": 0.89, + "NTG2": 0.6, + "OWC1": 2516.9, + "OWC2": 2447.6, + "OWC3": 2470.5, + "PARAM1": 0.03, + "PARAM2": -0.75, + "PARAM3": 0.0, + "REAL": 66.0, + "RMS_SEED": 1066.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.89, + "NTG2": 0.51, + "OWC1": 2516.0, + "OWC2": 2458.6, + "OWC3": 2448.6, + "PARAM1": 0.038, + "PARAM2": -0.16, + "PARAM3": 12.693, + "REAL": 67.0, + "RMS_SEED": 1067.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.15, + "NTG1": 0.83, + "NTG2": 0.56, + "OWC1": 2537.0, + "OWC2": 2483.0, + "OWC3": 2430.2, + "PARAM1": 0.031, + "PARAM2": -0.84, + "PARAM3": 6016.1, + "REAL": 68.0, + "RMS_SEED": 1068.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.033, + "NTG1": 0.8, + "NTG2": 0.59, + "OWC1": 2542.2, + "OWC2": 2461.9, + "OWC3": 2433.9, + "PARAM1": 0.034, + "PARAM2": 0.87, + "PARAM3": 3105.41, + "REAL": 69.0, + "RMS_SEED": 1069.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.029, + "NTG1": 0.85, + "NTG2": 0.54, + "OWC1": 2526.5, + "OWC2": 2467.2, + "OWC3": 2451.0, + "PARAM1": 0.03, + "PARAM2": 0.88, + "PARAM3": 0.058, + "REAL": 70.0, + "RMS_SEED": 1070.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.016, + "NTG1": 0.92, + "NTG2": 0.59, + "OWC1": 2538.9, + "OWC2": 2486.8, + "OWC3": 2434.7, + "PARAM1": 0.033, + "PARAM2": -0.74, + "PARAM3": 10.392, + "REAL": 71.0, + "RMS_SEED": 1071.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.003, + "NTG1": 0.9, + "NTG2": 0.62, + "OWC1": 2502.5, + "OWC2": 2454.9, + "OWC3": 2482.6, + "PARAM1": 0.036, + "PARAM2": -0.73, + "PARAM3": 28.252, + "REAL": 72.0, + "RMS_SEED": 1072.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.041, + "NTG1": 0.88, + "NTG2": 0.62, + "OWC1": 2532.9, + "OWC2": 2484.9, + "OWC3": 2434.0, + "PARAM1": 0.036, + "PARAM2": 0.38, + "PARAM3": 672094.0, + "REAL": 73.0, + "RMS_SEED": 1073.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.03, + "NTG1": 0.83, + "NTG2": 0.59, + "OWC1": 2502.2, + "OWC2": 2451.2, + "OWC3": 2485.9, + "PARAM1": 0.029, + "PARAM2": 0.88, + "PARAM3": 0.005, + "REAL": 74.0, + "RMS_SEED": 1074.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.001, + "NTG1": 0.88, + "NTG2": 0.61, + "OWC1": 2529.9, + "OWC2": 2455.6, + "OWC3": 2430.2, + "PARAM1": 0.039, + "PARAM2": 0.22, + "PARAM3": 113742.0, + "REAL": 75.0, + "RMS_SEED": 1075.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.76, + "NTG2": 0.58, + "OWC1": 2504.4, + "OWC2": 2444.0, + "OWC3": 2481.2, + "PARAM1": 0.038, + "PARAM2": -0.03, + "PARAM3": 22.731, + "REAL": 76.0, + "RMS_SEED": 1076.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.439, + "NTG1": 0.82, + "NTG2": 0.59, + "OWC1": 2537.8, + "OWC2": 2490.0, + "OWC3": 2441.3, + "PARAM1": 0.035, + "PARAM2": 0.18, + "PARAM3": 24794.9, + "REAL": 77.0, + "RMS_SEED": 1077.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.66, + "NTG1": 0.78, + "NTG2": 0.62, + "OWC1": 2536.8, + "OWC2": 2473.3, + "OWC3": 2432.9, + "PARAM1": 0.04, + "PARAM2": -0.06, + "PARAM3": 0.074, + "REAL": 78.0, + "RMS_SEED": 1078.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.009, + "NTG1": 0.76, + "NTG2": 0.57, + "OWC1": 2543.3, + "OWC2": 2484.5, + "OWC3": 2426.1, + "PARAM1": 0.032, + "PARAM2": 0.27, + "PARAM3": 2907.06, + "REAL": 79.0, + "RMS_SEED": 1079.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.05, + "NTG1": 0.78, + "NTG2": 0.57, + "OWC1": 2510.7, + "OWC2": 2466.5, + "OWC3": 2447.6, + "PARAM1": 0.04, + "PARAM2": 0.86, + "PARAM3": 0.036, + "REAL": 80.0, + "RMS_SEED": 1080.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.93, + "NTG2": 0.57, + "OWC1": 2506.3, + "OWC2": 2488.1, + "OWC3": 2459.0, + "PARAM1": 0.035, + "PARAM2": -0.08, + "PARAM3": 158.625, + "REAL": 81.0, + "RMS_SEED": 1081.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.8, + "NTG2": 0.59, + "OWC1": 2501.6, + "OWC2": 2436.3, + "OWC3": 2497.4, + "PARAM1": 0.028, + "PARAM2": -0.45, + "PARAM3": 0.0, + "REAL": 82.0, + "RMS_SEED": 1082.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.003, + "NTG1": 0.93, + "NTG2": 0.59, + "OWC1": 2543.4, + "OWC2": 2488.4, + "OWC3": 2420.0, + "PARAM1": 0.04, + "PARAM2": -0.49, + "PARAM3": 0.0, + "REAL": 83.0, + "RMS_SEED": 1083.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.099, + "NTG1": 0.98, + "NTG2": 0.59, + "OWC1": 2544.4, + "OWC2": 2492.0, + "OWC3": 2423.4, + "PARAM1": 0.035, + "PARAM2": -0.31, + "PARAM3": 665545000.0, + "REAL": 84.0, + "RMS_SEED": 1084.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.225, + "NTG1": 0.84, + "NTG2": 0.59, + "OWC1": 2520.5, + "OWC2": 2470.5, + "OWC3": 2465.5, + "PARAM1": 0.04, + "PARAM2": -0.79, + "PARAM3": 0.224, + "REAL": 85.0, + "RMS_SEED": 1085.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.042, + "NTG1": 0.77, + "NTG2": 0.53, + "OWC1": 2520.1, + "OWC2": 2482.8, + "OWC3": 2468.4, + "PARAM1": 0.038, + "PARAM2": -0.73, + "PARAM3": 0.001, + "REAL": 86.0, + "RMS_SEED": 1086.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.002, + "NTG1": 0.84, + "NTG2": 0.61, + "OWC1": 2506.1, + "OWC2": 2450.2, + "OWC3": 2466.2, + "PARAM1": 0.036, + "PARAM2": 0.47, + "PARAM3": 0.07, + "REAL": 87.0, + "RMS_SEED": 1087.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.583, + "NTG1": 0.86, + "NTG2": 0.6, + "OWC1": 2543.6, + "OWC2": 2484.3, + "OWC3": 2419.5, + "PARAM1": 0.035, + "PARAM2": 0.42, + "PARAM3": 107.93, + "REAL": 88.0, + "RMS_SEED": 1088.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.79, + "NTG2": 0.57, + "OWC1": 2545.9, + "OWC2": 2486.9, + "OWC3": 2420.6, + "PARAM1": 0.036, + "PARAM2": 0.71, + "PARAM3": 0.004, + "REAL": 89.0, + "RMS_SEED": 1089.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.014, + "NTG1": 0.86, + "NTG2": 0.55, + "OWC1": 2503.3, + "OWC2": 2460.0, + "OWC3": 2477.2, + "PARAM1": 0.032, + "PARAM2": 0.13, + "PARAM3": 14.614, + "REAL": 90.0, + "RMS_SEED": 1090.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.414, + "NTG1": 0.9, + "NTG2": 0.6, + "OWC1": 2521.5, + "OWC2": 2456.2, + "OWC3": 2466.0, + "PARAM1": 0.037, + "PARAM2": 0.01, + "PARAM3": 99926.9, + "REAL": 91.0, + "RMS_SEED": 1091.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.8, + "NTG2": 0.57, + "OWC1": 2548.2, + "OWC2": 2492.3, + "OWC3": 2417.2, + "PARAM1": 0.034, + "PARAM2": 0.29, + "PARAM3": 38056100.0, + "REAL": 92.0, + "RMS_SEED": 1092.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.056, + "NTG1": 0.89, + "NTG2": 0.59, + "OWC1": 2511.0, + "OWC2": 2445.3, + "OWC3": 2458.2, + "PARAM1": 0.036, + "PARAM2": -0.77, + "PARAM3": 0.001, + "REAL": 93.0, + "RMS_SEED": 1093.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.044, + "NTG1": 0.94, + "NTG2": 0.63, + "OWC1": 2501.0, + "OWC2": 2463.0, + "OWC3": 2469.8, + "PARAM1": 0.036, + "PARAM2": -0.33, + "PARAM3": 0.0, + "REAL": 94.0, + "RMS_SEED": 1094.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.366, + "NTG1": 0.76, + "NTG2": 0.63, + "OWC1": 2523.5, + "OWC2": 2442.0, + "OWC3": 2489.4, + "PARAM1": 0.035, + "PARAM2": -0.61, + "PARAM3": 64.825, + "REAL": 95.0, + "RMS_SEED": 1095.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.005, + "NTG1": 0.86, + "NTG2": 0.63, + "OWC1": 2526.0, + "OWC2": 2457.8, + "OWC3": 2458.9, + "PARAM1": 0.04, + "PARAM2": -0.15, + "PARAM3": 0.128, + "REAL": 96.0, + "RMS_SEED": 1096.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.791, + "NTG1": 0.8, + "NTG2": 0.61, + "OWC1": 2521.4, + "OWC2": 2472.7, + "OWC3": 2424.0, + "PARAM1": 0.037, + "PARAM2": -0.89, + "PARAM3": 586.68, + "REAL": 97.0, + "RMS_SEED": 1097.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.079, + "NTG1": 0.78, + "NTG2": 0.61, + "OWC1": 2534.4, + "OWC2": 2470.9, + "OWC3": 2445.7, + "PARAM1": 0.041, + "PARAM2": -0.46, + "PARAM3": 40421500000.0, + "REAL": 98.0, + "RMS_SEED": 1098.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.031, + "NTG1": 0.79, + "NTG2": 0.59, + "OWC1": 2507.6, + "OWC2": 2464.6, + "OWC3": 2470.9, + "PARAM1": 0.036, + "PARAM2": 0.67, + "PARAM3": 80.48, + "REAL": 99.0, + "RMS_SEED": 1099.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.067, + "NTG1": 0.81, + "NTG2": 0.59, + "OWC1": 2523.9, + "OWC2": 2468.6, + "OWC3": 2423.2, + "PARAM1": 0.03, + "PARAM2": -0.38, + "PARAM3": 0.0, + "REAL": 100.0, + "RMS_SEED": 1100.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.002, + "NTG1": 0.78, + "NTG2": 0.61, + "OWC1": 2508.6, + "OWC2": 2453.2, + "OWC3": 2452.8, + "PARAM1": 0.028, + "PARAM2": 0.03, + "PARAM3": 0.021, + "REAL": 101.0, + "RMS_SEED": 1101.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.007, + "NTG1": 0.82, + "NTG2": 0.63, + "OWC1": 2540.2, + "OWC2": 2479.6, + "OWC3": 2425.2, + "PARAM1": 0.036, + "PARAM2": 0.4, + "PARAM3": 0.001, + "REAL": 102.0, + "RMS_SEED": 1102.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.032, + "NTG1": 0.84, + "NTG2": 0.63, + "OWC1": 2538.0, + "OWC2": 2468.1, + "OWC3": 2455.8, + "PARAM1": 0.04, + "PARAM2": 0.64, + "PARAM3": 612431.0, + "REAL": 103.0, + "RMS_SEED": 1103.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.008, + "NTG1": 0.92, + "NTG2": 0.58, + "OWC1": 2504.6, + "OWC2": 2480.8, + "OWC3": 2438.8, + "PARAM1": 0.034, + "PARAM2": 0.06, + "PARAM3": 3261110.0, + "REAL": 104.0, + "RMS_SEED": 1104.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.083, + "NTG1": 0.83, + "NTG2": 0.6, + "OWC1": 2545.5, + "OWC2": 2476.1, + "OWC3": 2425.0, + "PARAM1": 0.03, + "PARAM2": 0.49, + "PARAM3": 0.006, + "REAL": 105.0, + "RMS_SEED": 1105.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.472, + "NTG1": 0.81, + "NTG2": 0.61, + "OWC1": 2546.8, + "OWC2": 2456.0, + "OWC3": 2436.5, + "PARAM1": 0.034, + "PARAM2": -0.11, + "PARAM3": 450.839, + "REAL": 106.0, + "RMS_SEED": 1106.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.269, + "NTG1": 0.77, + "NTG2": 0.62, + "OWC1": 2505.6, + "OWC2": 2450.9, + "OWC3": 2454.9, + "PARAM1": 0.042, + "PARAM2": 0.26, + "PARAM3": 885.285, + "REAL": 107.0, + "RMS_SEED": 1107.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.684, + "NTG1": 0.79, + "NTG2": 0.58, + "OWC1": 2512.5, + "OWC2": 2451.8, + "OWC3": 2470.3, + "PARAM1": 0.032, + "PARAM2": 0.78, + "PARAM3": 265.675, + "REAL": 108.0, + "RMS_SEED": 1108.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.004, + "NTG1": 0.84, + "NTG2": 0.62, + "OWC1": 2541.5, + "OWC2": 2487.6, + "OWC3": 2411.7, + "PARAM1": 0.037, + "PARAM2": 0.0, + "PARAM3": 3.055, + "REAL": 109.0, + "RMS_SEED": 1109.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.032, + "NTG1": 0.88, + "NTG2": 0.64, + "OWC1": 2518.1, + "OWC2": 2469.9, + "OWC3": 2439.9, + "PARAM1": 0.03, + "PARAM2": 0.34, + "PARAM3": 2.023, + "REAL": 110.0, + "RMS_SEED": 1110.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.006, + "NTG1": 0.87, + "NTG2": 0.6, + "OWC1": 2530.4, + "OWC2": 2475.8, + "OWC3": 2452.8, + "PARAM1": 0.031, + "PARAM2": 0.66, + "PARAM3": 0.076, + "REAL": 111.0, + "RMS_SEED": 1111.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.033, + "NTG1": 0.78, + "NTG2": 0.58, + "OWC1": 2526.0, + "OWC2": 2435.4, + "OWC3": 2465.9, + "PARAM1": 0.031, + "PARAM2": -0.07, + "PARAM3": 0.0, + "REAL": 112.0, + "RMS_SEED": 1112.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.189, + "NTG1": 0.79, + "NTG2": 0.6, + "OWC1": 2537.7, + "OWC2": 2470.4, + "OWC3": 2464.7, + "PARAM1": 0.036, + "PARAM2": -0.59, + "PARAM3": 3.581, + "REAL": 113.0, + "RMS_SEED": 1113.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.001, + "NTG1": 0.95, + "NTG2": 0.53, + "OWC1": 2507.5, + "OWC2": 2465.2, + "OWC3": 2469.0, + "PARAM1": 0.037, + "PARAM2": 0.14, + "PARAM3": 163179000000.0, + "REAL": 114.0, + "RMS_SEED": 1114.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.014, + "NTG1": 0.79, + "NTG2": 0.56, + "OWC1": 2532.1, + "OWC2": 2446.5, + "OWC3": 2468.6, + "PARAM1": 0.028, + "PARAM2": -0.31, + "PARAM3": 1227.5, + "REAL": 115.0, + "RMS_SEED": 1115.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.678, + "NTG1": 0.86, + "NTG2": 0.52, + "OWC1": 2530.1, + "OWC2": 2440.6, + "OWC3": 2450.1, + "PARAM1": 0.043, + "PARAM2": -0.01, + "PARAM3": 2.641, + "REAL": 116.0, + "RMS_SEED": 1116.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.533, + "NTG1": 0.87, + "NTG2": 0.59, + "OWC1": 2535.9, + "OWC2": 2470.0, + "OWC3": 2427.3, + "PARAM1": 0.033, + "PARAM2": -0.42, + "PARAM3": 0.0, + "REAL": 117.0, + "RMS_SEED": 1117.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.071, + "NTG1": 0.83, + "NTG2": 0.56, + "OWC1": 2517.6, + "OWC2": 2469.2, + "OWC3": 2447.3, + "PARAM1": 0.041, + "PARAM2": 0.95, + "PARAM3": 570.996, + "REAL": 118.0, + "RMS_SEED": 1118.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.021, + "NTG1": 0.78, + "NTG2": 0.56, + "OWC1": 2514.0, + "OWC2": 2469.6, + "OWC3": 2442.0, + "PARAM1": 0.033, + "PARAM2": 0.46, + "PARAM3": 138549.0, + "REAL": 119.0, + "RMS_SEED": 1119.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.003, + "NTG1": 0.84, + "NTG2": 0.54, + "OWC1": 2512.9, + "OWC2": 2461.4, + "OWC3": 2450.3, + "PARAM1": 0.043, + "PARAM2": 0.06, + "PARAM3": 0.004, + "REAL": 120.0, + "RMS_SEED": 1120.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.264, + "NTG1": 0.86, + "NTG2": 0.59, + "OWC1": 2528.2, + "OWC2": 2448.3, + "OWC3": 2472.1, + "PARAM1": 0.028, + "PARAM2": -0.24, + "PARAM3": 0.002, + "REAL": 121.0, + "RMS_SEED": 1121.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.005, + "NTG1": 0.89, + "NTG2": 0.59, + "OWC1": 2515.3, + "OWC2": 2485.0, + "OWC3": 2420.2, + "PARAM1": 0.041, + "PARAM2": -0.58, + "PARAM3": 0.003, + "REAL": 122.0, + "RMS_SEED": 1122.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.004, + "NTG1": 0.84, + "NTG2": 0.59, + "OWC1": 2510.5, + "OWC2": 2477.8, + "OWC3": 2445.9, + "PARAM1": 0.036, + "PARAM2": -0.19, + "PARAM3": 0.004, + "REAL": 123.0, + "RMS_SEED": 1123.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.067, + "NTG1": 0.89, + "NTG2": 0.62, + "OWC1": 2503.5, + "OWC2": 2443.7, + "OWC3": 2475.9, + "PARAM1": 0.038, + "PARAM2": -0.63, + "PARAM3": 0.0, + "REAL": 124.0, + "RMS_SEED": 1124.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.152, + "NTG1": 0.83, + "NTG2": 0.59, + "OWC1": 2541.5, + "OWC2": 2470.8, + "OWC3": 2449.0, + "PARAM1": 0.031, + "PARAM2": -0.53, + "PARAM3": 0.0, + "REAL": 125.0, + "RMS_SEED": 1125.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.068, + "NTG1": 0.85, + "NTG2": 0.55, + "OWC1": 2508.5, + "OWC2": 2451.7, + "OWC3": 2477.0, + "PARAM1": 0.034, + "PARAM2": 0.36, + "PARAM3": 13327.7, + "REAL": 126.0, + "RMS_SEED": 1126.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.118, + "NTG1": 0.89, + "NTG2": 0.58, + "OWC1": 2540.8, + "OWC2": 2457.8, + "OWC3": 2458.6, + "PARAM1": 0.033, + "PARAM2": 0.35, + "PARAM3": 296.314, + "REAL": 127.0, + "RMS_SEED": 1127.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.008, + "NTG1": 0.88, + "NTG2": 0.6, + "OWC1": 2518.7, + "OWC2": 2467.7, + "OWC3": 2461.1, + "PARAM1": 0.029, + "PARAM2": -0.26, + "PARAM3": 3.431, + "REAL": 128.0, + "RMS_SEED": 1128.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.015, + "NTG1": 0.81, + "NTG2": 0.61, + "OWC1": 2516.6, + "OWC2": 2476.9, + "OWC3": 2438.7, + "PARAM1": 0.032, + "PARAM2": 0.61, + "PARAM3": 6.329, + "REAL": 129.0, + "RMS_SEED": 1129.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.011, + "NTG1": 0.82, + "NTG2": 0.59, + "OWC1": 2534.9, + "OWC2": 2475.2, + "OWC3": 2428.2, + "PARAM1": 0.032, + "PARAM2": 0.09, + "PARAM3": 1.005, + "REAL": 130.0, + "RMS_SEED": 1130.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.023, + "NTG1": 0.9, + "NTG2": 0.57, + "OWC1": 2523.6, + "OWC2": 2485.5, + "OWC3": 2453.4, + "PARAM1": 0.035, + "PARAM2": -0.25, + "PARAM3": 124010.0, + "REAL": 131.0, + "RMS_SEED": 1131.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.207, + "NTG1": 0.85, + "NTG2": 0.59, + "OWC1": 2533.3, + "OWC2": 2478.3, + "OWC3": 2436.1, + "PARAM1": 0.041, + "PARAM2": 0.3, + "PARAM3": 93.759, + "REAL": 132.0, + "RMS_SEED": 1132.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.136, + "NTG1": 0.83, + "NTG2": 0.59, + "OWC1": 2536.7, + "OWC2": 2468.1, + "OWC3": 2463.7, + "PARAM1": 0.032, + "PARAM2": 0.59, + "PARAM3": 201034.0, + "REAL": 133.0, + "RMS_SEED": 1133.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.005, + "NTG1": 0.76, + "NTG2": 0.63, + "OWC1": 2538.3, + "OWC2": 2459.5, + "OWC3": 2442.3, + "PARAM1": 0.032, + "PARAM2": 0.32, + "PARAM3": 1017650.0, + "REAL": 134.0, + "RMS_SEED": 1134.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.004, + "NTG1": 0.77, + "NTG2": 0.6, + "OWC1": 2505.9, + "OWC2": 2470.3, + "OWC3": 2457.7, + "PARAM1": 0.035, + "PARAM2": 0.69, + "PARAM3": 1977.15, + "REAL": 135.0, + "RMS_SEED": 1135.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.006, + "NTG1": 0.88, + "NTG2": 0.64, + "OWC1": 2536.2, + "OWC2": 2490.5, + "OWC3": 2421.5, + "PARAM1": 0.034, + "PARAM2": 0.54, + "PARAM3": 462826.0, + "REAL": 136.0, + "RMS_SEED": 1136.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.051, + "NTG1": 0.83, + "NTG2": 0.6, + "OWC1": 2525.6, + "OWC2": 2484.8, + "OWC3": 2412.1, + "PARAM1": 0.032, + "PARAM2": -0.56, + "PARAM3": 0.0, + "REAL": 137.0, + "RMS_SEED": 1137.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.06, + "NTG1": 0.78, + "NTG2": 0.58, + "OWC1": 2532.8, + "OWC2": 2448.0, + "OWC3": 2437.3, + "PARAM1": 0.035, + "PARAM2": -0.52, + "PARAM3": 98.115, + "REAL": 138.0, + "RMS_SEED": 1138.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.016, + "NTG1": 0.83, + "NTG2": 0.6, + "OWC1": 2503.4, + "OWC2": 2440.4, + "OWC3": 2479.0, + "PARAM1": 0.032, + "PARAM2": 0.48, + "PARAM3": 0.0, + "REAL": 139.0, + "RMS_SEED": 1139.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.013, + "NTG1": 0.86, + "NTG2": 0.53, + "OWC1": 2520.5, + "OWC2": 2467.6, + "OWC3": 2446.9, + "PARAM1": 0.035, + "PARAM2": -0.66, + "PARAM3": 0.001, + "REAL": 140.0, + "RMS_SEED": 1140.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.272, + "NTG1": 0.82, + "NTG2": 0.61, + "OWC1": 2533.3, + "OWC2": 2462.6, + "OWC3": 2448.8, + "PARAM1": 0.037, + "PARAM2": 0.78, + "PARAM3": 1.838, + "REAL": 141.0, + "RMS_SEED": 1141.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.382, + "NTG1": 0.87, + "NTG2": 0.61, + "OWC1": 2502.7, + "OWC2": 2455.9, + "OWC3": 2481.6, + "PARAM1": 0.04, + "PARAM2": 0.56, + "PARAM3": 0.0, + "REAL": 142.0, + "RMS_SEED": 1142.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.001, + "NTG1": 0.86, + "NTG2": 0.61, + "OWC1": 2506.0, + "OWC2": 2459.8, + "OWC3": 2466.4, + "PARAM1": 0.038, + "PARAM2": -0.11, + "PARAM3": 16735.2, + "REAL": 143.0, + "RMS_SEED": 1143.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.012, + "NTG1": 0.77, + "NTG2": 0.61, + "OWC1": 2549.6, + "OWC2": 2465.5, + "OWC3": 2429.9, + "PARAM1": 0.039, + "PARAM2": -0.54, + "PARAM3": 0.407, + "REAL": 144.0, + "RMS_SEED": 1144.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.009, + "NTG1": 0.94, + "NTG2": 0.6, + "OWC1": 2504.2, + "OWC2": 2461.9, + "OWC3": 2470.0, + "PARAM1": 0.039, + "PARAM2": 0.05, + "PARAM3": 0.001, + "REAL": 145.0, + "RMS_SEED": 1145.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.544, + "NTG1": 0.79, + "NTG2": 0.62, + "OWC1": 2513.2, + "OWC2": 2440.0, + "OWC3": 2484.4, + "PARAM1": 0.037, + "PARAM2": -0.0, + "PARAM3": 11440.5, + "REAL": 146.0, + "RMS_SEED": 1146.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.964, + "NTG1": 0.81, + "NTG2": 0.56, + "OWC1": 2525.6, + "OWC2": 2458.0, + "OWC3": 2451.1, + "PARAM1": 0.037, + "PARAM2": -0.11, + "PARAM3": 248270.0, + "REAL": 147.0, + "RMS_SEED": 1147.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.009, + "NTG1": 0.76, + "NTG2": 0.61, + "OWC1": 2549.1, + "OWC2": 2494.5, + "OWC3": 2430.6, + "PARAM1": 0.035, + "PARAM2": 0.99, + "PARAM3": 0.0, + "REAL": 148.0, + "RMS_SEED": 1148.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.294, + "NTG1": 0.85, + "NTG2": 0.64, + "OWC1": 2534.9, + "OWC2": 2478.8, + "OWC3": 2418.2, + "PARAM1": 0.031, + "PARAM2": -0.25, + "PARAM3": 0.332, + "REAL": 149.0, + "RMS_SEED": 1149.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.003, + "NTG1": 0.93, + "NTG2": 0.62, + "OWC1": 2512.5, + "OWC2": 2463.3, + "OWC3": 2474.6, + "PARAM1": 0.028, + "PARAM2": -0.1, + "PARAM3": 0.0, + "REAL": 150.0, + "RMS_SEED": 1150.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.935, + "NTG1": 0.81, + "NTG2": 0.58, + "OWC1": 2507.2, + "OWC2": 2479.3, + "OWC3": 2464.9, + "PARAM1": 0.039, + "PARAM2": -0.6, + "PARAM3": 5426.66, + "REAL": 151.0, + "RMS_SEED": 1151.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.82, + "NTG2": 0.55, + "OWC1": 2540.6, + "OWC2": 2467.1, + "OWC3": 2449.1, + "PARAM1": 0.035, + "PARAM2": -0.69, + "PARAM3": 0.0, + "REAL": 152.0, + "RMS_SEED": 1152.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.048, + "NTG1": 0.83, + "NTG2": 0.58, + "OWC1": 2511.8, + "OWC2": 2466.5, + "OWC3": 2454.3, + "PARAM1": 0.037, + "PARAM2": 0.2, + "PARAM3": 131.092, + "REAL": 153.0, + "RMS_SEED": 1153.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.479, + "NTG1": 0.79, + "NTG2": 0.6, + "OWC1": 2543.8, + "OWC2": 2468.9, + "OWC3": 2440.7, + "PARAM1": 0.029, + "PARAM2": 0.12, + "PARAM3": 1.136, + "REAL": 154.0, + "RMS_SEED": 1154.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.81, + "NTG2": 0.6, + "OWC1": 2538.4, + "OWC2": 2458.7, + "OWC3": 2430.3, + "PARAM1": 0.037, + "PARAM2": 0.65, + "PARAM3": 0.0, + "REAL": 155.0, + "RMS_SEED": 1155.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.165, + "NTG1": 0.94, + "NTG2": 0.64, + "OWC1": 2533.1, + "OWC2": 2479.0, + "OWC3": 2433.2, + "PARAM1": 0.032, + "PARAM2": -0.78, + "PARAM3": 0.0, + "REAL": 156.0, + "RMS_SEED": 1156.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.123, + "NTG1": 0.87, + "NTG2": 0.61, + "OWC1": 2541.2, + "OWC2": 2481.9, + "OWC3": 2419.2, + "PARAM1": 0.036, + "PARAM2": 0.1, + "PARAM3": 0.0, + "REAL": 157.0, + "RMS_SEED": 1157.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.004, + "NTG1": 0.88, + "NTG2": 0.58, + "OWC1": 2540.2, + "OWC2": 2454.5, + "OWC3": 2453.2, + "PARAM1": 0.034, + "PARAM2": 0.93, + "PARAM3": 1.569, + "REAL": 158.0, + "RMS_SEED": 1158.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.024, + "NTG1": 0.83, + "NTG2": 0.59, + "OWC1": 2546.2, + "OWC2": 2485.7, + "OWC3": 2410.5, + "PARAM1": 0.027, + "PARAM2": -0.65, + "PARAM3": 406.363, + "REAL": 159.0, + "RMS_SEED": 1159.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.301, + "NTG1": 0.77, + "NTG2": 0.63, + "OWC1": 2540.7, + "OWC2": 2452.5, + "OWC3": 2438.5, + "PARAM1": 0.04, + "PARAM2": 0.41, + "PARAM3": 34583000.0, + "REAL": 160.0, + "RMS_SEED": 1160.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.063, + "NTG1": 0.85, + "NTG2": 0.63, + "OWC1": 2531.0, + "OWC2": 2451.0, + "OWC3": 2442.2, + "PARAM1": 0.034, + "PARAM2": -0.39, + "PARAM3": 2011750.0, + "REAL": 161.0, + "RMS_SEED": 1161.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.738, + "NTG1": 0.83, + "NTG2": 0.59, + "OWC1": 2503.9, + "OWC2": 2462.3, + "OWC3": 2466.3, + "PARAM1": 0.032, + "PARAM2": 0.44, + "PARAM3": 0.101, + "REAL": 162.0, + "RMS_SEED": 1162.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.006, + "NTG1": 0.83, + "NTG2": 0.56, + "OWC1": 2539.2, + "OWC2": 2475.0, + "OWC3": 2429.5, + "PARAM1": 0.039, + "PARAM2": 0.25, + "PARAM3": 0.055, + "REAL": 163.0, + "RMS_SEED": 1163.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.183, + "NTG1": 0.8, + "NTG2": 0.61, + "OWC1": 2509.8, + "OWC2": 2454.8, + "OWC3": 2474.5, + "PARAM1": 0.034, + "PARAM2": -0.21, + "PARAM3": 0.203, + "REAL": 164.0, + "RMS_SEED": 1164.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.037, + "NTG1": 0.81, + "NTG2": 0.61, + "OWC1": 2517.6, + "OWC2": 2461.4, + "OWC3": 2456.8, + "PARAM1": 0.036, + "PARAM2": 0.28, + "PARAM3": 75876.2, + "REAL": 165.0, + "RMS_SEED": 1165.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.009, + "NTG1": 0.8, + "NTG2": 0.63, + "OWC1": 2519.1, + "OWC2": 2443.3, + "OWC3": 2457.4, + "PARAM1": 0.033, + "PARAM2": 0.34, + "PARAM3": 8263.11, + "REAL": 166.0, + "RMS_SEED": 1166.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.035, + "NTG1": 0.8, + "NTG2": 0.6, + "OWC1": 2508.1, + "OWC2": 2457.2, + "OWC3": 2456.9, + "PARAM1": 0.03, + "PARAM2": -0.08, + "PARAM3": 0.033, + "REAL": 167.0, + "RMS_SEED": 1167.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.241, + "NTG1": 0.94, + "NTG2": 0.59, + "OWC1": 2519.9, + "OWC2": 2466.1, + "OWC3": 2456.0, + "PARAM1": 0.035, + "PARAM2": 0.66, + "PARAM3": 0.0, + "REAL": 168.0, + "RMS_SEED": 1168.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.005, + "NTG1": 0.88, + "NTG2": 0.62, + "OWC1": 2522.7, + "OWC2": 2453.7, + "OWC3": 2469.9, + "PARAM1": 0.032, + "PARAM2": -0.77, + "PARAM3": 176.632, + "REAL": 169.0, + "RMS_SEED": 1169.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.01, + "NTG1": 0.81, + "NTG2": 0.54, + "OWC1": 2511.8, + "OWC2": 2459.9, + "OWC3": 2477.3, + "PARAM1": 0.039, + "PARAM2": -0.37, + "PARAM3": 2.276, + "REAL": 170.0, + "RMS_SEED": 1170.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.667, + "NTG1": 0.82, + "NTG2": 0.63, + "OWC1": 2503.7, + "OWC2": 2437.1, + "OWC3": 2452.1, + "PARAM1": 0.027, + "PARAM2": 0.15, + "PARAM3": 0.0, + "REAL": 171.0, + "RMS_SEED": 1171.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.777, + "NTG1": 0.81, + "NTG2": 0.63, + "OWC1": 2511.3, + "OWC2": 2482.3, + "OWC3": 2448.9, + "PARAM1": 0.031, + "PARAM2": 0.9, + "PARAM3": 33.415, + "REAL": 172.0, + "RMS_SEED": 1172.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.004, + "NTG1": 0.9, + "NTG2": 0.57, + "OWC1": 2548.9, + "OWC2": 2494.0, + "OWC3": 2430.7, + "PARAM1": 0.039, + "PARAM2": -0.82, + "PARAM3": 0.613, + "REAL": 173.0, + "RMS_SEED": 1173.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.342, + "NTG1": 0.89, + "NTG2": 0.58, + "OWC1": 2523.1, + "OWC2": 2489.6, + "OWC3": 2435.5, + "PARAM1": 0.03, + "PARAM2": -0.43, + "PARAM3": 0.124, + "REAL": 174.0, + "RMS_SEED": 1174.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.448, + "NTG1": 0.81, + "NTG2": 0.6, + "OWC1": 2539.7, + "OWC2": 2459.0, + "OWC3": 2437.1, + "PARAM1": 0.034, + "PARAM2": -0.7, + "PARAM3": 542.855, + "REAL": 175.0, + "RMS_SEED": 1175.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.072, + "NTG1": 0.84, + "NTG2": 0.58, + "OWC1": 2536.8, + "OWC2": 2486.7, + "OWC3": 2415.9, + "PARAM1": 0.033, + "PARAM2": 0.73, + "PARAM3": 8.4, + "REAL": 176.0, + "RMS_SEED": 1176.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.003, + "NTG1": 0.77, + "NTG2": 0.64, + "OWC1": 2506.4, + "OWC2": 2453.6, + "OWC3": 2467.8, + "PARAM1": 0.025, + "PARAM2": -0.64, + "PARAM3": 0.0, + "REAL": 177.0, + "RMS_SEED": 1177.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.041, + "NTG1": 0.83, + "NTG2": 0.6, + "OWC1": 2530.6, + "OWC2": 2486.3, + "OWC3": 2414.9, + "PARAM1": 0.033, + "PARAM2": -0.33, + "PARAM3": 0.008, + "REAL": 178.0, + "RMS_SEED": 1178.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.025, + "NTG1": 0.96, + "NTG2": 0.6, + "OWC1": 2532.4, + "OWC2": 2467.7, + "OWC3": 2444.9, + "PARAM1": 0.038, + "PARAM2": -0.17, + "PARAM3": 0.0, + "REAL": 179.0, + "RMS_SEED": 1179.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.01, + "NTG1": 0.91, + "NTG2": 0.56, + "OWC1": 2500.2, + "OWC2": 2439.6, + "OWC3": 2494.9, + "PARAM1": 0.033, + "PARAM2": 0.24, + "PARAM3": 0.193, + "REAL": 180.0, + "RMS_SEED": 1180.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.258, + "NTG1": 0.75, + "NTG2": 0.54, + "OWC1": 2531.2, + "OWC2": 2486.6, + "OWC3": 2439.2, + "PARAM1": 0.039, + "PARAM2": -0.67, + "PARAM3": 4215710.0, + "REAL": 181.0, + "RMS_SEED": 1181.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.052, + "NTG1": 0.9, + "NTG2": 0.55, + "OWC1": 2506.5, + "OWC2": 2471.2, + "OWC3": 2435.8, + "PARAM1": 0.039, + "PARAM2": -0.02, + "PARAM3": 0.0, + "REAL": 182.0, + "RMS_SEED": 1182.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.362, + "NTG1": 0.87, + "NTG2": 0.64, + "OWC1": 2549.9, + "OWC2": 2483.7, + "OWC3": 2406.7, + "PARAM1": 0.032, + "PARAM2": -0.89, + "PARAM3": 0.941, + "REAL": 183.0, + "RMS_SEED": 1183.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.001, + "NTG1": 0.85, + "NTG2": 0.58, + "OWC1": 2513.4, + "OWC2": 2439.1, + "OWC3": 2486.6, + "PARAM1": 0.037, + "PARAM2": 0.21, + "PARAM3": 2.886, + "REAL": 184.0, + "RMS_SEED": 1184.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.93, + "NTG2": 0.6, + "OWC1": 2529.1, + "OWC2": 2445.1, + "OWC3": 2463.8, + "PARAM1": 0.033, + "PARAM2": -0.54, + "PARAM3": 0.0, + "REAL": 185.0, + "RMS_SEED": 1185.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.837, + "NTG1": 0.95, + "NTG2": 0.54, + "OWC1": 2511.2, + "OWC2": 2456.1, + "OWC3": 2471.4, + "PARAM1": 0.027, + "PARAM2": 0.2, + "PARAM3": 0.002, + "REAL": 186.0, + "RMS_SEED": 1186.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.391, + "NTG1": 0.87, + "NTG2": 0.61, + "OWC1": 2518.5, + "OWC2": 2471.5, + "OWC3": 2423.7, + "PARAM1": 0.027, + "PARAM2": -0.88, + "PARAM3": 0.0, + "REAL": 187.0, + "RMS_SEED": 1187.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.643, + "NTG1": 0.79, + "NTG2": 0.61, + "OWC1": 2544.7, + "OWC2": 2469.1, + "OWC3": 2421.0, + "PARAM1": 0.042, + "PARAM2": -1.0, + "PARAM3": 0.006, + "REAL": 188.0, + "RMS_SEED": 1188.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.003, + "NTG1": 0.79, + "NTG2": 0.58, + "OWC1": 2542.3, + "OWC2": 2476.7, + "OWC3": 2433.2, + "PARAM1": 0.036, + "PARAM2": 0.29, + "PARAM3": 13.842, + "REAL": 189.0, + "RMS_SEED": 1189.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.069, + "NTG1": 0.8, + "NTG2": 0.6, + "OWC1": 2525.8, + "OWC2": 2473.0, + "OWC3": 2462.9, + "PARAM1": 0.031, + "PARAM2": 0.52, + "PARAM3": 7588.49, + "REAL": 190.0, + "RMS_SEED": 1190.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.96, + "NTG2": 0.56, + "OWC1": 2501.6, + "OWC2": 2464.4, + "OWC3": 2472.9, + "PARAM1": 0.037, + "PARAM2": 0.45, + "PARAM3": 1.054, + "REAL": 191.0, + "RMS_SEED": 1191.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.018, + "NTG1": 0.79, + "NTG2": 0.53, + "OWC1": 2524.9, + "OWC2": 2459.2, + "OWC3": 2471.9, + "PARAM1": 0.033, + "PARAM2": -0.41, + "PARAM3": 0.0, + "REAL": 192.0, + "RMS_SEED": 1192.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.019, + "NTG1": 0.9, + "NTG2": 0.63, + "OWC1": 2529.2, + "OWC2": 2457.1, + "OWC3": 2456.4, + "PARAM1": 0.039, + "PARAM2": -0.31, + "PARAM3": 0.004, + "REAL": 193.0, + "RMS_SEED": 1193.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.012, + "NTG1": 0.85, + "NTG2": 0.59, + "OWC1": 2545.0, + "OWC2": 2480.1, + "OWC3": 2441.4, + "PARAM1": 0.041, + "PARAM2": -0.43, + "PARAM3": 0.264, + "REAL": 194.0, + "RMS_SEED": 1194.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.002, + "NTG1": 0.8, + "NTG2": 0.6, + "OWC1": 2524.5, + "OWC2": 2465.1, + "OWC3": 2468.7, + "PARAM1": 0.033, + "PARAM2": -0.24, + "PARAM3": 0.016, + "REAL": 195.0, + "RMS_SEED": 1195.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.731, + "NTG1": 0.79, + "NTG2": 0.63, + "OWC1": 2531.4, + "OWC2": 2479.1, + "OWC3": 2447.5, + "PARAM1": 0.035, + "PARAM2": -0.8, + "PARAM3": 71.745, + "REAL": 196.0, + "RMS_SEED": 1196.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.016, + "NTG1": 0.9, + "NTG2": 0.58, + "OWC1": 2517.7, + "OWC2": 2446.0, + "OWC3": 2464.5, + "PARAM1": 0.042, + "PARAM2": -0.12, + "PARAM3": 0.36, + "REAL": 197.0, + "RMS_SEED": 1197.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.013, + "NTG1": 0.97, + "NTG2": 0.63, + "OWC1": 2505.3, + "OWC2": 2469.8, + "OWC3": 2480.8, + "PARAM1": 0.033, + "PARAM2": 0.75, + "PARAM3": 0.0, + "REAL": 198.0, + "RMS_SEED": 1198.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.035, + "NTG1": 0.88, + "NTG2": 0.54, + "OWC1": 2547.6, + "OWC2": 2487.1, + "OWC3": 2418.0, + "PARAM1": 0.042, + "PARAM2": 0.38, + "PARAM3": 0.091, + "REAL": 199.0, + "RMS_SEED": 1199.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.604, + "NTG1": 0.97, + "NTG2": 0.54, + "OWC1": 2528.3, + "OWC2": 2449.2, + "OWC3": 2462.1, + "PARAM1": 0.034, + "PARAM2": 0.1, + "PARAM3": 1432730.0, + "REAL": 200.0, + "RMS_SEED": 1200.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.046, + "NTG1": 0.86, + "NTG2": 0.6, + "OWC1": 2514.6, + "OWC2": 2477.6, + "OWC3": 2434.2, + "PARAM1": 0.033, + "PARAM2": 0.01, + "PARAM3": 0.0, + "REAL": 201.0, + "RMS_SEED": 1201.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.077, + "NTG1": 0.82, + "NTG2": 0.62, + "OWC1": 2509.3, + "OWC2": 2447.0, + "OWC3": 2482.1, + "PARAM1": 0.035, + "PARAM2": -0.06, + "PARAM3": 2915850.0, + "REAL": 202.0, + "RMS_SEED": 1202.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.929, + "NTG1": 0.77, + "NTG2": 0.57, + "OWC1": 2518.1, + "OWC2": 2468.3, + "OWC3": 2436.0, + "PARAM1": 0.027, + "PARAM2": 0.65, + "PARAM3": 0.318, + "REAL": 203.0, + "RMS_SEED": 1203.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.001, + "NTG1": 0.8, + "NTG2": 0.64, + "OWC1": 2543.2, + "OWC2": 2477.3, + "OWC3": 2425.9, + "PARAM1": 0.036, + "PARAM2": 0.64, + "PARAM3": 112.948, + "REAL": 204.0, + "RMS_SEED": 1204.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.01, + "NTG1": 0.83, + "NTG2": 0.61, + "OWC1": 2539.9, + "OWC2": 2479.1, + "OWC3": 2442.8, + "PARAM1": 0.033, + "PARAM2": 0.01, + "PARAM3": 0.003, + "REAL": 205.0, + "RMS_SEED": 1205.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.023, + "NTG1": 0.9, + "NTG2": 0.59, + "OWC1": 2510.2, + "OWC2": 2450.8, + "OWC3": 2476.4, + "PARAM1": 0.035, + "PARAM2": 0.5, + "PARAM3": 0.031, + "REAL": 206.0, + "RMS_SEED": 1206.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.85, + "NTG2": 0.61, + "OWC1": 2537.3, + "OWC2": 2454.7, + "OWC3": 2449.8, + "PARAM1": 0.041, + "PARAM2": 0.31, + "PARAM3": 971.421, + "REAL": 207.0, + "RMS_SEED": 1207.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.003, + "NTG1": 0.9, + "NTG2": 0.58, + "OWC1": 2520.9, + "OWC2": 2460.9, + "OWC3": 2458.9, + "PARAM1": 0.035, + "PARAM2": 0.9, + "PARAM3": 39.432, + "REAL": 208.0, + "RMS_SEED": 1208.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.056, + "NTG1": 0.83, + "NTG2": 0.57, + "OWC1": 2506.8, + "OWC2": 2469.4, + "OWC3": 2464.3, + "PARAM1": 0.028, + "PARAM2": -0.68, + "PARAM3": 4162.86, + "REAL": 209.0, + "RMS_SEED": 1209.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.864, + "NTG1": 0.85, + "NTG2": 0.59, + "OWC1": 2537.1, + "OWC2": 2487.2, + "OWC3": 2414.8, + "PARAM1": 0.033, + "PARAM2": -0.87, + "PARAM3": 8807.35, + "REAL": 210.0, + "RMS_SEED": 1210.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.027, + "NTG1": 0.81, + "NTG2": 0.62, + "OWC1": 2542.8, + "OWC2": 2473.4, + "OWC3": 2418.7, + "PARAM1": 0.029, + "PARAM2": -0.2, + "PARAM3": 0.207, + "REAL": 211.0, + "RMS_SEED": 1211.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.003, + "NTG1": 0.81, + "NTG2": 0.65, + "OWC1": 2530.3, + "OWC2": 2461.6, + "OWC3": 2479.0, + "PARAM1": 0.033, + "PARAM2": 0.53, + "PARAM3": 0.0, + "REAL": 212.0, + "RMS_SEED": 1212.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.011, + "NTG1": 0.91, + "NTG2": 0.55, + "OWC1": 2521.7, + "OWC2": 2488.7, + "OWC3": 2432.1, + "PARAM1": 0.036, + "PARAM2": -0.84, + "PARAM3": 0.99, + "REAL": 213.0, + "RMS_SEED": 1213.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.458, + "NTG1": 0.95, + "NTG2": 0.58, + "OWC1": 2513.6, + "OWC2": 2469.1, + "OWC3": 2456.5, + "PARAM1": 0.029, + "PARAM2": -0.32, + "PARAM3": 0.0, + "REAL": 214.0, + "RMS_SEED": 1214.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.023, + "NTG1": 0.91, + "NTG2": 0.55, + "OWC1": 2516.1, + "OWC2": 2469.3, + "OWC3": 2446.3, + "PARAM1": 0.039, + "PARAM2": 0.23, + "PARAM3": 22.123, + "REAL": 215.0, + "RMS_SEED": 1215.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.098, + "NTG1": 0.79, + "NTG2": 0.59, + "OWC1": 2539.1, + "OWC2": 2470.6, + "OWC3": 2456.4, + "PARAM1": 0.029, + "PARAM2": 0.44, + "PARAM3": 0.006, + "REAL": 216.0, + "RMS_SEED": 1216.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.024, + "NTG1": 0.86, + "NTG2": 0.57, + "OWC1": 2544.7, + "OWC2": 2480.4, + "OWC3": 2409.0, + "PARAM1": 0.04, + "PARAM2": -0.09, + "PARAM3": 0.0, + "REAL": 217.0, + "RMS_SEED": 1217.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.014, + "NTG1": 0.94, + "NTG2": 0.61, + "OWC1": 2512.7, + "OWC2": 2442.9, + "OWC3": 2473.2, + "PARAM1": 0.032, + "PARAM2": 0.94, + "PARAM3": 0.0, + "REAL": 218.0, + "RMS_SEED": 1218.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.94, + "NTG2": 0.6, + "OWC1": 2542.6, + "OWC2": 2476.3, + "OWC3": 2429.8, + "PARAM1": 0.03, + "PARAM2": 0.19, + "PARAM3": 717.039, + "REAL": 219.0, + "RMS_SEED": 1219.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.192, + "NTG1": 0.81, + "NTG2": 0.58, + "OWC1": 2522.0, + "OWC2": 2480.8, + "OWC3": 2455.7, + "PARAM1": 0.034, + "PARAM2": -0.99, + "PARAM3": 0.0, + "REAL": 220.0, + "RMS_SEED": 1220.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.006, + "NTG1": 0.81, + "NTG2": 0.64, + "OWC1": 2527.2, + "OWC2": 2481.1, + "OWC3": 2435.0, + "PARAM1": 0.032, + "PARAM2": 0.74, + "PARAM3": 0.001, + "REAL": 221.0, + "RMS_SEED": 1221.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.83, + "NTG2": 0.63, + "OWC1": 2511.7, + "OWC2": 2444.3, + "OWC3": 2475.1, + "PARAM1": 0.028, + "PARAM2": 0.55, + "PARAM3": 2.186, + "REAL": 222.0, + "RMS_SEED": 1222.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.026, + "NTG1": 0.93, + "NTG2": 0.54, + "OWC1": 2542.9, + "OWC2": 2467.4, + "OWC3": 2453.6, + "PARAM1": 0.034, + "PARAM2": 0.57, + "PARAM3": 7.104, + "REAL": 223.0, + "RMS_SEED": 1223.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.125, + "NTG1": 0.87, + "NTG2": 0.63, + "OWC1": 2509.5, + "OWC2": 2433.0, + "OWC3": 2474.0, + "PARAM1": 0.041, + "PARAM2": 1.0, + "PARAM3": 0.0, + "REAL": 224.0, + "RMS_SEED": 1224.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.005, + "NTG1": 0.78, + "NTG2": 0.58, + "OWC1": 2542.0, + "OWC2": 2465.0, + "OWC3": 2436.2, + "PARAM1": 0.035, + "PARAM2": -0.47, + "PARAM3": 0.0, + "REAL": 225.0, + "RMS_SEED": 1225.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.007, + "NTG1": 0.8, + "NTG2": 0.63, + "OWC1": 2500.5, + "OWC2": 2455.2, + "OWC3": 2465.2, + "PARAM1": 0.038, + "PARAM2": -0.02, + "PARAM3": 144804000.0, + "REAL": 226.0, + "RMS_SEED": 1226.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.01, + "NTG1": 0.86, + "NTG2": 0.61, + "OWC1": 2540.4, + "OWC2": 2483.3, + "OWC3": 2448.9, + "PARAM1": 0.035, + "PARAM2": 0.35, + "PARAM3": 0.03, + "REAL": 227.0, + "RMS_SEED": 1227.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.008, + "NTG1": 0.81, + "NTG2": 0.6, + "OWC1": 2539.5, + "OWC2": 2467.9, + "OWC3": 2447.4, + "PARAM1": 0.035, + "PARAM2": -0.03, + "PARAM3": 0.086, + "REAL": 228.0, + "RMS_SEED": 1228.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.519, + "NTG1": 0.8, + "NTG2": 0.61, + "OWC1": 2541.2, + "OWC2": 2446.3, + "OWC3": 2470.7, + "PARAM1": 0.031, + "PARAM2": 0.16, + "PARAM3": 0.0, + "REAL": 229.0, + "RMS_SEED": 1229.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.025, + "NTG1": 0.99, + "NTG2": 0.61, + "OWC1": 2521.7, + "OWC2": 2491.2, + "OWC3": 2439.7, + "PARAM1": 0.033, + "PARAM2": -0.19, + "PARAM3": 0.005, + "REAL": 230.0, + "RMS_SEED": 1230.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.029, + "NTG1": 0.96, + "NTG2": 0.53, + "OWC1": 2522.1, + "OWC2": 2474.3, + "OWC3": 2445.0, + "PARAM1": 0.029, + "PARAM2": 0.22, + "PARAM3": 35448.0, + "REAL": 231.0, + "RMS_SEED": 1231.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.79, + "NTG2": 0.55, + "OWC1": 2502.1, + "OWC2": 2460.8, + "OWC3": 2469.4, + "PARAM1": 0.03, + "PARAM2": -0.85, + "PARAM3": 476.181, + "REAL": 232.0, + "RMS_SEED": 1232.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.186, + "NTG1": 0.81, + "NTG2": 0.6, + "OWC1": 2502.4, + "OWC2": 2447.4, + "OWC3": 2489.7, + "PARAM1": 0.044, + "PARAM2": -0.34, + "PARAM3": 6239.04, + "REAL": 233.0, + "RMS_SEED": 1233.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.003, + "NTG1": 0.99, + "NTG2": 0.57, + "OWC1": 2543.3, + "OWC2": 2460.5, + "OWC3": 2480.0, + "PARAM1": 0.036, + "PARAM2": 0.37, + "PARAM3": 0.002, + "REAL": 234.0, + "RMS_SEED": 1234.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.548, + "NTG1": 0.82, + "NTG2": 0.58, + "OWC1": 2510.0, + "OWC2": 2464.5, + "OWC3": 2450.4, + "PARAM1": 0.034, + "PARAM2": -0.58, + "PARAM3": 7.486, + "REAL": 235.0, + "RMS_SEED": 1235.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.007, + "NTG1": 0.8, + "NTG2": 0.57, + "OWC1": 2522.2, + "OWC2": 2438.3, + "OWC3": 2473.0, + "PARAM1": 0.035, + "PARAM2": -0.55, + "PARAM3": 0.0, + "REAL": 236.0, + "RMS_SEED": 1236.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.001, + "NTG1": 0.92, + "NTG2": 0.61, + "OWC1": 2519.1, + "OWC2": 2444.9, + "OWC3": 2469.5, + "PARAM1": 0.029, + "PARAM2": -0.53, + "PARAM3": 8.87, + "REAL": 237.0, + "RMS_SEED": 1237.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.003, + "NTG1": 0.77, + "NTG2": 0.56, + "OWC1": 2523.4, + "OWC2": 2448.6, + "OWC3": 2460.9, + "PARAM1": 0.044, + "PARAM2": -0.91, + "PARAM3": 2602.05, + "REAL": 238.0, + "RMS_SEED": 1238.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.005, + "NTG1": 0.83, + "NTG2": 0.59, + "OWC1": 2516.0, + "OWC2": 2474.4, + "OWC3": 2438.0, + "PARAM1": 0.037, + "PARAM2": -0.82, + "PARAM3": 19478.7, + "REAL": 239.0, + "RMS_SEED": 1239.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.007, + "NTG1": 0.86, + "NTG2": 0.62, + "OWC1": 2514.4, + "OWC2": 2466.8, + "OWC3": 2443.3, + "PARAM1": 0.034, + "PARAM2": -0.39, + "PARAM3": 2236.67, + "REAL": 240.0, + "RMS_SEED": 1240.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.1, + "NTG1": 0.84, + "NTG2": 0.57, + "OWC1": 2501.7, + "OWC2": 2459.3, + "OWC3": 2476.7, + "PARAM1": 0.038, + "PARAM2": -0.72, + "PARAM3": 313332.0, + "REAL": 241.0, + "RMS_SEED": 1241.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.003, + "NTG1": 0.91, + "NTG2": 0.63, + "OWC1": 2504.8, + "OWC2": 2445.7, + "OWC3": 2457.2, + "PARAM1": 0.045, + "PARAM2": -0.27, + "PARAM3": 759.979, + "REAL": 242.0, + "RMS_SEED": 1242.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.008, + "NTG1": 0.92, + "NTG2": 0.57, + "OWC1": 2531.8, + "OWC2": 2469.6, + "OWC3": 2443.4, + "PARAM1": 0.039, + "PARAM2": -0.16, + "PARAM3": 366904.0, + "REAL": 243.0, + "RMS_SEED": 1243.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.022, + "NTG1": 0.91, + "NTG2": 0.63, + "OWC1": 2534.0, + "OWC2": 2473.0, + "OWC3": 2461.5, + "PARAM1": 0.034, + "PARAM2": -0.04, + "PARAM3": 1.82, + "REAL": 244.0, + "RMS_SEED": 1244.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.001, + "NTG1": 0.84, + "NTG2": 0.63, + "OWC1": 2506.7, + "OWC2": 2466.2, + "OWC3": 2466.7, + "PARAM1": 0.029, + "PARAM2": 0.71, + "PARAM3": 0.0, + "REAL": 245.0, + "RMS_SEED": 1245.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.147, + "NTG1": 0.8, + "NTG2": 0.63, + "OWC1": 2513.9, + "OWC2": 2484.6, + "OWC3": 2447.0, + "PARAM1": 0.042, + "PARAM2": 0.82, + "PARAM3": 183.657, + "REAL": 246.0, + "RMS_SEED": 1246.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.358, + "NTG1": 0.85, + "NTG2": 0.58, + "OWC1": 2531.9, + "OWC2": 2487.9, + "OWC3": 2437.7, + "PARAM1": 0.042, + "PARAM2": 0.58, + "PARAM3": 4.148, + "REAL": 247.0, + "RMS_SEED": 1247.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.806, + "NTG1": 0.87, + "NTG2": 0.58, + "OWC1": 2504.4, + "OWC2": 2464.9, + "OWC3": 2453.1, + "PARAM1": 0.03, + "PARAM2": -0.4, + "PARAM3": 0.0, + "REAL": 248.0, + "RMS_SEED": 1248.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.039, + "NTG1": 0.83, + "NTG2": 0.61, + "OWC1": 2514.7, + "OWC2": 2479.3, + "OWC3": 2462.5, + "PARAM1": 0.029, + "PARAM2": -0.67, + "PARAM3": 5.797, + "REAL": 249.0, + "RMS_SEED": 1249.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.01, + "NTG1": 0.92, + "NTG2": 0.61, + "OWC1": 2511.5, + "OWC2": 2458.2, + "OWC3": 2449.7, + "PARAM1": 0.037, + "PARAM2": 0.03, + "PARAM3": 0.0, + "REAL": 250.0, + "RMS_SEED": 1250.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.691, + "NTG1": 0.77, + "NTG2": 0.56, + "OWC1": 2531.0, + "OWC2": 2475.9, + "OWC3": 2441.6, + "PARAM1": 0.042, + "PARAM2": 0.13, + "PARAM3": 2161.94, + "REAL": 251.0, + "RMS_SEED": 1251.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.79, + "NTG2": 0.59, + "OWC1": 2528.4, + "OWC2": 2469.5, + "OWC3": 2453.9, + "PARAM1": 0.041, + "PARAM2": 0.97, + "PARAM3": 70294.9, + "REAL": 252.0, + "RMS_SEED": 1252.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.37, + "NTG1": 0.91, + "NTG2": 0.59, + "OWC1": 2513.1, + "OWC2": 2485.3, + "OWC3": 2436.7, + "PARAM1": 0.036, + "PARAM2": -0.93, + "PARAM3": 448606000000000.0, + "REAL": 253.0, + "RMS_SEED": 1253.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.003, + "NTG1": 0.89, + "NTG2": 0.62, + "OWC1": 2518.9, + "OWC2": 2446.2, + "OWC3": 2455.0, + "PARAM1": 0.03, + "PARAM2": 0.75, + "PARAM3": 1074.78, + "REAL": 254.0, + "RMS_SEED": 1254.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.046, + "NTG1": 0.87, + "NTG2": 0.59, + "OWC1": 2522.9, + "OWC2": 2472.3, + "OWC3": 2441.1, + "PARAM1": 0.039, + "PARAM2": -0.44, + "PARAM3": 492590000.0, + "REAL": 255.0, + "RMS_SEED": 1255.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.054, + "NTG1": 0.85, + "NTG2": 0.62, + "OWC1": 2525.2, + "OWC2": 2482.1, + "OWC3": 2446.5, + "PARAM1": 0.033, + "PARAM2": -0.36, + "PARAM3": 0.005, + "REAL": 256.0, + "RMS_SEED": 1256.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.001, + "NTG1": 0.85, + "NTG2": 0.55, + "OWC1": 2515.2, + "OWC2": 2450.3, + "OWC3": 2483.9, + "PARAM1": 0.039, + "PARAM2": -0.69, + "PARAM3": 0.002, + "REAL": 257.0, + "RMS_SEED": 1257.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.155, + "NTG1": 0.82, + "NTG2": 0.58, + "OWC1": 2517.0, + "OWC2": 2449.3, + "OWC3": 2451.1, + "PARAM1": 0.027, + "PARAM2": 0.56, + "PARAM3": 29714.4, + "REAL": 258.0, + "RMS_SEED": 1258.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.306, + "NTG1": 0.82, + "NTG2": 0.61, + "OWC1": 2545.6, + "OWC2": 2478.1, + "OWC3": 2432.1, + "PARAM1": 0.032, + "PARAM2": -0.76, + "PARAM3": 25.441, + "REAL": 259.0, + "RMS_SEED": 1259.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.009, + "NTG1": 0.82, + "NTG2": 0.6, + "OWC1": 2506.9, + "OWC2": 2449.8, + "OWC3": 2458.5, + "PARAM1": 0.041, + "PARAM2": 0.83, + "PARAM3": 0.012, + "REAL": 260.0, + "RMS_SEED": 1260.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.062, + "NTG1": 0.83, + "NTG2": 0.65, + "OWC1": 2542.8, + "OWC2": 2488.4, + "OWC3": 2445.6, + "PARAM1": 0.035, + "PARAM2": 0.04, + "PARAM3": 0.0, + "REAL": 261.0, + "RMS_SEED": 1261.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.004, + "NTG1": 0.87, + "NTG2": 0.6, + "OWC1": 2501.1, + "OWC2": 2468.6, + "OWC3": 2460.7, + "PARAM1": 0.035, + "PARAM2": 0.08, + "PARAM3": 121.657, + "REAL": 262.0, + "RMS_SEED": 1262.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.322, + "NTG1": 0.92, + "NTG2": 0.59, + "OWC1": 2529.0, + "OWC2": 2481.4, + "OWC3": 2440.3, + "PARAM1": 0.036, + "PARAM2": -0.56, + "PARAM3": 20.237, + "REAL": 263.0, + "RMS_SEED": 1263.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.004, + "NTG1": 0.83, + "NTG2": 0.56, + "OWC1": 2500.8, + "OWC2": 2460.0, + "OWC3": 2467.1, + "PARAM1": 0.029, + "PARAM2": -0.58, + "PARAM3": 0.169, + "REAL": 264.0, + "RMS_SEED": 1264.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.004, + "NTG1": 0.8, + "NTG2": 0.61, + "OWC1": 2543.6, + "OWC2": 2442.4, + "OWC3": 2433.7, + "PARAM1": 0.034, + "PARAM2": 0.51, + "PARAM3": 0.011, + "REAL": 265.0, + "RMS_SEED": 1265.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.231, + "NTG1": 0.89, + "NTG2": 0.59, + "OWC1": 2547.6, + "OWC2": 2480.9, + "OWC3": 2452.0, + "PARAM1": 0.031, + "PARAM2": -0.33, + "PARAM3": 4.582, + "REAL": 266.0, + "RMS_SEED": 1266.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.991, + "NTG1": 0.83, + "NTG2": 0.6, + "OWC1": 2522.7, + "OWC2": 2475.7, + "OWC3": 2451.3, + "PARAM1": 0.039, + "PARAM2": 0.02, + "PARAM3": 4.379, + "REAL": 267.0, + "RMS_SEED": 1267.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.194, + "NTG1": 0.84, + "NTG2": 0.6, + "OWC1": 2501.8, + "OWC2": 2439.2, + "OWC3": 2477.8, + "PARAM1": 0.031, + "PARAM2": 0.87, + "PARAM3": 0.001, + "REAL": 268.0, + "RMS_SEED": 1268.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.88, + "NTG1": 0.83, + "NTG2": 0.56, + "OWC1": 2501.4, + "OWC2": 2453.5, + "OWC3": 2466.6, + "PARAM1": 0.033, + "PARAM2": 0.03, + "PARAM3": 0.001, + "REAL": 269.0, + "RMS_SEED": 1269.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.572, + "NTG1": 0.85, + "NTG2": 0.58, + "OWC1": 2541.6, + "OWC2": 2493.8, + "OWC3": 2412.6, + "PARAM1": 0.034, + "PARAM2": 0.92, + "PARAM3": 26369.7, + "REAL": 270.0, + "RMS_SEED": 1270.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.051, + "NTG1": 0.92, + "NTG2": 0.59, + "OWC1": 2525.3, + "OWC2": 2474.2, + "OWC3": 2454.4, + "PARAM1": 0.041, + "PARAM2": 0.21, + "PARAM3": 48.036, + "REAL": 271.0, + "RMS_SEED": 1271.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.002, + "NTG1": 0.79, + "NTG2": 0.6, + "OWC1": 2544.6, + "OWC2": 2459.1, + "OWC3": 2445.3, + "PARAM1": 0.037, + "PARAM2": 0.27, + "PARAM3": 3403.88, + "REAL": 272.0, + "RMS_SEED": 1272.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.114, + "NTG1": 0.9, + "NTG2": 0.52, + "OWC1": 2509.9, + "OWC2": 2456.3, + "OWC3": 2471.2, + "PARAM1": 0.03, + "PARAM2": -0.68, + "PARAM3": 0.0, + "REAL": 273.0, + "RMS_SEED": 1273.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.216, + "NTG1": 0.82, + "NTG2": 0.6, + "OWC1": 2500.0, + "OWC2": 2431.8, + "OWC3": 2496.4, + "PARAM1": 0.043, + "PARAM2": -0.5, + "PARAM3": 92990.6, + "REAL": 274.0, + "RMS_SEED": 1274.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.093, + "NTG1": 0.86, + "NTG2": 0.6, + "OWC1": 2533.5, + "OWC2": 2467.9, + "OWC3": 2443.7, + "PARAM1": 0.036, + "PARAM2": 0.33, + "PARAM3": 167.798, + "REAL": 275.0, + "RMS_SEED": 1275.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.059, + "NTG1": 0.83, + "NTG2": 0.56, + "OWC1": 2510.8, + "OWC2": 2472.3, + "OWC3": 2471.0, + "PARAM1": 0.038, + "PARAM2": -0.57, + "PARAM3": 4398.71, + "REAL": 276.0, + "RMS_SEED": 1276.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.016, + "NTG1": 0.95, + "NTG2": 0.61, + "OWC1": 2546.3, + "OWC2": 2498.7, + "OWC3": 2403.3, + "PARAM1": 0.029, + "PARAM2": -0.74, + "PARAM3": 9111100.0, + "REAL": 277.0, + "RMS_SEED": 1277.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.061, + "NTG1": 0.79, + "NTG2": 0.57, + "OWC1": 2536.0, + "OWC2": 2473.7, + "OWC3": 2437.0, + "PARAM1": 0.031, + "PARAM2": 0.33, + "PARAM3": 0.285, + "REAL": 278.0, + "RMS_SEED": 1278.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.8, + "NTG2": 0.58, + "OWC1": 2506.0, + "OWC2": 2449.4, + "OWC3": 2473.7, + "PARAM1": 0.037, + "PARAM2": -0.38, + "PARAM3": 809.6, + "REAL": 279.0, + "RMS_SEED": 1279.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.101, + "NTG1": 0.95, + "NTG2": 0.57, + "OWC1": 2540.9, + "OWC2": 2473.5, + "OWC3": 2432.8, + "PARAM1": 0.029, + "PARAM2": -0.21, + "PARAM3": 1.432, + "REAL": 280.0, + "RMS_SEED": 1280.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.01, + "NTG1": 0.81, + "NTG2": 0.57, + "OWC1": 2501.3, + "OWC2": 2458.8, + "OWC3": 2483.1, + "PARAM1": 0.026, + "PARAM2": 0.67, + "PARAM3": 1745.93, + "REAL": 281.0, + "RMS_SEED": 1281.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.005, + "NTG1": 0.78, + "NTG2": 0.55, + "OWC1": 2547.1, + "OWC2": 2478.4, + "OWC3": 2422.5, + "PARAM1": 0.033, + "PARAM2": -0.85, + "PARAM3": 419.857, + "REAL": 282.0, + "RMS_SEED": 1282.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.159, + "NTG1": 0.8, + "NTG2": 0.6, + "OWC1": 2522.9, + "OWC2": 2472.8, + "OWC3": 2457.3, + "PARAM1": 0.034, + "PARAM2": -0.7, + "PARAM3": 0.011, + "REAL": 283.0, + "RMS_SEED": 1283.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.005, + "NTG1": 0.88, + "NTG2": 0.6, + "OWC1": 2528.6, + "OWC2": 2476.9, + "OWC3": 2409.9, + "PARAM1": 0.037, + "PARAM2": -0.71, + "PARAM3": 336.359, + "REAL": 284.0, + "RMS_SEED": 1284.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.039, + "NTG1": 0.91, + "NTG2": 0.56, + "OWC1": 2512.1, + "OWC2": 2473.1, + "OWC3": 2455.9, + "PARAM1": 0.029, + "PARAM2": 0.28, + "PARAM3": 0.0, + "REAL": 285.0, + "RMS_SEED": 1285.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.016, + "NTG1": 0.85, + "NTG2": 0.63, + "OWC1": 2514.5, + "OWC2": 2465.4, + "OWC3": 2460.6, + "PARAM1": 0.032, + "PARAM2": -0.71, + "PARAM3": 10408.7, + "REAL": 286.0, + "RMS_SEED": 1286.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.238, + "NTG1": 0.87, + "NTG2": 0.61, + "OWC1": 2500.3, + "OWC2": 2454.3, + "OWC3": 2469.3, + "PARAM1": 0.038, + "PARAM2": -0.2, + "PARAM3": 0.001, + "REAL": 287.0, + "RMS_SEED": 1287.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.144, + "NTG1": 0.8, + "NTG2": 0.58, + "OWC1": 2544.4, + "OWC2": 2474.9, + "OWC3": 2438.1, + "PARAM1": 0.035, + "PARAM2": -0.52, + "PARAM3": 0.08, + "REAL": 288.0, + "RMS_SEED": 1288.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.008, + "NTG1": 0.96, + "NTG2": 0.64, + "OWC1": 2538.4, + "OWC2": 2463.3, + "OWC3": 2431.3, + "PARAM1": 0.038, + "PARAM2": 0.09, + "PARAM3": 21658.5, + "REAL": 289.0, + "RMS_SEED": 1289.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.229, + "NTG1": 0.83, + "NTG2": 0.62, + "OWC1": 2527.9, + "OWC2": 2451.6, + "OWC3": 2476.0, + "PARAM1": 0.028, + "PARAM2": -0.6, + "PARAM3": 11.941, + "REAL": 290.0, + "RMS_SEED": 1290.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.012, + "NTG1": 0.89, + "NTG2": 0.59, + "OWC1": 2511.2, + "OWC2": 2460.1, + "OWC3": 2482.7, + "PARAM1": 0.032, + "PARAM2": 0.18, + "PARAM3": 0.0, + "REAL": 291.0, + "RMS_SEED": 1291.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.129, + "NTG1": 0.96, + "NTG2": 0.63, + "OWC1": 2515.7, + "OWC2": 2461.7, + "OWC3": 2444.1, + "PARAM1": 0.042, + "PARAM2": -0.4, + "PARAM3": 0.0, + "REAL": 292.0, + "RMS_SEED": 1292.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.632, + "NTG1": 0.89, + "NTG2": 0.57, + "OWC1": 2516.6, + "OWC2": 2451.3, + "OWC3": 2457.1, + "PARAM1": 0.03, + "PARAM2": -0.48, + "PARAM3": 0.0, + "REAL": 293.0, + "RMS_SEED": 1293.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.003, + "NTG1": 0.94, + "NTG2": 0.62, + "OWC1": 2517.9, + "OWC2": 2456.9, + "OWC3": 2468.0, + "PARAM1": 0.041, + "PARAM2": -0.11, + "PARAM3": 11.641, + "REAL": 294.0, + "RMS_SEED": 1294.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.001, + "NTG1": 0.83, + "NTG2": 0.57, + "OWC1": 2503.0, + "OWC2": 2447.9, + "OWC3": 2484.9, + "PARAM1": 0.031, + "PARAM2": 0.97, + "PARAM3": 0.307, + "REAL": 295.0, + "RMS_SEED": 1295.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.106, + "NTG1": 0.82, + "NTG2": 0.57, + "OWC1": 2530.0, + "OWC2": 2462.3, + "OWC3": 2459.8, + "PARAM1": 0.036, + "PARAM2": 0.78, + "PARAM3": 3843.43, + "REAL": 296.0, + "RMS_SEED": 1296.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.221, + "NTG1": 0.84, + "NTG2": 0.58, + "OWC1": 2516.8, + "OWC2": 2462.8, + "OWC3": 2450.8, + "PARAM1": 0.042, + "PARAM2": 0.4, + "PARAM3": 192.296, + "REAL": 297.0, + "RMS_SEED": 1297.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.261, + "NTG1": 0.79, + "NTG2": 0.6, + "OWC1": 2524.2, + "OWC2": 2490.7, + "OWC3": 2428.4, + "PARAM1": 0.032, + "PARAM2": 0.61, + "PARAM3": 5.406, + "REAL": 298.0, + "RMS_SEED": 1298.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.022, + "NTG1": 0.81, + "NTG2": 0.6, + "OWC1": 2527.0, + "OWC2": 2477.6, + "OWC3": 2452.3, + "PARAM1": 0.04, + "PARAM2": -0.75, + "PARAM3": 12770100.0, + "REAL": 299.0, + "RMS_SEED": 1299.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.011, + "NTG1": 0.84, + "NTG2": 0.62, + "OWC1": 2508.7, + "OWC2": 2471.1, + "OWC3": 2447.8, + "PARAM1": 0.04, + "PARAM2": -0.41, + "PARAM3": 0.048, + "REAL": 300.0, + "RMS_SEED": 1300.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.138, + "NTG1": 0.83, + "NTG2": 0.58, + "OWC1": 2515.2, + "OWC2": 2464.2, + "OWC3": 2474.2, + "PARAM1": 0.04, + "PARAM2": 0.33, + "PARAM3": 9.375, + "REAL": 301.0, + "RMS_SEED": 1301.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.167, + "NTG1": 0.93, + "NTG2": 0.63, + "OWC1": 2521.4, + "OWC2": 2476.2, + "OWC3": 2452.2, + "PARAM1": 0.037, + "PARAM2": 0.07, + "PARAM3": 2.567, + "REAL": 302.0, + "RMS_SEED": 1302.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.141, + "NTG1": 0.98, + "NTG2": 0.59, + "OWC1": 2508.1, + "OWC2": 2465.7, + "OWC3": 2450.5, + "PARAM1": 0.042, + "PARAM2": 0.43, + "PARAM3": 261180000.0, + "REAL": 303.0, + "RMS_SEED": 1303.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.004, + "NTG1": 0.92, + "NTG2": 0.58, + "OWC1": 2517.2, + "OWC2": 2468.7, + "OWC3": 2437.5, + "PARAM1": 0.034, + "PARAM2": 0.25, + "PARAM3": 30086700.0, + "REAL": 304.0, + "RMS_SEED": 1304.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.007, + "NTG1": 0.9, + "NTG2": 0.62, + "OWC1": 2535.3, + "OWC2": 2483.1, + "OWC3": 2436.4, + "PARAM1": 0.035, + "PARAM2": 0.3, + "PARAM3": 5.207, + "REAL": 305.0, + "RMS_SEED": 1305.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.095, + "NTG1": 0.81, + "NTG2": 0.6, + "OWC1": 2546.6, + "OWC2": 2471.8, + "OWC3": 2416.9, + "PARAM1": 0.041, + "PARAM2": -0.86, + "PARAM3": 4.94, + "REAL": 306.0, + "RMS_SEED": 1306.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.2, + "NTG1": 0.88, + "NTG2": 0.55, + "OWC1": 2519.3, + "OWC2": 2442.6, + "OWC3": 2464.9, + "PARAM1": 0.032, + "PARAM2": -0.1, + "PARAM3": 1516.13, + "REAL": 307.0, + "RMS_SEED": 1307.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.025, + "NTG1": 0.89, + "NTG2": 0.63, + "OWC1": 2534.3, + "OWC2": 2491.3, + "OWC3": 2439.4, + "PARAM1": 0.038, + "PARAM2": -0.26, + "PARAM3": 1650.3, + "REAL": 308.0, + "RMS_SEED": 1308.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.087, + "NTG1": 0.86, + "NTG2": 0.64, + "OWC1": 2508.0, + "OWC2": 2473.2, + "OWC3": 2460.4, + "PARAM1": 0.038, + "PARAM2": 0.95, + "PARAM3": 2428.76, + "REAL": 309.0, + "RMS_SEED": 1309.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.959, + "NTG1": 0.84, + "NTG2": 0.57, + "OWC1": 2533.6, + "OWC2": 2459.6, + "OWC3": 2473.8, + "PARAM1": 0.042, + "PARAM2": -0.96, + "PARAM3": 32673.2, + "REAL": 310.0, + "RMS_SEED": 1310.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.024, + "NTG1": 0.89, + "NTG2": 0.61, + "OWC1": 2513.7, + "OWC2": 2480.6, + "OWC3": 2440.5, + "PARAM1": 0.031, + "PARAM2": 0.83, + "PARAM3": 0.001, + "REAL": 311.0, + "RMS_SEED": 1311.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.592, + "NTG1": 0.78, + "NTG2": 0.57, + "OWC1": 2532.7, + "OWC2": 2472.5, + "OWC3": 2453.4, + "PARAM1": 0.043, + "PARAM2": -0.03, + "PARAM3": 2.415, + "REAL": 312.0, + "RMS_SEED": 1312.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.021, + "NTG1": 0.94, + "NTG2": 0.59, + "OWC1": 2513.5, + "OWC2": 2478.7, + "OWC3": 2451.9, + "PARAM1": 0.041, + "PARAM2": -0.71, + "PARAM3": 7111350.0, + "REAL": 313.0, + "RMS_SEED": 1313.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.002, + "NTG1": 0.83, + "NTG2": 0.6, + "OWC1": 2549.5, + "OWC2": 2480.5, + "OWC3": 2428.5, + "PARAM1": 0.035, + "PARAM2": -0.17, + "PARAM3": 20.597, + "REAL": 314.0, + "RMS_SEED": 1314.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.009, + "NTG1": 0.88, + "NTG2": 0.6, + "OWC1": 2538.6, + "OWC2": 2461.2, + "OWC3": 2441.7, + "PARAM1": 0.037, + "PARAM2": 0.92, + "PARAM3": 64341.9, + "REAL": 315.0, + "RMS_SEED": 1315.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.008, + "NTG1": 0.78, + "NTG2": 0.58, + "OWC1": 2518.4, + "OWC2": 2435.8, + "OWC3": 2467.2, + "PARAM1": 0.037, + "PARAM2": 0.97, + "PARAM3": 1232470000000.0, + "REAL": 316.0, + "RMS_SEED": 1316.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.02, + "NTG1": 0.8, + "NTG2": 0.55, + "OWC1": 2505.0, + "OWC2": 2450.9, + "OWC3": 2490.8, + "PARAM1": 0.031, + "PARAM2": 0.14, + "PARAM3": 16.101, + "REAL": 317.0, + "RMS_SEED": 1317.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.001, + "NTG1": 0.87, + "NTG2": 0.62, + "OWC1": 2538.0, + "OWC2": 2489.0, + "OWC3": 2424.4, + "PARAM1": 0.037, + "PARAM2": -0.79, + "PARAM3": 0.242, + "REAL": 318.0, + "RMS_SEED": 1318.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.82, + "NTG2": 0.55, + "OWC1": 2517.4, + "OWC2": 2472.1, + "OWC3": 2459.3, + "PARAM1": 0.041, + "PARAM2": -0.51, + "PARAM3": 0.0, + "REAL": 319.0, + "RMS_SEED": 1319.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.246, + "NTG1": 0.84, + "NTG2": 0.59, + "OWC1": 2507.4, + "OWC2": 2481.8, + "OWC3": 2460.1, + "PARAM1": 0.032, + "PARAM2": 0.22, + "PARAM3": 0.002, + "REAL": 320.0, + "RMS_SEED": 1320.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.038, + "NTG1": 0.87, + "NTG2": 0.58, + "OWC1": 2524.2, + "OWC2": 2465.3, + "OWC3": 2446.2, + "PARAM1": 0.036, + "PARAM2": 0.84, + "PARAM3": 0.042, + "REAL": 321.0, + "RMS_SEED": 1321.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.018, + "NTG1": 0.87, + "NTG2": 0.61, + "OWC1": 2526.7, + "OWC2": 2471.4, + "OWC3": 2427.8, + "PARAM1": 0.034, + "PARAM2": -0.35, + "PARAM3": 346.387, + "REAL": 322.0, + "RMS_SEED": 1322.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.011, + "NTG1": 0.82, + "NTG2": 0.61, + "OWC1": 2500.7, + "OWC2": 2447.8, + "OWC3": 2493.5, + "PARAM1": 0.033, + "PARAM2": -0.73, + "PARAM3": 183689.0, + "REAL": 323.0, + "RMS_SEED": 1323.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.066, + "NTG1": 0.89, + "NTG2": 0.59, + "OWC1": 2509.2, + "OWC2": 2447.2, + "OWC3": 2463.0, + "PARAM1": 0.035, + "PARAM2": 0.49, + "PARAM3": 228019.0, + "REAL": 324.0, + "RMS_SEED": 1324.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.116, + "NTG1": 0.87, + "NTG2": 0.63, + "OWC1": 2503.4, + "OWC2": 2465.9, + "OWC3": 2460.2, + "PARAM1": 0.029, + "PARAM2": 0.58, + "PARAM3": 20246100.0, + "REAL": 325.0, + "RMS_SEED": 1325.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.018, + "NTG1": 0.85, + "NTG2": 0.61, + "OWC1": 2508.2, + "OWC2": 2459.5, + "OWC3": 2478.4, + "PARAM1": 0.039, + "PARAM2": 0.16, + "PARAM3": 51570200.0, + "REAL": 326.0, + "RMS_SEED": 1326.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.015, + "NTG1": 0.76, + "NTG2": 0.58, + "OWC1": 2521.3, + "OWC2": 2487.8, + "OWC3": 2447.1, + "PARAM1": 0.038, + "PARAM2": -0.23, + "PARAM3": 118.724, + "REAL": 327.0, + "RMS_SEED": 1327.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.31, + "NTG1": 0.89, + "NTG2": 0.59, + "OWC1": 2535.5, + "OWC2": 2471.7, + "OWC3": 2446.8, + "PARAM1": 0.038, + "PARAM2": -0.32, + "PARAM3": 0.007, + "REAL": 328.0, + "RMS_SEED": 1328.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.035, + "NTG1": 0.83, + "NTG2": 0.63, + "OWC1": 2525.7, + "OWC2": 2466.0, + "OWC3": 2448.3, + "PARAM1": 0.037, + "PARAM2": -0.49, + "PARAM3": 6910.68, + "REAL": 329.0, + "RMS_SEED": 1329.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.096, + "NTG1": 0.78, + "NTG2": 0.63, + "OWC1": 2517.5, + "OWC2": 2447.3, + "OWC3": 2478.3, + "PARAM1": 0.037, + "PARAM2": 0.6, + "PARAM3": 0.027, + "REAL": 330.0, + "RMS_SEED": 1330.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.11, + "NTG1": 0.83, + "NTG2": 0.63, + "OWC1": 2510.4, + "OWC2": 2434.5, + "OWC3": 2474.8, + "PARAM1": 0.04, + "PARAM2": -0.05, + "PARAM3": 16374.5, + "REAL": 331.0, + "RMS_SEED": 1331.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.001, + "NTG1": 0.84, + "NTG2": 0.57, + "OWC1": 2519.6, + "OWC2": 2444.7, + "OWC3": 2475.2, + "PARAM1": 0.03, + "PARAM2": 0.41, + "PARAM3": 5489190.0, + "REAL": 332.0, + "RMS_SEED": 1332.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.006, + "NTG1": 0.93, + "NTG2": 0.58, + "OWC1": 2537.0, + "OWC2": 2463.4, + "OWC3": 2438.5, + "PARAM1": 0.028, + "PARAM2": 0.48, + "PARAM3": 212.439, + "REAL": 333.0, + "RMS_SEED": 1333.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.93, + "NTG2": 0.57, + "OWC1": 2541.4, + "OWC2": 2471.9, + "OWC3": 2437.6, + "PARAM1": 0.034, + "PARAM2": 0.47, + "PARAM3": 0.0, + "REAL": 334.0, + "RMS_SEED": 1334.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.009, + "NTG1": 0.9, + "NTG2": 0.61, + "OWC1": 2535.7, + "OWC2": 2471.3, + "OWC3": 2451.7, + "PARAM1": 0.036, + "PARAM2": 0.51, + "PARAM3": 1247440.0, + "REAL": 335.0, + "RMS_SEED": 1335.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.007, + "NTG1": 0.85, + "NTG2": 0.62, + "OWC1": 2528.2, + "OWC2": 2455.1, + "OWC3": 2424.6, + "PARAM1": 0.033, + "PARAM2": -0.35, + "PARAM3": 83677.7, + "REAL": 336.0, + "RMS_SEED": 1336.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.92, + "NTG2": 0.62, + "OWC1": 2507.2, + "OWC2": 2453.0, + "OWC3": 2463.8, + "PARAM1": 0.036, + "PARAM2": 0.75, + "PARAM3": 230.34, + "REAL": 337.0, + "RMS_SEED": 1337.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.018, + "NTG1": 0.83, + "NTG2": 0.58, + "OWC1": 2526.8, + "OWC2": 2479.8, + "OWC3": 2439.3, + "PARAM1": 0.042, + "PARAM2": 0.16, + "PARAM3": 40833.4, + "REAL": 338.0, + "RMS_SEED": 1338.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.03, + "NTG1": 0.82, + "NTG2": 0.54, + "OWC1": 2533.8, + "OWC2": 2473.2, + "OWC3": 2445.2, + "PARAM1": 0.026, + "PARAM2": 0.28, + "PARAM3": 286.939, + "REAL": 339.0, + "RMS_SEED": 1339.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.41, + "NTG1": 0.89, + "NTG2": 0.6, + "OWC1": 2509.0, + "OWC2": 2464.6, + "OWC3": 2439.0, + "PARAM1": 0.038, + "PARAM2": 0.36, + "PARAM3": 17969.0, + "REAL": 340.0, + "RMS_SEED": 1340.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.727, + "NTG1": 0.82, + "NTG2": 0.6, + "OWC1": 2508.7, + "OWC2": 2450.6, + "OWC3": 2484.1, + "PARAM1": 0.036, + "PARAM2": -0.14, + "PARAM3": 0.096, + "REAL": 341.0, + "RMS_SEED": 1341.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.004, + "NTG1": 0.78, + "NTG2": 0.56, + "OWC1": 2504.2, + "OWC2": 2465.6, + "OWC3": 2455.3, + "PARAM1": 0.035, + "PARAM2": 0.53, + "PARAM3": 0.0, + "REAL": 342.0, + "RMS_SEED": 1342.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.204, + "NTG1": 0.86, + "NTG2": 0.61, + "OWC1": 2537.6, + "OWC2": 2476.5, + "OWC3": 2443.1, + "PARAM1": 0.032, + "PARAM2": -0.43, + "PARAM3": 22384700.0, + "REAL": 343.0, + "RMS_SEED": 1343.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.107, + "NTG1": 0.91, + "NTG2": 0.62, + "OWC1": 2532.5, + "OWC2": 2481.5, + "OWC3": 2422.9, + "PARAM1": 0.036, + "PARAM2": -0.28, + "PARAM3": 2710810000.0, + "REAL": 344.0, + "RMS_SEED": 1344.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.81, + "NTG2": 0.58, + "OWC1": 2505.7, + "OWC2": 2450.1, + "OWC3": 2453.8, + "PARAM1": 0.033, + "PARAM2": 0.46, + "PARAM3": 0.16, + "REAL": 345.0, + "RMS_SEED": 1345.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.9, + "NTG2": 0.61, + "OWC1": 2522.4, + "OWC2": 2456.7, + "OWC3": 2445.3, + "PARAM1": 0.03, + "PARAM2": -0.82, + "PARAM3": 0.001, + "REAL": 346.0, + "RMS_SEED": 1346.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.88, + "NTG2": 0.62, + "OWC1": 2549.9, + "OWC2": 2477.2, + "OWC3": 2416.5, + "PARAM1": 0.032, + "PARAM2": 0.93, + "PARAM3": 0.034, + "REAL": 347.0, + "RMS_SEED": 1347.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.04, + "NTG1": 0.8, + "NTG2": 0.56, + "OWC1": 2546.4, + "OWC2": 2474.7, + "OWC3": 2422.1, + "PARAM1": 0.034, + "PARAM2": -0.22, + "PARAM3": 0.039, + "REAL": 348.0, + "RMS_SEED": 1348.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.052, + "NTG1": 0.78, + "NTG2": 0.62, + "OWC1": 2542.6, + "OWC2": 2464.1, + "OWC3": 2441.8, + "PARAM1": 0.034, + "PARAM2": 0.73, + "PARAM3": 166683.0, + "REAL": 349.0, + "RMS_SEED": 1349.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.006, + "NTG1": 0.8, + "NTG2": 0.55, + "OWC1": 2534.6, + "OWC2": 2472.1, + "OWC3": 2444.4, + "PARAM1": 0.034, + "PARAM2": 0.62, + "PARAM3": 209.339, + "REAL": 350.0, + "RMS_SEED": 1350.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.086, + "NTG1": 0.87, + "NTG2": 0.62, + "OWC1": 2505.6, + "OWC2": 2475.5, + "OWC3": 2467.7, + "PARAM1": 0.037, + "PARAM2": 0.36, + "PARAM3": 0.88, + "REAL": 351.0, + "RMS_SEED": 1351.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.005, + "NTG1": 0.86, + "NTG2": 0.61, + "OWC1": 2547.5, + "OWC2": 2489.4, + "OWC3": 2404.8, + "PARAM1": 0.037, + "PARAM2": 0.23, + "PARAM3": 372.772, + "REAL": 352.0, + "RMS_SEED": 1352.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.178, + "NTG1": 0.79, + "NTG2": 0.59, + "OWC1": 2520.2, + "OWC2": 2468.5, + "OWC3": 2476.2, + "PARAM1": 0.028, + "PARAM2": 0.55, + "PARAM3": 0.002, + "REAL": 353.0, + "RMS_SEED": 1353.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.07, + "NTG1": 0.96, + "NTG2": 0.58, + "OWC1": 2528.8, + "OWC2": 2477.5, + "OWC3": 2451.4, + "PARAM1": 0.034, + "PARAM2": 0.96, + "PARAM3": 1308.85, + "REAL": 354.0, + "RMS_SEED": 1354.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.003, + "NTG1": 0.88, + "NTG2": 0.57, + "OWC1": 2539.1, + "OWC2": 2452.3, + "OWC3": 2446.1, + "PARAM1": 0.028, + "PARAM2": 0.77, + "PARAM3": 34.534, + "REAL": 355.0, + "RMS_SEED": 1355.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.251, + "NTG1": 0.88, + "NTG2": 0.57, + "OWC1": 2508.8, + "OWC2": 2464.2, + "OWC3": 2448.2, + "PARAM1": 0.034, + "PARAM2": 0.72, + "PARAM3": 3868.37, + "REAL": 356.0, + "RMS_SEED": 1356.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.815, + "NTG1": 0.81, + "NTG2": 0.58, + "OWC1": 2509.5, + "OWC2": 2456.5, + "OWC3": 2462.0, + "PARAM1": 0.04, + "PARAM2": 0.53, + "PARAM3": 0.0, + "REAL": 357.0, + "RMS_SEED": 1357.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.419, + "NTG1": 0.88, + "NTG2": 0.61, + "OWC1": 2524.7, + "OWC2": 2467.0, + "OWC3": 2467.6, + "PARAM1": 0.041, + "PARAM2": 0.04, + "PARAM3": 30498.5, + "REAL": 358.0, + "RMS_SEED": 1358.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.287, + "NTG1": 0.85, + "NTG2": 0.62, + "OWC1": 2514.8, + "OWC2": 2449.0, + "OWC3": 2487.4, + "PARAM1": 0.031, + "PARAM2": 0.38, + "PARAM3": 36.613, + "REAL": 359.0, + "RMS_SEED": 1359.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.012, + "NTG1": 0.88, + "NTG2": 0.59, + "OWC1": 2546.6, + "OWC2": 2468.9, + "OWC3": 2431.1, + "PARAM1": 0.035, + "PARAM2": 0.39, + "PARAM3": 0.15, + "REAL": 360.0, + "RMS_SEED": 1360.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.161, + "NTG1": 0.81, + "NTG2": 0.54, + "OWC1": 2544.0, + "OWC2": 2461.3, + "OWC3": 2447.2, + "PARAM1": 0.033, + "PARAM2": -0.65, + "PARAM3": 3248.35, + "REAL": 361.0, + "RMS_SEED": 1361.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.29, + "NTG1": 0.85, + "NTG2": 0.6, + "OWC1": 2510.6, + "OWC2": 2438.0, + "OWC3": 2492.5, + "PARAM1": 0.027, + "PARAM2": -0.15, + "PARAM3": 0.067, + "REAL": 362.0, + "RMS_SEED": 1362.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.213, + "NTG1": 0.85, + "NTG2": 0.59, + "OWC1": 2504.9, + "OWC2": 2470.3, + "OWC3": 2488.0, + "PARAM1": 0.039, + "PARAM2": -0.28, + "PARAM3": 76.398, + "REAL": 363.0, + "RMS_SEED": 1363.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.8, + "NTG2": 0.61, + "OWC1": 2529.4, + "OWC2": 2456.6, + "OWC3": 2465.6, + "PARAM1": 0.033, + "PARAM2": 0.11, + "PARAM3": 0.394, + "REAL": 364.0, + "RMS_SEED": 1364.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.022, + "NTG1": 0.91, + "NTG2": 0.61, + "OWC1": 2544.3, + "OWC2": 2474.6, + "OWC3": 2434.5, + "PARAM1": 0.032, + "PARAM2": -0.77, + "PARAM3": 0.0, + "REAL": 365.0, + "RMS_SEED": 1365.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.002, + "NTG1": 0.79, + "NTG2": 0.57, + "OWC1": 2545.1, + "OWC2": 2483.9, + "OWC3": 2431.9, + "PARAM1": 0.034, + "PARAM2": -0.53, + "PARAM3": 0.001, + "REAL": 366.0, + "RMS_SEED": 1366.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.502, + "NTG1": 0.81, + "NTG2": 0.6, + "OWC1": 2538.5, + "OWC2": 2466.4, + "OWC3": 2444.0, + "PARAM1": 0.034, + "PARAM2": 0.04, + "PARAM3": 30.804, + "REAL": 367.0, + "RMS_SEED": 1367.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.007, + "NTG1": 0.82, + "NTG2": 0.6, + "OWC1": 2530.4, + "OWC2": 2483.6, + "OWC3": 2434.8, + "PARAM1": 0.03, + "PARAM2": 0.47, + "PARAM3": 0.0, + "REAL": 368.0, + "RMS_SEED": 1368.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.83, + "NTG2": 0.57, + "OWC1": 2535.3, + "OWC2": 2471.5, + "OWC3": 2447.7, + "PARAM1": 0.038, + "PARAM2": -0.01, + "PARAM3": 2.832, + "REAL": 369.0, + "RMS_SEED": 1369.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.327, + "NTG1": 0.85, + "NTG2": 0.54, + "OWC1": 2535.2, + "OWC2": 2473.9, + "OWC3": 2425.8, + "PARAM1": 0.039, + "PARAM2": -0.29, + "PARAM3": 0.001, + "REAL": 370.0, + "RMS_SEED": 1370.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.006, + "NTG1": 0.86, + "NTG2": 0.6, + "OWC1": 2502.2, + "OWC2": 2448.4, + "OWC3": 2482.0, + "PARAM1": 0.033, + "PARAM2": 0.66, + "PARAM3": 1.202, + "REAL": 371.0, + "RMS_SEED": 1371.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.045, + "NTG1": 0.87, + "NTG2": 0.62, + "OWC1": 2501.9, + "OWC2": 2482.9, + "OWC3": 2465.7, + "PARAM1": 0.038, + "PARAM2": 0.86, + "PARAM3": 46.055, + "REAL": 372.0, + "RMS_SEED": 1372.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.003, + "NTG1": 0.97, + "NTG2": 0.62, + "OWC1": 2537.5, + "OWC2": 2468.2, + "OWC3": 2457.6, + "PARAM1": 0.035, + "PARAM2": -0.6, + "PARAM3": 28807800000.0, + "REAL": 373.0, + "RMS_SEED": 1373.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.006, + "NTG1": 0.8, + "NTG2": 0.63, + "OWC1": 2523.7, + "OWC2": 2471.0, + "OWC3": 2443.7, + "PARAM1": 0.032, + "PARAM2": -0.95, + "PARAM3": 0.02, + "REAL": 374.0, + "RMS_SEED": 1374.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.075, + "NTG1": 0.88, + "NTG2": 0.59, + "OWC1": 2512.3, + "OWC2": 2475.3, + "OWC3": 2461.4, + "PARAM1": 0.035, + "PARAM2": 0.14, + "PARAM3": 1895.11, + "REAL": 375.0, + "RMS_SEED": 1375.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.893, + "NTG1": 0.79, + "NTG2": 0.64, + "OWC1": 2548.6, + "OWC2": 2497.3, + "OWC3": 2408.9, + "PARAM1": 0.038, + "PARAM2": -0.47, + "PARAM3": 18.707, + "REAL": 376.0, + "RMS_SEED": 1376.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.198, + "NTG1": 0.77, + "NTG2": 0.57, + "OWC1": 2533.4, + "OWC2": 2464.4, + "OWC3": 2456.1, + "PARAM1": 0.032, + "PARAM2": 0.1, + "PARAM3": 0.0, + "REAL": 377.0, + "RMS_SEED": 1377.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.277, + "NTG1": 0.8, + "NTG2": 0.57, + "OWC1": 2513.3, + "OWC2": 2454.1, + "OWC3": 2455.1, + "PARAM1": 0.033, + "PARAM2": -0.98, + "PARAM3": 550197.0, + "REAL": 378.0, + "RMS_SEED": 1378.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.003, + "NTG1": 0.89, + "NTG2": 0.6, + "OWC1": 2549.7, + "OWC2": 2486.1, + "OWC3": 2442.9, + "PARAM1": 0.032, + "PARAM2": 0.8, + "PARAM3": 0.014, + "REAL": 379.0, + "RMS_SEED": 1379.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.048, + "NTG1": 0.9, + "NTG2": 0.58, + "OWC1": 2501.0, + "OWC2": 2438.6, + "OWC3": 2491.6, + "PARAM1": 0.035, + "PARAM2": -0.81, + "PARAM3": 7.046, + "REAL": 380.0, + "RMS_SEED": 1380.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.014, + "NTG1": 0.82, + "NTG2": 0.61, + "OWC1": 2536.2, + "OWC2": 2496.7, + "OWC3": 2425.6, + "PARAM1": 0.043, + "PARAM2": 0.85, + "PARAM3": 1.371, + "REAL": 381.0, + "RMS_SEED": 1381.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.105, + "NTG1": 0.78, + "NTG2": 0.55, + "OWC1": 2506.6, + "OWC2": 2441.8, + "OWC3": 2457.9, + "PARAM1": 0.035, + "PARAM2": 0.59, + "PARAM3": 0.0, + "REAL": 382.0, + "RMS_SEED": 1382.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.851, + "NTG1": 0.81, + "NTG2": 0.56, + "OWC1": 2548.1, + "OWC2": 2495.7, + "OWC3": 2429.0, + "PARAM1": 0.032, + "PARAM2": -0.4, + "PARAM3": 0.766, + "REAL": 383.0, + "RMS_SEED": 1383.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.057, + "NTG1": 0.84, + "NTG2": 0.6, + "OWC1": 2522.4, + "OWC2": 2473.6, + "OWC3": 2430.9, + "PARAM1": 0.035, + "PARAM2": 0.39, + "PARAM3": 46070.0, + "REAL": 384.0, + "RMS_SEED": 1384.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.007, + "NTG1": 0.77, + "NTG2": 0.61, + "OWC1": 2527.4, + "OWC2": 2441.2, + "OWC3": 2470.4, + "PARAM1": 0.032, + "PARAM2": -0.15, + "PARAM3": 52.829, + "REAL": 385.0, + "RMS_SEED": 1385.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.348, + "NTG1": 0.84, + "NTG2": 0.59, + "OWC1": 2534.3, + "OWC2": 2482.4, + "OWC3": 2432.6, + "PARAM1": 0.038, + "PARAM2": -0.87, + "PARAM3": 0.053, + "REAL": 386.0, + "RMS_SEED": 1386.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.89, + "NTG2": 0.64, + "OWC1": 2547.4, + "OWC2": 2492.8, + "OWC3": 2414.3, + "PARAM1": 0.034, + "PARAM2": -0.37, + "PARAM3": 6.413, + "REAL": 387.0, + "RMS_SEED": 1387.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.008, + "NTG1": 0.87, + "NTG2": 0.59, + "OWC1": 2533.9, + "OWC2": 2463.1, + "OWC3": 2444.8, + "PARAM1": 0.029, + "PARAM2": -0.57, + "PARAM3": 0.049, + "REAL": 388.0, + "RMS_SEED": 1388.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.005, + "NTG1": 0.88, + "NTG2": 0.56, + "OWC1": 2548.3, + "OWC2": 2472.6, + "OWC3": 2456.3, + "PARAM1": 0.036, + "PARAM2": -0.04, + "PARAM3": 0.0, + "REAL": 389.0, + "RMS_SEED": 1389.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.043, + "NTG1": 0.97, + "NTG2": 0.58, + "OWC1": 2521.0, + "OWC2": 2467.6, + "OWC3": 2440.7, + "PARAM1": 0.037, + "PARAM2": -0.26, + "PARAM3": 13868300.0, + "REAL": 390.0, + "RMS_SEED": 1390.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.175, + "NTG1": 0.93, + "NTG2": 0.58, + "OWC1": 2509.0, + "OWC2": 2445.9, + "OWC3": 2486.3, + "PARAM1": 0.026, + "PARAM2": 0.37, + "PARAM3": 5.739, + "REAL": 391.0, + "RMS_SEED": 1391.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.224, + "NTG1": 0.85, + "NTG2": 0.53, + "OWC1": 2545.3, + "OWC2": 2459.7, + "OWC3": 2433.4, + "PARAM1": 0.039, + "PARAM2": -0.59, + "PARAM3": 0.0, + "REAL": 392.0, + "RMS_SEED": 1392.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.436, + "NTG1": 0.82, + "NTG2": 0.62, + "OWC1": 2513.5, + "OWC2": 2472.4, + "OWC3": 2454.6, + "PARAM1": 0.034, + "PARAM2": 0.12, + "PARAM3": 0.0, + "REAL": 393.0, + "RMS_SEED": 1393.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.8, + "NTG2": 0.6, + "OWC1": 2526.1, + "OWC2": 2466.7, + "OWC3": 2484.5, + "PARAM1": 0.033, + "PARAM2": 0.89, + "PARAM3": 311.391, + "REAL": 394.0, + "RMS_SEED": 1394.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.451, + "NTG1": 0.89, + "NTG2": 0.56, + "OWC1": 2521.8, + "OWC2": 2476.0, + "OWC3": 2450.8, + "PARAM1": 0.043, + "PARAM2": 0.8, + "PARAM3": 502967.0, + "REAL": 395.0, + "RMS_SEED": 1395.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.073, + "NTG1": 0.86, + "NTG2": 0.61, + "OWC1": 2528.8, + "OWC2": 2485.4, + "OWC3": 2440.1, + "PARAM1": 0.032, + "PARAM2": 0.52, + "PARAM3": 0.026, + "REAL": 396.0, + "RMS_SEED": 1396.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.09, + "NTG1": 0.81, + "NTG2": 0.58, + "OWC1": 2515.1, + "OWC2": 2465.5, + "OWC3": 2446.6, + "PARAM1": 0.031, + "PARAM2": -0.64, + "PARAM3": 9396.82, + "REAL": 397.0, + "RMS_SEED": 1397.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.12, + "NTG1": 0.83, + "NTG2": 0.61, + "OWC1": 2531.7, + "OWC2": 2474.8, + "OWC3": 2422.2, + "PARAM1": 0.038, + "PARAM2": 0.07, + "PARAM3": 0.0, + "REAL": 398.0, + "RMS_SEED": 1398.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.38, + "NTG1": 0.87, + "NTG2": 0.6, + "OWC1": 2546.0, + "OWC2": 2455.0, + "OWC3": 2445.9, + "PARAM1": 0.036, + "PARAM2": 0.32, + "PARAM3": 1824950000.0, + "REAL": 399.0, + "RMS_SEED": 1399.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.003, + "NTG1": 0.8, + "NTG2": 0.55, + "OWC1": 2516.4, + "OWC2": 2468.0, + "OWC3": 2466.9, + "PARAM1": 0.036, + "PARAM2": 0.26, + "PARAM3": 0.0, + "REAL": 400.0, + "RMS_SEED": 1400.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.005, + "NTG1": 0.87, + "NTG2": 0.55, + "OWC1": 2527.8, + "OWC2": 2462.2, + "OWC3": 2431.7, + "PARAM1": 0.034, + "PARAM2": -0.42, + "PARAM3": 92.088, + "REAL": 401.0, + "RMS_SEED": 1401.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.049, + "NTG1": 0.86, + "NTG2": 0.57, + "OWC1": 2515.4, + "OWC2": 2456.9, + "OWC3": 2464.0, + "PARAM1": 0.034, + "PARAM2": 0.58, + "PARAM3": 0.0, + "REAL": 402.0, + "RMS_SEED": 1402.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.054, + "NTG1": 0.78, + "NTG2": 0.62, + "OWC1": 2536.3, + "OWC2": 2466.9, + "OWC3": 2461.9, + "PARAM1": 0.035, + "PARAM2": -0.63, + "PARAM3": 409930.0, + "REAL": 403.0, + "RMS_SEED": 1403.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.91, + "NTG2": 0.63, + "OWC1": 2548.4, + "OWC2": 2493.1, + "OWC3": 2407.9, + "PARAM1": 0.036, + "PARAM2": 0.79, + "PARAM3": 14647.7, + "REAL": 404.0, + "RMS_SEED": 1404.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.021, + "NTG1": 0.88, + "NTG2": 0.6, + "OWC1": 2548.8, + "OWC2": 2475.6, + "OWC3": 2450.1, + "PARAM1": 0.035, + "PARAM2": -0.45, + "PARAM3": 2620130.0, + "REAL": 405.0, + "RMS_SEED": 1405.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.181, + "NTG1": 0.81, + "NTG2": 0.56, + "OWC1": 2549.0, + "OWC2": 2465.8, + "OWC3": 2432.4, + "PARAM1": 0.03, + "PARAM2": -0.34, + "PARAM3": 44005.0, + "REAL": 406.0, + "RMS_SEED": 1406.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.011, + "NTG1": 0.84, + "NTG2": 0.55, + "OWC1": 2532.2, + "OWC2": 2480.3, + "OWC3": 2435.4, + "PARAM1": 0.037, + "PARAM2": -0.18, + "PARAM3": 0.0, + "REAL": 407.0, + "RMS_SEED": 1407.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.013, + "NTG1": 0.82, + "NTG2": 0.59, + "OWC1": 2514.1, + "OWC2": 2462.1, + "OWC3": 2485.5, + "PARAM1": 0.04, + "PARAM2": 0.42, + "PARAM3": 759399.0, + "REAL": 408.0, + "RMS_SEED": 1408.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.003, + "NTG1": 0.83, + "NTG2": 0.61, + "OWC1": 2549.2, + "OWC2": 2489.8, + "OWC3": 2424.2, + "PARAM1": 0.035, + "PARAM2": 0.0, + "PARAM3": 0.0, + "REAL": 409.0, + "RMS_SEED": 1409.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.043, + "NTG1": 0.86, + "NTG2": 0.62, + "OWC1": 2510.3, + "OWC2": 2476.6, + "OWC3": 2431.2, + "PARAM1": 0.037, + "PARAM2": 0.19, + "PARAM3": 17.485, + "REAL": 410.0, + "RMS_SEED": 1410.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.027, + "NTG1": 0.85, + "NTG2": 0.64, + "OWC1": 2524.5, + "OWC2": 2463.0, + "OWC3": 2467.3, + "PARAM1": 0.036, + "PARAM2": -0.52, + "PARAM3": 0.0, + "REAL": 411.0, + "RMS_SEED": 1411.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.81, + "NTG2": 0.56, + "OWC1": 2523.6, + "OWC2": 2469.7, + "OWC3": 2445.7, + "PARAM1": 0.036, + "PARAM2": -0.12, + "PARAM3": 0.451, + "REAL": 412.0, + "RMS_SEED": 1412.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.463, + "NTG1": 0.84, + "NTG2": 0.58, + "OWC1": 2517.3, + "OWC2": 2469.4, + "OWC3": 2452.9, + "PARAM1": 0.038, + "PARAM2": -0.89, + "PARAM3": 0.0, + "REAL": 413.0, + "RMS_SEED": 1413.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.3, + "NTG1": 0.88, + "NTG2": 0.62, + "OWC1": 2545.2, + "OWC2": 2460.3, + "OWC3": 2443.8, + "PARAM1": 0.034, + "PARAM2": -0.93, + "PARAM3": 0.0, + "REAL": 414.0, + "RMS_SEED": 1414.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.89, + "NTG2": 0.55, + "OWC1": 2534.7, + "OWC2": 2494.7, + "OWC3": 2427.7, + "PARAM1": 0.039, + "PARAM2": 0.76, + "PARAM3": 13.001, + "REAL": 415.0, + "RMS_SEED": 1415.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.491, + "NTG1": 0.87, + "NTG2": 0.62, + "OWC1": 2517.0, + "OWC2": 2452.3, + "OWC3": 2457.7, + "PARAM1": 0.031, + "PARAM2": 0.71, + "PARAM3": 0.0, + "REAL": 416.0, + "RMS_SEED": 1416.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.7, + "NTG1": 0.79, + "NTG2": 0.58, + "OWC1": 2541.8, + "OWC2": 2461.1, + "OWC3": 2428.1, + "PARAM1": 0.032, + "PARAM2": -0.5, + "PARAM3": 867.507, + "REAL": 417.0, + "RMS_SEED": 1417.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.212, + "NTG1": 0.93, + "NTG2": 0.59, + "OWC1": 2524.6, + "OWC2": 2477.4, + "OWC3": 2453.0, + "PARAM1": 0.034, + "PARAM2": -0.23, + "PARAM3": 0.0, + "REAL": 418.0, + "RMS_SEED": 1418.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.004, + "NTG1": 0.78, + "NTG2": 0.53, + "OWC1": 2520.2, + "OWC2": 2464.8, + "OWC3": 2442.6, + "PARAM1": 0.031, + "PARAM2": -0.88, + "PARAM3": 44.242, + "REAL": 419.0, + "RMS_SEED": 1419.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.131, + "NTG1": 0.94, + "NTG2": 0.64, + "OWC1": 2514.4, + "OWC2": 2460.4, + "OWC3": 2472.4, + "PARAM1": 0.033, + "PARAM2": 0.19, + "PARAM3": 18.06, + "REAL": 420.0, + "RMS_SEED": 1420.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.083, + "NTG1": 0.84, + "NTG2": 0.57, + "OWC1": 2511.5, + "OWC2": 2457.3, + "OWC3": 2471.9, + "PARAM1": 0.035, + "PARAM2": -0.18, + "PARAM3": 58.194, + "REAL": 421.0, + "RMS_SEED": 1421.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.034, + "NTG1": 0.88, + "NTG2": 0.56, + "OWC1": 2525.0, + "OWC2": 2452.8, + "OWC3": 2463.3, + "PARAM1": 0.037, + "PARAM2": -0.13, + "PARAM3": 261136.0, + "REAL": 422.0, + "RMS_SEED": 1422.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.254, + "NTG1": 0.96, + "NTG2": 0.61, + "OWC1": 2522.0, + "OWC2": 2479.5, + "OWC3": 2440.4, + "PARAM1": 0.028, + "PARAM2": 0.09, + "PARAM3": 0.014, + "REAL": 423.0, + "RMS_SEED": 1423.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.093, + "NTG1": 0.8, + "NTG2": 0.64, + "OWC1": 2520.7, + "OWC2": 2455.8, + "OWC3": 2456.9, + "PARAM1": 0.03, + "PARAM2": 0.57, + "PARAM3": 0.118, + "REAL": 424.0, + "RMS_SEED": 1424.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.002, + "NTG1": 0.82, + "NTG2": 0.58, + "OWC1": 2543.9, + "OWC2": 2470.6, + "OWC3": 2426.8, + "PARAM1": 0.037, + "PARAM2": -0.3, + "PARAM3": 310581.0, + "REAL": 425.0, + "RMS_SEED": 1425.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.04, + "NTG1": 0.81, + "NTG2": 0.57, + "OWC1": 2504.6, + "OWC2": 2461.8, + "OWC3": 2490.2, + "PARAM1": 0.031, + "PARAM2": -0.13, + "PARAM3": 31.235, + "REAL": 426.0, + "RMS_SEED": 1426.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.017, + "NTG1": 0.86, + "NTG2": 0.58, + "OWC1": 2515.9, + "OWC2": 2472.8, + "OWC3": 2454.1, + "PARAM1": 0.041, + "PARAM2": 0.17, + "PARAM3": 102650000.0, + "REAL": 427.0, + "RMS_SEED": 1427.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.155, + "NTG1": 0.77, + "NTG2": 0.58, + "OWC1": 2527.2, + "OWC2": 2482.5, + "OWC3": 2452.4, + "PARAM1": 0.032, + "PARAM2": 0.29, + "PARAM3": 4842770.0, + "REAL": 428.0, + "RMS_SEED": 1428.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.002, + "NTG1": 0.85, + "NTG2": 0.6, + "OWC1": 2512.1, + "OWC2": 2444.5, + "OWC3": 2487.0, + "PARAM1": 0.04, + "PARAM2": 0.12, + "PARAM3": 119614000.0, + "REAL": 429.0, + "RMS_SEED": 1429.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.975, + "NTG1": 0.88, + "NTG2": 0.56, + "OWC1": 2545.8, + "OWC2": 2472.6, + "OWC3": 2442.5, + "PARAM1": 0.033, + "PARAM2": -0.92, + "PARAM3": 0.584, + "REAL": 430.0, + "RMS_SEED": 1430.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.01, + "NTG1": 0.86, + "NTG2": 0.6, + "OWC1": 2534.2, + "OWC2": 2449.6, + "OWC3": 2480.5, + "PARAM1": 0.027, + "PARAM2": -0.99, + "PARAM3": 259.794, + "REAL": 431.0, + "RMS_SEED": 1431.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.036, + "NTG1": 0.91, + "NTG2": 0.63, + "OWC1": 2540.4, + "OWC2": 2448.9, + "OWC3": 2459.4, + "PARAM1": 0.041, + "PARAM2": -0.62, + "PARAM3": 0.001, + "REAL": 432.0, + "RMS_SEED": 1432.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.003, + "NTG1": 0.87, + "NTG2": 0.56, + "OWC1": 2504.9, + "OWC2": 2455.4, + "OWC3": 2448.5, + "PARAM1": 0.041, + "PARAM2": -0.16, + "PARAM3": 0.15, + "REAL": 433.0, + "RMS_SEED": 1433.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.509, + "NTG1": 0.78, + "NTG2": 0.57, + "OWC1": 2521.2, + "OWC2": 2475.7, + "OWC3": 2425.4, + "PARAM1": 0.037, + "PARAM2": -0.1, + "PARAM3": 0.84, + "REAL": 434.0, + "RMS_SEED": 1434.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.004, + "NTG1": 0.84, + "NTG2": 0.59, + "OWC1": 2537.7, + "OWC2": 2445.4, + "OWC3": 2446.5, + "PARAM1": 0.033, + "PARAM2": -0.27, + "PARAM3": 0.0, + "REAL": 435.0, + "RMS_SEED": 1435.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.004, + "NTG1": 0.8, + "NTG2": 0.6, + "OWC1": 2529.3, + "OWC2": 2462.5, + "OWC3": 2464.1, + "PARAM1": 0.033, + "PARAM2": 0.74, + "PARAM3": 0.0, + "REAL": 436.0, + "RMS_SEED": 1436.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.019, + "NTG1": 0.82, + "NTG2": 0.6, + "OWC1": 2541.1, + "OWC2": 2465.9, + "OWC3": 2426.4, + "PARAM1": 0.039, + "PARAM2": -0.48, + "PARAM3": 17014300.0, + "REAL": 437.0, + "RMS_SEED": 1437.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.006, + "NTG1": 0.81, + "NTG2": 0.59, + "OWC1": 2532.4, + "OWC2": 2456.4, + "OWC3": 2444.7, + "PARAM1": 0.033, + "PARAM2": 0.22, + "PARAM3": 414621000000.0, + "REAL": 438.0, + "RMS_SEED": 1438.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.003, + "NTG1": 0.82, + "NTG2": 0.53, + "OWC1": 2536.5, + "OWC2": 2481.7, + "OWC3": 2452.6, + "PARAM1": 0.03, + "PARAM2": -0.49, + "PARAM3": 0.506, + "REAL": 439.0, + "RMS_SEED": 1439.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.091, + "NTG1": 0.8, + "NTG2": 0.62, + "OWC1": 2516.3, + "OWC2": 2473.9, + "OWC3": 2440.2, + "PARAM1": 0.029, + "PARAM2": 0.7, + "PARAM3": 41.612, + "REAL": 440.0, + "RMS_SEED": 1440.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.02, + "NTG1": 0.82, + "NTG2": 0.56, + "OWC1": 2503.2, + "OWC2": 2461.5, + "OWC3": 2479.4, + "PARAM1": 0.039, + "PARAM2": -0.95, + "PARAM3": 679.412, + "REAL": 441.0, + "RMS_SEED": 1441.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.004, + "NTG1": 0.8, + "NTG2": 0.62, + "OWC1": 2549.3, + "OWC2": 2488.9, + "OWC3": 2403.0, + "PARAM1": 0.039, + "PARAM2": 0.79, + "PARAM3": 6784540.0, + "REAL": 442.0, + "RMS_SEED": 1442.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.027, + "NTG1": 0.9, + "NTG2": 0.59, + "OWC1": 2544.9, + "OWC2": 2444.1, + "OWC3": 2451.8, + "PARAM1": 0.031, + "PARAM2": -0.29, + "PARAM3": 24.875, + "REAL": 443.0, + "RMS_SEED": 1443.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.009, + "NTG1": 0.86, + "NTG2": 0.59, + "OWC1": 2523.9, + "OWC2": 2455.7, + "OWC3": 2455.4, + "PARAM1": 0.036, + "PARAM2": -0.5, + "PARAM3": 54780.1, + "REAL": 444.0, + "RMS_SEED": 1444.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.001, + "NTG1": 0.84, + "NTG2": 0.58, + "OWC1": 2530.7, + "OWC2": 2462.6, + "OWC3": 2449.9, + "PARAM1": 0.04, + "PARAM2": -0.2, + "PARAM3": 9.595, + "REAL": 445.0, + "RMS_SEED": 1445.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.026, + "NTG1": 0.8, + "NTG2": 0.59, + "OWC1": 2542.4, + "OWC2": 2478.6, + "OWC3": 2417.7, + "PARAM1": 0.043, + "PARAM2": -0.81, + "PARAM3": 0.01, + "REAL": 446.0, + "RMS_SEED": 1446.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.351, + "NTG1": 0.87, + "NTG2": 0.6, + "OWC1": 2505.5, + "OWC2": 2485.2, + "OWC3": 2451.5, + "PARAM1": 0.036, + "PARAM2": 0.99, + "PARAM3": 0.0, + "REAL": 447.0, + "RMS_SEED": 1447.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.427, + "NTG1": 0.84, + "NTG2": 0.54, + "OWC1": 2527.7, + "OWC2": 2477.0, + "OWC3": 2421.8, + "PARAM1": 0.034, + "PARAM2": -0.97, + "PARAM3": 0.009, + "REAL": 448.0, + "RMS_SEED": 1448.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.163, + "NTG1": 0.94, + "NTG2": 0.56, + "OWC1": 2526.6, + "OWC2": 2465.1, + "OWC3": 2454.0, + "PARAM1": 0.034, + "PARAM2": -0.05, + "PARAM3": 0.003, + "REAL": 449.0, + "RMS_SEED": 1449.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.171, + "NTG1": 0.96, + "NTG2": 0.6, + "OWC1": 2514.9, + "OWC2": 2463.6, + "OWC3": 2451.6, + "PARAM1": 0.033, + "PARAM2": 0.77, + "PARAM3": 0.017, + "REAL": 450.0, + "RMS_SEED": 1450.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.397, + "NTG1": 0.9, + "NTG2": 0.56, + "OWC1": 2542.0, + "OWC2": 2487.4, + "OWC3": 2435.3, + "PARAM1": 0.037, + "PARAM2": -0.63, + "PARAM3": 0.003, + "REAL": 451.0, + "RMS_SEED": 1451.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.484, + "NTG1": 0.91, + "NTG2": 0.58, + "OWC1": 2529.8, + "OWC2": 2467.3, + "OWC3": 2449.5, + "PARAM1": 0.043, + "PARAM2": -0.66, + "PARAM3": 178966000.0, + "REAL": 452.0, + "RMS_SEED": 1452.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.013, + "NTG1": 0.77, + "NTG2": 0.55, + "OWC1": 2519.9, + "OWC2": 2452.1, + "OWC3": 2464.6, + "PARAM1": 0.037, + "PARAM2": -0.42, + "PARAM3": 0.0, + "REAL": 453.0, + "RMS_SEED": 1453.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.085, + "NTG1": 0.83, + "NTG2": 0.6, + "OWC1": 2527.5, + "OWC2": 2486.1, + "OWC3": 2444.4, + "PARAM1": 0.039, + "PARAM2": -0.45, + "PARAM3": 0.046, + "REAL": 454.0, + "RMS_SEED": 1454.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.002, + "NTG1": 0.79, + "NTG2": 0.59, + "OWC1": 2547.8, + "OWC2": 2491.6, + "OWC3": 2422.7, + "PARAM1": 0.034, + "PARAM2": 0.06, + "PARAM3": 0.04, + "REAL": 455.0, + "RMS_SEED": 1455.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.008, + "NTG1": 0.95, + "NTG2": 0.63, + "OWC1": 2529.2, + "OWC2": 2478.9, + "OWC3": 2432.5, + "PARAM1": 0.026, + "PARAM2": 0.7, + "PARAM3": 141.136, + "REAL": 456.0, + "RMS_SEED": 1456.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.005, + "NTG1": 0.98, + "NTG2": 0.6, + "OWC1": 2512.9, + "OWC2": 2463.1, + "OWC3": 2431.6, + "PARAM1": 0.031, + "PARAM2": -0.45, + "PARAM3": 0.0, + "REAL": 457.0, + "RMS_SEED": 1457.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.047, + "NTG1": 0.9, + "NTG2": 0.59, + "OWC1": 2518.7, + "OWC2": 2476.4, + "OWC3": 2439.8, + "PARAM1": 0.033, + "PARAM2": 0.91, + "PARAM3": 0.0, + "REAL": 458.0, + "RMS_SEED": 1458.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.002, + "NTG1": 0.79, + "NTG2": 0.61, + "OWC1": 2529.6, + "OWC2": 2455.4, + "OWC3": 2437.9, + "PARAM1": 0.027, + "PARAM2": 0.84, + "PARAM3": 0.0, + "REAL": 459.0, + "RMS_SEED": 1459.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.14, + "NTG1": 0.79, + "NTG2": 0.52, + "OWC1": 2519.4, + "OWC2": 2452.1, + "OWC3": 2461.3, + "PARAM1": 0.03, + "PARAM2": -0.51, + "PARAM3": 0.0, + "REAL": 460.0, + "RMS_SEED": 1460.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.85, + "NTG2": 0.61, + "OWC1": 2518.9, + "OWC2": 2446.7, + "OWC3": 2477.5, + "PARAM1": 0.038, + "PARAM2": -0.07, + "PARAM3": 495.519, + "REAL": 461.0, + "RMS_SEED": 1461.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.003, + "NTG1": 0.92, + "NTG2": 0.56, + "OWC1": 2519.5, + "OWC2": 2485.9, + "OWC3": 2440.9, + "PARAM1": 0.038, + "PARAM2": -0.65, + "PARAM3": 0.022, + "REAL": 462.0, + "RMS_SEED": 1462.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.078, + "NTG1": 0.76, + "NTG2": 0.62, + "OWC1": 2500.2, + "OWC2": 2433.6, + "OWC3": 2488.6, + "PARAM1": 0.035, + "PARAM2": 0.05, + "PARAM3": 998.174, + "REAL": 463.0, + "RMS_SEED": 1463.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.001, + "NTG1": 0.87, + "NTG2": 0.58, + "OWC1": 2543.7, + "OWC2": 2476.0, + "OWC3": 2442.3, + "PARAM1": 0.037, + "PARAM2": 0.67, + "PARAM3": 0.0, + "REAL": 464.0, + "RMS_SEED": 1464.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.007, + "NTG1": 0.92, + "NTG2": 0.58, + "OWC1": 2507.4, + "OWC2": 2462.7, + "OWC3": 2479.6, + "PARAM1": 0.033, + "PARAM2": -0.34, + "PARAM3": 0.013, + "REAL": 465.0, + "RMS_SEED": 1465.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.074, + "NTG1": 0.92, + "NTG2": 0.54, + "OWC1": 2532.3, + "OWC2": 2448.8, + "OWC3": 2463.1, + "PARAM1": 0.038, + "PARAM2": 0.98, + "PARAM3": 59130.5, + "REAL": 466.0, + "RMS_SEED": 1466.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.001, + "NTG1": 0.95, + "NTG2": 0.59, + "OWC1": 2542.3, + "OWC2": 2478.3, + "OWC3": 2410.5, + "PARAM1": 0.042, + "PARAM2": -0.55, + "PARAM3": 0.18, + "REAL": 467.0, + "RMS_SEED": 1467.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.008, + "NTG1": 0.85, + "NTG2": 0.63, + "OWC1": 2531.8, + "OWC2": 2443.4, + "OWC3": 2449.4, + "PARAM1": 0.035, + "PARAM2": -0.08, + "PARAM3": 626.263, + "REAL": 468.0, + "RMS_SEED": 1468.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.044, + "NTG1": 0.82, + "NTG2": 0.57, + "OWC1": 2509.3, + "OWC2": 2460.7, + "OWC3": 2459.2, + "PARAM1": 0.031, + "PARAM2": 0.31, + "PARAM3": 0.002, + "REAL": 469.0, + "RMS_SEED": 1469.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.209, + "NTG1": 0.79, + "NTG2": 0.62, + "OWC1": 2530.5, + "OWC2": 2474.6, + "OWC3": 2433.6, + "PARAM1": 0.035, + "PARAM2": 0.86, + "PARAM3": 0.48, + "REAL": 470.0, + "RMS_SEED": 1470.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.019, + "NTG1": 0.78, + "NTG2": 0.58, + "OWC1": 2539.9, + "OWC2": 2479.6, + "OWC3": 2418.8, + "PARAM1": 0.036, + "PARAM2": -0.14, + "PARAM3": 2277410.0, + "REAL": 471.0, + "RMS_SEED": 1471.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.001, + "NTG1": 0.8, + "NTG2": 0.59, + "OWC1": 2538.2, + "OWC2": 2477.3, + "OWC3": 2449.4, + "PARAM1": 0.029, + "PARAM2": 0.69, + "PARAM3": 0.019, + "REAL": 472.0, + "RMS_SEED": 1472.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.028, + "NTG1": 0.82, + "NTG2": 0.57, + "OWC1": 2535.5, + "OWC2": 2466.6, + "OWC3": 2424.8, + "PARAM1": 0.035, + "PARAM2": -0.36, + "PARAM3": 9542600.0, + "REAL": 473.0, + "RMS_SEED": 1473.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.001, + "NTG1": 0.81, + "NTG2": 0.62, + "OWC1": 2503.9, + "OWC2": 2440.9, + "OWC3": 2478.8, + "PARAM1": 0.034, + "PARAM2": 0.43, + "PARAM3": 0.112, + "REAL": 474.0, + "RMS_SEED": 1474.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.112, + "NTG1": 0.83, + "NTG2": 0.57, + "OWC1": 2515.5, + "OWC2": 2453.4, + "OWC3": 2441.8, + "PARAM1": 0.038, + "PARAM2": -0.9, + "PARAM3": 0.0, + "REAL": 475.0, + "RMS_SEED": 1475.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.001, + "NTG1": 0.91, + "NTG2": 0.59, + "OWC1": 2535.7, + "OWC2": 2470.2, + "OWC3": 2438.2, + "PARAM1": 0.03, + "PARAM2": -0.8, + "PARAM3": 0.534, + "REAL": 476.0, + "RMS_SEED": 1476.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.037, + "NTG1": 0.82, + "NTG2": 0.6, + "OWC1": 2534.8, + "OWC2": 2479.8, + "OWC3": 2450.7, + "PARAM1": 0.034, + "PARAM2": -0.2, + "PARAM3": 0.0, + "REAL": 477.0, + "RMS_SEED": 1477.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.029, + "NTG1": 0.76, + "NTG2": 0.57, + "OWC1": 2505.3, + "OWC2": 2449.9, + "OWC3": 2473.5, + "PARAM1": 0.031, + "PARAM2": 0.17, + "PARAM3": 0.697, + "REAL": 478.0, + "RMS_SEED": 1478.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.02, + "NTG1": 0.91, + "NTG2": 0.62, + "OWC1": 2548.0, + "OWC2": 2471.4, + "OWC3": 2405.7, + "PARAM1": 0.038, + "PARAM2": -0.13, + "PARAM3": 0.0, + "REAL": 479.0, + "RMS_SEED": 1479.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.059, + "NTG1": 0.79, + "NTG2": 0.61, + "OWC1": 2545.8, + "OWC2": 2496.3, + "OWC3": 2412.9, + "PARAM1": 0.028, + "PARAM2": -0.06, + "PARAM3": 0.025, + "REAL": 480.0, + "RMS_SEED": 1480.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.763, + "NTG1": 0.79, + "NTG2": 0.6, + "OWC1": 2509.6, + "OWC2": 2467.5, + "OWC3": 2458.3, + "PARAM1": 0.027, + "PARAM2": -0.56, + "PARAM3": 0.0, + "REAL": 481.0, + "RMS_SEED": 1481.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.624, + "NTG1": 0.84, + "NTG2": 0.64, + "OWC1": 2535.0, + "OWC2": 2471.1, + "OWC3": 2443.0, + "PARAM1": 0.031, + "PARAM2": -0.0, + "PARAM3": 4.011, + "REAL": 482.0, + "RMS_SEED": 1482.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.013, + "NTG1": 0.84, + "NTG2": 0.54, + "OWC1": 2507.7, + "OWC2": 2450.4, + "OWC3": 2472.7, + "PARAM1": 0.036, + "PARAM2": -0.61, + "PARAM3": 1.565, + "REAL": 483.0, + "RMS_SEED": 1483.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.014, + "NTG1": 0.86, + "NTG2": 0.61, + "OWC1": 2525.0, + "OWC2": 2463.9, + "OWC3": 2429.2, + "PARAM1": 0.04, + "PARAM2": 0.44, + "PARAM3": 1783160.0, + "REAL": 484.0, + "RMS_SEED": 1484.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.004, + "NTG1": 0.86, + "NTG2": 0.56, + "OWC1": 2531.5, + "OWC2": 2469.0, + "OWC3": 2441.1, + "PARAM1": 0.03, + "PARAM2": 0.45, + "PARAM3": 55.897, + "REAL": 485.0, + "RMS_SEED": 1485.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.565, + "NTG1": 0.84, + "NTG2": 0.57, + "OWC1": 2544.1, + "OWC2": 2463.5, + "OWC3": 2461.2, + "PARAM1": 0.028, + "PARAM2": -0.18, + "PARAM3": 0.235, + "REAL": 486.0, + "RMS_SEED": 1486.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.146, + "NTG1": 0.78, + "NTG2": 0.56, + "OWC1": 2512.8, + "OWC2": 2440.2, + "OWC3": 2479.8, + "PARAM1": 0.039, + "PARAM2": 0.57, + "PARAM3": 11579.5, + "REAL": 487.0, + "RMS_SEED": 1487.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.002, + "NTG1": 0.93, + "NTG2": 0.63, + "OWC1": 2548.7, + "OWC2": 2482.0, + "OWC3": 2421.3, + "PARAM1": 0.042, + "PARAM2": 0.13, + "PARAM3": 238.771, + "REAL": 488.0, + "RMS_SEED": 1488.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.006, + "NTG1": 0.82, + "NTG2": 0.56, + "OWC1": 2532.9, + "OWC2": 2452.6, + "OWC3": 2459.6, + "PARAM1": 0.037, + "PARAM2": -0.69, + "PARAM3": 12879.7, + "REAL": 489.0, + "RMS_SEED": 1489.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.002, + "NTG1": 0.85, + "NTG2": 0.63, + "OWC1": 2500.5, + "OWC2": 2441.6, + "OWC3": 2485.8, + "PARAM1": 0.037, + "PARAM2": 0.26, + "PARAM3": 10.639, + "REAL": 490.0, + "RMS_SEED": 1490.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.021, + "NTG1": 0.91, + "NTG2": 0.57, + "OWC1": 2505.2, + "OWC2": 2434.8, + "OWC3": 2492.1, + "PARAM1": 0.043, + "PARAM2": 0.51, + "PARAM3": 1.313, + "REAL": 491.0, + "RMS_SEED": 1491.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.109, + "NTG1": 0.87, + "NTG2": 0.62, + "OWC1": 2529.7, + "OWC2": 2480.1, + "OWC3": 2435.2, + "PARAM1": 0.031, + "PARAM2": 0.17, + "PARAM3": 0.017, + "REAL": 492.0, + "RMS_SEED": 1492.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.591, + "NTG1": 0.87, + "NTG2": 0.63, + "OWC1": 2548.6, + "OWC2": 2484.1, + "OWC3": 2419.5, + "PARAM1": 0.034, + "PARAM2": 0.24, + "PARAM3": 0.0, + "REAL": 493.0, + "RMS_SEED": 1493.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.031, + "NTG1": 0.93, + "NTG2": 0.62, + "OWC1": 2518.3, + "OWC2": 2454.4, + "OWC3": 2468.4, + "PARAM1": 0.031, + "PARAM2": 0.07, + "PARAM3": 154753.0, + "REAL": 494.0, + "RMS_SEED": 1494.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.058, + "NTG1": 0.81, + "NTG2": 0.61, + "OWC1": 2523.1, + "OWC2": 2469.9, + "OWC3": 2452.6, + "PARAM1": 0.036, + "PARAM2": 0.54, + "PARAM3": 3750340.0, + "REAL": 495.0, + "RMS_SEED": 1495.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.019, + "NTG1": 0.8, + "NTG2": 0.61, + "OWC1": 2530.1, + "OWC2": 2466.2, + "OWC3": 2455.2, + "PARAM1": 0.036, + "PARAM2": -0.24, + "PARAM3": 3.26, + "REAL": 496.0, + "RMS_SEED": 1496.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-02", + "DERIVED_PARAM1": 1.0, + "DERIVED_PARAM2": "a", + "FAULTSEAL": 0.012, + "NTG1": 0.8, + "NTG2": 0.55, + "OWC1": 2503.7, + "OWC2": 2457.4, + "OWC3": 2468.2, + "PARAM1": 0.037, + "PARAM2": 0.24, + "PARAM3": 0.001, + "REAL": 497.0, + "RMS_SEED": 1497.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-04", + "DERIVED_PARAM1": 3.0, + "DERIVED_PARAM2": "c", + "FAULTSEAL": 0.388, + "NTG1": 0.97, + "NTG2": 0.57, + "OWC1": 2517.8, + "OWC2": 2452.9, + "OWC3": 2462.4, + "PARAM1": 0.04, + "PARAM2": -0.21, + "PARAM3": 0.798, + "REAL": 498.0, + "RMS_SEED": 1498.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + }, + { + "DATO": "2018-11-03", + "DERIVED_PARAM1": 2.0, + "DERIVED_PARAM2": "b", + "FAULTSEAL": 0.005, + "NTG1": 0.8, + "NTG2": 0.54, + "OWC1": 2524.4, + "OWC2": 2470.8, + "OWC3": 2454.6, + "PARAM1": 0.04, + "PARAM2": 0.94, + "PARAM3": 4969.53, + "REAL": 499.0, + "RMS_SEED": 1499.0, + "SENSCASE": "p10_p90", + "SENSNAME": "montecarlo" + } + ] +} \ No newline at end of file diff --git a/tests/ert/unit_tests/config/fmudesign/test_create_design.py b/tests/ert/unit_tests/config/fmudesign/test_create_design.py new file mode 100644 index 00000000000..d7640d2d368 --- /dev/null +++ b/tests/ert/unit_tests/config/fmudesign/test_create_design.py @@ -0,0 +1,685 @@ +"""Testing code for generation of design matrices""" + +import json +import math +import shutil +from datetime import datetime +from pathlib import Path + +import numpy as np +import pandas as pd +import pytest +from scipy import stats + +import semeio +from semeio.fmudesign import DesignMatrix, excel_to_dict +from semeio.fmudesign import design_distributions as design_dist +from semeio.fmudesign._excel_to_dict import _read_defaultvalues +from semeio.fmudesign.quality_report import print_corrmat + +TESTDATA = Path(__file__).parent / "data" + + +@pytest.mark.parametrize("correlations", [True, False]) +def test_distribution_statistis(tmpdir, monkeypatch, correlations): + """This test ensures that if any large-sample statistics for any distribution + changes, we will likely pick it up in the future.""" + + NUM_SAMPLES = 10**5 + + def gl(paramname, distname, p1, p2, p3="", p4=""): + """GL = Generate Line. Generates a line in the input sheet.""" + return [ + "", + pd.NA, + "", + paramname, + "", + pd.NA, + "", + pd.NA, + distname, + p1, + p2, + p3, + p4, + pd.NA, + "corr1" if correlations else "", + "", + ] + + # General input sheet + general_input = pd.DataFrame( + data=[ + ["designtype", "onebyone"], + ["repeats", 1], + ["rms_seeds", "default"], + ["background", "None"], + ["distribution_seed", 42], + ] + ) + + # Design input sheet + design_input = pd.DataFrame( + data=[ + # Normal has params (mean, std, low=-inf, high=inf) + gl("NORMAL", "normal", 0, 2), + gl("TRUNCNORM", "normal", 0, 1, -1, 2), + # Lognormal has params (mean, sigma) + gl("LOGNORMAL", "logn", 1.5, 0.5), + gl("TRUNCLOGNORMAL", "logn", 1.5, 0.5, 5, 15), + # Uniform has params (low, high) + gl("UNIFORM", "unif", -5, 0), + # Triangular has params (low, mode, high) + gl("TRIANG", "triang", -5, 0, 5), + # Pert has has params (low, mode, high, scale=4) + gl("DEFAULTPERT", "pert", -5, 0, 5), + gl("SCALEPERT", "pert", -5, 0, 5, 1), + # Loguniform has params (low, high) + gl("LOGUNIFORM", "logunif", 1, 5), + # P10/P90 versions + gl("NORMALP10P90", "normal_p10_p90", -2, 3), + gl("UNIFORMP10P90", "uniform_p10_p90", -2, 3), + gl("TRIANGULARP10P90", "triangular_p10_p90", -2, 2, 3), + gl("PERTP10P90", "pert_p10_p90", -2, 2, 3), + ], + columns=[ + "sensname", + "numreal", + "type", + "param_name", + "senscase1", + "value1", + "senscase2", + "value2", + "dist_name", + "dist_param1", + "dist_param2", + "dist_param3", + "dist_param4", + "decimals", + "corr_sheet", + "extern_file", + ], + ) + design_input.iloc[0, :3] = ["distr_test", (NUM_SAMPLES), "dist"] + + # Default values sheet + defaultvalues = pd.DataFrame( + { + "param_name": list(design_input["param_name"]), + "default_value": [0.5] * (len(design_input)), + } + ) + + # Correlation sheet + num_vars = len(design_input["param_name"]) + corr_values = np.zeros(shape=(num_vars, num_vars)) + 0.2 + np.fill_diagonal(corr_values, val=1.0) + upper_idx = np.triu_indices_from(corr_values, k=1) + # Set upper triangle to blank on the numpy array before creating the DataFrame, + # since DataFrame.to_numpy() returns a copy in pandas 3 (CoW). + str_values = corr_values.astype(str) + str_values[upper_idx] = "" + corr_sheet = pd.DataFrame( + str_values, + columns=list(design_input["param_name"]), + index=list(design_input["param_name"]), + ) + # Create a file to do the save => load roundtrip and test that too + FILENAME = "designinput.xlsx" + with pd.ExcelWriter(FILENAME, engine="openpyxl") as writer: + general_input.to_excel( + writer, sheet_name="general_input", index=False, header=None + ) + design_input.to_excel(writer, sheet_name="designinput", index=False) + defaultvalues.to_excel(writer, sheet_name="defaultvalues", index=False) + corr_sheet.to_excel(writer, sheet_name="corr1") + + # Read the file and draw samples + input_dict = excel_to_dict(FILENAME) + design = DesignMatrix() + design.generate(input_dict) + assert len(design.designvalues) == NUM_SAMPLES + df = design.designvalues + + # Test statistical properties and boundaries of all variables. + # There were either derived using analytical properties, or empirically + # by drawing 10 million samples. + # Tolerance must be high enough to not pick up on rng differences, but low + # enough to pick up meaningful changes. + atol = 0.005 + + assert np.isclose(df["NORMAL"].mean(), 0.0, atol=atol) + assert np.isclose(df["NORMAL"].std(), 2.0, atol=atol) + + assert np.isclose(df["TRUNCNORM"].mean(), 0.229637, atol=atol) + assert np.isclose(df["TRUNCNORM"].std(), 0.720945, atol=atol) + assert df["TRUNCNORM"].min() >= -1 + assert df["TRUNCNORM"].max() <= 2 + + assert np.isclose(df["LOGNORMAL"].mean(), 5.078418, atol=atol) + assert np.isclose(df["LOGNORMAL"].std(), 2.706487, atol=atol) + + assert df["TRUNCLOGNORMAL"].min() >= 5 + assert df["TRUNCLOGNORMAL"].max() <= 15 + + assert df["UNIFORM"].min() >= -5 + assert df["UNIFORM"].max() <= 0 + assert np.isclose(df["UNIFORM"].mean(), -2.5, atol=atol) + assert np.isclose(df["UNIFORM"].std(), 1.443375, atol=atol) + + assert df["TRIANG"].min() >= -5 + assert df["TRIANG"].max() <= 5 + assert np.isclose(df["TRIANG"].mean(), 0, atol=atol) + assert np.isclose(df["TRIANG"].std(), 2.041241, atol=atol) + + assert df["DEFAULTPERT"].min() >= -5 + assert df["DEFAULTPERT"].max() <= 5 + assert np.isclose(df["DEFAULTPERT"].mean(), 0, atol=atol) + assert np.isclose(df["DEFAULTPERT"].std(), 1.889822, atol=atol) + + assert df["SCALEPERT"].min() >= -5 + assert df["SCALEPERT"].max() <= 5 + assert np.isclose(df["SCALEPERT"].mean(), 0, atol=atol) + assert np.isclose(df["SCALEPERT"].std(), 2.5, atol=atol) + + assert np.isclose(df["LOGUNIFORM"].mean(), 2.485339, atol=atol) + assert np.isclose(df["LOGUNIFORM"].std(), 1.130975, atol=atol) + + # The P10/P90 distributions are all defined to have P10=-2 and P90=3, + # so we test them by checking that the observed percentiles match + assert np.isclose(df["NORMALP10P90"].quantile(0.1), -2, atol=atol) + assert np.isclose(df["NORMALP10P90"].quantile(0.9), 3, atol=atol) + + assert np.isclose(df["UNIFORMP10P90"].quantile(0.1), -2, atol=atol) + assert np.isclose(df["UNIFORMP10P90"].quantile(0.9), 3, atol=atol) + + assert np.isclose(df["TRIANGULARP10P90"].quantile(0.1), -2, atol=atol) + assert np.isclose(df["TRIANGULARP10P90"].quantile(0.9), 3, atol=atol) + + assert np.isclose(df["PERTP10P90"].quantile(0.1), -2, atol=atol) + assert np.isclose(df["PERTP10P90"].quantile(0.9), 3, atol=atol) + + # Check that correlations are close + if correlations: + obs_corr = df[design_input["param_name"]].corr().to_numpy() + assert np.sqrt(np.mean((obs_corr - corr_values) ** 2)) < 0.02 + + +def test_generate_onebyone(tmpdir): + """Test generation of onebyone design""" + + inputfile = TESTDATA / "config/design_input_example1.xlsx" + + input_dict = excel_to_dict(inputfile) + + # Note that repeats are set to 10 in general_input sheet. + # So, there are 10 rows for each senscase of type seed and scenario. + # However, there are 20 rows for multz because numreal is set to 20 in designinput. + rows_in_design_matrix = 80 + + design = DesignMatrix() + design.generate(input_dict) + # Checking dimensions of design matrix + assert design.designvalues.shape == (rows_in_design_matrix, 10) + + # Write to disk and check some validity + tmpdir.chdir() + design.to_xlsx("designmatrix.xlsx") + assert Path("designmatrix.xlsx").exists + diskdesign = pd.read_excel("designmatrix.xlsx", engine="openpyxl") + + assert ( + diskdesign.columns + == [ + "REAL", + "SENSNAME", + "SENSCASE", + "RMS_SEED", + "FAULT_POSITION", + "DC_MODEL", + "OWC1", + "OWC2", + "OWC3", + "MULTZ_ILE", + ] + ).all() + assert (diskdesign["REAL"].to_numpy() == np.arange(rows_in_design_matrix)).all() + ensemble_size = 10 + sensname = ( + ["rms_seed"] * ensemble_size + + ["faults"] * 2 * ensemble_size # 2 senscases, east and west + + ["velmodel"] * ensemble_size + + ["contacts"] * 2 * ensemble_size # 2 contacts, shallow and deep + + ["multz"] * 20 + ) + assert (diskdesign["SENSNAME"] == sensname).all() + # Sensitivities of type seed like rms_seed automatically get senscase p10_p90, + # so that P10/P90 is calculated for the tornado plot. + assert ( + diskdesign[diskdesign["SENSNAME"] == "rms_seed"]["SENSCASE"] == "p10_p90" + ).all() + assert ( + diskdesign[diskdesign["SENSNAME"] == "faults"]["SENSCASE"] + == ["east"] * ensemble_size + ["west"] * ensemble_size + ).all() + assert ( + diskdesign[diskdesign["SENSNAME"] == "velmodel"]["SENSCASE"] == "alternative" + ).all() + assert ( + diskdesign[diskdesign["SENSNAME"] == "contacts"]["SENSCASE"] + == ["shallow"] * ensemble_size + ["deep"] * ensemble_size + ).all() + assert ( + diskdesign[diskdesign["SENSNAME"] == "multz"]["SENSCASE"] == ["p10_p90"] * 20 + ).all() + + # When rms_seed is set to default it means that RMS_SEED numbers + # 1000, 1001,... are used. + # Note that for most senscases, RMS_SEED goes from 1000 to 1009, + # but that it goes from 1000 to 1019 for multz because numreal + # is set to 20 in the designinput sheet. + assert ( + diskdesign["RMS_SEED"] + == list(range(1000, 1000 + ensemble_size)) * 6 + list(range(1000, 1000 + 20)) + ).all() + + diskdefaults = pd.read_excel( + "designmatrix.xlsx", sheet_name="DefaultValues", header=None, engine="openpyxl" + ) + assert (diskdefaults.columns == [0, 1]).all() + assert ( + diskdefaults.iloc[:, 0] + == [ + "RMS_SEED", + "FAULT_POSITION", + "DC_MODEL", + "OWC1", + "OWC2", + "OWC3", + "MULTZ_ILE", + "PARAM1", + "PARAM2", + "PARAM3", + "PARAM4", + ] + ).all() + + diskdefaults = diskdefaults.set_index(0) + + # FAULT_POSITION has two senscases, east with value -1 and west with value 1, + # so we expect ensemble_size number of rows with -1s and ensemble_size rows with 1s. + # We expect the remaining rows to be set to the base value + # set in the defaultvalues sheet. + fault_position_base = diskdefaults.loc["FAULT_POSITION"].to_list() + fault_position = ( + fault_position_base * ensemble_size + + [-1] * ensemble_size + + [1] * ensemble_size + + fault_position_base * (rows_in_design_matrix - 3 * ensemble_size) + ) + assert (diskdesign["FAULT_POSITION"] == fault_position).all() + + dc_model_base = diskdefaults.loc["DC_MODEL"].to_list() + dc_model = ( + dc_model_base * 3 * ensemble_size + + ["alternative"] * ensemble_size + + dc_model_base * (rows_in_design_matrix - 4 * ensemble_size) + ) + assert (diskdesign["DC_MODEL"] == dc_model).all() + + owc1_base = diskdefaults.loc["OWC1"].to_list() + owc1 = ( + owc1_base * 4 * ensemble_size + + [2600] * ensemble_size + + [2700] * ensemble_size + + owc1_base * (rows_in_design_matrix - 6 * ensemble_size) + ) + assert (diskdesign["OWC1"] == owc1).all() + + owc2_base = diskdefaults.loc["OWC2"].to_list() + owc2 = ( + owc2_base * 4 * ensemble_size + + [2700] * ensemble_size + + [2800] * ensemble_size + + owc2_base * (rows_in_design_matrix - 6 * ensemble_size) + ) + assert (diskdesign["OWC2"] == owc2).all() + + owc3_base = diskdefaults.loc["OWC3"].to_list() + owc3 = ( + owc3_base * 4 * ensemble_size + + [2800] * ensemble_size + + [2900] * ensemble_size + + owc3_base * (rows_in_design_matrix - 6 * ensemble_size) + ) + assert (diskdesign["OWC3"] == owc3).all() + + # MULTZ_ILE contains random numbers so we won't test it here. + + diskmetadata = pd.read_excel( + "designmatrix.xlsx", sheet_name="Metadata", engine="openpyxl" + ) + + assert (diskmetadata.columns == ["Description", "Value"]).all() + assert diskmetadata["Description"].iloc[0] == "Created using semeio version:" + assert diskmetadata["Value"].iloc[0] == semeio.__version__ + assert diskmetadata["Description"].iloc[1] == "Created on:" + + # For the timestamp, we can't check the exact value since it will differ + # each time the test runs. Instead, we can verify it's a valid datetime string + # by attempting to parse it + timestamp = diskmetadata["Value"].iloc[1] + try: + datetime.fromisoformat(timestamp) + except ValueError: + pytest.fail("Timestamp in Metadata sheet is not in expected format") + + +def test_generate_full_mc_snapshot(snapshot): + """Test that full monte carlo design matrix generation remains consistent. + + This is a snapshot test that verifies the entire output of the design matrix + generation process, including both the design values and default values. + """ + # Setup + inputfile = TESTDATA / "config/design_input_mc_with_correls.xlsx" + input_dict = excel_to_dict(inputfile) + design = DesignMatrix() + + # Generate the design matrix + design.generate(input_dict) + + # Round to N significant figures + df_rounded = design.designvalues.map( + lambda x: x if isinstance(x, str) else float(f"{x:.6g}") + ) + + # Prepare data for snapshot comparison + snapshot_dict = { + "designvalues": df_rounded.to_dict("records"), + "defaultvalues": dict(design.defaultvalues), + } + + # Serialize to string for snapshot comparison + snapshot_str = json.dumps( + snapshot_dict, + indent=2, + sort_keys=True, + ) + + # Verify against snapshot + snapshot.assert_match(snapshot_str, "design_output_mc_with_correls.json") + + +def test_generate_full_mc(tmpdir): + """Test generation of full monte carlo""" + inputfile = TESTDATA / "config/design_input_mc_with_correls.xlsx" + input_dict = excel_to_dict(inputfile) + + design = DesignMatrix() + design.generate(input_dict) + + # Checking dimensions of design matrix + assert design.designvalues.shape == (500, 16) + + # Write to disk and check some validity + tmpdir.chdir() + design.to_xlsx("designmatrix.xlsx") + assert Path("designmatrix.xlsx").exists + diskdesign = pd.read_excel( + "designmatrix.xlsx", sheet_name="DesignSheet01", engine="openpyxl" + ) + assert "REAL" in diskdesign + assert "SENSNAME" in diskdesign + assert "SENSCASE" in diskdesign + assert not diskdesign.empty + + diskdefaults = pd.read_excel( + "designmatrix.xlsx", sheet_name="DefaultValues", engine="openpyxl" + ) + assert not diskdefaults.empty + assert len(diskdefaults.columns) == 2 + + # Make sure adding dependent discrete parameters works. + disk_depends = pd.read_excel(inputfile, sheet_name="depend1", engine="openpyxl") + df_merged = diskdesign.merge(disk_depends, on="DATO", how="inner") + assert (df_merged["DERIVED_PARAM1_x"] == df_merged["DERIVED_PARAM1_y"]).all() + assert (df_merged["DERIVED_PARAM2_x"] == df_merged["DERIVED_PARAM2_y"]).all() + + # Check that variables are correlated using Pearson correlation + # Using 95% confidence intervals for correlation coefficients. + # + # The confidence interval calculation assumes: + # - Large sample size (n > 30) + # - Bivariate normal distribution of variables + # - Linear relationship between variables + # When these assumptions are violated (e.g. with skewed distributions), + # the intervals become less reliable + r_obj = stats.pearsonr(diskdesign["OWC1"], diskdesign["OWC2"]) + r_ci = r_obj.confidence_interval(confidence_level=0.95) + assert r_ci[0] <= 0.5 <= r_ci[1] + + r_obj = stats.pearsonr(diskdesign["OWC2"], diskdesign["OWC3"]) + r_ci = r_obj.confidence_interval(confidence_level=0.95) + assert r_ci[0] <= -0.7 <= r_ci[1] + + r_obj = stats.pearsonr(diskdesign["PARAM1"], diskdesign["PARAM2"]) + r_ci = r_obj.confidence_interval(confidence_level=0.95) + assert r_ci[0] <= 0 <= r_ci[1] + + # Using wide tolerance because the non-linear transformation between normal + # and target distributions can alter correlation strength. + assert np.isclose( + stats.spearmanr(diskdesign["PARAM1"], diskdesign["PARAM3"])[0], 0.2, atol=0.1 + ) + + # Check that we can add correlations to discrete variables. + # DATO is stored as strings, so convert to ordinals: spearmanr needs + # numeric input, otherwise scipy passes an object array to np.cov. + dato_ordinal = pd.to_datetime(diskdesign["DATO"]).astype("int64") + assert np.isclose( + stats.spearmanr(dato_ordinal, diskdesign["NTG1"])[0], 0.8, atol=0.1 + ) + + date_fractions = diskdesign["DATO"].value_counts(normalize=True) + assert math.isclose(date_fractions.loc["2018-11-02"], 0.3) + assert math.isclose(date_fractions.loc["2018-11-03"], 0.4) + assert math.isclose(date_fractions.loc["2018-11-04"], 0.3) + + +def test_generate_background(tmpdir): + inputfile = TESTDATA / "config/design_input_background.xlsx" + input_dict = excel_to_dict(inputfile) + source_file = TESTDATA / "config/doe1.xlsx" + dest_file = tmpdir.join("doe1.xlsx") + shutil.copy2(source_file, dest_file) + + with tmpdir.as_cwd(): + design = DesignMatrix() + design.generate(input_dict) + + # Check that background parameters have same values in different sensitivities. + background_params = ["PARAM17", "PARAM18", "PARAM19"] + + background_vals = design.designvalues.loc[ + design.designvalues["SENSNAME"] == "background", background_params + ] + velmodel_vals = design.designvalues.loc[ + design.designvalues["SENSNAME"] == "velmodel", background_params + ] + + assert (background_vals.to_numpy() == velmodel_vals.to_numpy()).all() + + faults_vals = design.designvalues.loc[ + design.designvalues["SENSNAME"] == "faults", background_params + ] + contacts_vals = design.designvalues.loc[ + design.designvalues["SENSNAME"] == "contacts", background_params + ] + + assert (faults_vals.to_numpy() == contacts_vals.to_numpy()).all() + + sens6 = design.designvalues[design.designvalues["SENSNAME"] == "sens6"] + # PARAM5 ~ TruncatedNormal(3, 1, 1, 5) + # PARAM6 ~ Uniform(0, 1) + assert np.isclose( + stats.spearmanr(sens6["PARAM5"], sens6["PARAM6"])[0], + 0.8, + atol=0.1, + ) + sens7 = design.designvalues[design.designvalues["SENSNAME"] == "sens7"] + + # PARAM9 and PARAM10 have a target correlation of 0.9 in the design config. + # The input correlation matrix is not positive semi-definite and is + # transformed to the closest positive semi-definite correlation matrix. + # The new correlation coefficient is 0.8. + # Using wide tolerance because the non-linear transformation between normal + # and target distributions can alter correlation strength. + assert np.isclose( + stats.spearmanr(sens7["PARAM9"], sens7["PARAM10"])[0], + 0.8, + atol=0.2, + ) + + assert np.isclose( + stats.spearmanr(sens7["PARAM10"], sens7["PARAM11"])[0], + 0.8, + atol=0.20, + ) + + +def test_read_defaultvalues_duplicate_error(tmpdir, monkeypatch): + """Test that read_defaultvalues raises ValueError for duplicate parameter names.""" + monkeypatch.chdir(tmpdir) + + # Create a simple Excel file with duplicate parameter names in defaultvalues + defaultvalues = pd.DataFrame( + columns=["param_name", "default_value"], + data=[ + ["a", 1.0], + ["b", 2.0], + [" a", 3.0], # Should be treated as duplicate of "a" after stripping + ["c", 4.0], + ["c ", 5.0], # Should be treated as duplicate of "c" after stripping + ], + ) + + defaultvalues.to_excel( + "test_defaults.xlsx", sheet_name="defaultvalues", index=False + ) + + # Test that ValueError is raised with the exact expected message + with pytest.raises( + ValueError, + match=( + "Duplicate parameter names found in sheet " + r"'defaultvalues': a, c\. All parameter names must be unique\." + ), + ): + _read_defaultvalues("test_defaults.xlsx", "defaultvalues") + + +def _write_correlation_excel(filepath, names, lower_values): + """Helper: write a correlation sheet with given lower-triangular values.""" + n = len(names) + arr = np.full((n, n), np.nan) + for i in range(n): + for j in range(i + 1): + arr[i, j] = lower_values[i][j] + df = pd.DataFrame(arr, index=names, columns=names) + with pd.ExcelWriter(filepath, engine="openpyxl") as w: + df.to_excel(w, sheet_name="corr1") + + +def test_read_correlations_returns_symmetric_matrix(tmp_path): + names = ["A", "B", "C"] + lower = [[1.0], [0.5, 1.0], [0.3, 0.4, 1.0]] + filepath = tmp_path / "corr.xlsx" + _write_correlation_excel(filepath, names, lower) + + result = design_dist.read_correlations(str(filepath), corr_sheet="corr1") + arr = result.to_numpy() + + np.testing.assert_array_almost_equal(arr, arr.T) + np.testing.assert_array_almost_equal(np.diag(arr), [1.0, 1.0, 1.0]) + assert np.isclose(arr[1, 0], 0.5) + assert np.isclose(arr[0, 1], 0.5) + + +def test_read_correlations_preserves_index_and_columns(tmp_path): + names = ["X", "Y"] + lower = [[1.0], [0.8, 1.0]] + filepath = tmp_path / "corr.xlsx" + _write_correlation_excel(filepath, names, lower) + + result = design_dist.read_correlations(str(filepath), corr_sheet="corr1") + + assert list(result.index) == names + assert list(result.columns) == names + + +def test_read_correlations_to_numpy_is_writable(tmp_path): + """The returned DataFrame's to_numpy(copy=True) should be writable.""" + names = ["A", "B"] + lower = [[1.0], [0.5, 1.0]] + filepath = tmp_path / "corr.xlsx" + _write_correlation_excel(filepath, names, lower) + + result = design_dist.read_correlations(str(filepath), corr_sheet="corr1") + arr = result.to_numpy(copy=True) + arr[0, 1] = 0.99 # Should not raise + + +def test_print_corrmat_handles_negative_zeros(capsys): + values = np.array([[1, -0.0, 0.9], [-0.0, 1, 0], [0.9, 0, 1.0]]) + df = pd.DataFrame(values, index=["A", "B", "C"], columns=["A", "B", "C"]) + print_corrmat(df) + output = capsys.readouterr().out + assert "1.00" in output + assert ".90" in output + + +def test_print_corrmat_does_not_mutate_input(): + values = np.array([[1, -0.0, 0.9], [-0.0, 1, 0], [0.9, 0, 1.0]]) + df = pd.DataFrame(values, index=["A", "B", "C"], columns=["A", "B", "C"]) + original = df.copy() + print_corrmat(df) + pd.testing.assert_frame_equal(df, original) + + +def test_fill_with_background_values_no_index_column(): + dm = DesignMatrix() + dm.designvalues = pd.DataFrame( + { + "SENSNAME": ["s1", "s1"], + "SENSCASE": ["c1", "c1"], + "param1": [np.nan, np.nan], + } + ) + dm.backgroundvalues = pd.DataFrame({"param1": [1.0, 2.0]}) + dm._fill_with_background_values() + + assert "index" not in dm.designvalues.columns + + +def test_fill_with_background_values_are_filled(): + dm = DesignMatrix() + dm.designvalues = pd.DataFrame( + { + "SENSNAME": ["s1", "s1"], + "SENSCASE": ["c1", "c1"], + "param1": [np.nan, np.nan], + } + ) + dm.backgroundvalues = pd.DataFrame({"param1": [10.0, 20.0]}) + dm._fill_with_background_values() + + assert dm.designvalues["param1"].tolist() == [10.0, 20.0] + + +if __name__ == "__main__": + import pytest + + pytest.main(args=[__file__, "--doctest-modules", "-v", "-l"]) diff --git a/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py b/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py new file mode 100644 index 00000000000..565aa050516 --- /dev/null +++ b/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py @@ -0,0 +1,154 @@ +"""Testing generating design matrices from dictionary input""" + +import re +import shutil +import subprocess +from pathlib import Path + +import pandas as pd + +from semeio.fmudesign import DesignMatrix + +TESTDATA = Path(__file__).parent / "data" + + +def matches(pattern: str, text: str) -> bool: + """Match text against a pattern where acts as a wildcard. + + Examples + -------- + >>> matches("my name is !", "my name is John!") + True + >>> matches("my is !", "my name is John!") + True + matches("my is !", "my name are John!") + False + """ + regex_pattern = re.escape(pattern) + regex_pattern = regex_pattern.replace("", ".+?") + regex_pattern = f"^{regex_pattern}$" + return bool(re.match(regex_pattern, text)) + + +def valid_designmatrix(dframe): + """Performs general checks on a design matrix, that should always be valid""" + assert "REAL" in dframe + + # REAL always starts at 0 and is consecutive + assert dframe["REAL"][0] == 0 + assert dframe["REAL"].diff().dropna().unique() == 1 + + assert "SENSNAME" in dframe.columns + assert "SENSCASE" in dframe.columns + + # There should be no empty cells in the dataframe: + assert not dframe.isna().sum().sum() + + +def test_designmatrix(): + """Test the DesignMatrix class""" + + design = DesignMatrix() + + mock_dict = { + "designtype": "onebyone", + "seeds": "default", + "repeats": 10, + "distribution_seed": 42, + "defaultvalues": {}, + "sensitivities": { + "rms_seed": { + "seedname": "RMS_SEED", + "senstype": "seed", + "parameters": None, + "dependencies": {}, + } + }, + } + + design.generate(mock_dict) + valid_designmatrix(design.designvalues) + assert len(design.designvalues) == 10 + assert isinstance(design.defaultvalues, dict) + + +def test_endpoint(tmpdir, monkeypatch): + """Test the installed endpoint + + Will write generated design matrices to the pytest tmpdir directory, + usually /tmp/pytest-of-/ + """ + designfile = TESTDATA / "config/design_input_onebyone.xlsx" + + # The xlsx file contains a relative path, relative to the input design sheet: + dependency = ( + pd.read_excel(designfile, header=None, engine="openpyxl") + .set_index([0])[1] + .to_dict()["background"] + ) + + tmpdir.chdir() + monkeypatch.chdir(tmpdir) + # Copy over input files: + shutil.copy(str(designfile), ".") + shutil.copy(Path(designfile).parent / dependency, ".") + + result = subprocess.run( + ["fmudesign", str(designfile)], check=True, capture_output=True, text=True + ) + + # Use in the string below to match anything in CLI output + expected_output = """Reading file: design_input_onebyone.xlsx' + Reading background values from: doe1.xlsx + Generating sensitivity : seed + Generating sensitivity : faults + Generating sensitivity : velmodel + Generating sensitivity : contacts + Generating sensitivity : multz + Generating sensitivity : sens6 + Generating sensitivity : sens7 + Sampling 4 parameters in correlation group 'corr1' + + Warning: Correlation matrix 'corr1' is inconsistent + Requirements: + - All diagonal elements must be 1 + - All elements must be between -1 and 1 + - The matrix must be positive semi-definite + + Input correlation matrix: + | | (1) | (2) | (3) | (4) | + |:------------|------:|------:|------:|------:| + | (1) PARAM9 | 1.00 | | | | + | (2) PARAM10 | 0.90 | 1.00 | | | + | (3) PARAM11 | 0.00 | 0.90 | 1.00 | | + | (4) PARAM12 | 0.00 | 0.00 | 0.00 | 1.00 | + + Adjusted to nearest consistent correlation matrix: + | | (1) | (2) | (3) | (4) | + |:------------|------:|------:|------:|------:| + | (1) PARAM9 | 1.00 | | | | + | (2) PARAM10 | 0.74 | 1.00 | | | + | (3) PARAM11 | 0.11 | 0.74 | 1.00 | | + | (4) PARAM12 | 0.00 | 0.00 | 0.00 | 1.00 | + Generating sensitivity : sens8 +Provided number of background values (11) is smaller than number of realisations for sensitivity ('sens7', 'p10_p90') and parameter PARAM13. Will be filled with default values. +Provided number of background values (11) is smaller than number of realisations for sensitivity ('sens7', 'p10_p90') and parameter PARAM14. Will be filled with default values. +Provided number of background values (11) is smaller than number of realisations for sensitivity ('sens7', 'p10_p90') and parameter PARAM15. Will be filled with default values. +Provided number of background values (11) is smaller than number of realisations for sensitivity ('sens7', 'p10_p90') and parameter PARAM16. Will be filled with default values. +Design matrix of shape (91, 22) written to: 'generateddesignmatrix.xlsx' + + Thank you for using fmudesign + - Documentation: https://equinor.github.io/fmu-tools/fmudesign.html + - Course docs: https://fmu-docs.equinor.com/docs/fmu-coursedocs/fmu-howto/sensitivities/index.html + - Issues/feature requests: https://github.com/equinor/semeio/issues""" # noqa: E501 + + for stdout_line, expected_line in zip( + result.stdout.split(), expected_output.split(), strict=False + ): + assert matches(expected_line, stdout_line) + + assert Path("generateddesignmatrix.xlsx").exists # Default output file + valid_designmatrix(pd.read_excel("generateddesignmatrix.xlsx", engine="openpyxl")) + + subprocess.run(["fmudesign", str(designfile), "anotheroutput.xlsx"], check=True) + assert Path("anotheroutput.xlsx").exists diff --git a/tests/ert/unit_tests/config/fmudesign/test_designsummary.py b/tests/ert/unit_tests/config/fmudesign/test_designsummary.py new file mode 100644 index 00000000000..16e858e3d8b --- /dev/null +++ b/tests/ert/unit_tests/config/fmudesign/test_designsummary.py @@ -0,0 +1,53 @@ +from pathlib import Path + +from semeio.fmudesign import summarize_design + +TESTDATA = Path(__file__).parent / "data" + + +def test_designsummary(): + """Test import and summary of design matrix""" + + snorrebergdesign = summarize_design( + TESTDATA / "distributions/design.xlsx", "DesignSheet01" + ) + # checking dimensions and some values in summary of design matrix + assert snorrebergdesign.shape == (7, 9) + + assert ( + snorrebergdesign.columns + == [ + "sensno", + "sensname", + "senstype", + "casename1", + "startreal1", + "endreal1", + "casename2", + "startreal2", + "endreal2", + ] + ).all() + assert snorrebergdesign["sensname"][0] == "rms_seed" + assert snorrebergdesign["senstype"][0] == "mc" + assert snorrebergdesign["casename1"][0] == "P10_P90" + assert snorrebergdesign["startreal1"][0] == 0 + assert snorrebergdesign["endreal1"][0] == 9 + assert snorrebergdesign["casename2"][0] is None + assert snorrebergdesign["startreal2"][0] is None + assert snorrebergdesign["endreal2"][0] is None + + assert snorrebergdesign["sensname"][6] == "relp_go" + assert snorrebergdesign["senstype"][6] == "scalar" + assert snorrebergdesign["casename1"][6] == "lc" + assert snorrebergdesign["startreal1"][6] == 90 + assert snorrebergdesign["endreal1"][6] == 99 + assert snorrebergdesign["casename2"][6] == "hc" + assert snorrebergdesign["startreal2"][6] == 100 + assert snorrebergdesign["endreal2"][6] == 109 + + assert snorrebergdesign["endreal1"].sum() == 333 + + # Test same also when design matrix is in .csv format + designcsv = summarize_design(TESTDATA / "distributions/design.csv") + assert snorrebergdesign.equals(designcsv) diff --git a/tests/ert/unit_tests/config/fmudesign/test_excel_to_dict.py b/tests/ert/unit_tests/config/fmudesign/test_excel_to_dict.py new file mode 100644 index 00000000000..62262462ac2 --- /dev/null +++ b/tests/ert/unit_tests/config/fmudesign/test_excel_to_dict.py @@ -0,0 +1,249 @@ +"""Testing excel_to_dict""" + +from pathlib import Path + +import numpy as np +import openpyxl +import pandas as pd +import pytest + +from semeio.fmudesign import excel_to_dict, inputdict_to_yaml +from semeio.fmudesign._excel_to_dict import _assert_no_merged_cells, _has_value + +MOCK_GENERAL_INPUT = pd.DataFrame( + data=[ + ["designtype", "onebyone"], + ["repeats", "10"], + ["rms_seeds", "default"], + ["background", "None"], + ["distribution_seed", 42], + ] +) + +MOCK_DESIGNINPUT = pd.DataFrame( + data=[["sensname", "numreal", "type", "param_name"], ["rms_seed", "", "seed"]] +) + + +def test_excel_to_dict(tmpdir, monkeypatch): + """Test that we can convert an Excelfile to a dictionary""" + monkeypatch.chdir(tmpdir) + defaultvalues = pd.DataFrame() + # pylint: disable=abstract-class-instantiated + writer = pd.ExcelWriter("designinput.xlsx", engine="openpyxl") + MOCK_GENERAL_INPUT.to_excel( + writer, sheet_name="general_input", index=False, header=None + ) + MOCK_DESIGNINPUT.to_excel( + writer, sheet_name="designinput", index=False, header=None + ) + defaultvalues.to_excel(writer, sheet_name="defaultvalues", index=False, header=None) + writer.close() + + dict_design = excel_to_dict("designinput.xlsx") + assert isinstance(dict_design, dict) + assert dict_design["designtype"] == "onebyone" + assert dict_design["distribution_seed"] == 42 + assert "defaultvalues" in dict_design + + assert isinstance(dict_design["defaultvalues"], dict) + assert not dict_design["defaultvalues"] # (it is empty) + + assert isinstance(dict_design["sensitivities"], dict) + + sens = dict_design["sensitivities"] + # This now contains a key for each sensitivity to make + assert "rms_seed" in sens + assert isinstance(sens["rms_seed"], dict) + assert sens["rms_seed"]["seedname"] == "RMS_SEED" + assert sens["rms_seed"]["senstype"] == "seed" # upper-cased + + # Check that we can vary some strings + writer = pd.ExcelWriter("designinput2.xlsx", engine="openpyxl") + MOCK_GENERAL_INPUT.to_excel( + writer, sheet_name="Generalinput", index=False, header=None + ) + MOCK_DESIGNINPUT.to_excel( + writer, sheet_name="Design_input", index=False, header=None + ) + defaultvalues.to_excel(writer, sheet_name="DefaultValues", index=False, header=None) + writer.close() + + dict_design = excel_to_dict("designinput2.xlsx") + assert isinstance(dict_design, dict) + assert dict_design["sensitivities"]["rms_seed"]["senstype"] == "seed" + + # Dump to yaml: + inputdict_to_yaml(dict_design, "dictdesign.yaml") + assert Path("dictdesign.yaml").exists() + assert "RMS_SEED" in Path("dictdesign.yaml").read_text(encoding="utf-8") + + +def test_duplicate_sensname_exception(tmpdir, monkeypatch): + """Test that exceptions are raised for erroneous sensnames""" + # pylint: disable=abstract-class-instantiated + mock_erroneous_designinput = pd.DataFrame( + data=[ + ["sensname", "numreal", "type", "param_name"], + ["rms_seed", "", "seed"], + ["rms_seed", "", "seed"], + [np.nan, "", "seed"], # NaN sensname - should be ignored + ["", "", "seed"], # Empty string - should be ignored + ["valid_name", "", "seed"], # Valid unique name + ] + ) + monkeypatch.chdir(tmpdir) + defaultvalues = pd.DataFrame() + + writer = pd.ExcelWriter("designinput3.xlsx", engine="openpyxl") + MOCK_GENERAL_INPUT.to_excel( + writer, sheet_name="general_input", index=False, header=None + ) + mock_erroneous_designinput.to_excel( + writer, sheet_name="designinput", index=False, header=None + ) + defaultvalues.to_excel(writer, sheet_name="defaultvalues", index=False, header=None) + writer.close() + + with pytest.raises( + ValueError, match="Two sensitivities can not share the same sensname" + ): + excel_to_dict("designinput3.xlsx") + + +def test_strip_spaces(tmpdir, monkeypatch): + """Spaces before and after parameter names are probably + invisible user errors in Excel sheets. Remove them.""" + # pylint: disable=abstract-class-instantiated + mock_spacious_designinput = pd.DataFrame( + data=[ + ["sensname", "numreal", "type", "param_name"], + ["rms_seed ", "", "seed"], + ] + ) + defaultvalues_spacious = pd.DataFrame( + data=[ + ["parametername", "value"], + [" spacious_multiplier", 1.2], + ["spacious2 ", 3.3], + ] + ) + monkeypatch.chdir(tmpdir) + writer = pd.ExcelWriter("designinput_spaces.xlsx", engine="openpyxl") + MOCK_GENERAL_INPUT.to_excel( + writer, sheet_name="general_input", index=False, header=None + ) + mock_spacious_designinput.to_excel( + writer, sheet_name="designinput", index=False, header=None + ) + defaultvalues_spacious.to_excel( + writer, sheet_name="defaultvalues", index=False, header=None + ) + writer.close() + + dict_design = excel_to_dict("designinput_spaces.xlsx") + assert next(iter(dict_design["sensitivities"].keys())) == "rms_seed" + + # Check default values parameter names: + def_params = list(dict_design["defaultvalues"].keys()) + assert [par.strip() for par in def_params] == def_params + + +def test_mixed_senstype_exception(tmpdir, monkeypatch): + """Test that exceptions are raised for mixups in user input on types""" + # pylint: disable=abstract-class-instantiated + mock_erroneous_designinput = pd.DataFrame( + data=[ + ["sensname", "numreal", "type", "param_name"], + ["rms_seed", "", "seed"], + ["", "", "dist"], + ] + ) + monkeypatch.chdir(tmpdir) + defaultvalues = pd.DataFrame() + + writer = pd.ExcelWriter("designinput4.xlsx", engine="openpyxl") + MOCK_GENERAL_INPUT.to_excel( + writer, sheet_name="general_input", index=False, header=None + ) + mock_erroneous_designinput.to_excel( + writer, sheet_name="designinput", index=False, header=None + ) + defaultvalues.to_excel(writer, sheet_name="defaultvalues", index=False, header=None) + writer.close() + + with pytest.raises(ValueError, match="contains more than one sensitivity type"): + excel_to_dict("designinput4.xlsx") + + +def test_has_value(): + """Test a function that is used to check if xlsx-cells are empty or not""" + assert _has_value(1) + assert not _has_value(np.nan) + + # This possibly makes no sense, but is the current implementation: + assert _has_value(None) + + +def test_background_sheet(tmpdir, monkeypatch): + """Test loading background values from a sheet""" + monkeypatch.chdir(tmpdir) + general_input = pd.DataFrame( + data=[ + ["designtype", "onebyone"], + ["repeats", 3], + ["rms_seeds", "default"], + ["background", "backgroundsheet"], + ["distribution_seed", 42], + ] + ) + defaultvalues = pd.DataFrame( + columns=["param_name", "default_value"], data=[["extraseed", "0"]] + ) + background = pd.DataFrame( + data=[ + ["param_name", "dist_name", "dist_param1"], + ["extraseed", "scenario", "30,40,50"], + ] + ) + + writer = pd.ExcelWriter("designinput.xlsx", engine="openpyxl") + general_input.to_excel(writer, sheet_name="general_input", index=False, header=None) + MOCK_DESIGNINPUT.to_excel( + writer, sheet_name="design_input", index=False, header=None + ) + defaultvalues.to_excel(writer, sheet_name="defaultvalues", index=False) + background.to_excel(writer, sheet_name="backgroundsheet", index=False, header=None) + writer.close() + + dict_design = excel_to_dict("designinput.xlsx") + + # Assert it has been interpreted correctly from input files: + assert dict_design["background"]["parameters"]["extraseed"] == [ + "scenario", + ["30,40,50"], + None, + ] + assert dict_design["repeats"] == 3 + assert dict_design["defaultvalues"]["extraseed"] == 0 + + +def test_assert_no_merged_cells(tmpdir, monkeypatch): + """Test that assert_no_merged_cells detects merged cells""" + monkeypatch.chdir(tmpdir) + + # Create Excel file with merged cells + test_data = pd.DataFrame({"A": [1, 2], "B": [3, 4]}) + writer = pd.ExcelWriter("test_file.xlsx", engine="openpyxl") + test_data.to_excel(writer, sheet_name="sheet1", index=False) + writer.close() + + # Add merged cells + workbook = openpyxl.load_workbook("test_file.xlsx") + workbook["sheet1"].merge_cells("A1:B1") + workbook.save("test_file.xlsx") + workbook.close() + + # Should raise exception + with pytest.raises(Exception, match="Merged cells"): + _assert_no_merged_cells("test_file.xlsx") diff --git a/tests/ert/unit_tests/config/fmudesign/test_use_cases.py b/tests/ert/unit_tests/config/fmudesign/test_use_cases.py new file mode 100644 index 00000000000..b54356ed96a --- /dev/null +++ b/tests/ert/unit_tests/config/fmudesign/test_use_cases.py @@ -0,0 +1,224 @@ +"""Example use cases for semeio.fmudesign""" + +import os +import shutil +import subprocess +from pathlib import Path + +import pandas as pd +import pytest + +from semeio.fmudesign import DesignMatrix, excel_to_dict +from semeio.fmudesign.fmudesignrunner import EXAMPLES + +EXAMPLE_FILES = [ex.filename for ex in EXAMPLES] + +TESTDATA = Path(__file__).parent / "data" +TEST_FILES = list((TESTDATA / "config").glob("design_input*.xlsx")) + + +def test_prediction_rejection_sampled_ensemble(tmpdir, monkeypatch): + """Test making a design matrix for prediction realizations based on an + ensemble made with manual history matching (rejection sampling). + + In the use-case this test is modelled on, the design matrix is used + to set up a prediction ensemble where each DATA file points to another + Eclipse run on disk which contains the history, identified by the + realization index ("HMREAL") in the history match run. + """ + monkeypatch.chdir(tmpdir) + general_input = pd.DataFrame( + data=[ + ["designtype", "onebyone"], + ["repeats", 3], # This matches the number of HM-samples we have. + ["rms_seeds", "default"], # Geogrid from HM realization is used + ["background", "hmrealizations.xlsx"], + ["distribution_seed", 42], + ] + ) + defaultvalues = pd.DataFrame( + columns=["param_name", "default_value"], + data=[ + # All background parameters must be mentioned in + # DefaultValues (but these defaults are not used in + # this particular test scenario) + ["HMREAL", "-1"], + ["ORAT", 6000], + ["RESTARTPATH", "FOO"], + ["HMITER", "-1"], + ], + ) + + # Background to separate file, these define some history realizations that + # all scenarios should run over: + pd.DataFrame( + columns=["RESTARTPATH", "HMREAL", "HMITER"], + data=[ + ["/scratch/foo/2020a_hm3/", 31, 3], + ["/scratch/foo/2020a_hm3/", 38, 3], + ["/scratch/foo/2020a_hm3/", 54, 3], + ], + ).to_excel("hmrealizations.xlsx") + + writer = pd.ExcelWriter("designinput.xlsx", engine="openpyxl") + general_input.to_excel(writer, sheet_name="general_input", index=False, header=None) + pd.DataFrame( + columns=[ + "sensname", + "numreal", + "type", + "param_name", + "dist_name", + "dist_param1", + "dist_param2", + ], + data=[ + ["ref", None, "background", None], + ["oil_rate", None, "dist", "ORAT", "uniform", 5000, 9000], + ], + ).to_excel(writer, sheet_name="design_input", index=False) + defaultvalues.to_excel(writer, sheet_name="defaultvalues", index=False) + writer.close() + + dict_design = excel_to_dict("designinput.xlsx") + design = DesignMatrix() + design.generate(dict_design) + + assert set(design.designvalues["RESTARTPATH"]) == {"/scratch/foo/2020a_hm3/"} + assert set(design.designvalues["HMITER"]) == {3} + assert all(design.designvalues["REAL"] == [0, 1, 2, 3, 4, 5]) + assert all( + design.designvalues["SENSNAME"] + == [ + "ref", + "ref", + "ref", + "oil_rate", + "oil_rate", + "oil_rate", + ] + ) + + # This is the most important bit in this test function, that the realization + # list in the background xlsx is repeated for each sensitivity: + assert all(design.designvalues["HMREAL"] == [31, 38, 54, 31, 38, 54]) + + +@pytest.mark.parametrize( + "gen_input_sheet", ["general_input", "General_Input", "GENERALINPUT"] +) +def test_constant_distribution(tmpdir, monkeypatch, gen_input_sheet): + """Create a design matrix workbook with a single constant parameter 'a'.""" + monkeypatch.chdir(tmpdir) + + # General input configuration + general_input = pd.DataFrame( + data=[ + ["designtype", "onebyone"], + ["repeats", 1], + ["rms_seeds", "default"], + ["distribution_seed", 42], + ] + ) + + # Default values for parameters + defaultvalues = pd.DataFrame( + columns=["param_name", "default_value"], + data=[ + ["a", 1.0], + ], + ) + + # Design input with single constant parameter + design_input = pd.DataFrame( + columns=[ + "sensname", + "numreal", + "type", + "param_name", + "dist_name", + "dist_param1", + ], + data=[ + ["montecarlo", 100, "dist", "a", "const", 1.0], + ], + ) + + # Create Excel workbook with all sheets + writer = pd.ExcelWriter("designinput.xlsx", engine="openpyxl") + general_input.to_excel(writer, sheet_name=gen_input_sheet, index=False, header=None) + design_input.to_excel(writer, sheet_name="designinput", index=False) + defaultvalues.to_excel(writer, sheet_name="defaultvalues", index=False) + writer.close() + + # Generate design matrix + dict_design = excel_to_dict("designinput.xlsx", gen_input_sheet="generalinput") + design = DesignMatrix() + design.generate(dict_design) + + # Print results + print(f"Parameter 'a' values: {set(design.designvalues['a'])}") + print(f"Number of realizations: {len(design.designvalues)}") + print(f"Sensitivity name: {set(design.designvalues['SENSNAME'])}") + + +@pytest.mark.parametrize("designfile", TEST_FILES, ids=[p.stem for p in TEST_FILES]) +@pytest.mark.parametrize("verbosity", [0, 1, 2]) +def test_all_input_files(tmpdir, monkeypatch, designfile, verbosity): + """Smoketest all files.""" + + monkeypatch.chdir(tmpdir) + + # Copy all example files over, to guarantee existence of dependency files + for filename in designfile.parent.glob("*"): + if Path(filename).is_file(): + shutil.copy(filename, ".") + + # Run the CLI tool (test will fail on non-zero status code) + verbose = ["--verbose"] * verbosity + subprocess.run( + ["fmudesign", designfile, *verbose], check=True, capture_output=True, text=True + ) + + +@pytest.mark.parametrize("designfile", EXAMPLE_FILES, ids=EXAMPLE_FILES) +@pytest.mark.parametrize("verbosity", [0]) +def test_all_example_files_cmd_init(tmpdir, monkeypatch, designfile, verbosity): + """Smoketest all files available in fmudesign init subcommand.""" + monkeypatch.chdir(tmpdir) + subprocess.run( + ["fmudesign", "init", designfile], check=True, capture_output=True, text=True + ) + + # Run the CLI tool (test will fail on non-zero status code) + verbose = ["--verbose"] * verbosity + subprocess.run( + ["fmudesign", "run", designfile, *verbose], + check=True, + capture_output=True, + text=True, + ) + + +@pytest.mark.parametrize("designfile", TEST_FILES, ids=[p.stem for p in TEST_FILES]) +def test_all_input_files_relative_paths(tmpdir, monkeypatch, designfile): + """Smoketest all files, but invoke them from a directory above. + This tests that relative paths in the Excel files work correctly.""" + + monkeypatch.chdir(tmpdir) + copy_to = os.path.join(".", "path", "going", "down") + + Path(copy_to).mkdir(exist_ok=True, parents=True) + + # Copy all example files over, to guarantee existence of dependency files + for filename in designfile.parent.glob("*"): + if Path(filename).is_file(): + shutil.copy(filename, copy_to) + + # Run the CLI tool (test will fail on non-zero status code) + subprocess.run( + ["fmudesign", os.path.join(".", "path", "going", "down", designfile)], + check=True, + capture_output=True, + text=True, + ) From feef3600682ba57b1b4b75d5d65099cd44346bca Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Thu, 6 Aug 2026 11:13:03 +0200 Subject: [PATCH 02/14] Resolve imports Resolves imports in fmudesign src code and tests. Replaced the semeio version in metadata sheet to avoid importing semeio --- src/ert/config/fmudesign/__init__.py | 12 ++------ src/ert/config/fmudesign/_excel_to_dict.py | 12 ++++---- src/ert/config/fmudesign/create_design.py | 18 ++++++------ src/ert/config/fmudesign/fmudesignrunner.py | 29 +++++-------------- src/ert/config/fmudesign/quality_report.py | 6 ++-- .../config/fmudesign/test_create_design.py | 20 ++++++------- .../config/fmudesign/test_designmatrix.py | 2 +- .../config/fmudesign/test_designsummary.py | 2 +- .../config/fmudesign/test_excel_to_dict.py | 7 +++-- .../config/fmudesign/test_use_cases.py | 7 +++-- 10 files changed, 48 insertions(+), 67 deletions(-) diff --git a/src/ert/config/fmudesign/__init__.py b/src/ert/config/fmudesign/__init__.py index ef5fe374476..cea45b146e1 100644 --- a/src/ert/config/fmudesign/__init__.py +++ b/src/ert/config/fmudesign/__init__.py @@ -1,12 +1,6 @@ -""" -Used for pre and processing of ert sensitivities, such as -setting up design matrix to run single sensitivities with ERT. -Output of this module can be used in custom standalone applications. -""" - -from semeio.fmudesign._designsummary import summarize_design -from semeio.fmudesign._excel_to_dict import excel_to_dict, inputdict_to_yaml -from semeio.fmudesign.create_design import DesignMatrix +from ._designsummary import summarize_design +from ._excel_to_dict import excel_to_dict, inputdict_to_yaml +from .create_design import DesignMatrix __all__ = [ "DesignMatrix", diff --git a/src/ert/config/fmudesign/_excel_to_dict.py b/src/ert/config/fmudesign/_excel_to_dict.py index 3c48bed499f..aef7bf7e48b 100644 --- a/src/ert/config/fmudesign/_excel_to_dict.py +++ b/src/ert/config/fmudesign/_excel_to_dict.py @@ -16,8 +16,8 @@ import pandas as pd import yaml -from semeio.fmudesign.design_distributions import read_correlations -from semeio.fmudesign.utils import seeds_from_extern +from .design_distributions import read_correlations +from .utils import seeds_from_extern def excel_to_dict( @@ -138,7 +138,8 @@ def _check_designinput(dsgn_input: pd.DataFrame) -> None: def _check_for_mixed_sensitivities(sens_name: str, sens_group: pd.DataFrame) -> None: """Checks for valid input in designinput sheet. A sensitivity cannot contain - two different sensitivity types""" + two different sensitivity types + """ unique_types = sens_group["type"].dropna().unique() if len(unique_types) > 1: @@ -602,7 +603,8 @@ def _read_scenario_sensitivity(sensgroup: pd.DataFrame) -> dict[str, Any]: def _read_constants(sensgroup: pd.DataFrame) -> dict[str, Any]: """Reads constants to be used together with - seed sensitivity""" + seed sensitivity + """ if "dist_param1" not in sensgroup.columns.to_numpy(): sensgroup["dist_param1"] = float("NaN") paramdict: dict[str, Any] = {} @@ -728,7 +730,7 @@ def _read_correlations( return correlations -def _has_value(value: Any) -> bool: # noqa: ANN401 +def _has_value(value: Any) -> bool: """Returns False only if the argument is np.nan""" try: return not np.isnan(value) diff --git a/src/ert/config/fmudesign/create_design.py b/src/ert/config/fmudesign/create_design.py index fabdc022db9..d0f870c8c78 100644 --- a/src/ert/config/fmudesign/create_design.py +++ b/src/ert/config/fmudesign/create_design.py @@ -19,12 +19,11 @@ import pandas as pd import probabilit -import semeio -from semeio.fmudesign import design_distributions as design_dist -from semeio.fmudesign._excel_to_dict import _raise_if_duplicates -from semeio.fmudesign.config_validation import validate_configuration -from semeio.fmudesign.quality_report import QualityReporter, print_corrmat -from semeio.fmudesign.utils import ( +from . import design_distributions as design_dist +from ._excel_to_dict import _raise_if_duplicates +from .config_validation import validate_configuration +from .quality_report import QualityReporter, print_corrmat +from .utils import ( find_max_realisations, map_dependencies, parameters_from_extern, @@ -70,7 +69,8 @@ def __init__(self, verbosity: int = 0, output_dir: Path | None = None) -> None: def reset(self) -> None: """Resets DesignMatrix to empty. Necessary iin case method generate - is used several times for same instance of DesignMatrix""" + is used several times for same instance of DesignMatrix + """ self.designvalues = pd.DataFrame() self.defaultvalues = {} self.backgroundvalues = None @@ -272,7 +272,7 @@ def to_xlsx( { "Description": ["Created using semeio version:", "Created on:"], "Value": [ - semeio.__version__, + "semeio.__version__", datetime.now() .astimezone() .isoformat(sep=" ", timespec="seconds"), @@ -302,7 +302,7 @@ def create_rms_seeds(seeds: list | str | None, max_reals: int) -> list | None: Provided number of seed values (3) in external file is lower than the maximum number of realisations (5). Seeds will be repeated, e.g. [1, 2, 3] => [1, 2, 3, 1, 2, ...] [1, 2, 3, 1, 2] - """ # noqa: E501 + """ # ruff: ignore[line-too-long] if seeds is None: return None diff --git a/src/ert/config/fmudesign/fmudesignrunner.py b/src/ert/config/fmudesign/fmudesignrunner.py index 1e0af1bbd11..288ee6d8508 100644 --- a/src/ert/config/fmudesign/fmudesignrunner.py +++ b/src/ert/config/fmudesign/fmudesignrunner.py @@ -26,10 +26,8 @@ from importlib.resources import as_file, files from pathlib import Path -from packaging.version import Version - -import semeio -from semeio.fmudesign import DesignMatrix, excel_to_dict +from ._excel_to_dict import excel_to_dict +from .create_design import DesignMatrix @dataclasses.dataclass @@ -117,12 +115,6 @@ def get_parser() -> tuple[ArgumentParser, _SubParsersAction]: add_help=False, ) - parser.add_argument( - "-v", - "--version", - action="version", - version=f"fmudesign {Version(semeio.__version__)}", - ) parser.add_argument( "-h", "--help", action="help", help="Show this help message and exit" ) @@ -274,7 +266,7 @@ def subcommand_run(args: Namespace, parser: ArgumentParser) -> None: def subcommand_init(args: Namespace, parser: ArgumentParser) -> None: """Handles the 'init' subcommand.""" - EXAMPLES_DIR = files("semeio.fmudesign.examples") + EXAMPLES_DIR = files("ert.config.fmudesign.examples") # Verify that all examples in EXAMPLES_DIR exist on disk for example in EXAMPLES: @@ -311,14 +303,15 @@ def subcommand_init(args: Namespace, parser: ArgumentParser) -> None: def main() -> None: """semeio.fmudesign is a command line utility for generating design matrices - Wrapper for the the semeio.fmudesign module""" + Wrapper for the the semeio.fmudesign module + """ warnings.filterwarnings("ignore", category=DeprecationWarning) warnings.filterwarnings("ignore", category=FutureWarning) parser, _subparsers = get_parser() # Backwards compatibility. If not a known command, assume "run" - valid_cmds = ("run", "init", "-h", "--help", "-v", "--version") + valid_cmds = ("run", "init", "-h", "--help", "-v") if len(sys.argv) > 1 and sys.argv[1] not in valid_cmds: sys.argv.insert(1, "run") @@ -331,7 +324,7 @@ def main() -> None: try: args.func(args) - except Exception: # noqa: BLE001 + except Exception: traceback.print_exc() print( "\n \n", @@ -343,14 +336,6 @@ def main() -> None: ) sys.exit(1) # Exit with a non-zero status code (required for smoke tests!) - print( - "\n", - f"Thank you for using fmudesign {Version(semeio.__version__).base_version}\n", - " - Documentation: https://equinor.github.io/fmu-tools/fmudesign.html\n", - " - Course docs: https://fmu-docs.equinor.com/docs/fmu-coursedocs/fmu-howto/sensitivities/index.html\n", - " - Issues/feature requests: https://github.com/equinor/semeio/issues\n", - ) - if __name__ == "__main__": main() diff --git a/src/ert/config/fmudesign/quality_report.py b/src/ert/config/fmudesign/quality_report.py index 4f792aad0fe..0759fcb5a23 100644 --- a/src/ert/config/fmudesign/quality_report.py +++ b/src/ert/config/fmudesign/quality_report.py @@ -13,7 +13,7 @@ nearest_correlation_matrix, ) -from semeio.fmudesign.design_distributions import to_probabilit +from .design_distributions import to_probabilit if TYPE_CHECKING: from matplotlib.patches import Rectangle @@ -382,7 +382,7 @@ def plot_correlation( def corrfunc( x: npt.NDArray[np.float64], y: npt.NDArray[np.float64], - **kwargs: Any, # noqa: ANN401 + **kwargs: Any, ) -> None: # Add correlations and grid to plots r, _ = sp.stats.pearsonr(x, y) @@ -394,7 +394,7 @@ def corrfunc( ) ax.grid(visible=True, ls="--", alpha=0.5) - def add_grid(*args: Any, **kwargs: Any) -> None: # noqa: ANN401 + def add_grid(*args: Any, **kwargs: Any) -> None: ax = plt.gca() ax.grid(visible=True, ls="--", alpha=0.5) diff --git a/tests/ert/unit_tests/config/fmudesign/test_create_design.py b/tests/ert/unit_tests/config/fmudesign/test_create_design.py index d7640d2d368..20b14fe0060 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_create_design.py +++ b/tests/ert/unit_tests/config/fmudesign/test_create_design.py @@ -11,11 +11,10 @@ import pytest from scipy import stats -import semeio -from semeio.fmudesign import DesignMatrix, excel_to_dict -from semeio.fmudesign import design_distributions as design_dist -from semeio.fmudesign._excel_to_dict import _read_defaultvalues -from semeio.fmudesign.quality_report import print_corrmat +from ert.config.fmudesign import DesignMatrix, excel_to_dict +from ert.config.fmudesign._excel_to_dict import _read_defaultvalues +from ert.config.fmudesign.design_distributions import read_correlations +from ert.config.fmudesign.quality_report import print_corrmat TESTDATA = Path(__file__).parent / "data" @@ -23,7 +22,8 @@ @pytest.mark.parametrize("correlations", [True, False]) def test_distribution_statistis(tmpdir, monkeypatch, correlations): """This test ensures that if any large-sample statistics for any distribution - changes, we will likely pick it up in the future.""" + changes, we will likely pick it up in the future. + """ NUM_SAMPLES = 10**5 @@ -363,8 +363,6 @@ def test_generate_onebyone(tmpdir): ) assert (diskmetadata.columns == ["Description", "Value"]).all() - assert diskmetadata["Description"].iloc[0] == "Created using semeio version:" - assert diskmetadata["Value"].iloc[0] == semeio.__version__ assert diskmetadata["Description"].iloc[1] == "Created on:" # For the timestamp, we can't check the exact value since it will differ @@ -599,7 +597,7 @@ def test_read_correlations_returns_symmetric_matrix(tmp_path): filepath = tmp_path / "corr.xlsx" _write_correlation_excel(filepath, names, lower) - result = design_dist.read_correlations(str(filepath), corr_sheet="corr1") + result = read_correlations(str(filepath), corr_sheet="corr1") arr = result.to_numpy() np.testing.assert_array_almost_equal(arr, arr.T) @@ -614,7 +612,7 @@ def test_read_correlations_preserves_index_and_columns(tmp_path): filepath = tmp_path / "corr.xlsx" _write_correlation_excel(filepath, names, lower) - result = design_dist.read_correlations(str(filepath), corr_sheet="corr1") + result = read_correlations(str(filepath), corr_sheet="corr1") assert list(result.index) == names assert list(result.columns) == names @@ -627,7 +625,7 @@ def test_read_correlations_to_numpy_is_writable(tmp_path): filepath = tmp_path / "corr.xlsx" _write_correlation_excel(filepath, names, lower) - result = design_dist.read_correlations(str(filepath), corr_sheet="corr1") + result = read_correlations(str(filepath), corr_sheet="corr1") arr = result.to_numpy(copy=True) arr[0, 1] = 0.99 # Should not raise diff --git a/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py b/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py index 565aa050516..f7640884470 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py +++ b/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py @@ -7,7 +7,7 @@ import pandas as pd -from semeio.fmudesign import DesignMatrix +from ert.config.fmudesign import DesignMatrix TESTDATA = Path(__file__).parent / "data" diff --git a/tests/ert/unit_tests/config/fmudesign/test_designsummary.py b/tests/ert/unit_tests/config/fmudesign/test_designsummary.py index 16e858e3d8b..fa294d746bf 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_designsummary.py +++ b/tests/ert/unit_tests/config/fmudesign/test_designsummary.py @@ -1,6 +1,6 @@ from pathlib import Path -from semeio.fmudesign import summarize_design +from ert.config.fmudesign import summarize_design TESTDATA = Path(__file__).parent / "data" diff --git a/tests/ert/unit_tests/config/fmudesign/test_excel_to_dict.py b/tests/ert/unit_tests/config/fmudesign/test_excel_to_dict.py index 62262462ac2..3c0e2d227a0 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_excel_to_dict.py +++ b/tests/ert/unit_tests/config/fmudesign/test_excel_to_dict.py @@ -7,8 +7,8 @@ import pandas as pd import pytest -from semeio.fmudesign import excel_to_dict, inputdict_to_yaml -from semeio.fmudesign._excel_to_dict import _assert_no_merged_cells, _has_value +from ert.config.fmudesign import excel_to_dict, inputdict_to_yaml +from ert.config.fmudesign._excel_to_dict import _assert_no_merged_cells, _has_value MOCK_GENERAL_INPUT = pd.DataFrame( data=[ @@ -113,7 +113,8 @@ def test_duplicate_sensname_exception(tmpdir, monkeypatch): def test_strip_spaces(tmpdir, monkeypatch): """Spaces before and after parameter names are probably - invisible user errors in Excel sheets. Remove them.""" + invisible user errors in Excel sheets. Remove them. + """ # pylint: disable=abstract-class-instantiated mock_spacious_designinput = pd.DataFrame( data=[ diff --git a/tests/ert/unit_tests/config/fmudesign/test_use_cases.py b/tests/ert/unit_tests/config/fmudesign/test_use_cases.py index b54356ed96a..54bf82926da 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_use_cases.py +++ b/tests/ert/unit_tests/config/fmudesign/test_use_cases.py @@ -8,8 +8,8 @@ import pandas as pd import pytest -from semeio.fmudesign import DesignMatrix, excel_to_dict -from semeio.fmudesign.fmudesignrunner import EXAMPLES +from ert.config.fmudesign import DesignMatrix, excel_to_dict +from ert.config.fmudesign.fmudesignrunner import EXAMPLES EXAMPLE_FILES = [ex.filename for ex in EXAMPLES] @@ -203,7 +203,8 @@ def test_all_example_files_cmd_init(tmpdir, monkeypatch, designfile, verbosity): @pytest.mark.parametrize("designfile", TEST_FILES, ids=[p.stem for p in TEST_FILES]) def test_all_input_files_relative_paths(tmpdir, monkeypatch, designfile): """Smoketest all files, but invoke them from a directory above. - This tests that relative paths in the Excel files work correctly.""" + This tests that relative paths in the Excel files work correctly. + """ monkeypatch.chdir(tmpdir) copy_to = os.path.join(".", "path", "going", "down") From ec787e5e33337be8c66613f459a9cb3c2aa35d2d Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Thu, 6 Aug 2026 11:14:22 +0200 Subject: [PATCH 03/14] Replace E501 with ruff ignore --- src/ert/config/fmudesign/_excel_to_dict.py | 2 +- src/ert/config/fmudesign/fmudesignrunner.py | 4 ++-- src/ert/config/fmudesign/quality_report.py | 4 ++-- tests/ert/unit_tests/config/fmudesign/test_designmatrix.py | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/ert/config/fmudesign/_excel_to_dict.py b/src/ert/config/fmudesign/_excel_to_dict.py index aef7bf7e48b..4a559511e34 100644 --- a/src/ert/config/fmudesign/_excel_to_dict.py +++ b/src/ert/config/fmudesign/_excel_to_dict.py @@ -99,7 +99,7 @@ def find_sheet(name: str, names: list[str]) -> str: Traceback (most recent call last): ... ValueError: No match for variable_input: ['generalinput', 'designinput', 'defaultinput'] - """ # noqa: E501 + """ # ruff: ignore[line-too-long] def sanitize(inputstring: str) -> str: return inputstring.lower().strip().replace("_", "") diff --git a/src/ert/config/fmudesign/fmudesignrunner.py b/src/ert/config/fmudesign/fmudesignrunner.py index 288ee6d8508..6399ba02e00 100644 --- a/src/ert/config/fmudesign/fmudesignrunner.py +++ b/src/ert/config/fmudesign/fmudesignrunner.py @@ -330,9 +330,9 @@ def main() -> None: "\n \n", "fmudesign failed. Read the error message above and fix the input file.\n", " - Documentation: https://equinor.github.io/fmu-tools/fmudesign.html\n", - " - Course docs: https://fmu-docs.equinor.com/docs/fmu-coursedocs/fmu-howto/sensitivities/index.html \n", # noqa: E501 + " - Course docs: https://fmu-docs.equinor.com/docs/fmu-coursedocs/fmu-howto/sensitivities/index.html \n", # ruff: ignore[line-too-long] " - Issues/feature requests: https://github.com/equinor/semeio/issues\n", - "If you believe this error is a bug or are unable to fix it, create an issue or contact the scout team \n", # noqa: E501 + "If you believe this error is a bug or are unable to fix it, create an issue or contact the scout team \n", # ruff: ignore[line-too-long] ) sys.exit(1) # Exit with a non-zero status code (required for smoke tests!) diff --git a/src/ert/config/fmudesign/quality_report.py b/src/ert/config/fmudesign/quality_report.py index 0759fcb5a23..97e58b54a24 100644 --- a/src/ert/config/fmudesign/quality_report.py +++ b/src/ert/config/fmudesign/quality_report.py @@ -354,9 +354,9 @@ def print_correlation(self, corr_name: str, df_corr: pd.DataFrame) -> None: print( "Target correlation matrix and empirical correlation achieved", " in data does not match well\n" - "This is natural with few samples, or very high/low desired correlations, " # noqa: E501 + "This is natural with few samples, or very high/low desired correlations, " # ruff: ignore[line-too-long] "or distributions that are far from\nnormal (e.g. lognormal)." - " Setting 'correlation_iterations' to 999 in the general input sheet might help.", # noqa: E501 + " Setting 'correlation_iterations' to 999 in the general input sheet might help.", # ruff: ignore[line-too-long] ) def plot_correlation( diff --git a/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py b/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py index f7640884470..baf4ce3cd0f 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py +++ b/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py @@ -140,7 +140,7 @@ def test_endpoint(tmpdir, monkeypatch): Thank you for using fmudesign - Documentation: https://equinor.github.io/fmu-tools/fmudesign.html - Course docs: https://fmu-docs.equinor.com/docs/fmu-coursedocs/fmu-howto/sensitivities/index.html - - Issues/feature requests: https://github.com/equinor/semeio/issues""" # noqa: E501 + - Issues/feature requests: https://github.com/equinor/semeio/issues""" # ruff: ignore[line-too-long] for stdout_line, expected_line in zip( result.stdout.split(), expected_output.split(), strict=False From ecce04873f2598d153bd9d6f01a199f046f77e2f Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Thu, 6 Aug 2026 11:35:37 +0200 Subject: [PATCH 04/14] Add probabilit and openpyxl to ert dependencies These are dependencies of fmudesign --- pyproject.toml | 2 + uv.lock | 282 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 284 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index 670d60c0c4c..d7007b1b5ce 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -79,6 +79,8 @@ dependencies = [ "resfo-utilities>=0.5.0", "natsort>=8.4.0", "shapely>=2.1.2", + "probabilit>=0.4.2", + "openpyxl>=3.1.5", ] [project.scripts] diff --git a/uv.lock b/uv.lock index db87c428002..fd4de9ec776 100644 --- a/uv.lock +++ b/uv.lock @@ -622,6 +622,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/98/2b/f97f1c193fb855c345d678f5077d6926034db0722df74c8f057020e05a25/charset_normalizer-3.4.9-py3-none-any.whl", hash = "sha256:68e5f26a1ad57ded6d1cfb85331d1c1a195314756471d97758c48498bb4dcdf5", size = 64538, upload-time = "2026-07-07T14:34:56.993Z" }, ] +[[package]] +name = "clarabel" +version = "0.11.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, + { name = "numpy" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/81/e2/47f692161779dbd98876015de934943effb667a014e6f79a6d746b3e4c2a/clarabel-0.11.1.tar.gz", hash = "sha256:e7c41c47f0e59aeab99aefff9e58af4a8753ee5269bbeecbd5526fc6f41b9598", size = 253949, upload-time = "2025-06-11T16:49:05.864Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/f7/f82698b6d00a40a80c67e9a32b2628886aadfaf7f7b32daa12a463e44571/clarabel-0.11.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c39160e4222040f051f2a0598691c4f9126b4d17f5b9e7678f76c71d611e12d8", size = 1039511, upload-time = "2025-06-11T16:48:58.525Z" }, + { url = "https://files.pythonhosted.org/packages/b0/8f/13650cfe25762b51175c677330e6471d5d2c5851a6fbd6df77f0681bb34e/clarabel-0.11.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:8963687ee250d27310d139eea5a6816f9c3ae31f33691b56579ca4f0f0b64b63", size = 935135, upload-time = "2025-06-11T16:48:59.901Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9e/7af10d2b540b39f1a05d1ebba604fce933cc9bc0e65e88ec3b7a84976425/clarabel-0.11.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4837b9d0db01e98239f04b1e3526a6cf568529d3c19a8b3f591befdc467f9bb", size = 1079226, upload-time = "2025-06-11T16:49:00.987Z" }, + { url = "https://files.pythonhosted.org/packages/6b/a9/c76edf781ca3283186ff4b54a9a4fb51367fd04313a68e2b09f062407439/clarabel-0.11.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8c41aaa6f3f8c0f3bd9d86c3e568dcaee079562c075bd2ec9fb3a80287380ef", size = 1164345, upload-time = "2025-06-11T16:49:02.675Z" }, + { url = "https://files.pythonhosted.org/packages/41/e6/4eee3062088c221e5a18b054e51c69f616e0bb0dc1b0a1a5e0fe90dfa18e/clarabel-0.11.1-cp39-abi3-win_amd64.whl", hash = "sha256:557d5148a4377ae1980b65d00605ae870a8f34f95f0f6a41e04aa6d3edf67148", size = 887310, upload-time = "2025-06-11T16:49:04.277Z" }, +] + [[package]] name = "click" version = "8.4.2" @@ -846,6 +864,43 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/20/0c/7bb51e3acfafd16c48875bf3db03607674df16f5b6ef8d056586af7e2b8b/cssselect-1.4.0-py3-none-any.whl", hash = "sha256:c0ec5c0191c8ee39fcc8afc1540331d8b55b0183478c50e9c8a79d44dbceb1d8", size = 18540, upload-time = "2026-01-29T07:00:24.994Z" }, ] +[[package]] +name = "cvxpy" +version = "1.9.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "clarabel" }, + { name = "highspy" }, + { name = "numpy" }, + { name = "osqp" }, + { name = "qdldl" }, + { name = "scipy" }, + { name = "scs" }, + { name = "sparsediffpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ea/b7/209c6df38f3621fc2f32298c93e7d0310b8a1ee4ef15e5fa59d90492fa6f/cvxpy-1.9.2.tar.gz", hash = "sha256:b2e939f197a7081a300d5a95812fec8643fabaf23a149abf7e67ca7f89671d92", size = 1916772, upload-time = "2026-06-22T04:37:31.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b4/43/929526a0801cdd56fbb8350f2200cec49739344d12f310f0aafea1f3506e/cvxpy-1.9.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bc9082110ac7f9d9a121f4dea73936f9b65ec043af91562677478edf4962905b", size = 1635177, upload-time = "2026-06-22T04:32:07.194Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0b/3be49d69c0a90e22572b5ed1c568d4f2357f14f013597a4314f4ea98a2da/cvxpy-1.9.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ba59da053c4d15fffa54921dc4b8b929d5a11937692703133858c2be6329107b", size = 1425036, upload-time = "2026-06-22T04:32:08.444Z" }, + { url = "https://files.pythonhosted.org/packages/28/70/80e2ec67a9588cf6e2b99f3e528c4508457cba16c5f5a2a8195c255d043e/cvxpy-1.9.2-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fa6e86a6ecd19a63751b470a3ed44d5fba6663ab9e05d6040bb954e80a4f7551", size = 4379465, upload-time = "2026-06-22T04:37:29.121Z" }, + { url = "https://files.pythonhosted.org/packages/56/6b/f0f804c7b626917edfe1801baddb85076cdb2fc0e52ed49ff112db82f980/cvxpy-1.9.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:074897ae8f2378174099c082feef5a93b44f4c8dc9b3e960397c31fa3cebf722", size = 4427785, upload-time = "2026-06-22T04:37:30.5Z" }, + { url = "https://files.pythonhosted.org/packages/60/54/81871ee6599d33e3a60907829aafff78e713e1c3a34ce57d1e4ef26fdb5d/cvxpy-1.9.2-cp312-cp312-win_amd64.whl", hash = "sha256:1cc56d04515201a3e2f58a16ea59812a0126dd1419f0726f8322e6dc227a9062", size = 1386030, upload-time = "2026-06-22T04:35:23.856Z" }, + { url = "https://files.pythonhosted.org/packages/9d/0a/40f3ef2bd1a89002a4716fbe3f6aa9f55f92ee7a095a73d23242b528463a/cvxpy-1.9.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5dbbd7e149f191e21e21ec5bda41ab562d05c5d553d0103cabe3c7b8f7f5f90b", size = 1635226, upload-time = "2026-06-22T04:35:21.744Z" }, + { url = "https://files.pythonhosted.org/packages/20/26/0c0b02d6a116997412c311481b12fa628a8c43f128a405a1afea41b25040/cvxpy-1.9.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f649df44a798420c5a2fec75e073c067ffda92fb00a6d64d2221bef275d2d065", size = 1425026, upload-time = "2026-06-22T04:35:23.099Z" }, + { url = "https://files.pythonhosted.org/packages/80/3b/86e06eb6cc5d42166f02b67956403a0f2dc44e35fe0f94912659bc343d8b/cvxpy-1.9.2-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae51f459010fa8d8ecb4b19bb8a8c63781592fc070ba2e3d119c6b9c10995e26", size = 4379643, upload-time = "2026-06-22T04:35:59.328Z" }, + { url = "https://files.pythonhosted.org/packages/80/81/19e6a2b66124dc42eee0e542c3fa47d2b4dd6c2c9f0030543698c7a50be7/cvxpy-1.9.2-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a48e498cbe2ced52a20dd3a1b14bcd2aa939fa0a51a766c443aa8a75081285ce", size = 4427686, upload-time = "2026-06-22T04:36:00.695Z" }, + { url = "https://files.pythonhosted.org/packages/54/bd/6cbe32217d3221578211518efce0a1edc45761d7b60fb360d027d576005d/cvxpy-1.9.2-cp313-cp313-win_amd64.whl", hash = "sha256:956b292452a5eed7cacffed25d7d1848618e97ca6ea4a83302591a46149f8f2f", size = 1386056, upload-time = "2026-06-22T04:35:41.799Z" }, + { url = "https://files.pythonhosted.org/packages/79/5f/db68cbe59c20a21e477ecba53c1fe93d34785f7d44e114d447b02f3ad5d2/cvxpy-1.9.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:54a34e4ff10b80659023ba5f1517f4171ea9b905e90c824b467a7a4234379faf", size = 1636070, upload-time = "2026-06-22T04:34:15.021Z" }, + { url = "https://files.pythonhosted.org/packages/8a/e4/f01d7f8921a7e3ccce2848459b2265a4712bd132d199c03e6c60119cfc0a/cvxpy-1.9.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:908b0423e1fd29768b076547aa2328876e6c09b4d3550d1a37409423f907dd6e", size = 1425490, upload-time = "2026-06-22T04:34:16.175Z" }, + { url = "https://files.pythonhosted.org/packages/e3/b6/a88a61cea293d90a1751b39c77a5d5775b8a3dd4907f4461d0b34e7aa558/cvxpy-1.9.2-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:417a2881d6490f3a13b3b88ee98b3ece5bbc1f1a76aa7a374e0690735f14ba40", size = 4376093, upload-time = "2026-06-22T04:36:45.174Z" }, + { url = "https://files.pythonhosted.org/packages/a3/e0/e7b8caba3b0fc86e9402452b7c3d037af2e995110385d9760e3bc984b491/cvxpy-1.9.2-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:44ca674f9427d7d8019bf80e71fd1035f1aa9eabc6a09b5e6bad52f352f830e5", size = 4423171, upload-time = "2026-06-22T04:36:46.518Z" }, + { url = "https://files.pythonhosted.org/packages/44/08/03871e44cfef2b604fcbe0649d6c02893c60737748580d641a6084ebc532/cvxpy-1.9.2-cp314-cp314-win_amd64.whl", hash = "sha256:d25f16ab7da70ac3a44b49df985f00afbe89e64c44625afd38379ca5d77f4787", size = 1392074, upload-time = "2026-06-22T04:33:59.083Z" }, + { url = "https://files.pythonhosted.org/packages/63/b8/2be562808af2ca22edc3c7b74caeace9ebcae3e7e3467ac67e19d5a8f836/cvxpy-1.9.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:fb6aa08b89aedfee2a3c62902551df67d5c6b8684038e019fbe8e5a472142845", size = 1643586, upload-time = "2026-06-22T04:35:11.342Z" }, + { url = "https://files.pythonhosted.org/packages/66/a1/ab623b3e94533e7bfd34abd881d2215956864d706313f244b79d4964aba5/cvxpy-1.9.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:8cc42bfa468cc474609900de211b1f6db69ca1215c850cbf00f2646d06d5cbf9", size = 1429833, upload-time = "2026-06-22T04:35:12.604Z" }, + { url = "https://files.pythonhosted.org/packages/90/8a/5fa9717f974d30b573c34b49d0704afab1379d12a7b1b0ebc928dd777c4f/cvxpy-1.9.2-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:27d0d08dfc1484eed29cbb98616409a677be41a81e58c91c2b954b8c19968dfa", size = 4362226, upload-time = "2026-06-22T04:37:39.135Z" }, + { url = "https://files.pythonhosted.org/packages/07/9e/5711925094fba396062ef700f95427a8be6614631a28fa255a3e526333ce/cvxpy-1.9.2-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4a07593837d772edd5efafee3dbd069a5299f78633c944004469ce2728e1c0ac", size = 4414598, upload-time = "2026-06-22T04:37:40.586Z" }, +] + [[package]] name = "cwrap" version = "1.6.16" @@ -992,6 +1047,7 @@ dependencies = [ { name = "netcdf4" }, { name = "networkx" }, { name = "numpy" }, + { name = "openpyxl" }, { name = "opentelemetry-api" }, { name = "opentelemetry-instrumentation-threading" }, { name = "opentelemetry-sdk" }, @@ -1000,6 +1056,7 @@ dependencies = [ { name = "pandas" }, { name = "pluggy" }, { name = "polars" }, + { name = "probabilit" }, { name = "progressbar2" }, { name = "psutil" }, { name = "pyarrow" }, @@ -1108,6 +1165,7 @@ requires-dist = [ { name = "netcdf4" }, { name = "networkx" }, { name = "numpy" }, + { name = "openpyxl", specifier = ">=3.1.5" }, { name = "opentelemetry-api" }, { name = "opentelemetry-instrumentation-threading" }, { name = "opentelemetry-sdk" }, @@ -1116,6 +1174,7 @@ requires-dist = [ { name = "pandas" }, { name = "pluggy", specifier = ">=1.3.0" }, { name = "polars", specifier = ">=1.36.0" }, + { name = "probabilit", specifier = ">=0.4.2" }, { name = "progressbar2" }, { name = "psutil" }, { name = "pyarrow" }, @@ -1199,6 +1258,15 @@ types = [ { name = "types-tqdm" }, ] +[[package]] +name = "et-xmlfile" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54", size = 17234, upload-time = "2024-10-25T17:25:40.039Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059, upload-time = "2024-10-25T17:25:39.051Z" }, +] + [[package]] name = "execnet" version = "2.1.2" @@ -1638,6 +1706,47 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/4e/14/32cf2aae083c74b95678875e11d25d0cb9e51a33d27f4218eb9aeacfcd70/hdf5plugin-7.0.0-py3-none-win_amd64.whl", hash = "sha256:2e052af8d7848e8bac92646584617503a08bb9b466cfa810a49ecd93e89b7ffa", size = 3523827, upload-time = "2026-06-25T20:59:37.758Z" }, ] +[[package]] +name = "highspy" +version = "1.15.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/87/02/c6b658f79911fee921721da728b9ab8f5e19ff06121fff36f90f77127f4d/highspy-1.15.1.tar.gz", hash = "sha256:20ed2fbf1cb64bf3044ee6632364b7e2653d93e6901e2b19fd3d5df10702e8c5", size = 1703256, upload-time = "2026-07-02T12:03:25.009Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/59/b79a7b1711ddfcca36674ddb41759e98eb1797f4a94513e7dd215e32e94d/highspy-1.15.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a781dc8432568ea990fcdcc8d6e4365e67aa4848ca1f99275db096645b27cae3", size = 4878738, upload-time = "2026-07-02T12:02:03.82Z" }, + { url = "https://files.pythonhosted.org/packages/5e/e4/ae08124f71187628471a177e6db1ed2c1c45e9dceadc45f7111dfd7c2254/highspy-1.15.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9499d631edeb9642fc08dee59ca6c5815be1764c13a336c58ab7ba063011aa24", size = 4473938, upload-time = "2026-07-02T12:02:05.754Z" }, + { url = "https://files.pythonhosted.org/packages/ff/7f/185b8c9579a9e4ef88eda45d1fdaf8d23a3a640f73c403a7b29fc0f0c4be/highspy-1.15.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef048fa722cdeb80062d271b8ba211cd6650ab73419762d80da7642bbd4a8420", size = 4636755, upload-time = "2026-07-02T12:02:07.996Z" }, + { url = "https://files.pythonhosted.org/packages/82/6b/18bec60d8585df860b8d33d310e99e7893eaabe3c8e9ebfa7e387ba9d2a4/highspy-1.15.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9730647160a6481426729f46d9989a0507d05f3cf96f9fb180f4ab9891bea67b", size = 5034168, upload-time = "2026-07-02T12:02:09.89Z" }, + { url = "https://files.pythonhosted.org/packages/d4/51/e43f06e64e994ccb41a336ff78802c0dae63aed46c17acd52167b5ca3d76/highspy-1.15.1-cp312-cp312-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:6a6a2f21ee31a9205a928fbbc3f8c054893c1aec34f6a7c56588317e2800e673", size = 5861937, upload-time = "2026-07-02T12:02:11.801Z" }, + { url = "https://files.pythonhosted.org/packages/d4/2a/5501a23cac55926e4b0554352b4285734b417dbec385c593f2ae405ea637/highspy-1.15.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9a6760962b3e813814dc5e88301890d7cce975de5ce97cc3aed589cfdd461811", size = 6192004, upload-time = "2026-07-02T12:02:14.544Z" }, + { url = "https://files.pythonhosted.org/packages/94/08/fb7d30ea0e6c83fb943b16bf31951ba13a5be01a638ec13962a477009b91/highspy-1.15.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:787c92d5ff274256ba8848ab174cfc65d5af696f51bffe87423c85b2ea25c3fe", size = 7233098, upload-time = "2026-07-02T12:02:16.609Z" }, + { url = "https://files.pythonhosted.org/packages/23/77/9a07df7181834cfb61dafa5594e5eedc78369797c6487806bd3221d20667/highspy-1.15.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dd9ee8e139e7260ec1306a48e30f1bd7937d9cfb8cb201d25da10e1099e5129b", size = 6636717, upload-time = "2026-07-02T12:02:18.72Z" }, + { url = "https://files.pythonhosted.org/packages/9a/25/5083d8e3d5cf5ff5edf5bcc03e3f693630ab59142c9d0a0bcbb2d315c50e/highspy-1.15.1-cp312-cp312-win32.whl", hash = "sha256:01c6585e83938ecf4139248b074b2ee736816d63716a20dc608b1d2fc9637b66", size = 2306753, upload-time = "2026-07-02T12:02:20.837Z" }, + { url = "https://files.pythonhosted.org/packages/d4/01/05521ca6b38e34e68d707888c378d3bcac34e62715b739e7c0c9b9887993/highspy-1.15.1-cp312-cp312-win_amd64.whl", hash = "sha256:8c548165270608a40147a7ea6d985fd62a65fabf0f075b3c0c59ea910b724223", size = 2711114, upload-time = "2026-07-02T12:02:22.621Z" }, + { url = "https://files.pythonhosted.org/packages/3f/1e/283ea32eac82dd24fe86c439013d7c7666f4889de89f0957362ea5fa425e/highspy-1.15.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4db297486a7a42a18656d1cc0ea9e1596fe45b8f7f75669a0c55b9081531ee0a", size = 4878819, upload-time = "2026-07-02T12:02:24.668Z" }, + { url = "https://files.pythonhosted.org/packages/7f/1c/c6518fc7c2bd5c90d86bd7a8f3cf16c1ea0ace4335a80d45b8d3f96c0cba/highspy-1.15.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:818256db731339605a7b2c31cabfcbf820fe50402ff5e9b7aa8410ead06e8735", size = 4474016, upload-time = "2026-07-02T12:02:26.572Z" }, + { url = "https://files.pythonhosted.org/packages/2f/97/4b5e345affc107f1f315c55dd0b6f35f13be07092feccbdfe1d9bfe38e63/highspy-1.15.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:383cd3f28cce0753dec8e949719b10864e068c53a485624fcab4c6b585496dd7", size = 4636833, upload-time = "2026-07-02T12:02:28.467Z" }, + { url = "https://files.pythonhosted.org/packages/ca/6e/f00e914f2bd88e2b73a8b3ea1b47171a85cfa23d1a06dc373ca797f43208/highspy-1.15.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:238b2ee88b974b21c7e9ef198139502a7d87451939cae143dce789bbda121182", size = 5034140, upload-time = "2026-07-02T12:02:30.294Z" }, + { url = "https://files.pythonhosted.org/packages/61/03/8f821d39dc8ee06a35e0fa54c754ab592139640c1e839b587e60068ad822/highspy-1.15.1-cp313-cp313-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:b6dcc545235c0765b48fc736122b105e174d907622d20986ac653c5b2a04911f", size = 5862229, upload-time = "2026-07-02T12:02:32.065Z" }, + { url = "https://files.pythonhosted.org/packages/ea/55/708b7523ad80106b91fb66471ab8b1c178a8c8adc222c839cc14147542cd/highspy-1.15.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e1f8a21a0f48aedb129a5a60d4cad9ee0767de271cd7450de16192440671b38", size = 6191747, upload-time = "2026-07-02T12:02:34.034Z" }, + { url = "https://files.pythonhosted.org/packages/8d/cd/737f43e9c56163ebae501ab21fdbc37dd2dde3e02fd18e37d0062b9b9c7c/highspy-1.15.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:9ea683af80e4fb7c9d712b5df4bae34c63fa9e6afc78d750ba2d9f5e6f3203e0", size = 7233066, upload-time = "2026-07-02T12:02:36.109Z" }, + { url = "https://files.pythonhosted.org/packages/33/60/b9ae92e8454f42cb5c5ccca63862a75f5d43afead1f725f3b8af19f507f5/highspy-1.15.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:565cf6a6e7c84e36c101b118a3c5fd09bc14aeece599bba12625e79b5ab0cecb", size = 6636826, upload-time = "2026-07-02T12:02:37.863Z" }, + { url = "https://files.pythonhosted.org/packages/54/0b/35e5e63be2e70951c3224ed33c4300f1cd37fcfe4eb6d25e259e13571e0f/highspy-1.15.1-cp313-cp313-win32.whl", hash = "sha256:6cc7008b82094b2a2377338398b38f5b6c306397bd23282e55dec46a101a2dac", size = 2306720, upload-time = "2026-07-02T12:02:39.839Z" }, + { url = "https://files.pythonhosted.org/packages/ca/63/2e104bab0117415c68950f249e42f0974f74665d0313dfeddceb1f74c47d/highspy-1.15.1-cp313-cp313-win_amd64.whl", hash = "sha256:46fe314b918257361c54170852bc561c78d0f84d94e2ad263859d818127e6e76", size = 2711119, upload-time = "2026-07-02T12:02:41.861Z" }, + { url = "https://files.pythonhosted.org/packages/0c/73/8cd42c3ca7baf4857494a0294ef068f2216f1216173f3f298046820a7a57/highspy-1.15.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a7b11dc80781052a6e7c163b5c2696fe9e06c72927cfdb48f67f7e8c77096f4f", size = 4879694, upload-time = "2026-07-02T12:02:43.623Z" }, + { url = "https://files.pythonhosted.org/packages/fb/5b/308821aeefa0e85f90645e15a86bc63c156bf08b00e33a0a906a0c430b41/highspy-1.15.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9a00e1278ea46a426b1eaa0aea69df9d72ed1d75b18227cad992384ebbdc0c74", size = 4475059, upload-time = "2026-07-02T12:02:45.455Z" }, + { url = "https://files.pythonhosted.org/packages/a3/20/9c75531c03c7121d576ef0ff8415bfb255fdd060c435f9f26e5b103b0559/highspy-1.15.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:193b9751d3705bc948552b138800af0ad8af17a5b801d5940d7db7ff1ffc4f10", size = 4637880, upload-time = "2026-07-02T12:02:47.239Z" }, + { url = "https://files.pythonhosted.org/packages/89/ea/6d6136f01ce82c049740b00380a39999a15c689a9a4d43fdb1ea25090c2b/highspy-1.15.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6298b6ef691e83544d395d45fa4e856874c44b32936d85c36564f7697d27bb0b", size = 5034792, upload-time = "2026-07-02T12:02:49.044Z" }, + { url = "https://files.pythonhosted.org/packages/38/9d/ccf4a0d4e7a4fa4141dbabe9f78e94fa9d37b6b5becafe8a61e8369031eb/highspy-1.15.1-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:9d436b5f8d50b01497d494606695746147e15b8e22eec6ae475a60cb8b22c1d7", size = 5861891, upload-time = "2026-07-02T12:02:51.432Z" }, + { url = "https://files.pythonhosted.org/packages/19/b4/655f6ce06e17159c001456c97c4be84dcb1448477e3ea52bd5401f5c27c3/highspy-1.15.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bbb22b7ceed298c0b75237186eb4671915b1c41c07f966e527643af10493671e", size = 6195707, upload-time = "2026-07-02T12:02:53.446Z" }, + { url = "https://files.pythonhosted.org/packages/ea/93/a35495b3326cdc0c2ff59de69d26f2600f41399d9381b59f4826742c054e/highspy-1.15.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:74c1eb71d3c0fa0c190492d9c0c67266d1dd6b4244c93b53e95a687504db309d", size = 7235019, upload-time = "2026-07-02T12:02:55.989Z" }, + { url = "https://files.pythonhosted.org/packages/20/5e/8b21c908ee94db28f2de58326c8a25e361b3d504f145f7972f096028a908/highspy-1.15.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cb8b8298a74786e1cbc1a9e102b7749e2bbd9c41826ffd4a1d7ba738232646ff", size = 6637185, upload-time = "2026-07-02T12:02:58.165Z" }, + { url = "https://files.pythonhosted.org/packages/25/81/8f984e500536ca40a8fb1d74ecb7a213e170683adcfd01edee8e21e5735b/highspy-1.15.1-cp314-cp314-win32.whl", hash = "sha256:780c021441f548711818833d3a986fcb253849734aa00c3bf83d342c38b03629", size = 2362473, upload-time = "2026-07-02T12:03:00.147Z" }, + { url = "https://files.pythonhosted.org/packages/bf/97/e85d751aaba8231e86915077532fd584711d30aa9eb85c26331e2bd87596/highspy-1.15.1-cp314-cp314-win_amd64.whl", hash = "sha256:864258c59aeaea9d3bd7ccdd10c03258e2be764e2cf1e21f829fd1f8d8c15d57", size = 2813851, upload-time = "2026-07-02T12:03:01.836Z" }, +] + [[package]] name = "hpack" version = "4.2.0" @@ -3314,6 +3423,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b6/31/ee7747c1d66b064f95bc756b35119879b805f96da288df17aac516813c83/oil_reservoir_synthesizer-0.2.0-py3-none-any.whl", hash = "sha256:5cb9aeaeac121892e8291f987b151b544be7db5a28659c08cb723fc0bca33a62", size = 19654, upload-time = "2023-12-08T10:21:18.587Z" }, ] +[[package]] +name = "openpyxl" +version = "3.1.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "et-xmlfile" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050", size = 186464, upload-time = "2024-06-28T14:03:44.161Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2", size = 250910, upload-time = "2024-06-28T14:03:41.161Z" }, +] + [[package]] name = "opentelemetry-api" version = "1.44.0" @@ -3435,6 +3556,41 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/16/21/5a3f1e8913103b703a436a5664238e5b965ec392b555fe68943ea3691e6b/orjson-3.11.9-cp314-cp314-win_arm64.whl", hash = "sha256:eebdbdeef0094e4f5aefa20dcd4eb2368ab5e7a3b4edea27f1e7b2892e009cf9", size = 126687, upload-time = "2026-05-06T15:11:06.602Z" }, ] +[[package]] +name = "osqp" +version = "1.1.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jinja2" }, + { name = "joblib" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "setuptools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b0/7f/b441062e4766851fdf1d066857134c4c3bcf7e0089e4a1d007b6114cecd5/osqp-1.1.3.tar.gz", hash = "sha256:48f53ef5ec89e6ce99ffa955bc6ea0cf2eec09ea3d40905f0c9fadc939609907", size = 57816, upload-time = "2026-06-12T16:59:27.208Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d2/f21ddf1b41ecc14784186129125c4e9c19d8f6f7ade0f2e0efd4a44dded6/osqp-1.1.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2b59e8094fe29d928d568cad0156a42daa44257ce142fb7808400016a62dc28c", size = 328512, upload-time = "2026-06-12T16:58:49.796Z" }, + { url = "https://files.pythonhosted.org/packages/de/45/1f99a9f25dc9534323b8ef9e578dc93acb33e2b762d5be267e1380b2dda5/osqp-1.1.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e5620abbdb259190da6f0e5421b9fdfd9386b46690210ce82aea6102cc85c67f", size = 308891, upload-time = "2026-06-12T16:58:51.07Z" }, + { url = "https://files.pythonhosted.org/packages/d5/25/176dbb33c3c3605367c0de8720945c6bdd8f9b0d411e0a94ef747085f034/osqp-1.1.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e44ad08234cfbd6d9f2a823118547e683b038676887e096533935b9fcc15fd3c", size = 328135, upload-time = "2026-06-12T16:58:52.185Z" }, + { url = "https://files.pythonhosted.org/packages/77/89/96e2e4de3b89e7363931c70eb58bded22656f5512bde18eb7a9272ce48d8/osqp-1.1.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6ceef7fb4f332892b6e0bbc17323d5c9e028c3f9db726b62a15d876d0f81cc06", size = 354077, upload-time = "2026-06-12T16:58:53.379Z" }, + { url = "https://files.pythonhosted.org/packages/c4/4b/6a1e4f5aa28117bc0a78be5e9f4071b6a11c00a33a01bc673c3faf2a0a65/osqp-1.1.3-cp312-cp312-win_amd64.whl", hash = "sha256:e7e9bd3939e47e726673218a7b04b9784ecbf9ef0b8bc69107d20cc659836ac1", size = 316733, upload-time = "2026-06-12T16:58:54.397Z" }, + { url = "https://files.pythonhosted.org/packages/14/f8/9f74aa53b35cb9c552ff1348abe5a17d22b4e65b0dfbe987980874c8bd36/osqp-1.1.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ff6cf15a5404b28a4d9aaada72ae73c6b179120892321ec9b70f52ecb7f34261", size = 328538, upload-time = "2026-06-12T16:58:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/6d/4e/4a7197f508cfa62abf40f7eacc7efa2f6147e6d9f7bbb22b18e8e10d6736/osqp-1.1.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a9c46b4adf2b1f76a40ef8f72426be5aa014c94efca20ac5acf8afa52e352afa", size = 308914, upload-time = "2026-06-12T16:58:56.906Z" }, + { url = "https://files.pythonhosted.org/packages/e7/1d/e967f4f1e3709baf6500914abd212d863a54fc90e90cd61dbbb0af14d6a4/osqp-1.1.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bcca27693d0506c6816f989cf38e6352ed74ac8eaada9babc5487456d0cb0bf8", size = 328191, upload-time = "2026-06-12T16:58:58.211Z" }, + { url = "https://files.pythonhosted.org/packages/5f/dc/7c06a4ce4d1de3e5fbf294cf435ee351a39e44d534154647b2a1a18bc6a2/osqp-1.1.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2d3ee63e8c65ef89fce979c068d05bfc3ed92b1bbc4246fbacc663f86cbe02b2", size = 354138, upload-time = "2026-06-12T16:58:59.398Z" }, + { url = "https://files.pythonhosted.org/packages/05/22/2b4198a40847bff9b19230f3e55ac7537fe275a55a27eccebfdfee77fecb/osqp-1.1.3-cp313-cp313-win_amd64.whl", hash = "sha256:9b9fe3daa15313d281233babeb102007062933241a855f6b399becd03ec5f1e3", size = 316744, upload-time = "2026-06-12T16:59:00.702Z" }, + { url = "https://files.pythonhosted.org/packages/e3/54/bdb0611de308ddf9868d7bd75e61d62ca8a3bacca71260e1876a354ebd71/osqp-1.1.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f5eade025877e5d2fb61efdd91337cc6f259335b2783ca59bce10e7be61c1d12", size = 328883, upload-time = "2026-06-12T16:59:02.162Z" }, + { url = "https://files.pythonhosted.org/packages/84/7f/4bca14a7a0402e5dd865225f193074217f019273f7a91e2d0018853b1ad5/osqp-1.1.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e730047c4cba86ad97ca73c03ea4c3cca765b22fa79c3fbefff11b3cce317742", size = 309534, upload-time = "2026-06-12T16:59:03.427Z" }, + { url = "https://files.pythonhosted.org/packages/b6/0d/8e5ca2e9f4630f249602e91cb78b052b61744fac042f91b22a9e4d86088b/osqp-1.1.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1547e515c16feb1ab2889b64bcd4eecbbc59c40af4faf67258047a199780b98a", size = 328836, upload-time = "2026-06-12T16:59:04.833Z" }, + { url = "https://files.pythonhosted.org/packages/83/17/cb502af2a69da5f915d487db565b61e67684c65d3a4e5ae1ea42cece31f7/osqp-1.1.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bdcbe47c2c37bf7296971a40811a883e793923699394a73a9d677ab7a9093e8", size = 354268, upload-time = "2026-06-12T16:59:06.014Z" }, + { url = "https://files.pythonhosted.org/packages/56/09/56bb7302f545fafbdfd9f0ad1042424c51c7a89407569bf005cc012b8a0f/osqp-1.1.3-cp314-cp314-win_amd64.whl", hash = "sha256:e80447b95d7b7dec3d13cc9e5a67ef4c5eaac3affee60fd83d1ce461e9270816", size = 322177, upload-time = "2026-06-12T16:59:07.175Z" }, + { url = "https://files.pythonhosted.org/packages/93/11/b4edd9cf7f3ceac4785357203f98b7661ae489b2721f30d994a2870aaa09/osqp-1.1.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:97df452d5e3b000b075fcce1c9f628289411501a2c0ea9a94acea281ed57bbd3", size = 336601, upload-time = "2026-06-12T16:59:08.521Z" }, + { url = "https://files.pythonhosted.org/packages/51/0f/ebc13231f58eaf4a7f73d5c2116c05214a871f49e777d63ff2cc80ee2439/osqp-1.1.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3efaf5fa72b45bec9b67dcaf5ae58a4e2d1bd5d8053b249c0ecd5b8b60c1bc0e", size = 318836, upload-time = "2026-06-12T16:59:09.684Z" }, + { url = "https://files.pythonhosted.org/packages/22/0b/b74016cdd06cf37e4efb9d7540ce56e466d77a803ccd1ffc80a8b3e3d489/osqp-1.1.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1d6cf30cdccf07baecb7232dc5fe22a1421ea3278a88a40580df3563a419d64", size = 330294, upload-time = "2026-06-12T16:59:11.094Z" }, + { url = "https://files.pythonhosted.org/packages/e0/22/d9a756198d1e48931ddf6363df7162a5c13aecdca5af1f1489bebfa92a7d/osqp-1.1.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8ae5b09be77b987421216dae535b4c007a14f6c034a844ad6eb4244289a881d", size = 355773, upload-time = "2026-06-12T16:59:12.274Z" }, + { url = "https://files.pythonhosted.org/packages/07/fc/07ad9b479417934c7533e137be82ed0c0ef76663d6d67a1af5e068a44466/osqp-1.1.3-cp314-cp314t-win_amd64.whl", hash = "sha256:f5d66a344ff483eeb5a9213521b91427d2d898885d7e2db0712f648664482264", size = 337988, upload-time = "2026-06-12T16:59:13.366Z" }, +] + [[package]] name = "packaging" version = "26.2" @@ -3641,6 +3797,23 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fb/49/bc925106abcdac498074f2cbe6137e94e09f418dd2b7775df5b577dc0313/pre_commit-4.6.1-py2.py3-none-any.whl", hash = "sha256:0e3b2942510d1fb34eec167a3ec57331bf8442122f1153a9fb8b58f5c49b2717", size = 226186, upload-time = "2026-07-21T20:56:57.064Z" }, ] +[[package]] +name = "probabilit" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cvxpy" }, + { name = "networkx" }, + { name = "numpy" }, + { name = "pandas" }, + { name = "scipy" }, + { name = "seaborn" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/21/2fcad34174930358637b4a8311e5af459f1aba2f3698153595d8c3de01a4/probabilit-0.4.2.tar.gz", hash = "sha256:e3d4a0b5dd87a61f6dfc1836408fabbd3269a69366ce64238bed927523b57bff", size = 60611, upload-time = "2026-03-18T08:29:41.784Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/9c/bb72fd8d74e02b9850ed6e124b565e7be0bfdd2c9922e220a28c9e40f38a/probabilit-0.4.2-py3-none-any.whl", hash = "sha256:3e16f4e7a348da560c67804d7143e1d8d4395237f4d1201af26d86bae0d27170", size = 50023, upload-time = "2026-03-18T08:29:40.517Z" }, +] + [[package]] name = "progressbar2" version = "4.5.0" @@ -4397,6 +4570,48 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, ] +[[package]] +name = "qdldl" +version = "0.1.9.post1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/51/4e/452984a63df9421cf8e7d25e8e6a44832cf0247a5e7b65e437cd516a0f8f/qdldl-0.1.9.post1.tar.gz", hash = "sha256:da2016d541c26cefc79bca4d8b5bebfa00f35db19704abb20efbd1c08df3b4c7", size = 76295, upload-time = "2026-02-19T16:48:36.651Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/ed/2ae64314f84211cb963136168fb119e595d1aea42d1f03a1e84ef7d04d68/qdldl-0.1.9.post1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:25525962e90f1b9bfe3c4fb565222daf2bd77249bb6ffb9ae20b7da551f73538", size = 122478, upload-time = "2026-02-19T16:47:51.279Z" }, + { url = "https://files.pythonhosted.org/packages/15/45/767d8a6da3a04ee3c7262f897c1dd81e92d156c60eb5b43bcab4f2bc5af5/qdldl-0.1.9.post1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a2c005c9365dea6389a9feacf636028453790cace114b54e40fd302d6f4bf91c", size = 117691, upload-time = "2026-02-19T16:47:52.287Z" }, + { url = "https://files.pythonhosted.org/packages/1f/58/cb80bb5d379a7e570a160a198ff6bff2398d6c61b5514462736348218013/qdldl-0.1.9.post1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee5b35c1dd419cbf388664d26d410c89a3e0c7e055e25223b6d28bd920349c8a", size = 1449354, upload-time = "2026-02-19T16:47:53.163Z" }, + { url = "https://files.pythonhosted.org/packages/43/11/8d89f71d4e1cb3152e4e3262db667282e0df6788d21800725195ee2384c0/qdldl-0.1.9.post1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa0e9721d272467c95a9748e6acea8911a12041ef3d8b20176aff829388ce57d", size = 1476880, upload-time = "2026-02-19T16:47:54.391Z" }, + { url = "https://files.pythonhosted.org/packages/d4/19/b30374cd37f145c4ee086642eca46c1a0b29d16027e02417b825d3708602/qdldl-0.1.9.post1-cp312-cp312-win_amd64.whl", hash = "sha256:f5a9bcda38dd19f75d72e47558f5132a99e5443238e5153a984c6f552bc4f4ac", size = 104542, upload-time = "2026-02-19T16:47:55.558Z" }, + { url = "https://files.pythonhosted.org/packages/22/51/2a683eddd1f0cf50440e0d173ccc4cb500775a8449e27651963873cdb4df/qdldl-0.1.9.post1-cp312-cp312-win_arm64.whl", hash = "sha256:ba3e19399553821b5ceee0c082fdb4453d00a38bd420b76dddec92ce2a5a065c", size = 98901, upload-time = "2026-02-19T16:47:56.553Z" }, + { url = "https://files.pythonhosted.org/packages/42/f6/5ab7f37e7607396eb7a61736471b54be881fc5697bb18e57992fb14a0867/qdldl-0.1.9.post1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00331a5e45cc60bf6f75f027ae2a2c137295de0b5e1a0af358a37aaa07427476", size = 122503, upload-time = "2026-02-19T16:47:57.435Z" }, + { url = "https://files.pythonhosted.org/packages/e1/49/144ec3c6b7cfe650191dac35a21d93eebfcc043a3ecd8b499adb3b7cec1d/qdldl-0.1.9.post1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dbfb46f7290917146b076449fb3fee1eefdf018e710c7033c11739ae1723da07", size = 117760, upload-time = "2026-02-19T16:47:58.407Z" }, + { url = "https://files.pythonhosted.org/packages/82/a1/f8d58f100140d416f40912a7bf8bc28ab8276e7e8e6a24a8889a4e5c895a/qdldl-0.1.9.post1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e881f51dc779441c0910dc5a9d89bfd40a459daaf8088934aebf6f4c84adf1e0", size = 1448988, upload-time = "2026-02-19T16:47:59.377Z" }, + { url = "https://files.pythonhosted.org/packages/f3/7d/6d621819d3340f2cb4555e5263481be1e741578634d09569c67acc186ff0/qdldl-0.1.9.post1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bc0f30e521da345d25e4fa5308fda4964e25beacd10e8de9f08d084a600a42e2", size = 1476075, upload-time = "2026-02-19T16:48:00.583Z" }, + { url = "https://files.pythonhosted.org/packages/76/97/423a7cbe11add0b7b6afe97c9d6e934776c632a8c6e1d2a457c1f9dffbf6/qdldl-0.1.9.post1-cp313-cp313-win_amd64.whl", hash = "sha256:27b02a730c39b2dba205bb5c08dca5deb994f655f6eeacee687ac006c50b3366", size = 104586, upload-time = "2026-02-19T16:48:01.586Z" }, + { url = "https://files.pythonhosted.org/packages/ca/dc/425dfec0bd5a18ad43790764f091567fba18d63d9f9d6b202a796a8fd9ca/qdldl-0.1.9.post1-cp313-cp313-win_arm64.whl", hash = "sha256:98a13e234ea335484cf76441b95638d0f9ecdd43242dd5a073f77c758977d980", size = 98954, upload-time = "2026-02-19T16:48:02.486Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a4/bc38a8f2edd88adc3bd87a53493e3ddfcab1c173a0310dcfe7f56063d254/qdldl-0.1.9.post1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:576edaf8b847d087806e3d2a860a06d52a435aa3192b21bbc39e69a55187805d", size = 129346, upload-time = "2026-02-19T16:48:03.325Z" }, + { url = "https://files.pythonhosted.org/packages/21/3f/0b157bd706ee91838d22d57dd0bd3a7ea0837142fb97b5df3d8acfad9f6c/qdldl-0.1.9.post1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:547f73046ef615827317fbedb21b5e1b11f5082d304e8d775e9e17d6c447a598", size = 124236, upload-time = "2026-02-19T16:48:04.313Z" }, + { url = "https://files.pythonhosted.org/packages/30/ab/185e0620e424fab6eeafd3e37f37723e72c80a795419556575d47b27d4c5/qdldl-0.1.9.post1-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0cb2e82b4f40cb18638da47adf491a016d76d0d82f25377c4c330453a8785f94", size = 1494339, upload-time = "2026-02-19T16:48:05.364Z" }, + { url = "https://files.pythonhosted.org/packages/1a/55/0982ba5565863e3fa4306891158cb509088a875e76a5eeb683744d8a1610/qdldl-0.1.9.post1-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1ddd5b43b760ffb4cc85ca1acfb0eb139bff78bcc7bd30cad4c55564074685d4", size = 1517878, upload-time = "2026-02-19T16:48:06.517Z" }, + { url = "https://files.pythonhosted.org/packages/79/bf/b75b0fee2ea07e0dd2c8824356cd78200ac429172fa24f12a2cf84f95bd8/qdldl-0.1.9.post1-cp313-cp313t-win_amd64.whl", hash = "sha256:0fba64949c3197c6691c8fe4c3fbcb4f95d6e85b314824ba75981efcdf06d98c", size = 113642, upload-time = "2026-02-19T16:48:07.858Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/cc4bfa56f8d29a5ed7956c97ede9dfc4ec408f61e4b75ecd9e19232a64a8/qdldl-0.1.9.post1-cp313-cp313t-win_arm64.whl", hash = "sha256:31296314679c6ccfad8760704dbc9e25b5e49fd442f803638a2aaa1886724f7d", size = 104321, upload-time = "2026-02-19T16:48:08.79Z" }, + { url = "https://files.pythonhosted.org/packages/08/28/9b991fdcc16569b1bc7119ae1f62495c948033d791d469c031058d7b2c4c/qdldl-0.1.9.post1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:0d69a8d011f47f287c5e7668b92b9e3574798b9687bc751af6f89c15037aa26e", size = 122733, upload-time = "2026-02-19T16:48:09.694Z" }, + { url = "https://files.pythonhosted.org/packages/18/92/56437eb5a31edb9275450dac94a94f7df252147527974ef50ba56cbb8d66/qdldl-0.1.9.post1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:496bebf154c002fb7a36443b9a26cc0f7251e8e9251d3742590300cd2edec7a8", size = 117977, upload-time = "2026-02-19T16:48:10.606Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7e/9594e0cea5aaf33c2579f722ad02e5117ede62e99aca62245f2c2d3df0d5/qdldl-0.1.9.post1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1922c11ddb59419ab969cd1a069e85da9e37db9b14d92b0900e73be94d25c318", size = 1448404, upload-time = "2026-02-19T16:48:11.497Z" }, + { url = "https://files.pythonhosted.org/packages/bf/85/c5e380aeaa3f5d61cbf21b815b3caac5909a165c747aadd5675500fa92dc/qdldl-0.1.9.post1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e8c0148de01346722ef07ce9434485b97b8f3aa7042cac5c341b58a728fe7588", size = 1474644, upload-time = "2026-02-19T16:48:12.831Z" }, + { url = "https://files.pythonhosted.org/packages/b6/a7/a3b62d9ec100604778d0596910f4bd20eaf23445af20bdd1d3cac77b6632/qdldl-0.1.9.post1-cp314-cp314-win_amd64.whl", hash = "sha256:9adb8625012e96ceb6c24a8278b8aa9477727ae8fde35dee730988747ab95144", size = 107693, upload-time = "2026-02-19T16:48:14.231Z" }, + { url = "https://files.pythonhosted.org/packages/30/ec/55b21669cad250f55fee6a8ae0fe65dfb547baeb3463f576e8642795e392/qdldl-0.1.9.post1-cp314-cp314-win_arm64.whl", hash = "sha256:0db9f197fb51c6fa96ff1964707e2ba9a89b7b0d91c305e6e0b668e1bcb66fbf", size = 102546, upload-time = "2026-02-19T16:48:15.226Z" }, + { url = "https://files.pythonhosted.org/packages/43/e8/09c59c9f4a1df9b2b415cbc13eb0daadab418e252c698f622d94e4dcb026/qdldl-0.1.9.post1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:25da2bcd44dd272435db3b4208b47943837503f43db4d24c02e5e15b7d5ddf33", size = 129500, upload-time = "2026-02-19T16:48:16.221Z" }, + { url = "https://files.pythonhosted.org/packages/86/03/dcf73d806a4c3f0250a56cc56dafadc2dfacccf5df9caf8f7f181a5e3a89/qdldl-0.1.9.post1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e3438e9cb3f8a26531a24f25bb05152a7446112f4c8ff62d537debfb8147435c", size = 124224, upload-time = "2026-02-19T16:48:17.17Z" }, + { url = "https://files.pythonhosted.org/packages/5b/2e/7770f0ad70c6cc834041c2c19262c3315d312d0d3e72ac33ecb7c94f2f9a/qdldl-0.1.9.post1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9a2aed01dbdc705bcab71270ce20753a016bd7b112ea7e06d1166d897e7483cb", size = 1485196, upload-time = "2026-02-19T16:48:18.415Z" }, + { url = "https://files.pythonhosted.org/packages/0b/6d/f1919ae97e1482484239edcda8b4f29aaba11817c808c775403e8a35aa54/qdldl-0.1.9.post1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd08bbb431f138c2946a0d99cb70fbfe67435c8b3dc1dbf23e4e80edfd2b1456", size = 1509644, upload-time = "2026-02-19T16:48:20.273Z" }, + { url = "https://files.pythonhosted.org/packages/7a/33/89ca4741cb651385a12600c0e93d24ad20eef5a954bb2b7ddc596442fc8c/qdldl-0.1.9.post1-cp314-cp314t-win_amd64.whl", hash = "sha256:213f6125564f61d9597d5d36c5556d4c898225bc31a99f8c87fd549b2e65b60a", size = 117569, upload-time = "2026-02-19T16:48:21.459Z" }, + { url = "https://files.pythonhosted.org/packages/63/48/34fa827457aa0e373fb50dab4490757350076f9afcf7eb749a71926023af/qdldl-0.1.9.post1-cp314-cp314t-win_arm64.whl", hash = "sha256:fcc2184cac1e502ed624efe7f00c1c215b95cfd324a8cacf7f0053c00fa524f5", size = 107844, upload-time = "2026-02-19T16:48:22.899Z" }, +] + [[package]] name = "referencing" version = "0.37.0" @@ -4839,6 +5054,38 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d5/19/969dc072906c84dd0a3b05dcf57ea750936087d7873549e408b35cfc3f97/scipy-1.18.0-cp314-cp314t-win_arm64.whl", hash = "sha256:368e0a705903c466aa5f08eefb39e6b1b6b2d659e7352a31fd9e2438365be0f8", size = 25279661, upload-time = "2026-06-19T15:01:40.817Z" }, ] +[[package]] +name = "scs" +version = "3.2.11" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/59/5cb7f9612a5a3ff6efd4ab2d899902a536cc5974a7edb589084c5577291c/scs-3.2.11.tar.gz", hash = "sha256:2a5455cf2093d07f84f2f848c199faed52e79cdb3a11fe250b5622b6bbac4913", size = 1691825, upload-time = "2026-01-09T17:53:54.074Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/80/74/87a97e5fc2aac7ab3661c2555a25115121734c51eb4ebbabc2127f53bd83/scs-3.2.11-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ad646848375b5cf2d3e45a9ebefd87ccc37a53da9c32f2bf30ea5ad0e84d9e5b", size = 96302, upload-time = "2026-01-09T17:53:01.95Z" }, + { url = "https://files.pythonhosted.org/packages/24/0c/e34764a320249465dc6c11e67a6d34e2e53a9186a64f21759e94dfb043ee/scs-3.2.11-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f30821521a74f6930924b13e731e9455b6bdcfc964f66d5623d3c8d3fdd98126", size = 5071418, upload-time = "2026-01-09T17:53:03.59Z" }, + { url = "https://files.pythonhosted.org/packages/db/3d/dd17a1c1890ce25efd3908f7ab67a56b208e89c5a5d60a2dedaf99394dcb/scs-3.2.11-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a89c71ebacd4790c461d3032a47e59ed4759e11c0f03fa79b5b84086ef9c7bc", size = 12079957, upload-time = "2026-01-09T17:53:05.439Z" }, + { url = "https://files.pythonhosted.org/packages/38/63/6f83bfa17e074c92b17e16a9bd897aedeec64f10f9200c86588d7fc583c2/scs-3.2.11-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4e37dc60081dd742bdcd63eeb5b260db116b3803162bcf6084eb203ebedcb080", size = 11973936, upload-time = "2026-01-09T17:53:07.926Z" }, + { url = "https://files.pythonhosted.org/packages/1a/fe/5d8f6048a90abc3aa053b5ac2acf3885dc46af94c3baf7d9ccf201a1ce19/scs-3.2.11-cp312-cp312-win_amd64.whl", hash = "sha256:2504266ff8e6a226f7ecb987567c93e6e996534cbf479a60a5a886549446205e", size = 7478461, upload-time = "2026-01-09T17:53:11.899Z" }, + { url = "https://files.pythonhosted.org/packages/90/1b/6611b98b114621444078da50be9e83c43fadc4079ef0df867091b5c9ee38/scs-3.2.11-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a42696b0a26c3e749b8da8d2ffc57a93af4f0f500fc3a83acb50daad92386de4", size = 96309, upload-time = "2026-01-09T17:53:13.589Z" }, + { url = "https://files.pythonhosted.org/packages/52/16/e49eff778292000bc7dca204952e430bc138c21e7eb1c4348341f3bd2ef5/scs-3.2.11-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50d204ae417c014a1756be36e8c0b857ed39c7b64e2c63b6afb1ff64c0a465d0", size = 5071425, upload-time = "2026-01-09T17:53:14.966Z" }, + { url = "https://files.pythonhosted.org/packages/7f/f4/b7b2df5bece1b7e5f11d2bf21744c9fa346f3cea0a849cb54dabb9b83055/scs-3.2.11-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:594c09207395de922e0ff40ced562453e46f4f197dd0128022cb82c096f06615", size = 12079963, upload-time = "2026-01-09T17:53:16.976Z" }, + { url = "https://files.pythonhosted.org/packages/d6/78/11db8c58c071ece82aaefe53c7f6d5932fe8dafe381b2f6fd35fcc22cf33/scs-3.2.11-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fd672701ed81744e8c300df71d823700b05e7fe3d6a26f8b19b74b0a31fe3c8a", size = 11973938, upload-time = "2026-01-09T17:53:19.239Z" }, + { url = "https://files.pythonhosted.org/packages/8a/ca/cd9cc63fc22f452188b9cda41a8d65d4124e733bc54f34f706b9c5939f92/scs-3.2.11-cp313-cp313-win_amd64.whl", hash = "sha256:2f4ebc0be14783ce3fcda61c616a7e922ac528af033e44a0da952dda0fe98091", size = 7478466, upload-time = "2026-01-09T17:53:21.494Z" }, + { url = "https://files.pythonhosted.org/packages/94/8a/52facc80a6515edd6560d918a68a0dd9186299a709e64c180ad24551aeb8/scs-3.2.11-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fe43181c3822bed600363c25c7566a643b319e0edb0c2af385c5f086a9c826d2", size = 96344, upload-time = "2026-01-09T17:53:22.949Z" }, + { url = "https://files.pythonhosted.org/packages/91/2b/c125e6b01aa6936f604e1b46a4b8c37e126af703cc228af7e9d0fe012bcb/scs-3.2.11-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b3c59ce43585d3ea0c6771c5ce3df272b6c8239231acbb9567876be5d0a0474d", size = 5071403, upload-time = "2026-01-09T17:53:24.327Z" }, + { url = "https://files.pythonhosted.org/packages/58/ae/94055cafac0d9b81ffa2a12f7050c394c39182ec901faff42a471cca50cc/scs-3.2.11-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3c46f597892c9f8c5551bb9a3a680dfb86e86a1a6c3bc67b09a5af2e89ba5357", size = 12079963, upload-time = "2026-01-09T17:53:26.2Z" }, + { url = "https://files.pythonhosted.org/packages/d8/72/43ff8bc4a281e84d4ae8f13dcf7436ff030bc5f67fba02368c829537386d/scs-3.2.11-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:513131af6991fb4983f84c4ba276c756c0a3574003c2790dda891c68d5b6da30", size = 11973979, upload-time = "2026-01-09T17:53:29.979Z" }, + { url = "https://files.pythonhosted.org/packages/af/55/695c509c0852bc32695b1995ff12227dfc78e9d91867ccf637d7cf85a948/scs-3.2.11-cp314-cp314-win_amd64.whl", hash = "sha256:7b2c37e87baca0389f005fe19a0ca8209d43c0f1e9136a1a6fde23cae1735db9", size = 7569717, upload-time = "2026-01-09T17:53:32.938Z" }, + { url = "https://files.pythonhosted.org/packages/4e/a1/b30e470a7440c57ed53a1d92a9e58f17ecf548888b4eea658be047500ae5/scs-3.2.11-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:29c0a5c233fb5a964ea5f7523ec2b2209f000217c0a24423ab5dcd8b8922f37d", size = 97042, upload-time = "2026-01-09T17:53:35.676Z" }, + { url = "https://files.pythonhosted.org/packages/14/31/86b6aa0fca4be4701b59bcfcf29007b16dea118051a5b46a43396f2a4543/scs-3.2.11-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7519c2f436e793b004d1eae4aaf98c18857e519f8169219d1167fe88b3b0a568", size = 5072473, upload-time = "2026-01-09T17:53:37.021Z" }, + { url = "https://files.pythonhosted.org/packages/98/eb/2c07015938c50f46e9323e379e9799c3e28e0d07c9bae8b6735a6ecf1b6c/scs-3.2.11-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2c166768dc87c389b2d000b5dcd472bb0ba40f96b4cf0e63c0fb603a4a5c80db", size = 12080259, upload-time = "2026-01-09T17:53:38.897Z" }, + { url = "https://files.pythonhosted.org/packages/f2/1b/d52e3b17554791726ba788abff053f4b27df157a49438f01134fec3c859d/scs-3.2.11-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f51a14a5315974fae4ca4e1b4dc8926f872eca7e66b42e070dbdcfa6904b7860", size = 11974311, upload-time = "2026-01-09T17:53:41.003Z" }, + { url = "https://files.pythonhosted.org/packages/cb/d7/023ba290cfaf97b21c710b675b8a860b97d8226f62e35d7a08e37ddbb6d3/scs-3.2.11-cp314-cp314t-win_amd64.whl", hash = "sha256:7fe26e8a0efc96232f4c5b7649817e48dae04a61be911417e925071091b8cbf6", size = 7570221, upload-time = "2026-01-09T17:53:42.845Z" }, +] + [[package]] name = "seaborn" version = "0.13.2" @@ -4900,6 +5147,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl", hash = "sha256:0da2f112e6d6bb22de6aa6daa7e144831a4febf2a87261451c4ad849fe9a873c", size = 17610, upload-time = "2026-01-14T06:27:35.218Z" }, ] +[[package]] +name = "setuptools" +version = "83.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", hash = "sha256:025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef", size = 1154254, upload-time = "2026-07-04T15:31:22.699Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", hash = "sha256:29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3", size = 1008090, upload-time = "2026-07-04T15:31:20.885Z" }, +] + [[package]] name = "shapely" version = "2.1.2" @@ -4987,6 +5243,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0f/2c/437fe806897c2d6cfdc3ee43a18da8bf8e568530a4ae9bac781541ca9896/soupsieve-2.9.1-py3-none-any.whl", hash = "sha256:4f4477399246b7a0c720a88ca2454b11cd6bb9ae4c9d170140786e916776c14c", size = 37404, upload-time = "2026-07-21T16:57:16.421Z" }, ] +[[package]] +name = "sparsediffpy" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/e7/6a3227a25a79a440e5ec5eff1e90f5911515a7c219ee95fc6dfe5d74ec30/sparsediffpy-0.3.0.tar.gz", hash = "sha256:fdd9115db63ee228d09e1917365b263a16811645c6d32ee7dce50ada09b3d5a5", size = 180927, upload-time = "2026-05-14T06:57:48.196Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/82/c2eb05d191fdeaee1f03d7ed5bc7f796256fd975eceb344a2a23fe6225e2/sparsediffpy-0.3.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:22848d97852554c8814cd5a0bffc4f4f41930aa7155f2193e99332e8a9cf6f6d", size = 207399, upload-time = "2026-05-14T06:57:18.379Z" }, + { url = "https://files.pythonhosted.org/packages/12/8a/31b924d6756469af09e44ac93507e6cf9b80c3de3cae63e7185a89f0605f/sparsediffpy-0.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cc49c774a44776afd728aca4ee1f062756416ee25366acbf32ad6416bdfb2630", size = 138478, upload-time = "2026-05-14T06:57:20.077Z" }, + { url = "https://files.pythonhosted.org/packages/23/4b/46834436ee28b2aa1404ac0b9fa2a3fcef4ee249d5fa624b0b16c50bee42/sparsediffpy-0.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:31560dc28732401d922cb910d997adabed72f26338dbf03409e1a3c6639d1908", size = 5091184, upload-time = "2026-05-14T06:57:21.78Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b7/e23622b87b93bdcca8ac3bd0ffe825a670ab7710ccafda7f4ca0d7d0af1b/sparsediffpy-0.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:614ba5d5fbdd64c3f53fa9b6dbd37d6794c55176093eba4b58f3618cf20d62bf", size = 12099967, upload-time = "2026-05-14T06:57:24.009Z" }, + { url = "https://files.pythonhosted.org/packages/a6/a7/487fcf2157472235411e30795f1b8270e311db73e1bb58b3fe73d70c19d3/sparsediffpy-0.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:695be68fedc2c1b6fc258d05e37e20b4081c38e020ec5c9d862e42266d1ece84", size = 130146, upload-time = "2026-05-14T06:57:26.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/e0/c9bc5b18b025567b02df87198d434c286777f491bc3c0b38949861e2e039/sparsediffpy-0.3.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aae700842a43bfdf09c7709c23354999d8e34da7f82dbc78d933a008fd63c285", size = 207404, upload-time = "2026-05-14T06:57:28.183Z" }, + { url = "https://files.pythonhosted.org/packages/11/ca/021de6a523e739a038f6e527bf71acab6ccb5181ddd5beff304f349e968e/sparsediffpy-0.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:afcc042d56af4e978e9a798c8c41a7432d9ff715d993cc2ac733565d72080a5e", size = 138483, upload-time = "2026-05-14T06:57:29.899Z" }, + { url = "https://files.pythonhosted.org/packages/76/64/e5ffb808435040177345cbaeed5623ebb49bc5567665e2001373197d6239/sparsediffpy-0.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6bc0720d58f4858ed28b1a760a96bc328d4a9591da5abf2c2c46955bcd2d6f59", size = 5091193, upload-time = "2026-05-14T06:57:32.066Z" }, + { url = "https://files.pythonhosted.org/packages/8f/17/670c5fd1f0b4da16e4b691d48963b195092d7bcf3d9afb92722a6a878f42/sparsediffpy-0.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:73df847a5ae8fbb14b4af9b8eb8e0c2e96f2c8479da2eff8afd89adc55752c5d", size = 12099975, upload-time = "2026-05-14T06:57:34.696Z" }, + { url = "https://files.pythonhosted.org/packages/6e/1c/8c2a4f03e10b418dc957db87287a777cda74b58cf39779cecefccd5f4b2d/sparsediffpy-0.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:b018a3e9783ae547a83a82049f26d72a6f0a5dfb61f42eb88ed921412f8aa087", size = 130147, upload-time = "2026-05-14T06:57:36.83Z" }, + { url = "https://files.pythonhosted.org/packages/80/f0/0b8b505563699767fa125a453cd40004476084c3e7a1975e7dfca957ca3a/sparsediffpy-0.3.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:b62d0531c6470d6cea800ff60952857d16b7a3e177369c729a8e5f31dba9a4ea", size = 207430, upload-time = "2026-05-14T06:57:38.273Z" }, + { url = "https://files.pythonhosted.org/packages/56/8c/9be63f71098b8c3ffe82ab4094195ea95a33822787fa67b97e8eb5e13b77/sparsediffpy-0.3.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:5140ee4bb70c877d01ad1e07cee76a375c684af8e3672bf37c1de424e6f8b3b7", size = 138542, upload-time = "2026-05-14T06:57:40.124Z" }, + { url = "https://files.pythonhosted.org/packages/77/01/e2f5cc15d0fd7244c26632a4ee746e94d2721e5e44f49c2a3988b3e23d87/sparsediffpy-0.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a746cc822c2bce50dd696ef7a7c59f4e795f2c4c0a24750146b7c106809e12a", size = 5091213, upload-time = "2026-05-14T06:57:41.842Z" }, + { url = "https://files.pythonhosted.org/packages/48/03/6656660e7f0564c99405173848c65d92408af0372bbd30b8a6728d9bcee2/sparsediffpy-0.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6a28052dc02a9424b84406a0ac8c573f19471ccbf3f0ee4331588549e4de5dbe", size = 12099943, upload-time = "2026-05-14T06:57:44.524Z" }, + { url = "https://files.pythonhosted.org/packages/20/ce/57472c85900e2937b921ccc1aa492e9449a1babf8b4c6a228f892f5d3b7f/sparsediffpy-0.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:2c13dd751963611419273d7cf99c9f7e0c7793c7edba2941a57847cc62f3aa18", size = 132153, upload-time = "2026-05-14T06:57:46.598Z" }, +] + [[package]] name = "sphinx" version = "9.1.0" From f20c141ac1465213a4258d3670487e30881ab8d5 Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Thu, 6 Aug 2026 11:42:07 +0200 Subject: [PATCH 05/14] Add fmudesign cli entrypoint This is a temporary addition, to see that the test suite works. This will be removed later, as it should not be a cli tool. --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index d7007b1b5ce..624c112ee38 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -85,6 +85,7 @@ dependencies = [ [project.scripts] ert = "ert.__main__:main" +fmudesign = "ert.config.fmudesign.fmudesignrunner:main" "fm_dispatch.py" = "_ert.forward_model_runner.fm_dispatch:main" everest = "everest.bin.main:start_everest" everserver = "everest.detached.everserver:main" From 165a212ae26da070cb2120a443dc738560178910 Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Thu, 6 Aug 2026 12:03:38 +0200 Subject: [PATCH 06/14] Fix broken test --- tests/ert/unit_tests/config/fmudesign/test_designmatrix.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py b/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py index baf4ce3cd0f..1c239d3424d 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py +++ b/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py @@ -21,7 +21,7 @@ def matches(pattern: str, text: str) -> bool: True >>> matches("my is !", "my name is John!") True - matches("my is !", "my name are John!") + >>> matches("my is !", "my name are John!") False """ regex_pattern = re.escape(pattern) From a06746a8a8c914b68f03d4a089f1e616a777645b Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Thu, 6 Aug 2026 12:04:01 +0200 Subject: [PATCH 07/14] Replace tmpdir with use_tmpdir fixture Some tests were cluttering the test directory with files. --- .../config/fmudesign/test_create_design.py | 104 +++++++++--------- .../config/fmudesign/test_designmatrix.py | 4 +- .../config/fmudesign/test_excel_to_dict.py | 3 +- .../config/fmudesign/test_use_cases.py | 16 +-- 4 files changed, 57 insertions(+), 70 deletions(-) diff --git a/tests/ert/unit_tests/config/fmudesign/test_create_design.py b/tests/ert/unit_tests/config/fmudesign/test_create_design.py index 20b14fe0060..cf9d65c7727 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_create_design.py +++ b/tests/ert/unit_tests/config/fmudesign/test_create_design.py @@ -20,7 +20,7 @@ @pytest.mark.parametrize("correlations", [True, False]) -def test_distribution_statistis(tmpdir, monkeypatch, correlations): +def test_distribution_statistis(use_tmpdir, monkeypatch, correlations): """This test ensures that if any large-sample statistics for any distribution changes, we will likely pick it up in the future. """ @@ -207,7 +207,7 @@ def gl(paramname, distname, p1, p2, p3="", p4=""): assert np.sqrt(np.mean((obs_corr - corr_values) ** 2)) < 0.02 -def test_generate_onebyone(tmpdir): +def test_generate_onebyone(use_tmpdir): """Test generation of onebyone design""" inputfile = TESTDATA / "config/design_input_example1.xlsx" @@ -225,7 +225,6 @@ def test_generate_onebyone(tmpdir): assert design.designvalues.shape == (rows_in_design_matrix, 10) # Write to disk and check some validity - tmpdir.chdir() design.to_xlsx("designmatrix.xlsx") assert Path("designmatrix.xlsx").exists diskdesign = pd.read_excel("designmatrix.xlsx", engine="openpyxl") @@ -411,7 +410,7 @@ def test_generate_full_mc_snapshot(snapshot): snapshot.assert_match(snapshot_str, "design_output_mc_with_correls.json") -def test_generate_full_mc(tmpdir): +def test_generate_full_mc(use_tmpdir): """Test generation of full monte carlo""" inputfile = TESTDATA / "config/design_input_mc_with_correls.xlsx" input_dict = excel_to_dict(inputfile) @@ -423,7 +422,6 @@ def test_generate_full_mc(tmpdir): assert design.designvalues.shape == (500, 16) # Write to disk and check some validity - tmpdir.chdir() design.to_xlsx("designmatrix.xlsx") assert Path("designmatrix.xlsx").exists diskdesign = pd.read_excel( @@ -487,70 +485,68 @@ def test_generate_full_mc(tmpdir): assert math.isclose(date_fractions.loc["2018-11-04"], 0.3) -def test_generate_background(tmpdir): +def test_generate_background(use_tmpdir): inputfile = TESTDATA / "config/design_input_background.xlsx" input_dict = excel_to_dict(inputfile) source_file = TESTDATA / "config/doe1.xlsx" - dest_file = tmpdir.join("doe1.xlsx") + dest_file = "doe1.xlsx" shutil.copy2(source_file, dest_file) - with tmpdir.as_cwd(): - design = DesignMatrix() - design.generate(input_dict) + design = DesignMatrix() + design.generate(input_dict) - # Check that background parameters have same values in different sensitivities. - background_params = ["PARAM17", "PARAM18", "PARAM19"] + # Check that background parameters have same values in different sensitivities. + background_params = ["PARAM17", "PARAM18", "PARAM19"] - background_vals = design.designvalues.loc[ - design.designvalues["SENSNAME"] == "background", background_params - ] - velmodel_vals = design.designvalues.loc[ - design.designvalues["SENSNAME"] == "velmodel", background_params - ] + background_vals = design.designvalues.loc[ + design.designvalues["SENSNAME"] == "background", background_params + ] + velmodel_vals = design.designvalues.loc[ + design.designvalues["SENSNAME"] == "velmodel", background_params + ] - assert (background_vals.to_numpy() == velmodel_vals.to_numpy()).all() + assert (background_vals.to_numpy() == velmodel_vals.to_numpy()).all() - faults_vals = design.designvalues.loc[ - design.designvalues["SENSNAME"] == "faults", background_params - ] - contacts_vals = design.designvalues.loc[ - design.designvalues["SENSNAME"] == "contacts", background_params - ] + faults_vals = design.designvalues.loc[ + design.designvalues["SENSNAME"] == "faults", background_params + ] + contacts_vals = design.designvalues.loc[ + design.designvalues["SENSNAME"] == "contacts", background_params + ] - assert (faults_vals.to_numpy() == contacts_vals.to_numpy()).all() + assert (faults_vals.to_numpy() == contacts_vals.to_numpy()).all() - sens6 = design.designvalues[design.designvalues["SENSNAME"] == "sens6"] - # PARAM5 ~ TruncatedNormal(3, 1, 1, 5) - # PARAM6 ~ Uniform(0, 1) - assert np.isclose( - stats.spearmanr(sens6["PARAM5"], sens6["PARAM6"])[0], - 0.8, - atol=0.1, - ) - sens7 = design.designvalues[design.designvalues["SENSNAME"] == "sens7"] - - # PARAM9 and PARAM10 have a target correlation of 0.9 in the design config. - # The input correlation matrix is not positive semi-definite and is - # transformed to the closest positive semi-definite correlation matrix. - # The new correlation coefficient is 0.8. - # Using wide tolerance because the non-linear transformation between normal - # and target distributions can alter correlation strength. - assert np.isclose( - stats.spearmanr(sens7["PARAM9"], sens7["PARAM10"])[0], - 0.8, - atol=0.2, - ) + sens6 = design.designvalues[design.designvalues["SENSNAME"] == "sens6"] + # PARAM5 ~ TruncatedNormal(3, 1, 1, 5) + # PARAM6 ~ Uniform(0, 1) + assert np.isclose( + stats.spearmanr(sens6["PARAM5"], sens6["PARAM6"])[0], + 0.8, + atol=0.1, + ) + sens7 = design.designvalues[design.designvalues["SENSNAME"] == "sens7"] - assert np.isclose( - stats.spearmanr(sens7["PARAM10"], sens7["PARAM11"])[0], - 0.8, - atol=0.20, - ) + # PARAM9 and PARAM10 have a target correlation of 0.9 in the design config. + # The input correlation matrix is not positive semi-definite and is + # transformed to the closest positive semi-definite correlation matrix. + # The new correlation coefficient is 0.8. + # Using wide tolerance because the non-linear transformation between normal + # and target distributions can alter correlation strength. + assert np.isclose( + stats.spearmanr(sens7["PARAM9"], sens7["PARAM10"])[0], + 0.8, + atol=0.2, + ) + + assert np.isclose( + stats.spearmanr(sens7["PARAM10"], sens7["PARAM11"])[0], + 0.8, + atol=0.20, + ) -def test_read_defaultvalues_duplicate_error(tmpdir, monkeypatch): +def test_read_defaultvalues_duplicate_error(use_tmpdir, monkeypatch): """Test that read_defaultvalues raises ValueError for duplicate parameter names.""" - monkeypatch.chdir(tmpdir) # Create a simple Excel file with duplicate parameter names in defaultvalues defaultvalues = pd.DataFrame( diff --git a/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py b/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py index 1c239d3424d..290976a100b 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py +++ b/tests/ert/unit_tests/config/fmudesign/test_designmatrix.py @@ -72,7 +72,7 @@ def test_designmatrix(): assert isinstance(design.defaultvalues, dict) -def test_endpoint(tmpdir, monkeypatch): +def test_endpoint(use_tmpdir, monkeypatch): """Test the installed endpoint Will write generated design matrices to the pytest tmpdir directory, @@ -87,8 +87,6 @@ def test_endpoint(tmpdir, monkeypatch): .to_dict()["background"] ) - tmpdir.chdir() - monkeypatch.chdir(tmpdir) # Copy over input files: shutil.copy(str(designfile), ".") shutil.copy(Path(designfile).parent / dependency, ".") diff --git a/tests/ert/unit_tests/config/fmudesign/test_excel_to_dict.py b/tests/ert/unit_tests/config/fmudesign/test_excel_to_dict.py index 3c0e2d227a0..9b7138b6df7 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_excel_to_dict.py +++ b/tests/ert/unit_tests/config/fmudesign/test_excel_to_dict.py @@ -229,9 +229,8 @@ def test_background_sheet(tmpdir, monkeypatch): assert dict_design["defaultvalues"]["extraseed"] == 0 -def test_assert_no_merged_cells(tmpdir, monkeypatch): +def test_assert_no_merged_cells(use_tmpdir, monkeypatch): """Test that assert_no_merged_cells detects merged cells""" - monkeypatch.chdir(tmpdir) # Create Excel file with merged cells test_data = pd.DataFrame({"A": [1, 2], "B": [3, 4]}) diff --git a/tests/ert/unit_tests/config/fmudesign/test_use_cases.py b/tests/ert/unit_tests/config/fmudesign/test_use_cases.py index 54bf82926da..c02345b4758 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_use_cases.py +++ b/tests/ert/unit_tests/config/fmudesign/test_use_cases.py @@ -17,7 +17,7 @@ TEST_FILES = list((TESTDATA / "config").glob("design_input*.xlsx")) -def test_prediction_rejection_sampled_ensemble(tmpdir, monkeypatch): +def test_prediction_rejection_sampled_ensemble(use_tmpdir, monkeypatch): """Test making a design matrix for prediction realizations based on an ensemble made with manual history matching (rejection sampling). @@ -26,7 +26,6 @@ def test_prediction_rejection_sampled_ensemble(tmpdir, monkeypatch): Eclipse run on disk which contains the history, identified by the realization index ("HMREAL") in the history match run. """ - monkeypatch.chdir(tmpdir) general_input = pd.DataFrame( data=[ ["designtype", "onebyone"], @@ -107,9 +106,8 @@ def test_prediction_rejection_sampled_ensemble(tmpdir, monkeypatch): @pytest.mark.parametrize( "gen_input_sheet", ["general_input", "General_Input", "GENERALINPUT"] ) -def test_constant_distribution(tmpdir, monkeypatch, gen_input_sheet): +def test_constant_distribution(use_tmpdir, monkeypatch, gen_input_sheet): """Create a design matrix workbook with a single constant parameter 'a'.""" - monkeypatch.chdir(tmpdir) # General input configuration general_input = pd.DataFrame( @@ -164,11 +162,9 @@ def test_constant_distribution(tmpdir, monkeypatch, gen_input_sheet): @pytest.mark.parametrize("designfile", TEST_FILES, ids=[p.stem for p in TEST_FILES]) @pytest.mark.parametrize("verbosity", [0, 1, 2]) -def test_all_input_files(tmpdir, monkeypatch, designfile, verbosity): +def test_all_input_files(use_tmpdir, monkeypatch, designfile, verbosity): """Smoketest all files.""" - monkeypatch.chdir(tmpdir) - # Copy all example files over, to guarantee existence of dependency files for filename in designfile.parent.glob("*"): if Path(filename).is_file(): @@ -183,9 +179,8 @@ def test_all_input_files(tmpdir, monkeypatch, designfile, verbosity): @pytest.mark.parametrize("designfile", EXAMPLE_FILES, ids=EXAMPLE_FILES) @pytest.mark.parametrize("verbosity", [0]) -def test_all_example_files_cmd_init(tmpdir, monkeypatch, designfile, verbosity): +def test_all_example_files_cmd_init(use_tmpdir, monkeypatch, designfile, verbosity): """Smoketest all files available in fmudesign init subcommand.""" - monkeypatch.chdir(tmpdir) subprocess.run( ["fmudesign", "init", designfile], check=True, capture_output=True, text=True ) @@ -201,12 +196,11 @@ def test_all_example_files_cmd_init(tmpdir, monkeypatch, designfile, verbosity): @pytest.mark.parametrize("designfile", TEST_FILES, ids=[p.stem for p in TEST_FILES]) -def test_all_input_files_relative_paths(tmpdir, monkeypatch, designfile): +def test_all_input_files_relative_paths(use_tmpdir, monkeypatch, designfile): """Smoketest all files, but invoke them from a directory above. This tests that relative paths in the Excel files work correctly. """ - monkeypatch.chdir(tmpdir) copy_to = os.path.join(".", "path", "going", "down") Path(copy_to).mkdir(exist_ok=True, parents=True) From 71d751f72042892a2f8136c7986fee276aa9bc40 Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Thu, 6 Aug 2026 12:56:00 +0200 Subject: [PATCH 08/14] Make changes to satisfy pre-commit --- src/ert/config/fmudesign/_excel_to_dict.py | 11 ++++++----- src/ert/config/fmudesign/config_validation.py | 12 +++++------- src/ert/config/fmudesign/create_design.py | 12 +++++++----- src/ert/config/fmudesign/design_distributions.py | 2 +- src/ert/config/fmudesign/fmudesignrunner.py | 2 +- src/ert/config/fmudesign/quality_report.py | 4 ++-- src/ert/config/fmudesign/utils.py | 4 +--- .../design_output_mc_with_correls.json | 2 +- .../unit_tests/config/fmudesign/test_use_cases.py | 5 ++--- 9 files changed, 26 insertions(+), 28 deletions(-) diff --git a/src/ert/config/fmudesign/_excel_to_dict.py b/src/ert/config/fmudesign/_excel_to_dict.py index 4a559511e34..e713201bb9a 100644 --- a/src/ert/config/fmudesign/_excel_to_dict.py +++ b/src/ert/config/fmudesign/_excel_to_dict.py @@ -12,7 +12,7 @@ from typing import Any, cast import numpy as np -import openpyxl +import openpyxl # type: ignore[import-untyped] import pandas as pd import yaml @@ -218,7 +218,7 @@ def _excel_to_dict_onebyone( ) def parse_value(value: object) -> object: - if pd.isna(value): # type: ignore[call-overload] + if pd.isna(value): return None if isinstance(value, str): return value.strip() @@ -533,8 +533,8 @@ def _read_background(inp_filename: str, bck_sheet: str) -> dict[str, Any]: if "decimals" in bck_input: decimals: dict[str, Any] = {} for row in bck_input.itertuples(): - if _has_value(row.decimals) and _is_int(row.decimals): # type: ignore[arg-type] - decimals[row.param_name] = int(row.decimals) # type: ignore[arg-type, index] + if _has_value(row.decimals) and _is_int(row.decimals): + decimals[row.param_name] = int(row.decimals) backdict["decimals"] = decimals return backdict @@ -743,9 +743,10 @@ def _is_int(teststring: str) -> bool: try: if not np.isnan(int(teststring)): return math.isclose((float(teststring) % 1), 0, abs_tol=1e-14) - return False # It was a "number", but it was NaN. except ValueError: return False + else: + return False # It was a "number", but it was NaN. def _raise_if_duplicates(container: Sequence[Hashable]) -> None: diff --git a/src/ert/config/fmudesign/config_validation.py b/src/ert/config/fmudesign/config_validation.py index 7c8dd6a8743..db218bb9ab3 100644 --- a/src/ert/config/fmudesign/config_validation.py +++ b/src/ert/config/fmudesign/config_validation.py @@ -1,6 +1,4 @@ -""" -Module for validation of config (typically read from Excel). -""" +"""Module for validation of config (typically read from Excel).""" import copy import numbers @@ -35,12 +33,12 @@ def validate_configuration( print(f"{key!r} not set in general input sheet. Setting to default 0.") print(" - When set to 0, Iman Conover is used to induce correlations.") print( - " - When set to a positive integer N, Iman Conover is followed by N iterations\n" # noqa: E501 - " of random permutations (swaps). This leads to results that are never worse, and often better.\n" # noqa: E501 - " It is especially useful for skewed distributions like lognormal and high dimensional problems." # noqa: E501 + " - When set to a positive integer N, Iman Conover is followed by N iterations\n" # ruff: ignore[line-too-long] + " of random permutations (swaps). This leads to results that are never worse, and often better.\n" # ruff: ignore[line-too-long] + " It is especially useful for skewed distributions like lognormal and high dimensional problems." # ruff: ignore[line-too-long] ) print( - f" If desired correlation does not match observed, try setting {key!r}=999 or higher." # noqa: E501 + f" If desired correlation does not match observed, try setting {key!r}=999 or higher." # ruff: ignore[line-too-long] ) config[key] = 0 else: diff --git a/src/ert/config/fmudesign/create_design.py b/src/ert/config/fmudesign/create_design.py index d0f870c8c78..7db2cd4882d 100644 --- a/src/ert/config/fmudesign/create_design.py +++ b/src/ert/config/fmudesign/create_design.py @@ -17,7 +17,7 @@ import numpy as np import pandas as pd -import probabilit +import probabilit # type: ignore[import-untyped] from . import design_distributions as design_dist from ._excel_to_dict import _raise_if_duplicates @@ -286,7 +286,9 @@ def to_xlsx( ) @staticmethod - def create_rms_seeds(seeds: list | str | None, max_reals: int) -> list | None: + def create_rms_seeds( + seeds: list[str] | str | None, max_reals: int + ) -> list[int] | None: """Create RMS seems from 'seeds' argument. Args: @@ -300,7 +302,7 @@ def create_rms_seeds(seeds: list | str | None, max_reals: int) -> list | None: -------- >>> DesignMatrix.create_rms_seeds([1, 2, 3], max_reals=5) Provided number of seed values (3) in external file is lower than the maximum number of realisations (5). - Seeds will be repeated, e.g. [1, 2, 3] => [1, 2, 3, 1, 2, ...] + Seeds will be repeated, e.g. [1, 2, 3] => [1, 2, 3, 1, 2, ...] [1, 2, 3, 1, 2] """ # ruff: ignore[line-too-long] if seeds is None: @@ -314,10 +316,10 @@ def create_rms_seeds(seeds: list | str | None, max_reals: int) -> list | None: print( f"Provided number of seed values ({len(seeds)}) in external file " f"is lower than the maximum number of realisations ({max_reals}).\n" - " Seeds will be repeated, e.g. [1, 2, 3] => [1, 2, 3, 1, 2, ...]" + "Seeds will be repeated, e.g. [1, 2, 3] => [1, 2, 3, 1, 2, ...]" ) - return [seeds[item % len(seeds)] for item in range(max_reals)] + return [int(seeds[item % len(seeds)]) for item in range(max_reals)] # Raise if none of the cases above apply. We do this because if we did not we # would return None, which is a valid case in itself. diff --git a/src/ert/config/fmudesign/design_distributions.py b/src/ert/config/fmudesign/design_distributions.py index c317f4fb50c..0c6f32051f8 100644 --- a/src/ert/config/fmudesign/design_distributions.py +++ b/src/ert/config/fmudesign/design_distributions.py @@ -6,7 +6,7 @@ import numpy as np import numpy.typing as npt import pandas as pd -import probabilit +import probabilit # type: ignore[import-untyped] from scipy import stats diff --git a/src/ert/config/fmudesign/fmudesignrunner.py b/src/ert/config/fmudesign/fmudesignrunner.py index 6399ba02e00..f30eb0ec245 100644 --- a/src/ert/config/fmudesign/fmudesignrunner.py +++ b/src/ert/config/fmudesign/fmudesignrunner.py @@ -92,7 +92,7 @@ class Example: ] -def get_parser() -> tuple[ArgumentParser, _SubParsersAction]: +def get_parser() -> tuple[ArgumentParser, _SubParsersAction]: # type: ignore[type-arg] """Create argument parser and return (parser, subparsers).""" # =============== MAIN PARSER =============== diff --git a/src/ert/config/fmudesign/quality_report.py b/src/ert/config/fmudesign/quality_report.py index 97e58b54a24..343aa9890a6 100644 --- a/src/ert/config/fmudesign/quality_report.py +++ b/src/ert/config/fmudesign/quality_report.py @@ -9,7 +9,7 @@ import pandas as pd import scipy as sp import seaborn as sns -from probabilit.correlation import ( +from probabilit.correlation import ( # type: ignore[import-untyped] nearest_correlation_matrix, ) @@ -416,7 +416,7 @@ def add_grid(*args: Any, **kwargs: Any) -> None: # Add rugplots to diagonal plots for i, var in enumerate(df.columns): - pairgrid.diag_axes[i].scatter( # type: ignore[index] + pairgrid.diag_axes[i].scatter( df[var].to_numpy(), np.zeros(len(df)), marker="|", diff --git a/src/ert/config/fmudesign/utils.py b/src/ert/config/fmudesign/utils.py index f35ab20635d..c8fc41e4302 100644 --- a/src/ert/config/fmudesign/utils.py +++ b/src/ert/config/fmudesign/utils.py @@ -1,6 +1,4 @@ -""" -Module for utility functions that do not belong elsewhere. -""" +"""Module for utility functions that do not belong elsewhere.""" from typing import Any diff --git a/tests/ert/unit_tests/config/fmudesign/snapshots/test_create_design/test_generate_full_mc_snapshot/design_output_mc_with_correls.json b/tests/ert/unit_tests/config/fmudesign/snapshots/test_create_design/test_generate_full_mc_snapshot/design_output_mc_with_correls.json index 8e0162c15a5..793926d21db 100644 --- a/tests/ert/unit_tests/config/fmudesign/snapshots/test_create_design/test_generate_full_mc_snapshot/design_output_mc_with_correls.json +++ b/tests/ert/unit_tests/config/fmudesign/snapshots/test_create_design/test_generate_full_mc_snapshot/design_output_mc_with_correls.json @@ -9020,4 +9020,4 @@ "SENSNAME": "montecarlo" } ] -} \ No newline at end of file +} diff --git a/tests/ert/unit_tests/config/fmudesign/test_use_cases.py b/tests/ert/unit_tests/config/fmudesign/test_use_cases.py index c02345b4758..65de8ad727a 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_use_cases.py +++ b/tests/ert/unit_tests/config/fmudesign/test_use_cases.py @@ -1,6 +1,5 @@ """Example use cases for semeio.fmudesign""" -import os import shutil import subprocess from pathlib import Path @@ -201,7 +200,7 @@ def test_all_input_files_relative_paths(use_tmpdir, monkeypatch, designfile): This tests that relative paths in the Excel files work correctly. """ - copy_to = os.path.join(".", "path", "going", "down") + copy_to = Path(".") / "path" / "going" / "down" Path(copy_to).mkdir(exist_ok=True, parents=True) @@ -212,7 +211,7 @@ def test_all_input_files_relative_paths(use_tmpdir, monkeypatch, designfile): # Run the CLI tool (test will fail on non-zero status code) subprocess.run( - ["fmudesign", os.path.join(".", "path", "going", "down", designfile)], + ["fmudesign", Path(".") / "path" / "going" / "down" / designfile], check=True, capture_output=True, text=True, From 87eebb0587831555bd8370cf22ea5b42eb4f509f Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Thu, 6 Aug 2026 13:24:22 +0200 Subject: [PATCH 09/14] Mark some tests slow --- .../unit_tests/config/fmudesign/test_create_design.py | 11 +++++++---- .../ert/unit_tests/config/fmudesign/test_use_cases.py | 5 +++++ 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/tests/ert/unit_tests/config/fmudesign/test_create_design.py b/tests/ert/unit_tests/config/fmudesign/test_create_design.py index cf9d65c7727..706332a8465 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_create_design.py +++ b/tests/ert/unit_tests/config/fmudesign/test_create_design.py @@ -400,10 +400,13 @@ def test_generate_full_mc_snapshot(snapshot): } # Serialize to string for snapshot comparison - snapshot_str = json.dumps( - snapshot_dict, - indent=2, - sort_keys=True, + snapshot_str = ( + json.dumps( + snapshot_dict, + indent=2, + sort_keys=True, + ) + + "\n" # The snapshot needs newline to satisfy formatting ) # Verify against snapshot diff --git a/tests/ert/unit_tests/config/fmudesign/test_use_cases.py b/tests/ert/unit_tests/config/fmudesign/test_use_cases.py index 65de8ad727a..1cb24931ec2 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_use_cases.py +++ b/tests/ert/unit_tests/config/fmudesign/test_use_cases.py @@ -16,6 +16,7 @@ TEST_FILES = list((TESTDATA / "config").glob("design_input*.xlsx")) +@pytest.mark.slow def test_prediction_rejection_sampled_ensemble(use_tmpdir, monkeypatch): """Test making a design matrix for prediction realizations based on an ensemble made with manual history matching (rejection sampling). @@ -105,6 +106,7 @@ def test_prediction_rejection_sampled_ensemble(use_tmpdir, monkeypatch): @pytest.mark.parametrize( "gen_input_sheet", ["general_input", "General_Input", "GENERALINPUT"] ) +@pytest.mark.slow def test_constant_distribution(use_tmpdir, monkeypatch, gen_input_sheet): """Create a design matrix workbook with a single constant parameter 'a'.""" @@ -161,6 +163,7 @@ def test_constant_distribution(use_tmpdir, monkeypatch, gen_input_sheet): @pytest.mark.parametrize("designfile", TEST_FILES, ids=[p.stem for p in TEST_FILES]) @pytest.mark.parametrize("verbosity", [0, 1, 2]) +@pytest.mark.slow def test_all_input_files(use_tmpdir, monkeypatch, designfile, verbosity): """Smoketest all files.""" @@ -178,6 +181,7 @@ def test_all_input_files(use_tmpdir, monkeypatch, designfile, verbosity): @pytest.mark.parametrize("designfile", EXAMPLE_FILES, ids=EXAMPLE_FILES) @pytest.mark.parametrize("verbosity", [0]) +@pytest.mark.slow def test_all_example_files_cmd_init(use_tmpdir, monkeypatch, designfile, verbosity): """Smoketest all files available in fmudesign init subcommand.""" subprocess.run( @@ -195,6 +199,7 @@ def test_all_example_files_cmd_init(use_tmpdir, monkeypatch, designfile, verbosi @pytest.mark.parametrize("designfile", TEST_FILES, ids=[p.stem for p in TEST_FILES]) +@pytest.mark.slow def test_all_input_files_relative_paths(use_tmpdir, monkeypatch, designfile): """Smoketest all files, but invoke them from a directory above. This tests that relative paths in the Excel files work correctly. From d3b9df8ed7958a1fbcd058e685c01c1cf9634904 Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Fri, 7 Aug 2026 10:02:50 +0200 Subject: [PATCH 10/14] Convert docstring test to normal test --- src/ert/config/fmudesign/create_design.py | 9 +-------- .../config/fmudesign/test_create_design.py | 15 +++++++++++++++ 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/src/ert/config/fmudesign/create_design.py b/src/ert/config/fmudesign/create_design.py index 7db2cd4882d..3c2bf89639e 100644 --- a/src/ert/config/fmudesign/create_design.py +++ b/src/ert/config/fmudesign/create_design.py @@ -297,14 +297,7 @@ def create_rms_seeds( - "default": Generates sequential seeds 1001, 1002, 1003, ... - list of seeds, e.g. [1, 2, 3] max_reals: Maximum number of seed values to generate or load - - Examples - -------- - >>> DesignMatrix.create_rms_seeds([1, 2, 3], max_reals=5) - Provided number of seed values (3) in external file is lower than the maximum number of realisations (5). - Seeds will be repeated, e.g. [1, 2, 3] => [1, 2, 3, 1, 2, ...] - [1, 2, 3, 1, 2] - """ # ruff: ignore[line-too-long] + """ if seeds is None: return None diff --git a/tests/ert/unit_tests/config/fmudesign/test_create_design.py b/tests/ert/unit_tests/config/fmudesign/test_create_design.py index 706332a8465..f90fa8c96e7 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_create_design.py +++ b/tests/ert/unit_tests/config/fmudesign/test_create_design.py @@ -680,3 +680,18 @@ def test_fill_with_background_values_are_filled(): import pytest pytest.main(args=[__file__, "--doctest-modules", "-v", "-l"]) + + +def test_that_fewer_seeds_than_realizations_are_repeated_and_informs_user(capsys): + reals = 5 + seeds = [1, 2, 3] + + rms_seeds = DesignMatrix().create_rms_seeds(seeds, max_reals=reals) + + assert rms_seeds == [1, 2, 3, 1, 2] + stdout = capsys.readouterr().out + assert ( + "Provided number of seed values (3) in external file is " + "lower than the maximum number of realisations (5)" in stdout + ) + assert "Seeds will be repeated, e.g. [1, 2, 3] => [1, 2, 3, 1, 2, ...]" in stdout From 1e7c80814178da116be9cb0bbb15f16bab8e0787 Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Fri, 7 Aug 2026 10:04:09 +0200 Subject: [PATCH 11/14] Correct typing of seeds parameter I still dont know if it should be float --- src/ert/config/fmudesign/create_design.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ert/config/fmudesign/create_design.py b/src/ert/config/fmudesign/create_design.py index 3c2bf89639e..44db4f63fae 100644 --- a/src/ert/config/fmudesign/create_design.py +++ b/src/ert/config/fmudesign/create_design.py @@ -287,7 +287,7 @@ def to_xlsx( @staticmethod def create_rms_seeds( - seeds: list[str] | str | None, max_reals: int + seeds: list[int] | str | None, max_reals: int ) -> list[int] | None: """Create RMS seems from 'seeds' argument. From d29b6dc0a7d5380a1f57d9d246a29862a01d555f Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Fri, 7 Aug 2026 10:05:18 +0200 Subject: [PATCH 12/14] Delete cli smoke test This test tests that the cli tooling can be invoked from certain folder structures, but this tooling will not be a cli tool in ert. --- .../config/fmudesign/test_use_cases.py | 25 ------------------- 1 file changed, 25 deletions(-) diff --git a/tests/ert/unit_tests/config/fmudesign/test_use_cases.py b/tests/ert/unit_tests/config/fmudesign/test_use_cases.py index 1cb24931ec2..355dbf7be1e 100644 --- a/tests/ert/unit_tests/config/fmudesign/test_use_cases.py +++ b/tests/ert/unit_tests/config/fmudesign/test_use_cases.py @@ -196,28 +196,3 @@ def test_all_example_files_cmd_init(use_tmpdir, monkeypatch, designfile, verbosi capture_output=True, text=True, ) - - -@pytest.mark.parametrize("designfile", TEST_FILES, ids=[p.stem for p in TEST_FILES]) -@pytest.mark.slow -def test_all_input_files_relative_paths(use_tmpdir, monkeypatch, designfile): - """Smoketest all files, but invoke them from a directory above. - This tests that relative paths in the Excel files work correctly. - """ - - copy_to = Path(".") / "path" / "going" / "down" - - Path(copy_to).mkdir(exist_ok=True, parents=True) - - # Copy all example files over, to guarantee existence of dependency files - for filename in designfile.parent.glob("*"): - if Path(filename).is_file(): - shutil.copy(filename, copy_to) - - # Run the CLI tool (test will fail on non-zero status code) - subprocess.run( - ["fmudesign", Path(".") / "path" / "going" / "down" / designfile], - check=True, - capture_output=True, - text=True, - ) From df94588fd1b850362a41528dd735f5f325060ca7 Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Fri, 7 Aug 2026 10:17:53 +0200 Subject: [PATCH 13/14] wip --- tests/ert/ui_tests/test_fmu_design.py | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 tests/ert/ui_tests/test_fmu_design.py diff --git a/tests/ert/ui_tests/test_fmu_design.py b/tests/ert/ui_tests/test_fmu_design.py new file mode 100644 index 00000000000..0427f6bf63f --- /dev/null +++ b/tests/ert/ui_tests/test_fmu_design.py @@ -0,0 +1,6 @@ +from io import BytesIO +import polars as pl + +def _df_to_excel_stream(df: pl.DataFrame) -> BytesIO: + byte_stream = BytesIO() + From d59b367857f907e7dc43265d276f39dac96edc9e Mon Sep 17 00:00:00 2001 From: eq-sandkav Date: Fri, 7 Aug 2026 15:30:20 +0200 Subject: [PATCH 14/14] Add replacement framework for excel file My first attempt was by writing polars dataframes to excel bytestreams, but polars have a limitation where multityped columns are cast to string, such that the produced excel_to_dict dictionary differs from the one produced by the .xlsx file - where numeric values were turned to strings. This solution can be iterated on, but it gives a relatively clear framework for how one of these test data classes to generate excel bytestreams should look like. It is simply writing one row at a time in the form of lists, perhaps not the most elegant solution, but quite simple to maintain. Can find a better way of displaying the row values, as these are formatted vertically when containing a lot of elements. The idea going forward is to create test files like test_one_by_one_sensitivity.py and populate them with tests targeting specific functionalities of fmudesign. Hopefully, we can just delete some of these files as they probably test the same. --- tests/ert/ui_tests/fmudesign/__init__.py | 0 .../fmudesign/design_input/__init__.py | 0 .../fmudesign/design_input/design_input.py | 31 ++++ .../design_input/fmudesign_ex_onebyone.py | 146 ++++++++++++++++++ .../fmudesign/test_one_by_one_sensitivity.py | 26 ++++ 5 files changed, 203 insertions(+) create mode 100644 tests/ert/ui_tests/fmudesign/__init__.py create mode 100644 tests/ert/ui_tests/fmudesign/design_input/__init__.py create mode 100644 tests/ert/ui_tests/fmudesign/design_input/design_input.py create mode 100644 tests/ert/ui_tests/fmudesign/design_input/fmudesign_ex_onebyone.py create mode 100644 tests/ert/ui_tests/fmudesign/test_one_by_one_sensitivity.py diff --git a/tests/ert/ui_tests/fmudesign/__init__.py b/tests/ert/ui_tests/fmudesign/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/ert/ui_tests/fmudesign/design_input/__init__.py b/tests/ert/ui_tests/fmudesign/design_input/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/ert/ui_tests/fmudesign/design_input/design_input.py b/tests/ert/ui_tests/fmudesign/design_input/design_input.py new file mode 100644 index 00000000000..a4fc7e768b3 --- /dev/null +++ b/tests/ert/ui_tests/fmudesign/design_input/design_input.py @@ -0,0 +1,31 @@ +from abc import ABC, abstractmethod +from io import BytesIO + +import xlsxwriter + + +class DesignInput(ABC): + """Baseclass for creating test data mimicking Excel workbooks containing the 3 + sheets required by fmudesign in the form of a bytestream which can be passed + to fmudesign.excel_to_dict(). + """ + + GENERAL_SHEET: str = "general_input" + DESIGN_SHEET: str = "designinput" + DEFAULT_SHEET: str = "defaultvalues" + + @abstractmethod + def excel_byte_stream(self) -> BytesIO: + pass + + @abstractmethod + def _write_general_input(self, wb: xlsxwriter.Workbook) -> None: + pass + + @abstractmethod + def _write_design_input(self, wb: xlsxwriter.Workbook) -> None: + pass + + @abstractmethod + def _write_default_values(self, wb: xlsxwriter.Workbook) -> None: + pass diff --git a/tests/ert/ui_tests/fmudesign/design_input/fmudesign_ex_onebyone.py b/tests/ert/ui_tests/fmudesign/design_input/fmudesign_ex_onebyone.py new file mode 100644 index 00000000000..9097305f33a --- /dev/null +++ b/tests/ert/ui_tests/fmudesign/design_input/fmudesign_ex_onebyone.py @@ -0,0 +1,146 @@ +from io import BytesIO + +import xlsxwriter + +from tests.ert.ui_tests.fmudesign.design_input.design_input import DesignInput + + +class FmudesignOneByOne(DesignInput): + def excel_byte_stream(self) -> BytesIO: + byte_stream = BytesIO() + with xlsxwriter.Workbook(byte_stream) as wb: + self._write_general_input(wb) + self._write_design_input(wb) + self._write_default_values(wb) + byte_stream.seek(0) + return byte_stream + + def _write_general_input(self, wb: xlsxwriter.Workbook) -> None: + ws = wb.add_worksheet(self.GENERAL_SHEET) + rows = [ + ["designtype", "onebyone"], + ["repeats", 10], + ["rms_seeds", "default"], + ["background", None], + ["distribution_seed", None], + ] + for row_idx, row in enumerate(rows): + ws.write_row(row_idx, 0, row) + + def _write_design_input(self, wb: xlsxwriter.Workbook) -> None: + ws = wb.add_worksheet(self.DESIGN_SHEET) + header = [ + "sensname", + "numreal", + "type", + "param_name", + "senscase1", + "value1", + "senscase2", + "value2", + "dist_name", + "dist_param1", + "dist_param2", + "dist_param3", + "dist_param4", + "decimals", + "corr_sheet", + "extern_file", + ] + rows = [ + [ + "rms_seed", + None, + "seed", + ] + + [None] * 13, + [ + "faults", + None, + "scenario", + "FAULT_POSITION", + "east", + -1, + "west", + 1, + ] + + [None] * 8, + [ + "velmodel", + None, + "scenario", + "DC_MODEL", + "alternative", + "hum2", + ] + + [None] * 10, + [ + "contacts", + None, + "scenario", + "OWC1", + "shallow", + 2600, + "deep", + 2700, + ] + + [None] * 8, + [ + None, + None, + None, + "OWC2", + None, + 2700, + None, + 2800, + ] + + [None] * 8, + [ + None, + None, + None, + "OWC3", + None, + 2800, + None, + 2900, + ] + + [None] * 8, + [ + "multz", + 20, + "dist", + "MULTZ_ILE", + None, + None, + None, + None, + "logunif", + 0.0001, + 1, + ] + + [None] * 5, + ] + ws.write_row(0, 0, header) + for row_idx, row in enumerate(rows, start=1): + ws.write_row(row_idx, 0, row) + + def _write_default_values(self, wb: xlsxwriter.Workbook) -> None: + ws = wb.add_worksheet(self.DEFAULT_SHEET) + header = ["param_name", "default_values"] + rows = [ + ["RMS_SEED", 1000], + ["FAULT_POSITION", 0], + ["DC_MODEL", "base"], + ["OWC1", 2650], + ["OWC2", 2750], + ["OWC3", 2850], + ["MULTZ_ILE", 0.1], + ["PARAM1", 100], + ["PARAM2", 200], + ["PARAM3", 0.5], + ] + ws.write_row(0, 0, header) + for row_idx, row in enumerate(rows, start=1): + ws.write_row(row_idx, 0, row) diff --git a/tests/ert/ui_tests/fmudesign/test_one_by_one_sensitivity.py b/tests/ert/ui_tests/fmudesign/test_one_by_one_sensitivity.py new file mode 100644 index 00000000000..e4c168b6e83 --- /dev/null +++ b/tests/ert/ui_tests/fmudesign/test_one_by_one_sensitivity.py @@ -0,0 +1,26 @@ +from importlib.resources import files + +from ert.config.fmudesign import excel_to_dict +from tests.ert.ui_tests.fmudesign.design_input.fmudesign_ex_onebyone import ( + FmudesignOneByOne, +) + +EXAMPLES_DIR = files("ert.config.fmudesign.examples") + + +def test_that_one_by_one_byte_stream_gives_same_dict_result_as_file(): + xlsx_byte_stream = FmudesignOneByOne().excel_byte_stream() + + stream_result = excel_to_dict(xlsx_byte_stream) + + one_by_one_example_filename = str(EXAMPLES_DIR / "fmudesign_ex_onebyone.xlsx") + + xlsx_result = excel_to_dict(one_by_one_example_filename) + + assert stream_result.keys() == xlsx_result.keys() + assert all( + stream_result[key] == xlsx_result[key] + for key in xlsx_result + # The inputfile will differ as one is a byte steam while the other a string + if key != "input_file" + )