pyforce.online package

Submodules

pyforce.online.geim module

class pyforce.online.geim.GEIM(magic_fun: FunctionsList, magic_sen: FunctionsList, name: str)

Bases: object

This class can be used to perform the online phase of the GEIM algorihtm for synthetic and real measures \(\mathbf{y}\in\mathbb{R}^M\) either obtained as evaluations of the magic sensors on the snapshot \(u(\mathbf{x};\,\boldsymbol{\mu})\) as

\[y_m = v_m(u)+\varepsilon_m \qquad \qquad m = 1, \dots, M\]

given \(\varepsilon_m\) random noise (either present or not), or by real experimental data on the physical system.

Parameters:

• magic_fun (FunctionsList) – List of magic functions computed during the offline phase.

• magic_sen (FunctionsList) – List of magic sensors computed during the offline phase.

• name (str) – Name of the snapshots (e.g., temperature T)

compute_measure(snap: dolfinx.fem.Function, M=None) → ndarray

Computes the measurement vector \(\mathbf{y}\in\mathbb{R}^M\) from the snap \(u\) input, using the magic sensors stored.

\[y_m = v_m(u) \qquad \qquad m = 1, \dots, M\]

If the dimension \(M\) is not given, the whole set of magic sensors is used.

Parameters:

• snap (Function) – Function from which measurements are to be extracted

• M (int, optional (default = None)) – Maximum number of sensor to use (if None is set to the number of magic functions/sensors)

Returns:

measure – Measurement vector :math:mathbf{y}inmathbb{R}^M`

Return type:

np.ndarray

real_reconstruct(measure: ndarray)

The interpolant given the measure vector \(\mathbf{y}\) input is computed, by solving the GEIM linear system

\[\mathbb{B}\boldsymbol{\beta} = \mathbf{y}\]

then the interpolant is computed and returned

\[\mathcal{I}_M(\mathbf{x}) = \sum_{m=1}^M \beta_m[u] \cdot q_m(\mathbf{x})\]

Parameters:

measure (np.ndarray) – Measurement vector, shaped as \(M \times N_s\), given \(M\) the number of sensors used and \(N_s\) the number of parametric realisation.

Returns:

• interp (np.ndarray) – Interpolant Field \(\mathcal{I}_M\) of GEIM

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

reconstruct(snap: ndarray, M, noise_value=None)

The interpolant for snap \(u\) input is computed, by solving the GEIM linear system

\[\mathbb{B}\boldsymbol{\beta} = \mathbf{y}\]

then the inteprolant and residual are computed and returned

\[\mathcal{I}_M[u] = \sum_{m=1}^M \beta_m[u] \cdot q_m\qquad\qquad r_M = \left| u - \mathcal{I}_M[u]\right|\]

Parameters:

• snap (Function as np.ndarray) – Snap to reconstruct, if a function is provided, the variable is reshaped.

• M (int) – Number of sensor to use

• noise_value (float, optional (default = None)) – Standard deviation of the noise, modelled as a normal \(\mathcal{N}(0, \sigma^2)\)

Returns:

• interp (np.ndarray) – Interpolant Field \(\mathcal{I}_M[u]\) of GEIM

• resid (np.ndarray) – Residual Field \(r_M[u]\)

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

synt_test_error(snaps: FunctionsList, M=None, noise_value=None, verbose=False) → namedtuple

The absolute and relative error on the test set is computed, by solving the GEIM linear system

\[\mathbb{B}\boldsymbol{\beta} = \mathbf{y}\]

Parameters:

• snaps (FunctionsList) – List of functions belonging to the test set to reconstruct

• M (int, optional (default = None)) – Maximum number of magic functions to use (if None is set to the number of magic functions/sensors)

• noise_value (float, optional (default = None)) – Standard deviation of the noise, modelled as a normal \(\mathcal{N}(0, \sigma^2)\)

• verbose (boolean, optional (default = False)) – If true, output is printed.

Returns:

• mean_abs_err (np.ndarray) – Average absolute error measured in \(L^2\).

• mean_rel_err (np.ndarray) – Average relative error measured in \(L^2\).

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

pyforce.online.indirect_recon module

class pyforce.online.indirect_recon.PE(B: ndarray, coeff_maps: list, bnds: list)

Bases: object

A class to perform Parameter Estimation (PE) exploiting GEIM and numerical optimisation starting from a set of measurements \(\mathbf{y}\in\mathbb{R}^M\)

\[\hat{\boldsymbol{\mu}} = \text{arg}\,\min\limits_{\boldsymbol{\mu}\in\mathcal{D}} \mathcal{L}_{PE}(\boldsymbol{\mu})\]

Parameters:

• B (np.ndarray) – Lower-triangular matrix \(\mathbb{B}\) of dimension \(M\times M\), arising from GEIM magic function and sensors.

• coeff_maps (list) – List containing the map \(\mathcal{F}_m:\boldsymbol{\mu} \rightarrow \beta_m\).

• bnds (list) – List of tuples, each element contains the mininum and maximum of the components of the parameter.

optimise(measure: ndarray, use_brute=True, grid_elem=10)

This auxiliary function performs the optimisation process given an input collection of measurements.

Two options are available:

• brute force method for finding the first guess of the parameter estimation + Least squares

• differential evolution method for finding the first guess of the parameter estimation + Least squares

Parameters:

• measure (np.ndarray) – Measurement vector of M elements, array-like.

• use_brute (bool, optional (Default = True)) – brute force method for finding the first guess of the parameter estimation

• grid_elem (int, optional (Default = 10)) – Number of elements in the grid for the brute force method

Returns:

• solution (np.ndarray) – Solution of the optimisation (after least squares)

• guess (np.ndarray) – Solution of the optimisation (before least squares)

synt_test_error(test_param: ndarray, test_snaps: FunctionsList, GEIM_msen: FunctionsList, Mmax: int, noise_value=None, use_brute=True, grid_elem=10, verbose=False)

The absolute and relative error of the PE phase, using different measurements coming from the test set, are computed.

Parameters:

• test_param (np.ndarray) – np.ndarray with shape $(N_s, p)$ given $N_s$ the number of samples and $p$ the dimension of the parameter vector

• test_snaps (FunctionsList) – List of functions belonging to the test set, used to generate the measurements

• GEIM_msen (FunctionsList) – List of sensors to mimic the measurement process

• Mmax (int) – Maximum number of sensor to use

• noise_value (float, optional (Default = None)) – Standard deviation of the noise, modelled as a normal \(\mathcal{N}(0, \sigma^2)\).

• use_brute (bool, optional (Default = True)) – brute force method for finding the first guess of the parameter estimation

• grid_elem (int, optional (Default = 10)) – Number of elements in the grid for the brute force method

• verbose (bool, optional (Default = False)) – If true, printing is produced

Returns:

• mean_abs_err (np.ndarray) – Average absolute error of the parameter estimation

• mean_rel_err (np.ndarray) – Average relative error of the parameter estimation

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

• mu_PE (list) – List containing the estimated parameters after least squares at varying number of measurements

• mu_PE_guess (list) – List containing the estimated parameters before least squares at varying number of measurements

pyforce.online.indirect_recon.objective(mu: ndarray, measure: ndarray, B: ndarray, maps: list)

This function evaluates the standard loss function \(\mathcal{L}_{PE}\) to be minimized during the Parameter Estimation phase

\[\mathcal{L}_{PE}(\boldsymbol{\mu}) = \|B\boldsymbol{\beta}(\boldsymbol{\mu}) - \mathbf{y}\|_2^2 \qquad\qquad \text{ given }\mathcal{F}_m(\boldsymbol{\mu}) = \beta_m(\boldsymbol{\mu})\]

given the maps \(\mathcal{F}_m:\boldsymbol{\mu} \rightarrow \beta_m\) (\(m = 1, \dots, M\)).

Parameters:

• mu (np.ndarray) – Input parameter, array-like.

• measure (np.ndarray) – Input measurements of M elements, array-like.

• B (np.ndarray) – Lower-triangular matrix \(\mathbb{B}\) of dimension \(M\times M\).

• maps (list) – List containing the map \(\mathcal{F}_m:\boldsymbol{\mu} \rightarrow \beta_m\).

pyforce.online.pbdw module

class pyforce.online.pbdw.PBDW(basis_functions: FunctionsList, basis_sensors: FunctionsList, name: str, is_H1: bool = False)

Bases: object

A class implementing the online phase of the Parameterised-Background Data-Weak (PBDW) formulation, given a list of sensors’ Riesz representation \(\{g_m\}_{m=1}^M\) for the update space and basis functions \(\{\zeta_n\}_{n=1}^N\) for the reduced one. In particular, the following matrices are defined \((n,n' = 1,\dots,N)\) and \((m,m' = 1,\dots,M)\)

\[\mathbb{A}_{mm'}=\left(g_m,\,g_{m'}\right)_{\mathcal{U}} \qquad \qquad \mathbb{K}_{mn}=\left(g_m,\,\zeta_{n}\right)_{\mathcal{U}}\]

given \(\mathcal{U}\) as the functional space.

Parameters:

• basis_functions (FunctionsList) – List of functions spanning the reduced space

• basis_sensors (FunctionsList) – List of sensors representation spanning the update space

• name (str) – Name of the snapshots (e.g., temperature T)

• is_H1 (boolean, optional (Default= False)) – Boolean indicating whether to use scalar product in \(\mathcal{H}^1\) or \(L^2\).

compute_measure(snap: dolfinx.fem.Function, noise_value: float, M=None) → ndarray

Computes the measurement vector from the snap input, using the basis sensors stored to which synthetic random noise is added. If the dimension M is not given, the whole set of basis sensors is used.

\[y_m = v_m(u) +\varepsilon_m \qquad \qquad m = 1, \dots, M\]

If the dimension \(M\) is not given, the whole set of basis sensors is used.

Parameters:

• snap (Function) – Function from which measurements are to be extracted

• noise_value (float) – Standard deviation of the noise, modelled as a normal \(\mathcal{N}(0, \sigma^2)\)

• M (int, optional (default = None)) – Maximum number of sensor to use (if None is set to the number of basis sensors)

Returns:

measure – Measurement vector :math:mathbf{y}inmathbb{R}^M`

Return type:

np.ndarray

hyperparameter_tuning(snaps: FunctionsList, noise_value: float, xi_lim=[-4, 5], n_samples: int = 10, num_rep_exp: int = 10, N: int | None = None, M: int | None = None, verbose: bool = False)

The hyperparameter \(\xi\) of the PBDW statement is calibrated as the one minimising the absolute error in \(L^2\), namely

\[\hat{\xi} = \text{arg}\,\min\limits_{\xi\in\mathbb{R}^+} E_{M, \xi}\]

given \(E_{M, \xi}\) the average absolute error in \(L^2\) with \(M\) sensors. The optimization problem is solved sampling \(\xi\) in a specific range \(\Xi \subset\mathbb{R}^+\).

Parameters:

• snaps (FunctionsList) – List of functions belonging to the validation set to reconstruct

• noise_value (float) – Standard deviation of the noise, modelled as a normal \(\mathcal{N}(0, \sigma^2)\)

• xi_lim (tuple of floats, optional (Default = [0, 6])) – Lower and upper bound (the input is the exponent for \(10^x\)) of \(\xi\), regularisation parameter of PBDW.

• num_rep_exp (int, optional (Default = 10)) – Number of repeated numerical experiment to ensure statistical robustness

• N (int, optional (Default = None)) – Number of basis function to use (if None is set to the number of basis functions)

• M (int, optional (Default = None)) – Number of sensor to use (if None is set to the number of basis sensors)

• verbose (boolean, optional (default = False)) – If true, output is printed.

Returns:

• xi_opt (float) – Optimal value of \(\hat{\xi}\) per each numerical experiment

• xi_samples (np.ndarray) – Sample values of \(\xi\)

• ave_abs_err (np.ndarray) – Average (also averaged wrt to the num. experiments) absolure reconstruction error associated to each output value of \(\xi_{sample}\)

real_reconstruct(measure: ndarray, N: int | None = None, reg_param: float = 0.0)

The state estimation given the measure vector \(\mathbf{y}\) input is computed, by solving the PBDW linear system

\[\begin{split}\left[ \begin{array}{ccc} \xi \cdot M \cdot \mathbb{I} + \mathbb{A} & & \mathbb{K} \\ & & \\ \mathbb{K}^T & & 0 \end{array} \right] \cdot \left[ \begin{array}{c} \boldsymbol{\alpha} \\ \\ \boldsymbol{\theta} \end{array} \right] = \left[ \begin{array}{c} \mathbf{y} \\ \\ \mathbf{0} \end{array} \right]\end{split}\]

given \(\mathbf{y}\in\mathbb{R}^M\). Then, the full can state for the snapshot \(u\) can be written as

\[u(\mathbf{x};\boldsymbol{\mu}) \simeq z_N(\mathbf{x};\boldsymbol{\mu})+\eta_M(\mathbf{x};\boldsymbol{\mu}) = \sum_{n=1}^N\alpha_n(\boldsymbol{\mu})\cdot \zeta_n(\mathbf{x})+ \sum_{m=1}^M \theta_m(\boldsymbol{\mu})\cdot g_m(\mathbf{x})\]

Parameters:

• measure (np.ndarray) – Measurement vector, shaped as \(M \times N_s\), given \(M\) the number of sensors used and \(N_s\) the number of parametric realisation.

• N (int, optional (default = None)) – Maximum number of basis functions \(\zeta_n\) to use (if None is set to the number of basis functions)

• reg_param (float, optional (default = 0.)) – Hyperparameter \(\xi\) weighting the importance of the model with respect to the measurements.

Returns:

• interp (np.ndarray) – Interpolant Field \(\mathcal{I}_M\) of GEIM

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

reconstruct(snap: ndarray, N: int, M: int, noise_value: float | None = None, reg_param: float = 0.0)

The PBDW system is solved

\[\begin{split}\left[ \begin{array}{ccc} \xi \cdot M \cdot \mathbb{I} + \mathbb{A} & & \mathbb{K} \\ & & \\ \mathbb{K}^T & & 0 \end{array} \right] \cdot \left[ \begin{array}{c} \boldsymbol{\alpha} \\ \\ \boldsymbol{\theta} \end{array} \right] = \left[ \begin{array}{c} \mathbf{y} \\ \\ \mathbf{0} \end{array} \right]\end{split}\]

given \(\mathbf{y}\in\mathbb{R}^M\). Then, the full can state for the snapshot \(u\) can be written as

\[u(\mathbf{x};\boldsymbol{\mu}) \simeq z_N(\mathbf{x};\boldsymbol{\mu})+\eta_M(\mathbf{x};\boldsymbol{\mu}) = \sum_{n=1}^N\alpha_n(\boldsymbol{\mu})\cdot \zeta_n(\mathbf{x})+ \sum_{m=1}^M \theta_m(\boldsymbol{\mu})\cdot g_m(\mathbf{x})\]

Parameters:

• snap (Function as np.ndarray) – Snap to reconstruct, if a function is provided, the variable is reshaped.

• N (int, optional (default = None)) – Maximum number of basis functions \(\zeta_n\) to use (if None is set to the number of basis functions)

• M (int, optional (default = None)) – Maximum number of basis sensors \(g_m\) to use (if None is set to the number of basis sensors)

• noise_value (float, optional (default = None)) – Standard deviation of the noise, modelled as a normal \(\mathcal{N}(0, \sigma^2)\)

• reg_param (float, optional (default = 0.)) – Hyperparameter \(\xi\) weighting the importance of the model with respect to the measurements.

Returns:

• recon (Function) – Function containing the reconstruction using \(M\) sensors

• resid (Function) – Function containing the residual field (absolute difference between interpolant and true field) using \(M\) sensors

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

synt_test_error(test_snap: FunctionsList, N: int | None = None, M: int | None = None, noise_value: float | None = None, reg_param: float = 0.0, verbose: bool = False) → namedtuple

The absolute and relative error on the test set is computed, by solving the PBDW system

\[\begin{split}\left[ \begin{array}{ccc} \xi \cdot M \cdot \mathbb{I} + \mathbb{A} & & \mathbb{K} \\ & & \\ \mathbb{K}^T & & 0 \end{array} \right] \cdot \left[ \begin{array}{c} \boldsymbol{\alpha} \\ \\ \boldsymbol{\theta} \end{array} \right] = \left[ \begin{array}{c} \mathbf{y} \\ \\ \mathbf{0} \end{array} \right]\end{split}\]

given \(\mathbf{y}\in\mathbb{R}^M\). Then, the full can state for the snapshot \(u\) can be written as

\[u(\mathbf{x};\boldsymbol{\mu}) \simeq z_N(\mathbf{x};\boldsymbol{\mu})+\eta_M(\mathbf{x};\boldsymbol{\mu}) = \sum_{n=1}^N\alpha_n(\boldsymbol{\mu})\cdot \zeta_n(\mathbf{x})+ \sum_{m=1}^M \theta_m(\boldsymbol{\mu})\cdot g_m(\mathbf{x})\]

Parameters:

• test_snap (FunctionsList) – List of functions belonging to the test set to reconstruct with PBDW

• N (int, optional (default = None)) – Maximum number of basis functions \(\zeta_n\) to use (if None is set to the number of basis functions)

• M (int, optional (default = None)) – Maximum number of basis sensors \(g_m\) to use (if None is set to the number of basis sensors)

• noise_value (float, optional (default = None)) – Standard deviation of the noise, modelled as a normal \(\mathcal{N}(0, \sigma^2)\)

• reg_param (float, optional (default = 0.)) – Hyperparameter \(\xi\) weighting the importance of the model with respect to the measurements.

• verbose (boolean, optional (default = False)) – If true, output is printed.

Returns:

• mean_abs_err (np.ndarray) – Average absolute error measured in \(L^2\).

• mean_rel_err (np.ndarray) – Average relative error measured in \(L^2\).

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

pyforce.online.pod_interpolation module

class pyforce.online.pod_interpolation.PODI(modes: FunctionsList, maps: list, name: str)

Bases: object

A class to perform the online phase of the POD with Inteprolation (PODI) algorithm, in which the modal coefficients are found from suitable maps \(\mathcal{F}_n:\boldsymbol{\mu} \rightarrow \alpha_n\) (\(n = 1, \dots, N\)).

Parameters:

• modes (FunctionsList) – List of POD modes computed during the offline phase.

• maps (list) – List of maps for the POD modal coefficients, they must be callable. If None, the reduced coefficient must be provided as input later!

• name (str) – Name of the snapshots (e.g., temperature T)

reconstruct(snap: ndarray, mu_estimated: ndarray, maxBasis: int, alpha_coeffs: ndarray | None = None)

After the coefficients of the POD basis are obtained by interpolating using the maps or given as input, the snap is approximated using linear combination of the POD modes.

Parameters:

• snap (Function as np.ndarray) – Snap to reconstruct, if a function is provided, the variable is reshaped.

• mu_estimated (np.ndarray) – Arrays with the estimated parameters from the Parameter Estimation phase, it must have dimension [1, p] in which p the number of parameters.

• maxBasis (int) – Integer input indicating the maximum number of modes to use.

• alpha_coeff (np.ndarray (optional, Default: None)) – Array with the estimated coefficients \(\alpha_n\), they will be used if the input alpha_coeffs is not None.

Returns:

• reconstruction (np.ndarray) – Reconstructed field using maxBasis POD modes.

• resid (np.ndarray) – Residual field using maxBasis POD modes.

synt_test_error(test_snap: FunctionsList, mu_estimated: ndarray, maxBasis: int, alpha_coeffs: ndarray | None = None, verbose=False) → namedtuple

The maximum absolute \(E_N\) and relative \(\varepsilon_N\) error on the test set is computed, by projecting it onto the reduced space in \(L^2\) with the coefficients estimated through callable maps or given as input.

\[E_N = \max\limits_{\boldsymbol{\mu}\in\Xi_{\text{test}}} \left\| u(\mathbf{x};\,\boldsymbol{\mu}) - \sum_{n=1}^N \alpha_n(\boldsymbol{\mu})\cdot \psi_n(\mathbf{x})\right\|_{L^2}\]

\[\varepsilon_N = \max\limits_{\boldsymbol{\mu}\in\Xi_{\text{test}}} \frac{\left\| u(\mathbf{x};\,\boldsymbol{\mu}) - \sum_{n=1}^N \alpha_n(\boldsymbol{\mu})\cdot \psi_n(\mathbf{x})\right\|_{L^2}}{\left\| u(\mathbf{x};\,\boldsymbol{\mu})\right\|_{L^2}}\]

The coefficients of the POD basis are obtained by interpolating using the maps.

Parameters:

• test_snap (FunctionsList) – List of snapshots onto which the test error of the POD basis is performed.

• mu_estimated (np.ndarray) – Arrays with the estimated parameters from the Parameter Estimation phase, it must have dimension [Ns, p] in which Ns is the number of test snapshots and p the number of parameters. If None, the reduced coefficients alpha_coeffs must be given.

• maxBasis (int) – Integer input indicating the maximum number of modes to use.

• alpha_coeff (np.ndarray (optional, Default: None)) – Matrix with the estimated coefficients \(\alpha_n\), they will be used if the input alpha_coeffs is not None.

• verbose (boolean, optional (Default = False)) – If True, print of the progress is enabled.

Returns:

• mean_abs_err (np.ndarray) – Average absolute error measured in \(L^2\).

• mean_rel_err (np.ndarray) – Average relative error measured in \(L^2\).

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

pyforce.online.pod_projection module

class pyforce.online.pod_projection.PODproject(modes: FunctionsList, name: str)

Bases: object

A class to perform the online phase of the POD with projection from true field, in which the modal coefficients are found from the projection of the snapshot onto the reduced space.

Parameters:

• modes (FunctionsList) – List of POD modes computed during the offline phase.

• name (str) – Name of the snapshots (e.g., temperature T)

project(snap: dolfinx.fem.Function, maxBasis: int)

Project snap onto the reduced space of dimension maxBasis, by computing the modal coefficients \(\{\alpha_i\}\)

\[\alpha_i = (u, \psi_i)_{L^2} = \int_\Omega u\cdot \psi_i\,d\Omega\]

Parameters:

• snap (Function) – Snap to project.

• maxBasis (int) – Integer input indicating the maximum number of modes to use.

Returns:

coeff – Modal coefficient obtain by projection with POD modes.

Return type:

np.ndarray

reconstruct(snap: ndarray, maxBasis: int)

The coefficients of the POD basis are obtained by projection, the snap is approximated using linear combination of the POD modes.

Parameters:

• snap (Function as np.ndarray) – Snap to reconstruct, if a function is provided, the variable is reshaped.

• maxBasis (int) – Integer input indicating the maximum number of modes to use.

Returns:

• reconstruction (np.ndarray) – Reconstructed field using maxBasis POD modes.

• resid (np.ndarray) – Residual field using maxBasis POD modes.

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

synt_test_error(test_snap: FunctionsList, maxBasis: int, return_int=False, verbose=False) → namedtuple

The maximum absolute \(E_N\) and relative \(\varepsilon_N\) error on the test set is computed, by projecting it onto the reduced space in \(L^2\)

\[E_N = \max\limits_{\boldsymbol{\mu}\in\Xi_{\text{test}}} \left\| u(\mathbf{x};\,\boldsymbol{\mu}) - \sum_{n=1}^N \alpha_n(\boldsymbol{\mu})\cdot \psi_n(\mathbf{x})\right\|_{L^2}\]

\[\varepsilon_N = \max\limits_{\boldsymbol{\mu}\in\Xi_{\text{test}}} \frac{\left\| u(\mathbf{x};\,\boldsymbol{\mu}) - \sum_{n=1}^N \alpha_n(\boldsymbol{\mu})\cdot \psi_n(\mathbf{x})\right\|_{L^2}}{\left\| u(\mathbf{x};\,\boldsymbol{\mu})\right\|_{L^2}}\]

The coefficients of the POD basis are obtained by interpolating using the maps.

Parameters:

• test_snap (FunctionsList) – List of snapshots onto which the test error of the POD basis is performed.

• maxBasis (int) – Integer input indicating the maximum number of modes to use.

• verbose (boolean, optional (Default = False)) – If True, print of the progress is enabled.

Returns:

• mean_abs_err (np.ndarray) – Average absolute error measured in \(L^2\).

• mean_rel_err (np.ndarray) – Average relative error measured in \(L^2\).

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

pyforce.online.tr_geim module

class pyforce.online.tr_geim.TRGEIM(magic_fun: FunctionsList, magic_sen: FunctionsList, mean_beta: ndarray, std_beta: ndarray, name: str)

Bases: object

This class can be used to perform the online phase of the TR-GEIM algorihtm for synthetic and real measures \(\mathbf{y}\in\mathbb{R}^M\) obtained as evaluations of the magic sensors on the snapshot \(u(\mathbf{x};\,\boldsymbol{\mu})\) as

\[y_m = v_m(u)+\varepsilon_m \qquad \qquad m = 1, \dots, M\]

given \(\varepsilon_m\) random noise, or by real experimental data on the physical system.

Parameters:

• magic_fun (FunctionsList) – List of magic functions computed during the offline phase.

• magic_sen (FunctionsList) – List of magic sensors computed during the offline phase.

• mean_beta (np.ndarray) – Mean values \(\langle\beta_m\rangle\) of the training reduced coefficients

• std_beta (np.ndarray) – Standard deviations \(\sigma_{\beta_m}\) of the training reduced coefficients

• name (str) – Name of the snapshots (e.g., temperature T)

compute_measure(snap: dolfinx.fem.Function, noise_value: float, M=None) → ndarray

Computes the measurement vector from the snap input, using the magic sensors stored to which synthetic random noise is added. If the dimension M is not given, the whole set of magic sensors is used.

\[y_m = v_m(u) +\varepsilon_m \qquad \qquad m = 1, \dots, M\]

If the dimension \(M\) is not given, the whole set of magic sensors is used.

Parameters:

• snap (Function) – Function from which measurements are to be extracted

• noise_value (float) – Standard deviation of the noise, modelled as a normal \(\mathcal{N}(0, \sigma^2)\)

• M (int, optional (default = None)) – Maximum number of sensor to use (if None is set to the number of magic functions/sensors)

Returns:

measure – Measurement vector :math:mathbf{y}inmathbb{R}^M`

Return type:

np.ndarray

hyperparameter_tuning(snaps: FunctionsList, noise_value: float, lambda_lim=[10, 50], n_samples: int = 20, M: int | None = None, verbose=False)

The regularising parameter \(\lambda\) of the TR-GEIM linear system is calibrated as the one minimising the absolute error in \(L^2\), namely

\[\hat{\lambda} = \text{arg}\,\min\limits_{\lambda\in\mathbb{R}^+} E_{M, \lambda}\]

given \(E_{M, \lambda}\) the average absolute error in \(L^2\) with \(M\) sensors. The optimization problem is solved sampling \(\lambda\) in a specific range.

Parameters:

• snaps (FunctionsList) – List of functions belonging to the validation set to reconstruct

• noise_value (float) – Standard deviation of the noise, modelled as a normal \(\mathcal{N}(0, \sigma^2)\)

• lambda_lim (tuple of floats, optional (Default = [10, 50])) – Lower and upper bound for \(\lambda^*\) entering in the regularisation parameter of TR-GEIM as \(\lambda = \lambda^* \cdot \sigma^2\), given \(\sigma^2\) as the variance of the noise.

• n_samples (int, optional (Default = 20)) – Number of samples for the hyperparameter \(\lambda\) to optimize.

• M (int, optional (Default = None)) – Number of sensor to use (if None is set to the number of magic functions/sensors)

• verbose (boolean, optional (default = False)) – If true, output is printed.

Returns:

• lambda_opt (float) – Optimal value of \(\hat{\lambda}\)

• lambda_star_samples (np.ndarray) – Sample values of \(\lambda^\star\) entering the regularising parameter as \(\lambda=\lambda^\star \cdot \sigma^2\)

• ave_abs_err (np.ndarray) – Average absolure reconstruction error associated to each output value of \(\lambda^\star\)

real_reconstruct(measure: ndarray, reg_param: float)

The interpolant given the measure vector \(\mathbf{y}\) input is computed, by solving the GEIM linear system

\[\left(\mathbb{B}^T\mathbb{B}+\lambda \mathbb{T}^T\mathbb{T}\right)\boldsymbol{\beta} = \mathbb{B}^T\mathbf{y}+\lambda \mathbb{T}^T\mathbb{T} \langle{\boldsymbol{\beta}}\rangle\]

then the interpolant is computed and returned

\[\mathcal{I}_M(\mathbf{x}) = \sum_{m=1}^M \beta_m[u] \cdot q_m(\mathbf{x})\]

Parameters:

• measure (np.ndarray) – Measurement vector, shaped as \(M \times N_s\), given \(M\) the number of sensors used and \(N_s\) the number of parametric realisation.

• reg_param (float) – Regularising parameter \(\lambda\)

Returns:

• interp (np.ndarray) – Interpolant Field \(\mathcal{I}_M\) of GEIM

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

reconstruct(snap: ndarray, M: int, noise_value: float, reg_param: float) → Tuple[dolfinx.fem.Function, dolfinx.fem.Function]

The interpolant for snap \(u\) input is computed, by solving the TR-GEIM linear system

\[\left(\mathbb{B}^T\mathbb{B}+\lambda \mathbb{T}^T\mathbb{T}\right)\boldsymbol{\beta} = \mathbb{B}^T\mathbf{y}+\lambda \mathbb{T}^T\mathbb{T} \langle{\boldsymbol{\beta}}\rangle\]

then the inteprolant and residual are computed and returned

\[\mathcal{I}_M[u] = \sum_{m=1}^M \beta_m[u] \cdot q_m\qquad\qquad r_M = \left| u - \mathcal{I}_M[u]\right|\]

Parameters:

• snap (Function as np.ndarray) – Snap to reconstruct, if a function is provided, the variable is reshaped.

• M (int) – Number of sensor to use

• noise_value (float) – Standard deviation of the noise, modelled as a normal \(\mathcal{N}(0, \sigma^2)\)

• reg_param (float) – Regularising parameter \(\lambda\)

Returns:

• interp (Function) – Interpolant Field \(\mathcal{I}_M[u]\) of TR-GEIM

• resid (Function) – Residual Field \(r_M[u]\)

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

• coeff (np.ndarray) – Coefficients of the GEIM expansion \(\boldsymbol{\beta}(\boldsymbol{\mu})\)

synt_test_error(snaps: FunctionsList, noise_value: float, reg_param: float, M=None, verbose=False) → namedtuple

The absolute and relative error on the test set is computed using the reconstruction obtained by solving the TR-GEIM linear system

\[\left(\mathbb{B}^T\mathbb{B}+\lambda \mathbb{T}^T\mathbb{T}\right)\boldsymbol{\beta} = \mathbb{B}^T\mathbf{y}+\lambda \mathbb{T}^T\mathbb{T} \langle{\boldsymbol{\beta}}\rangle\]

Parameters:

• snaps (FunctionsList) – List of functions belonging to the test set to reconstruct

• M (int, optional (default = None)) – Maximum number of magic functions to use (if None is set to the number of magic functions/sensors)

• noise_value (float) – Standard deviation of the noise, modelled as a normal \(\mathcal{N}(0, \sigma^2)\)

• reg_param (float) – Regularising parameter \(\lambda\)

• verbose (boolean, optional (default = False)) – If true, output is printed.

Returns:

• mean_abs_err (np.ndarray) – Average absolute error measured in \(L^2\).

• mean_rel_err (np.ndarray) – Average relative error measured in \(L^2\).

• computational_time (dict) – Dictionary with the CPU time of the most relevant operations during the online phase.

Module contents

pyforce/online.

Online phase of the pyforce library.