@gridsuite/commons-ui 0.192.0 → 0.194.0

package/dist/components/parameters/dynamic-simulation/solver/common-solver/common-solver-parameters.js

@@ -0,0 +1,134 @@
+import { jsx, Fragment } from "react/jsx-runtime";
+import "../../../../../utils/conversionUtils.js";
+import "../../../../../utils/types/equipmentType.js";
+import { ParameterType } from "../../../../../utils/types/parameters.type.js";
+import "@mui/icons-material";
+import "../../../../../utils/yupConfig.js";
+import { CommonSolver } from "./common-solver-parameters-constants.js";
+import ParameterField from "../../../common/parameter-field.js";
+const params = [
+  {
+    name: CommonSolver.F_NORM_TOL_ALG,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverFNormTolAlg"
+  },
+  {
+    name: CommonSolver.INITIAL_ADD_TOL_ALG,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverInitialAddTolAlg"
+  },
+  {
+    name: CommonSolver.SC_STEP_TOL_ALG,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverScStepTolAlg"
+  },
+  {
+    name: CommonSolver.MX_NEW_T_STEP_ALG,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverMxNewTStepAlg"
+  },
+  {
+    name: CommonSolver.MSBSET_ALG,
+    type: ParameterType.INTEGER,
+    label: "DynamicSimulationSolverMsbsetAlg"
+  },
+  {
+    name: CommonSolver.MX_ITER_ALG,
+    type: ParameterType.INTEGER,
+    label: "DynamicSimulationSolverMxIterAlg"
+  },
+  {
+    name: CommonSolver.PRINT_FL_ALG,
+    type: ParameterType.INTEGER,
+    label: "DynamicSimulationSolverPrintFlAlg"
+  },
+  {
+    name: CommonSolver.F_NORM_TOL_ALG_J,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverFNormTolAlgJ"
+  },
+  {
+    name: CommonSolver.INITIAL_ADD_TOL_ALG_J,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverInitialAddTolAlgJ"
+  },
+  {
+    name: CommonSolver.SC_STEP_TOL_ALG_J,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverScStepTolAlgJ"
+  },
+  {
+    name: CommonSolver.MX_NEW_T_STEP_ALG_J,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverMxNewTStepAlgJ"
+  },
+  {
+    name: CommonSolver.MSBSET_ALG_J,
+    type: ParameterType.INTEGER,
+    label: "DynamicSimulationSolverMsbsetAlgJ"
+  },
+  {
+    name: CommonSolver.MX_ITER_ALG_J,
+    type: ParameterType.INTEGER,
+    label: "DynamicSimulationSolverMxIterAlgJ"
+  },
+  {
+    name: CommonSolver.PRINT_FL_ALG_J,
+    type: ParameterType.INTEGER,
+    label: "DynamicSimulationSolverPrintFlAlgJ"
+  },
+  {
+    name: CommonSolver.F_NORM_TOL_ALG_INIT,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverFNormTolAlgInit"
+  },
+  {
+    name: CommonSolver.INITIAL_ADD_TOL_ALG_INIT,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverInitialAddTolAlgInit"
+  },
+  {
+    name: CommonSolver.SC_STEP_TOL_ALG_INIT,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverScStepTolAlgInit"
+  },
+  {
+    name: CommonSolver.MX_NEW_T_STEP_ALG_INIT,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverMxNewTStepAlgInit"
+  },
+  {
+    name: CommonSolver.MSBSET_ALG_INIT,
+    type: ParameterType.INTEGER,
+    label: "DynamicSimulationSolverMsbsetAlgInit"
+  },
+  {
+    name: CommonSolver.MX_ITER_ALG_INIT,
+    type: ParameterType.INTEGER,
+    label: "DynamicSimulationSolverMxIterAlgInit"
+  },
+  {
+    name: CommonSolver.PRINT_FL_ALG_INIT,
+    type: ParameterType.INTEGER,
+    label: "DynamicSimulationSolverPrintFlAlgInit"
+  },
+  {
+    name: CommonSolver.MAXIMUM_NUMBER_SLOW_STEP_INCREASE,
+    type: ParameterType.INTEGER,
+    label: "DynamicSimulationSolverMaximumNumberSlowStepIncrease"
+  },
+  {
+    name: CommonSolver.MINIMAL_ACCEPTABLE_STEP,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationSolverMinimalAcceptableStep"
+  }
+];
+function CommonSolverParameters({ path }) {
+  return /* @__PURE__ */ jsx(Fragment, { children: params.map((param) => {
+    const { name, type, ...otherParams } = param;
+    return /* @__PURE__ */ jsx(ParameterField, { id: path, name: param.name, type: param.type, ...otherParams }, param.name);
+  }) });
+}
+export {
+  CommonSolverParameters
+};

package/dist/components/parameters/dynamic-simulation/solver/common-solver/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+export * from './common-solver-parameters-constants';
+export * from './common-solver-parameters-utils';
+export * from './common-solver-parameters';

package/dist/components/parameters/dynamic-simulation/solver/common-solver/index.js

@@ -0,0 +1,8 @@
+import { CommonSolver } from "./common-solver-parameters-constants.js";
+import { getFormSchema } from "./common-solver-parameters-utils.js";
+import { CommonSolverParameters } from "./common-solver-parameters.js";
+export {
+  CommonSolver,
+  CommonSolverParameters,
+  getFormSchema
+};

package/dist/components/parameters/dynamic-simulation/solver/ida-solver/ida-solver-parameters-constants.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+export declare enum IdaSolver {
+    ORDER = "order",
+    INIT_STEP = "initStep",
+    MIN_STEP = "minStep",
+    MAX_STEP = "maxStep",
+    ABS_ACCURACY = "absAccuracy",
+    REL_ACCURACY = "relAccuracy"
+}

package/dist/components/parameters/dynamic-simulation/solver/ida-solver/ida-solver-parameters-constants.js

@@ -0,0 +1,12 @@
+var IdaSolver = /* @__PURE__ */ ((IdaSolver2) => {
+  IdaSolver2["ORDER"] = "order";
+  IdaSolver2["INIT_STEP"] = "initStep";
+  IdaSolver2["MIN_STEP"] = "minStep";
+  IdaSolver2["MAX_STEP"] = "maxStep";
+  IdaSolver2["ABS_ACCURACY"] = "absAccuracy";
+  IdaSolver2["REL_ACCURACY"] = "relAccuracy";
+  return IdaSolver2;
+})(IdaSolver || {});
+export {
+  IdaSolver
+};

package/dist/components/parameters/dynamic-simulation/solver/ida-solver/ida-solver-parameters-utils.d.ts

@@ -0,0 +1,62 @@
+import { default as yup } from '../../../../../utils/yupConfig';
+export declare const getIdaFormSchema: () => yup.ObjectSchema<{
+    fNormTolAlg: number;
+    initialAddTolAlg: number;
+    scStepTolAlg: number;
+    mxNewTStepAlg: number;
+    msbsetAlg: number;
+    mxIterAlg: number;
+    printFlAlg: number;
+    fNormTolAlgJ: number;
+    initialAddTolAlgJ: number;
+    scStepTolAlgJ: number;
+    mxNewTStepAlgJ: number;
+    msbsetAlgJ: number;
+    mxIterAlgJ: number;
+    printFlAlgJ: number;
+    fNormTolAlgInit: number;
+    initialAddTolAlgInit: number;
+    scStepTolAlgInit: number;
+    mxNewTStepAlgInit: number;
+    msbsetAlgInit: number;
+    mxIterAlgInit: number;
+    printFlAlgInit: number;
+    maximumNumberSlowStepIncrease: number;
+    minimalAcceptableStep: number;
+    order: number;
+    initStep: number;
+    minStep: number;
+    maxStep: number;
+    absAccuracy: number;
+    relAccuracy: number;
+}, yup.AnyObject, {
+    fNormTolAlg: undefined;
+    initialAddTolAlg: undefined;
+    scStepTolAlg: undefined;
+    mxNewTStepAlg: undefined;
+    msbsetAlg: undefined;
+    mxIterAlg: undefined;
+    printFlAlg: undefined;
+    fNormTolAlgJ: undefined;
+    initialAddTolAlgJ: undefined;
+    scStepTolAlgJ: undefined;
+    mxNewTStepAlgJ: undefined;
+    msbsetAlgJ: undefined;
+    mxIterAlgJ: undefined;
+    printFlAlgJ: undefined;
+    fNormTolAlgInit: undefined;
+    initialAddTolAlgInit: undefined;
+    scStepTolAlgInit: undefined;
+    mxNewTStepAlgInit: undefined;
+    msbsetAlgInit: undefined;
+    mxIterAlgInit: undefined;
+    printFlAlgInit: undefined;
+    maximumNumberSlowStepIncrease: undefined;
+    minimalAcceptableStep: undefined;
+    order: undefined;
+    initStep: undefined;
+    minStep: undefined;
+    maxStep: undefined;
+    absAccuracy: undefined;
+    relAccuracy: undefined;
+}, "">;

package/dist/components/parameters/dynamic-simulation/solver/ida-solver/ida-solver-parameters-utils.js

@@ -0,0 +1,17 @@
+import "../../../../../utils/yupConfig.js";
+import { IdaSolver } from "./ida-solver-parameters-constants.js";
+import { getFormSchema } from "../common-solver/common-solver-parameters-utils.js";
+import "../common-solver/common-solver-parameters.js";
+import * as yup from "yup";
+const getIdaFormSchema = () => yup.object().shape({
+  [IdaSolver.ORDER]: yup.number().integer().oneOf([1, 2], "DynamicSimulationIDASolverOrderMustBeOneOfValues").required(),
+  [IdaSolver.INIT_STEP]: yup.number().required(),
+  [IdaSolver.MIN_STEP]: yup.number().required(),
+  [IdaSolver.MAX_STEP]: yup.number().required(),
+  [IdaSolver.ABS_ACCURACY]: yup.number().required(),
+  [IdaSolver.REL_ACCURACY]: yup.number().required(),
+  ...getFormSchema()
+});
+export {
+  getIdaFormSchema
+};

package/dist/components/parameters/dynamic-simulation/solver/ida-solver/ida-solver-parameters.d.ts

@@ -0,0 +1,3 @@
+export declare function IdaSolverParameters({ path }: Readonly<{
+    path: string;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/dynamic-simulation/solver/ida-solver/ida-solver-parameters.js

@@ -0,0 +1,53 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import "../../../../../utils/yupConfig.js";
+import { CommonSolverParameters } from "../common-solver/common-solver-parameters.js";
+import "../../../../../utils/conversionUtils.js";
+import "../../../../../utils/types/equipmentType.js";
+import { ParameterType } from "../../../../../utils/types/parameters.type.js";
+import "@mui/icons-material";
+import ParameterField from "../../../common/parameter-field.js";
+import { IdaSolver } from "./ida-solver-parameters-constants.js";
+const params = [
+  {
+    name: IdaSolver.ORDER,
+    type: ParameterType.INTEGER,
+    label: "DynamicSimulationIDASolverOrder"
+  },
+  {
+    name: IdaSolver.INIT_STEP,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationIDASolverInitStep"
+  },
+  {
+    name: IdaSolver.MIN_STEP,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationIDASolverMinStep"
+  },
+  {
+    name: IdaSolver.MAX_STEP,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationIDASolverMaxStep"
+  },
+  {
+    name: IdaSolver.ABS_ACCURACY,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationIDASolverAbsAccuracy"
+  },
+  {
+    name: IdaSolver.REL_ACCURACY,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationIDASolverRelAccuracy"
+  }
+];
+function IdaSolverParameters({ path }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    params.map((param) => {
+      const { name, type, ...otherParams } = param;
+      return /* @__PURE__ */ jsx(ParameterField, { id: path, name: param.name, type: param.type, ...otherParams }, param.name);
+    }),
+    /* @__PURE__ */ jsx(CommonSolverParameters, { path })
+  ] });
+}
+export {
+  IdaSolverParameters
+};

package/dist/components/parameters/dynamic-simulation/solver/ida-solver/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+export * from './ida-solver-parameters-constants';
+export * from './ida-solver-parameters-utils';
+export * from './ida-solver-parameters';

package/dist/components/parameters/dynamic-simulation/solver/ida-solver/index.js

@@ -0,0 +1,8 @@
+import { IdaSolver } from "./ida-solver-parameters-constants.js";
+import { getIdaFormSchema } from "./ida-solver-parameters-utils.js";
+import { IdaSolverParameters } from "./ida-solver-parameters.js";
+export {
+  IdaSolver,
+  IdaSolverParameters,
+  getIdaFormSchema
+};

package/dist/components/parameters/dynamic-simulation/solver/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+export * from './solver-parameters-constants';
+export * from './solver-parameters-utils';
+export * from './solver-parameters';

package/dist/components/parameters/dynamic-simulation/solver/index.js

@@ -0,0 +1,9 @@
+import { Solver } from "./solver-parameters-constants.js";
+import { solverEmptyFormData, solverFormSchema } from "./solver-parameters-utils.js";
+import { SolverParameters } from "./solver-parameters.js";
+export {
+  Solver,
+  SolverParameters,
+  solverEmptyFormData,
+  solverFormSchema
+};

package/dist/components/parameters/dynamic-simulation/solver/sim-solver/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+export * from './simplified-solver-parameters-constant';
+export * from './simplified-solver-parameters-utils';
+export * from './simplified-solver-parameters';

package/dist/components/parameters/dynamic-simulation/solver/sim-solver/index.js

@@ -0,0 +1,8 @@
+import { SimplifiedSolver } from "./simplified-solver-parameters-constant.js";
+import { getSimplifiedFormSchema } from "./simplified-solver-parameters-utils.js";
+import { SimplifiedSolverParameters } from "./simplified-solver-parameters.js";
+export {
+  SimplifiedSolver,
+  SimplifiedSolverParameters,
+  getSimplifiedFormSchema
+};

package/dist/components/parameters/dynamic-simulation/solver/sim-solver/simplified-solver-parameters-constant.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+export declare enum SimplifiedSolver {
+    H_MIN = "hMin",
+    H_MAX = "hMax",
+    K_REDUCE_STEP = "kReduceStep",
+    MAX_NEWTON_TRY = "maxNewtonTry",
+    LINEAR_SOLVER_NAME = "linearSolverName",
+    F_NORM_TOL = "fNormTol",
+    INITIAL_ADD_TOL = "initialAddTol",
+    SC_STEP_TOL = "scStepTol",
+    MX_NEW_T_STEP = "mxNewTStep",
+    MSBSET = "msbset",
+    MX_ITER = "mxIter",
+    PRINT_FL = "printFl",
+    OPTIMIZE_ALGEBRAIC_RESIDUALS_EVALUATIONS = "optimizeAlgebraicResidualsEvaluations",
+    SKIP_NR_IF_INITIAL_GUESS_OK = "skipNRIfInitialGuessOK",
+    ENABLE_SILENT_Z = "enableSilentZ",
+    OPTIMIZE_RE_INIT_ALGEBRAIC_RESIDUALS_EVALUATIONS = "optimizeReInitAlgebraicResidualsEvaluations",
+    MINIMUM_MODE_CHANGE_TYPE_FOR_ALGEBRAIC_RESTORATION = "minimumModeChangeTypeForAlgebraicRestoration",
+    MINIMUM_MODE_CHANGE_TYPE_FOR_ALGEBRAIC_RESTORATION_INIT = "minimumModeChangeTypeForAlgebraicRestorationInit"
+}

package/dist/components/parameters/dynamic-simulation/solver/sim-solver/simplified-solver-parameters-constant.js

@@ -0,0 +1,24 @@
+var SimplifiedSolver = /* @__PURE__ */ ((SimplifiedSolver2) => {
+  SimplifiedSolver2["H_MIN"] = "hMin";
+  SimplifiedSolver2["H_MAX"] = "hMax";
+  SimplifiedSolver2["K_REDUCE_STEP"] = "kReduceStep";
+  SimplifiedSolver2["MAX_NEWTON_TRY"] = "maxNewtonTry";
+  SimplifiedSolver2["LINEAR_SOLVER_NAME"] = "linearSolverName";
+  SimplifiedSolver2["F_NORM_TOL"] = "fNormTol";
+  SimplifiedSolver2["INITIAL_ADD_TOL"] = "initialAddTol";
+  SimplifiedSolver2["SC_STEP_TOL"] = "scStepTol";
+  SimplifiedSolver2["MX_NEW_T_STEP"] = "mxNewTStep";
+  SimplifiedSolver2["MSBSET"] = "msbset";
+  SimplifiedSolver2["MX_ITER"] = "mxIter";
+  SimplifiedSolver2["PRINT_FL"] = "printFl";
+  SimplifiedSolver2["OPTIMIZE_ALGEBRAIC_RESIDUALS_EVALUATIONS"] = "optimizeAlgebraicResidualsEvaluations";
+  SimplifiedSolver2["SKIP_NR_IF_INITIAL_GUESS_OK"] = "skipNRIfInitialGuessOK";
+  SimplifiedSolver2["ENABLE_SILENT_Z"] = "enableSilentZ";
+  SimplifiedSolver2["OPTIMIZE_RE_INIT_ALGEBRAIC_RESIDUALS_EVALUATIONS"] = "optimizeReInitAlgebraicResidualsEvaluations";
+  SimplifiedSolver2["MINIMUM_MODE_CHANGE_TYPE_FOR_ALGEBRAIC_RESTORATION"] = "minimumModeChangeTypeForAlgebraicRestoration";
+  SimplifiedSolver2["MINIMUM_MODE_CHANGE_TYPE_FOR_ALGEBRAIC_RESTORATION_INIT"] = "minimumModeChangeTypeForAlgebraicRestorationInit";
+  return SimplifiedSolver2;
+})(SimplifiedSolver || {});
+export {
+  SimplifiedSolver
+};

package/dist/components/parameters/dynamic-simulation/solver/sim-solver/simplified-solver-parameters-utils.d.ts

@@ -0,0 +1,86 @@
+import { default as yup } from '../../../../../utils/yupConfig';
+export declare const getSimplifiedFormSchema: () => yup.ObjectSchema<{
+    fNormTolAlg: number;
+    initialAddTolAlg: number;
+    scStepTolAlg: number;
+    mxNewTStepAlg: number;
+    msbsetAlg: number;
+    mxIterAlg: number;
+    printFlAlg: number;
+    fNormTolAlgJ: number;
+    initialAddTolAlgJ: number;
+    scStepTolAlgJ: number;
+    mxNewTStepAlgJ: number;
+    msbsetAlgJ: number;
+    mxIterAlgJ: number;
+    printFlAlgJ: number;
+    fNormTolAlgInit: number;
+    initialAddTolAlgInit: number;
+    scStepTolAlgInit: number;
+    mxNewTStepAlgInit: number;
+    msbsetAlgInit: number;
+    mxIterAlgInit: number;
+    printFlAlgInit: number;
+    maximumNumberSlowStepIncrease: number;
+    minimalAcceptableStep: number;
+    hMin: number;
+    hMax: number;
+    kReduceStep: number;
+    maxNewtonTry: number;
+    linearSolverName: string;
+    fNormTol: number;
+    initialAddTol: number;
+    scStepTol: number;
+    mxNewTStep: number;
+    msbset: number;
+    mxIter: number;
+    printFl: number;
+    optimizeAlgebraicResidualsEvaluations: NonNullable<boolean | undefined>;
+    skipNRIfInitialGuessOK: NonNullable<boolean | undefined>;
+    enableSilentZ: NonNullable<boolean | undefined>;
+    optimizeReInitAlgebraicResidualsEvaluations: NonNullable<boolean | undefined>;
+    minimumModeChangeTypeForAlgebraicRestoration: string;
+    minimumModeChangeTypeForAlgebraicRestorationInit: string;
+}, yup.AnyObject, {
+    fNormTolAlg: undefined;
+    initialAddTolAlg: undefined;
+    scStepTolAlg: undefined;
+    mxNewTStepAlg: undefined;
+    msbsetAlg: undefined;
+    mxIterAlg: undefined;
+    printFlAlg: undefined;
+    fNormTolAlgJ: undefined;
+    initialAddTolAlgJ: undefined;
+    scStepTolAlgJ: undefined;
+    mxNewTStepAlgJ: undefined;
+    msbsetAlgJ: undefined;
+    mxIterAlgJ: undefined;
+    printFlAlgJ: undefined;
+    fNormTolAlgInit: undefined;
+    initialAddTolAlgInit: undefined;
+    scStepTolAlgInit: undefined;
+    mxNewTStepAlgInit: undefined;
+    msbsetAlgInit: undefined;
+    mxIterAlgInit: undefined;
+    printFlAlgInit: undefined;
+    maximumNumberSlowStepIncrease: undefined;
+    minimalAcceptableStep: undefined;
+    hMin: undefined;
+    hMax: undefined;
+    kReduceStep: undefined;
+    maxNewtonTry: undefined;
+    linearSolverName: undefined;
+    fNormTol: undefined;
+    initialAddTol: undefined;
+    scStepTol: undefined;
+    mxNewTStep: undefined;
+    msbset: undefined;
+    mxIter: undefined;
+    printFl: undefined;
+    optimizeAlgebraicResidualsEvaluations: undefined;
+    skipNRIfInitialGuessOK: undefined;
+    enableSilentZ: undefined;
+    optimizeReInitAlgebraicResidualsEvaluations: undefined;
+    minimumModeChangeTypeForAlgebraicRestoration: undefined;
+    minimumModeChangeTypeForAlgebraicRestorationInit: undefined;
+}, "">;

package/dist/components/parameters/dynamic-simulation/solver/sim-solver/simplified-solver-parameters-utils.js

@@ -0,0 +1,31 @@
+import "../../../../../utils/yupConfig.js";
+import { SimplifiedSolver } from "./simplified-solver-parameters-constant.js";
+import { getFormSchema } from "../common-solver/common-solver-parameters-utils.js";
+import "../common-solver/common-solver-parameters.js";
+import * as yup from "yup";
+const getSimplifiedFormSchema = () => {
+  return yup.object().shape({
+    [SimplifiedSolver.H_MIN]: yup.number().required(),
+    [SimplifiedSolver.H_MAX]: yup.number().required(),
+    [SimplifiedSolver.K_REDUCE_STEP]: yup.number().required(),
+    [SimplifiedSolver.MAX_NEWTON_TRY]: yup.number().integer().required(),
+    [SimplifiedSolver.LINEAR_SOLVER_NAME]: yup.string().required(),
+    [SimplifiedSolver.F_NORM_TOL]: yup.number().required(),
+    [SimplifiedSolver.INITIAL_ADD_TOL]: yup.number().required(),
+    [SimplifiedSolver.SC_STEP_TOL]: yup.number().required(),
+    [SimplifiedSolver.MX_NEW_T_STEP]: yup.number().required(),
+    [SimplifiedSolver.MSBSET]: yup.number().integer().required(),
+    [SimplifiedSolver.MX_ITER]: yup.number().integer().required(),
+    [SimplifiedSolver.PRINT_FL]: yup.number().integer().required(),
+    [SimplifiedSolver.OPTIMIZE_ALGEBRAIC_RESIDUALS_EVALUATIONS]: yup.boolean().required(),
+    [SimplifiedSolver.SKIP_NR_IF_INITIAL_GUESS_OK]: yup.boolean().required(),
+    [SimplifiedSolver.ENABLE_SILENT_Z]: yup.boolean().required(),
+    [SimplifiedSolver.OPTIMIZE_RE_INIT_ALGEBRAIC_RESIDUALS_EVALUATIONS]: yup.boolean().required(),
+    [SimplifiedSolver.MINIMUM_MODE_CHANGE_TYPE_FOR_ALGEBRAIC_RESTORATION]: yup.string().required(),
+    [SimplifiedSolver.MINIMUM_MODE_CHANGE_TYPE_FOR_ALGEBRAIC_RESTORATION_INIT]: yup.string().required(),
+    ...getFormSchema()
+  });
+};
+export {
+  getSimplifiedFormSchema
+};

package/dist/components/parameters/dynamic-simulation/solver/sim-solver/simplified-solver-parameters.d.ts

@@ -0,0 +1,3 @@
+export declare function SimplifiedSolverParameters({ path }: Readonly<{
+    path: string;
+}>): import("react/jsx-runtime").JSX.Element;