Diffusion RationalROMPy (feature_greedy_coarsening) Browse

rational_interpolant_greedy.py
b9ced405bab8feature_greedy_coarseni…

rational_interpolant_greedy.py
View Options

			# Copyright (C) 2018 by the RROMPy authors
			#
			# This file is part of RROMPy.
			#
			# RROMPy is free software: you can redistribute it and/or modify
			# it under the terms of the GNU Lesser General Public License as published by
			# the Free Software Foundation, either version 3 of the License, or
			# (at your option) any later version.
			#
			# RROMPy is distributed in the hope that it will be useful,
			# but WITHOUT ANY WARRANTY; without even the implied warranty of
			# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			# GNU Lesser General Public License for more details.
			#
			# You should have received a copy of the GNU Lesser General Public License
			# along with RROMPy. If not, see <http://www.gnu.org/licenses/>.
			#

			from copy import copy
			import numpy as np
			from scipy.special import factorial as fact
			from .generic_distributed_greedy_approximant import \
			GenericDistributedGreedyApproximant
			from rrompy.utilities.poly_fitting import (polybases, polyvander, polydomcoeff,
			polyfitname, customFit)
			from rrompy.reduction_methods.distributed import RationalInterpolant
			from rrompy.reduction_methods.trained_model import TrainedModelPade as tModel
			from rrompy.reduction_methods.trained_model import TrainedModelData
			from rrompy.utilities.base.types import DictAny, List, HFEng
			from rrompy.utilities.base import purgeDict, verbosityDepth
			from rrompy.utilities.exception_manager import RROMPyWarning
			from rrompy.utilities.exception_manager import RROMPyException

			__all__ = ['RationalInterpolantGreedy']

			class RationalInterpolantGreedy(GenericDistributedGreedyApproximant,
			RationalInterpolant):
			"""
			ROM greedy rational interpolant computation for parametric problems.

			Args:
			HFEngine: HF problem solver.
			mu0(optional): Default parameter. Defaults to 0.
			approxParameters(optional): Dictionary containing values for main
			parameters of approximant. Recognized keys are:
			- 'POD': whether to compute POD of snapshots; defaults to True;
			- 'muBounds': list of bounds for parameter values; defaults to
			[0, 1];
			- 'S': number of starting training points; defaults to 2;
			- 'sampler': sample point generator; defaults to uniform sampler on
			muBounds;
			- 'basis': type of basis for interpolation; allowed values include
			'MONOMIAL', 'CHEBYSHEV' and 'LEGENDRE'; defaults to 'MONOMIAL';
			- 'Delta': difference between M and N in rational approximant;
			defaults to 0;
			- 'greedyTol': uniform error tolerance for greedy algorithm;
			defaults to 1e-2;
			- 'errorEstimatorKind': kind of error estimator; available values
			include 'EXACT', 'SIMPLIFIED', 'BASIC', and 'BARE'; defaults to
			'SIMPLIFIED';
			- 'maxIter': maximum number of greedy steps; defaults to 1e2;
			- 'refinementRatio': ratio of training points to be exhausted
			before training set refinement; defaults to 0.2;
			- 'nTestPoints': number of test points; defaults to maxIter /
			refinementRatio;
			- 'trainSetGenerator': training sample points generator; defaults
			to Chebyshev sampler within muBounds;
			- 'interpRcond': tolerance for interpolation via numpy.polyfit;
			defaults to None;
			- 'robustTol': tolerance for robust Pade' denominator management;
			defaults to 0.
			Defaults to empty dict.
			homogeneized(optional): Whether to homogeneize Dirichlet BCs. Defaults
			to False.
			verbosity(optional): Verbosity level. Defaults to 10.

			Attributes:
			HFEngine: HF problem solver.
			mu0: Default parameter.
			mus: Array of snapshot parameters.
			homogeneized: Whether to homogeneize Dirichlet BCs.
			approxParameters: Dictionary containing values for main parameters of
			approximant. Recognized keys are in parameterList.
			parameterList: Recognized keys of approximant parameters:
			- 'POD': whether to compute POD of snapshots;
			- 'muBounds': list of bounds for parameter values;
			- 'S': number of starting training points;
			- 'sampler': sample point generator;
			- 'basis': type of basis for interpolation;
			- 'Delta': difference between M and N in rational approximant;
			- 'greedyTol': uniform error tolerance for greedy algorithm;
			- 'errorEstimatorKind': kind of error estimator;
			- 'maxIter': maximum number of greedy steps;
			- 'refinementRatio': ratio of training points to be exhausted
			before training set refinement;
			- 'nTestPoints': number of test points;
			- 'trainSetGenerator': training sample points generator;
			- 'interpRcond': tolerance for interpolation via numpy.polyfit;
			- 'robustTol': tolerance for robust Pade' denominator management.
			extraApproxParameters: List of approxParameters keys in addition to
			mother class's.
			POD: whether to compute POD of snapshots.
			muBounds: list of bounds for parameter values.
			S: number of starting training points.
			sampler: Sample point generator.
			greedyTol: uniform error tolerance for greedy algorithm.
			errorEstimatorKind: kind of error estimator.
			maxIter: maximum number of greedy steps.
			refinementRatio: ratio of training points to be exhausted before
			training set refinement.
			nTestPoints: number of starting training points.
			trainSetGenerator: training sample points generator.
			interpRcond: Tolerance for interpolation via numpy.polyfit.
			robustTol: Tolerance for robust Pade' denominator management.
			estimatorEnergyMatrix: matrix representing inner product for error
			estimation.
			samplingEngine: Sampling engine.
			uHF: High fidelity solution with wavenumber lastSolvedHF as numpy
			complex vector.
			lastSolvedHF: Wavenumber corresponding to last computed high fidelity
			solution.
			uApp: Last evaluated approximant as numpy complex vector.
			"""

			_allowedEstimatorKinds = ["EXACT", "SIMPLIFIED", "BASIC", "BARE"]

			def __init__(self, HFEngine:HFEng, mu0 : complex = 0.,
			approxParameters : DictAny = {}, homogeneized : bool = False,
			verbosity : int = 10, timestamp : bool = True):
			self._preInit()
			self._addParametersToList(["polybasis", "Delta", "errorEstimatorKind",
			"interpRcond", "robustTol"])
			super().__init__(HFEngine = HFEngine, mu0 = mu0,
			approxParameters = approxParameters,
			homogeneized = homogeneized,
			verbosity = verbosity, timestamp = timestamp)
			if self.verbosity >= 7:
			verbosityDepth("INIT", "Computing Taylor blocks of system.",
			timestamp = self.timestamp)
			nAs = self.HFEngine.nAs - 1
			nbs = max(self.HFEngine.nbs, (nAs + 1) * self.homogeneized)
			self.As = [self.HFEngine.A(self.mu0, j + 1) for j in range(nAs)]
			self.bs = [self.HFEngine.b(self.mu0, j, self.homogeneized)
			for j in range(nbs)]
			if self.verbosity >= 7:
			verbosityDepth("DEL", "Done computing Taylor blocks.",
			timestamp = self.timestamp)
			self._postInit()

			@property
			def approxParameters(self):
			"""
			Value of approximant parameters. Its assignment may change robustTol.
			"""
			return self._approxParameters
			@approxParameters.setter
			def approxParameters(self, approxParams):
			approxParameters = purgeDict(approxParams, self.parameterList,
			dictname = self.name() + ".approxParameters",
			baselevel = 1)
			approxParametersCopy = purgeDict(approxParameters, ["polybasis",
			"Delta",
			"errorEstimatorKind",
			"interpRcond",
			"robustTol"],
			True, True, baselevel = 1)
			if "Delta" in list(approxParameters.keys()):
			self._Delta = approxParameters["Delta"]
			elif not hasattr(self, "_Delta") or self._Delta is None:
			self._Delta = 0
			GenericDistributedGreedyApproximant.approxParameters.fset(self,
			approxParametersCopy)
			keyList = list(approxParameters.keys())
			self.Delta = self.Delta
			if "polybasis" in keyList:
			self.polybasis = approxParameters["polybasis"]
			elif not hasattr(self, "_polybasis") or self._polybasis is None:
			self.polybasis = "MONOMIAL"
			if "errorEstimatorKind" in keyList:
			self.errorEstimatorKind = approxParameters["errorEstimatorKind"]
			elif (not hasattr(self, "_errorEstimatorKind")
			or self.errorEstimatorKind is None):
			self.errorEstimatorKind = "SIMPLIFIED"
			if "interpRcond" in keyList:
			self.interpRcond = approxParameters["interpRcond"]
			elif not hasattr(self, "interpRcond") or self.interpRcond is None:
			self.interpRcond = None
			if "robustTol" in keyList:
			self.robustTol = approxParameters["robustTol"]
			elif not hasattr(self, "_robustTol") or self._robustTol is None:
			self.robustTol = 0

			@property
			def polybasis(self):
			"""Value of polybasis."""
			return self._polybasis
			@polybasis.setter
			def polybasis(self, polybasis):
			try:
			polybasis = polybasis.upper().strip().replace(" ","")
			if polybasis not in polybases:
			raise RROMPyException("Sample type not recognized.")
			self._polybasis = polybasis
			except:
			RROMPyWarning(("Prescribed polybasis not recognized. Overriding "
			"to 'MONOMIAL'."))
			self._polybasis = "MONOMIAL"
			self._approxParameters["polybasis"] = self.polybasis

			@property
			def Delta(self):
			"""Value of Delta."""
			return self._Delta
			@Delta.setter
			def Delta(self, Delta):
			if not np.isclose(Delta, np.floor(Delta)):
			raise RROMPyException("Delta must be an integer.")
			if Delta < 0:
			RROMPyWarning(("Error estimator unreliable for Delta < 0. "
			"Overloading of errorEstimator is suggested."))
			else:
			Deltamin = (max(self.HFEngine.nbs,
			self.HFEngine.nAs * self.homogeneized)
			- 1 - 1 * (self.HFEngine.nAs > 1))
			if Delta < Deltamin:
			RROMPyWarning(("Method may be unreliable for selected Delta. "
			"Suggested minimal value of Delta: {}.").format(
			Deltamin))
			self._Delta = Delta
			self._approxParameters["Delta"] = self.Delta

			@property
			def errorEstimatorKind(self):
			"""Value of errorEstimatorKind."""
			return self._errorEstimatorKind
			@errorEstimatorKind.setter
			def errorEstimatorKind(self, errorEstimatorKind):
			errorEstimatorKind = errorEstimatorKind.upper()
			if errorEstimatorKind not in self._allowedEstimatorKinds:
			RROMPyWarning(("Error estimator kind not recognized. Overriding "
			"to 'SIMPLIFIED'."))
			errorEstimatorKind = "SIMPLIFIED"
			self._errorEstimatorKind = errorEstimatorKind
			self._approxParameters["errorEstimatorKind"] = self.errorEstimatorKind

			@property
			def nTestPoints(self):
			"""Value of nTestPoints."""
			return self._nTestPoints
			@nTestPoints.setter
			def nTestPoints(self, nTestPoints):
			if nTestPoints <= np.abs(self.Delta):
			RROMPyWarning(("nTestPoints must be at least abs(Delta) + 1. "
			"Increasing value to abs(Delta) + 1."))
			nTestPoints = np.abs(self.Delta) + 1
			if not np.isclose(nTestPoints, np.int(nTestPoints)):
			raise RROMPyException("nTestPoints must be an integer.")
			nTestPoints = np.int(nTestPoints)
			if hasattr(self, "_nTestPoints") and self.nTestPoints is not None:
			nTestPointsold = self.nTestPoints
			else: nTestPointsold = -1
			self._nTestPoints = nTestPoints
			self._approxParameters["nTestPoints"] = self.nTestPoints
			if nTestPointsold != self.nTestPoints:
			self.resetSamples()

			def errorEstimator(self, mus:List[np.complex]) -> List[np.complex]:
			"""Standard residual-based error estimator."""
			self.setupApprox()
			PM = self.trainedModel.data.P[:, -1]
			if np.any(np.isnan(PM)) or np.any(np.isinf(PM)):
			err = np.empty(len(mus))
			err[:] = np.inf
			return err
			nAs = self.HFEngine.nAs - 1
			nbs = max(self.HFEngine.nbs - 1, nAs * self.homogeneized)
			S = len(self.mus)
			muRTest = self.radiusPade(mus)
			muRTrain = self.radiusPade(self.mus)
			nodalVals = np.prod(np.tile(muRTest.reshape(-1, 1), [1, S])
			- muRTrain.reshape(1, -1), axis = 1)
			denVals = self.trainedModel.getQVal(mus)

			self.assembleReducedResidualBlocks(kind = self.errorEstimatorKind)
			vanderBase = np.polynomial.polynomial.polyvander(muRTest,
			max(nAs, nbs)).T
			radiusb0 = vanderBase[: nbs + 1, :]
			# 'ij,jk,ik->k', resbb, radiusb0, radiusb0.conj()
			b0resb0 = np.sum(self.trainedModel.data.resbb.dot(radiusb0)
			* radiusb0.conj(), axis = 0)
			RHSnorms = np.power(np.abs(b0resb0), .5)
			if self.errorEstimatorKind == "BARE":
			self.assembleReducedResidualGramian(self.trainedModel.data.projMat)
			pDom = self.trainedModel.data.P[:, -1]
			LL = pDom.conj().dot(self.trainedModel.data.gramian.dot(pDom))
			Adiag = self.As[0].diagonal()
			LL = ((self.scaleFactor * np.linalg.norm(Adiag)) ** 2.
			/ np.size(Adiag) * LL)
			elif self.errorEstimatorKind == "BASIC":
			pDom = self.trainedModel.data.P[:, -1]
			LL = pDom.conj().dot(self.trainedModel.data.resAA.dot(pDom))
			else:
			vanderBase = vanderBase[: -1, :]
			delta = S - len(self.trainedModel.data.Q)
			nbsEff = max(0, nbs - delta)
			if self.errorEstimatorKind == "SIMPLIFIED":
			radiusA = np.tensordot(PM, vanderBase[: nAs, :], 0)
			if delta == 0:
			radiusb = (np.abs(self.trainedModel.data.Q[-1])
			* radiusb0[: -1, :])
			else: #if self.errorEstimatorKind == "EXACT":
			momentQ = np.zeros(nbsEff, dtype = np.complex)
			momentQu = np.zeros((S, nAs), dtype = np.complex)
			radiusbTen = np.zeros((nbsEff, nbsEff, len(mus)),
			dtype = np.complex)
			radiusATen = np.zeros((nAs, nAs, len(mus)), dtype = np.complex)
			if nbsEff > 0:
			momentQ[0] = self.trainedModel.data.Q[-1]
			radiusbTen[0, :, :] = vanderBase[: nbsEff, :]
			momentQu[:, 0] = self.trainedModel.data.P[:, -1]
			radiusATen[0, :, :] = vanderBase[: nAs, :]
			Qvals = self.trainedModel.getQVal(self.mus)
			for k in range(1, max(nAs, nbs * (nbsEff > 0))):
			Qvals = Qvals * muRTrain
			if k > delta and k < nbs:
			momentQ[k - delta] = self._fitinv.dot(Qvals)
			radiusbTen[k - delta, k :, :] = (
			radiusbTen[0, : delta - k, :])
			if k < nAs:
			momentQu[:, k] = Qvals * self._fitinv
			radiusATen[k, k :, :] = radiusATen[0, : - k, :]
			if self.POD and nAs > 1:
			momentQu[:, 1 :] = self.samplingEngine.RPOD.dot(
			momentQu[:, 1 :])
			radiusA = np.tensordot(momentQu, radiusATen, 1)
			if nbsEff > 0:
			radiusb = np.tensordot(momentQ, radiusbTen, 1)
			if ((self.errorEstimatorKind == "SIMPLIFIED" and delta == 0)
			or (self.errorEstimatorKind == "EXACT" and nbsEff > 0)):
			# 'ij,jk,ik->k', resbb, radiusb, radiusb.conj()
			ff = np.sum(self.trainedModel.data.resbb[delta + 1 :, delta + 1 :]\
			.dot(radiusb) * radiusb.conj(), axis = 0)
			# 'ijk,jkl,il->l', resAb, radiusA, radiusb.conj()
			Lf = np.sum(np.tensordot(
			self.trainedModel.data.resAb[delta :, :, :], radiusA, 2)
			* radiusb.conj(), axis = 0)
			else:
			ff, Lf = 0., 0.
			if self.errorEstimatorKind not in ["BARE", "BASIC"]:
			# 'ijkl,klt,ijt->t', resAA, radiusA, radiusA.conj()
			LL = np.sum(np.tensordot(self.trainedModel.data.resAA, radiusA, 2)
			* radiusA.conj(), axis = (0, 1))
			jOpt = np.power(np.abs(ff - 2. * np.real(Lf) + LL), .5)
			return (polydomcoeff[self.polybasis](S - 1) * jOpt
			* np.abs(nodalVals / denVals) / RHSnorms)

			def _setupDenominator(self):
			"""Compute Pade' denominator."""
			if self.verbosity >= 7:
			verbosityDepth("INIT", "Starting computation of denominator.",
			timestamp = self.timestamp)
			S = len(self.mus)
			TS = polyvander[self.polybasis](self.radiusPade(self.mus), S - 1).T
			RHS = np.zeros(S)
			RHS[-1] = 1.
			fitOut = customFit(TS, RHS, full = True, rcond = self.interpRcond)
			if self.verbosity >= 2:
			condfit = fitOut[1][2][0] / fitOut[1][2][-1]
			verbosityDepth("MAIN", ("Fitting {} samples with degree {} "
			"through {}... Conditioning of system: "
			"{:.4e}.").format(S, S - 1,
			polyfitname[self.polybasis],
			condfit),
			timestamp = self.timestamp)
			if fitOut[1][1] < S:
			RROMPyWarning(("Polyfit is poorly conditioned. Starting "
			"preemptive termination of computation of "
			"approximant."))
			Q = np.empty(max(self.N, 0) + 1, dtype = np.complex)
			P = np.empty((len(self.mus), max(self.M, 0) + 1),
			dtype = np.complex)
			Q[:] = np.nan
			P[:] = np.nan
			self.trainedModel.data.Q = np.copy(Q)
			self.trainedModel.data.P = np.copy(P)
			self.trainedModel.data.approxParameters = copy(
			self.approxParameters)
			if self.verbosity >= 7:
			verbosityDepth("DEL", "Aborting computation of denominator.",
			timestamp = self.timestamp)
			return
			self._fitinv = fitOut[0]
			while self.N > 0:
			Ghalf = (TS[: self.N + 1, :] * self._fitinv).T
			if self.POD:
			self.Ghalf = self.samplingEngine.RPOD.dot(Ghalf)
			ev, eV = self.findeveVGQR(2)
			else:
			self.Ghalf = self.samplingEngine.samples.dot(Ghalf)
			ev, eV = self.findeveVGQR(2)
			Nstable = np.sum(np.abs(ev) >= self.robustTol * np.linalg.norm(ev))
			if self.N <= Nstable: break
			if self.verbosity >= 2:
			verbosityDepth("MAIN", ("Smallest {} eigenvalues below "
			"tolerance. Reducing N to {}.")\
			.format(self.N - Nstable + 1, Nstable),
			timestamp = self.timestamp)
			self._N = Nstable
			if self.N <= 0:
			self._N = 0
			eV = np.ones((1, 1))
			if self.verbosity >= 7:
			verbosityDepth("DEL", "Done computing denominator.",
			timestamp = self.timestamp)
			return eV[:, 0]

			def _setupNumerator(self):
			"""Compute Pade' numerator."""
			if self.verbosity >= 7:
			verbosityDepth("INIT", "Starting computation of numerator.",
			timestamp = self.timestamp)
			Qevaldiag = np.diag(self.trainedModel.getQVal(self.mus))
			verb = self.trainedModel.verbosity
			self.trainedModel.verbosity = 0
			mus_un, idx_un, cnt_un = np.unique(self.mus, return_inverse = True,
			return_counts = True)
			for j in range(len(mus_un)):
			if cnt_un[j] > 1:
			Q_loc = np.zeros((cnt_un[j], cnt_un[j]), dtype = np.complex)
			for der in range(1, cnt_un[j]):
			Qderj = (self.trainedModel.getQVal(mus_un[j], der)
			/ fact(der))
			Q_loc = Q_loc + Qderj * np.diag(np.ones(cnt_un[j] - der),
			k = - der)
			I = idx_un == j
			I = np.arange(len(self.mus))[I]
			I = np.ix_(I, I)
			Qevaldiag[I] = Qevaldiag[I] + Q_loc
			self.trainedModel.verbosity = verb
			while self.M >= 0:
			fitVander = polyvander[self.polybasis](self.radiusPade(self.mus),
			self.M)
			w = None
			S = len(self.mus)
			if self.M == S - 1: w = "AUTO"
			fitOut = customFit(fitVander, Qevaldiag, full = True, w = w,
			rcond = self.interpRcond)
			if self.verbosity >= 2:
			condfit = fitOut[1][2][0] / fitOut[1][2][-1]
			verbosityDepth("MAIN", ("Fitting {} samples with degree {} "
			"through {}... Conditioning of "
			"system: {:.4e}.").format(
			S, self.M,
			polyfitname[self.polybasis],
			condfit),
			timestamp = self.timestamp)
			if fitOut[1][1] == self.M + 1:
			P = fitOut[0].T
			break
			RROMPyWarning(("Polyfit is poorly conditioned. Reducing M from {} "
			"to {}. Exact snapshot interpolation not "
			"guaranteed.").format(self.M, fitOut[1][1] - 1))
			self._M = fitOut[1][1] - 1
			if self.M < 0:
			raise RROMPyException(("Instability in computation of numerator. "
			"Aborting."))
			return np.atleast_2d(P)

			def setupApprox(self, plotEst : bool = False):
			"""
			Compute Pade' interpolant.
			SVD-based robust eigenvalue management.
			"""
			if self.checkComputedApprox():
			return
			if self.verbosity >= 5:
			verbosityDepth("INIT", "Setting up {}.". format(self.name()),
			timestamp = self.timestamp)
			self.computeScaleFactor()
			self.greedy(plotEst)
			S = len(self.mus)
			self._M = S - 1
			self._N = S - 1
			if self.Delta < 0:
			self._M += self.Delta
			else:
			self._N -= self.Delta

			if self.trainedModel is None:
			self.trainedModel = tModel()
			self.trainedModel.verbosity = self.verbosity
			self.trainedModel.timestamp = self.timestamp
			data = TrainedModelData(self.trainedModel.name(), self.mu0,
			np.copy(self.samplingEngine.samples),
			self.HFEngine.rescalingExp)
			data.polytype = self.polybasis
			data.scaleFactor = self.scaleFactor
			data.mus = np.copy(self.mus)
			self.trainedModel.data = data
			else:
			self.trainedModel.data.projMat = np.copy(
			self.samplingEngine.samples)
			self.trainedModel.data.mus = np.copy(self.mus)
			if min(self.M, self.N) < 0:
			if self.verbosity >= 5:
			verbosityDepth("MAIN", "Minimal sample size not achieved.",
			timestamp = self.timestamp)
			Q = np.empty(max(self.N, 0) + 1, dtype = np.complex)
			P = np.empty((len(self.mus), max(self.M, 0) + 1),
			dtype = np.complex)
			Q[:] = np.nan
			P[:] = np.nan
			self.trainedModel.data.Q = np.copy(Q)
			self.trainedModel.data.P = np.copy(P)
			self.trainedModel.data.approxParameters = copy(
			self.approxParameters)
			if self.verbosity >= 5:
			verbosityDepth("DEL", "Aborting computation of approximant.",
			timestamp = self.timestamp)
			return
			if self.N > 0:
			Q = self._setupDenominator()
			if Q is None:
			if self.verbosity >= 5:
			verbosityDepth("DEL",
			"Aborting computation of approximant.",
			timestamp = self.timestamp)
			return
			else:
			Q = np.ones((1,), dtype = np.complex)
			self.trainedModel.data.Q = np.copy(Q)
			P = self._setupNumerator()
			if self.POD:
			P = self.samplingEngine.RPOD.dot(P)
			self.trainedModel.data.P = np.copy(P)
			if self.verbosity >= 7:
			verbosityDepth("DEL", "Done computing numerator.",
			timestamp = self.timestamp)
			self.trainedModel.data.approxParameters = copy(self.approxParameters)
			if self.verbosity >= 5:
			verbosityDepth("DEL", "Done setting up approximant.",
			timestamp = self.timestamp)

			def assembleReducedResidualBlocks(self, kind : str = "EXACT"):
			"""Build affine blocks of reduced linear system through projections."""
			pMat = self.trainedModel.data.projMat
			scaling = self.trainedModel.data.scaleFactor
			self.assembleReducedResidualBlocksbb(self.bs, pMat, scaling)
			if kind in ["EXACT", "SIMPLIFIED"]:
			self.assembleReducedResidualBlocksAb(self.As, self.bs[1 :],
			pMat, scaling)
			if kind != "BARE":
			self.assembleReducedResidualBlocksAA(self.As, pMat, scaling,
			basic = (kind == "BASIC"))

RROMPy/rrompy/reduction_methods/distributed_greedy/rational_interpolant_greedy.pyb9ced405bab8feature_greedy_coarseni…

rational_interpolant_greedy.pyView Options

RROMPy/rrompy/reduction_methods/distributed_greedy/rational_interpolant_greedy.py
b9ced405bab8feature_greedy_coarseni…

rational_interpolant_greedy.py
View Options