generic_pivoted_greedy_approximant.py
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Apr 27, 07:59

generic_pivoted_greedy_approximant.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 abc import abstractmethod
	from copy import deepcopy as copy
	import numpy as np
	from collections.abc import Iterable
	from matplotlib import pyplot as plt
	from rrompy.reduction_methods.pivoted.generic_pivoted_approximant import (
	GenericPivotedApproximantBase,
	GenericPivotedApproximantNoMatch,
	GenericPivotedApproximant)
	from rrompy.reduction_methods.pivoted.gather_pivoted_approximant import (
	gatherPivotedApproximant)
	from rrompy.utilities.base.types import (Np1D, Np2D, Tuple, List, paramVal,
	paramList, ListAny)
	from rrompy.utilities.base import verbosityManager as vbMng
	from rrompy.utilities.numerical import pointMatching
	from rrompy.utilities.numerical.point_distances import chordalMetricAngleMatrix
	from rrompy.utilities.exception_manager import (RROMPyException, RROMPyAssert,
	RROMPyWarning)
	from rrompy.parameter import emptyParameterList
	from rrompy.utilities.parallel import (masterCore, indicesScatter,
	arrayGatherv, isend)

	__all__ = ['GenericPivotedGreedyApproximantNoMatch',
	'GenericPivotedGreedyApproximant']

	class GenericPivotedGreedyApproximantBase(GenericPivotedApproximantBase):
	_allowedEstimatorKindsMarginal = ["LOOK_AHEAD", "LOOK_AHEAD_RECOVER",
	"NONE"]

	def __init__(self, args, *kwargs):
	self._preInit()
	self._addParametersToList(["matchingWeightError",
	"errorEstimatorKindMarginal",
	"greedyTolMarginal", "maxIterMarginal"],
	[0., "NONE", 1e-1, 1e2])
	super().__init__(args, *kwargs)
	self._postInit()

	@property
	def scaleFactorDer(self):
	"""Value of scaleFactorDer."""
	if self._scaleFactorDer == "NONE": return 1.
	if self._scaleFactorDer == "AUTO": return self._scaleFactorOldPivot
	return self._scaleFactorDer
	@scaleFactorDer.setter
	def scaleFactorDer(self, scaleFactorDer):
	if isinstance(scaleFactorDer, (str,)):
	scaleFactorDer = scaleFactorDer.upper()
	elif isinstance(scaleFactorDer, Iterable):
	scaleFactorDer = list(scaleFactorDer)
	self._scaleFactorDer = scaleFactorDer
	self._approxParameters["scaleFactorDer"] = self._scaleFactorDer

	@property
	def samplerMarginal(self):
	"""Value of samplerMarginal."""
	return self._samplerMarginal
	@samplerMarginal.setter
	def samplerMarginal(self, samplerMarginal):
	if 'refine' not in dir(samplerMarginal):
	raise RROMPyException("Marginal sampler type not recognized.")
	GenericPivotedApproximantBase.samplerMarginal.fset(self,
	samplerMarginal)

	@property
	def errorEstimatorKindMarginal(self):
	"""Value of errorEstimatorKindMarginal."""
	return self._errorEstimatorKindMarginal
	@errorEstimatorKindMarginal.setter
	def errorEstimatorKindMarginal(self, errorEstimatorKindMarginal):
	errorEstimatorKindMarginal = errorEstimatorKindMarginal.upper()
	if errorEstimatorKindMarginal not in (
	self._allowedEstimatorKindsMarginal):
	RROMPyWarning(("Marginal error estimator kind not recognized. "
	"Overriding to 'NONE'."))
	errorEstimatorKindMarginal = "NONE"
	self._errorEstimatorKindMarginal = errorEstimatorKindMarginal
	self._approxParameters["errorEstimatorKindMarginal"] = (
	self.errorEstimatorKindMarginal)

	@property
	def matchingWeightError(self):
	"""Value of matchingWeightError."""
	return self._matchingWeightError
	@matchingWeightError.setter
	def matchingWeightError(self, matchingWeightError):
	self._matchingWeightError = matchingWeightError
	self._approxParameters["matchingWeightError"] = (
	self.matchingWeightError)

	@property
	def greedyTolMarginal(self):
	"""Value of greedyTolMarginal."""
	return self._greedyTolMarginal
	@greedyTolMarginal.setter
	def greedyTolMarginal(self, greedyTolMarginal):
	if greedyTolMarginal < 0:
	raise RROMPyException("greedyTolMarginal must be non-negative.")
	if (hasattr(self, "_greedyTolMarginal")
	and self.greedyTolMarginal is not None):
	greedyTolMarginalold = self.greedyTolMarginal
	else:
	greedyTolMarginalold = -1
	self._greedyTolMarginal = greedyTolMarginal
	self._approxParameters["greedyTolMarginal"] = self.greedyTolMarginal
	if greedyTolMarginalold != self.greedyTolMarginal:
	self.resetSamples()

	@property
	def maxIterMarginal(self):
	"""Value of maxIterMarginal."""
	return self._maxIterMarginal
	@maxIterMarginal.setter
	def maxIterMarginal(self, maxIterMarginal):
	if maxIterMarginal <= 0:
	raise RROMPyException("maxIterMarginal must be positive.")
	if (hasattr(self, "_maxIterMarginal")
	and self.maxIterMarginal is not None):
	maxIterMarginalold = self.maxIterMarginal
	else:
	maxIterMarginalold = -1
	self._maxIterMarginal = maxIterMarginal
	self._approxParameters["maxIterMarginal"] = self.maxIterMarginal
	if maxIterMarginalold != self.maxIterMarginal:
	self.resetSamples()

	def resetSamples(self):
	"""Reset samples."""
	super().resetSamples()
	if not hasattr(self, "_temporaryPivot"):
	self._mus = emptyParameterList()
	self._musMarginal = emptyParameterList()
	if hasattr(self, "samplerMarginal"): self.samplerMarginal.reset()
	if hasattr(self, "samplingEngine") and self.samplingEngine is not None:
	self.samplingEngine.resetHistory()

	def _getDistanceApp(self, polesEx:Np1D, resEx:Np2D, muTest:paramVal,
	foci:Tuple[float, float], ground:float) -> float:
	polesAp = self.trainedModel.interpolateMarginalPoles(muTest)[0]
	if self.matchingWeightError != 0:
	resAp = self.trainedModel.interpolateMarginalCoeffs(muTest)[0][
	: len(polesAp), :]
	resEx = self.trainedModel.data.projMat[:,
	: resEx.shape[1]].dot(resEx.T)
	resAp = self.trainedModel.data.projMat[:,
	: resAp.shape[1]].dot(resAp.T)
	else:
	resAp = None
	dist = chordalMetricAngleMatrix(polesEx, polesAp,
	self.matchingWeightError, resEx, resAp,
	self.HFEngine, False)
	pmR, pmC = pointMatching(dist)
	return np.mean(dist[pmR, pmC])

	def getErrorEstimatorMarginalLookAhead(self) -> Np1D:
	if not hasattr(self.trainedModel, "_musMExcl"):
	err = np.zeros(0)
	err[:] = np.inf
	self._musMarginalTestIdxs = np.zeros(0, dtype = int)
	return err
	self._musMarginalTestIdxs = np.array(self.trainedModel._idxExcl,
	dtype = int)
	idx, sizes = indicesScatter(len(self.trainedModel._musMExcl),
	return_sizes = True)
	err = []
	if len(idx) > 0:
	self.verbosity -= 35
	self.trainedModel.verbosity -= 35
	foci = self.samplerPivot.normalFoci()
	ground = self.samplerPivot.groundPotential()
	for j in idx:
	muTest = self.trainedModel._musMExcl[j]
	HITest = self.trainedModel._HIsExcl[j]
	polesEx = HITest.poles
	idxGood = np.logical_not(np.logical_or(np.isinf(polesEx),
	np.isnan(polesEx)))
	polesEx = polesEx[idxGood]
	if self.matchingWeightError != 0:
	resEx = HITest.coeffs[np.where(idxGood)[0]]
	else:
	resEx = None
	if len(polesEx) == 0:
	err += [0.]
	continue
	err += [self._getDistanceApp(polesEx, resEx, muTest,
	foci, ground)]
	self.verbosity += 35
	self.trainedModel.verbosity += 35
	return arrayGatherv(np.array(err), sizes)

	def getErrorEstimatorMarginalNone(self) -> Np1D:
	nErr = len(self.trainedModel.data.musMarginal)
	self._musMarginalTestIdxs = np.arange(nErr)
	return (1. + self.greedyTolMarginal) * np.ones(nErr)

	def errorEstimatorMarginal(self, return_max : bool = False) -> Np1D:
	vbMng(self.trainedModel, "INIT",
	"Evaluating error estimator at mu = {}.".format(
	self.trainedModel.data.musMarginal), 10)
	if self.errorEstimatorKindMarginal == "NONE":
	nErr = len(self.trainedModel.data.musMarginal)
	self._musMarginalTestIdxs = np.arange(nErr)
	err = (1. + self.greedyTolMarginal) * np.ones(nErr)
	else:#if self.errorEstimatorKindMarginal[: 10] == "LOOK_AHEAD":
	err = self.getErrorEstimatorMarginalLookAhead()
	vbMng(self.trainedModel, "DEL", "Done evaluating error estimator", 10)
	if not return_max: return err
	idxMaxEst = np.where(err > self.greedyTolMarginal)[0]
	maxErr = err[idxMaxEst]
	if self.errorEstimatorKindMarginal == "NONE": maxErr = None
	return err, idxMaxEst, maxErr

	def plotEstimatorMarginal(self, est:Np1D, idxMax:List[int],
	estMax:List[float]):
	if self.errorEstimatorKindMarginal == "NONE": return
	if (not (np.any(np.isnan(est)) or np.any(np.isinf(est)))
	and masterCore() and hasattr(self.trainedModel, "_musMExcl")):
	fig = plt.figure(figsize = plt.figaspect(1. / self.nparMarginal))
	for jpar in range(self.nparMarginal):
	ax = fig.add_subplot(1, self.nparMarginal, 1 + jpar)
	musre = np.real(self.trainedModel._musMExcl)
	if len(idxMax) > 0 and estMax is not None:
	maxrej = musre[idxMax, jpar]
	errCP = copy(est)
	idx = np.delete(np.arange(self.nparMarginal), jpar)
	while len(musre) > 0:
	if self.nparMarginal == 1:
	currIdx = np.arange(len(musre))
	else:
	currIdx = np.where(np.isclose(np.sum(
	np.abs(musre[:, idx] - musre[0, idx]), 1), 0.))[0]
	currIdxSorted = currIdx[np.argsort(musre[currIdx, jpar])]
	ax.semilogy(musre[currIdxSorted, jpar],
	errCP[currIdxSorted], 'k.-', linewidth = 1)
	musre = np.delete(musre, currIdx, 0)
	errCP = np.delete(errCP, currIdx)
	ax.semilogy(self.musMarginal.re(jpar),
	(self.greedyTolMarginal,) * len(self.musMarginal),
	'*m')
	if len(idxMax) > 0 and estMax is not None:
	ax.semilogy(maxrej, estMax, 'xr')
	ax.set_xlim(*list(self.samplerMarginal.lims.re(jpar)))
	ax.grid()
	plt.tight_layout()
	plt.show()

	def _addMarginalSample(self, mus:paramList):
	mus = self.checkParameterListMarginal(mus)
	if len(mus) == 0: return
	self._nmusOld, nmus = len(self.musMarginal), len(mus)
	if (hasattr(self, "trainedModel") and self.trainedModel is not None
	and hasattr(self.trainedModel, "_musMExcl")):
	self._nmusOld += len(self.trainedModel._musMExcl)
	vbMng(self, "MAIN",
	("Adding marginal sample point{} no. {}{} at {} to training "
	"set.").format("s" * (nmus > 1), self._nmusOld + 1,
	"--{}".format(self._nmusOld + nmus) * (nmus > 1),
	mus), 3)
	self.musMarginal.append(mus)
	self.setupApproxPivoted(mus)
	self._poleMatching()
	del self._nmusOld
	if (self.errorEstimatorKindMarginal[: 10] == "LOOK_AHEAD"
	and not self.firstGreedyIterM):
	ubRange = len(self.trainedModel.data.musMarginal)
	if hasattr(self.trainedModel, "_idxExcl"):
	shRange = len(self.trainedModel._musMExcl)
	else:
	shRange = 0
	testIdxs = list(range(ubRange + shRange - len(mus),
	ubRange + shRange))
	for j in testIdxs[::-1]:
	self.musMarginal.pop(j - shRange)
	if hasattr(self.trainedModel, "_idxExcl"):
	testIdxs = self.trainedModel._idxExcl + testIdxs
	self._updateTrainedModelMarginalSamples(testIdxs)
	self._finalizeMarginalization()
	self._SMarginal = len(self.musMarginal)
	self._approxParameters["SMarginal"] = self.SMarginal
	self.trainedModel.data.approxParameters["SMarginal"] = self.SMarginal

	def greedyNextSampleMarginal(self, muidx:List[int],
	plotEst : str = "NONE") \
	-> Tuple[Np1D, List[int], float, paramVal]:
	RROMPyAssert(self._mode, message = "Cannot add greedy sample.")
	muidx = self._musMarginalTestIdxs[muidx]
	if (self.errorEstimatorKindMarginal[: 10] == "LOOK_AHEAD"
	and not self.firstGreedyIterM):
	if not hasattr(self.trainedModel, "_idxExcl"):
	raise RROMPyException(("Sample index to be added not present "
	"in trained model."))
	testIdxs = copy(self.trainedModel._idxExcl)
	skippedIdx = 0
	for cj, j in enumerate(self.trainedModel._idxExcl):
	if j in muidx:
	testIdxs.pop(skippedIdx)
	self.musMarginal.insert(self.trainedModel._musMExcl[cj],
	j - skippedIdx)
	else:
	skippedIdx += 1
	if len(self.trainedModel._idxExcl) < (len(muidx)
	+ len(testIdxs)):
	raise RROMPyException(("Sample index to be added not present "
	"in trained model."))
	self._updateTrainedModelMarginalSamples(testIdxs)
	self._SMarginal = len(self.musMarginal)
	self._approxParameters["SMarginal"] = self.SMarginal
	self.trainedModel.data.approxParameters["SMarginal"] = (
	self.SMarginal)
	self.firstGreedyIterM = False
	idxAdded = self.samplerMarginal.refine(muidx)[0]
	self._addMarginalSample(self.samplerMarginal.points[idxAdded])
	errorEstTest, muidx, maxErrorEst = self.errorEstimatorMarginal(True)
	if plotEst == "ALL":
	self.plotEstimatorMarginal(errorEstTest, muidx, maxErrorEst)
	return (errorEstTest, muidx, maxErrorEst,
	self.samplerMarginal.points[muidx])

	def _preliminaryTrainingMarginal(self):
	"""Initialize starting snapshots of solution map."""
	RROMPyAssert(self._mode, message = "Cannot start greedy algorithm.")
	if np.sum(self.samplingEngine.nsamples) > 0: return
	self.resetSamples()
	self._addMarginalSample(self.samplerMarginal.generatePoints(
	self.SMarginal))

	def _preSetupApproxPivoted(self, mus:paramList) \
	-> Tuple[ListAny, ListAny, ListAny]:
	self.computeScaleFactor()
	if self.trainedModel is None:
	self._setupTrainedModel(np.zeros((0, 0)))
	self.trainedModel.data.Qs, self.trainedModel.data.Ps = [], []
	self.trainedModel.data.Psupp = []
	self._trainedModelOld = copy(self.trainedModel)
	self._scaleFactorOldPivot = copy(self.scaleFactor)
	self.scaleFactor = self.scaleFactorPivot
	self._temporaryPivot = 1
	self._musLoc = copy(self.mus)
	idx, sizes = indicesScatter(len(mus), return_sizes = True)
	emptyCores = np.where(np.logical_not(sizes))[0]
	self.verbosity -= 15
	return idx, sizes, emptyCores

	def _postSetupApproxPivoted(self, mus:Np2D, pMat:Np2D, Ps:ListAny,
	Qs:ListAny, sizes:ListAny):
	self.scaleFactor = self._scaleFactorOldPivot
	del self._scaleFactorOldPivot, self._temporaryPivot
	pMat, Ps, Qs, mus, nsamples = gatherPivotedApproximant(pMat, Ps, Qs,
	mus, sizes,
	self.polybasis)
	if len(self._musLoc) > 0:
	self._mus = self.checkParameterList(self._musLoc)
	self._mus.append(mus)
	else:
	self._mus = self.checkParameterList(mus)
	self.trainedModel = self._trainedModelOld
	del self._trainedModelOld
	padLeft = self.trainedModel.data.projMat.shape[1]
	suppNew = np.append(0, np.cumsum(nsamples))
	self._setupTrainedModel(pMat, padLeft > 0)
	self.trainedModel.data.Qs += Qs
	self.trainedModel.data.Ps += Ps
	self.trainedModel.data.Psupp += list(padLeft + suppNew[: -1])
	self.trainedModel.data.approxParameters = copy(self.approxParameters)
	self.verbosity += 15

	def _localPivotedResult(self, pMat:Np2D, req:ListAny, emptyCores:ListAny,
	mus:Np2D) -> Tuple[Np2D, ListAny, Np2D]:
	pMati = self.samplingEngine.projectionMatrix
	musi = self.samplingEngine.mus
	if self.approx_state:
	if self.POD == 1 and not (
	hasattr(self.HFEngine.C, "is_pivot_independent")
	and self.HFEngine.C.is_pivot_independent):
	raise RROMPyException(("Cannot apply mu-dependent C to "
	"orthonormalized samples."))
	pMati = self.HFEngine.applyC(pMati, musi)
	if pMat is None:
	mus = copy(musi.data)
	pMat = copy(pMati)
	if masterCore():
	for dest in emptyCores:
	req += [isend((len(pMat), pMat.dtype, mus.dtype),
	dest = dest, tag = dest)]
	else:
	mus = np.vstack((mus, musi.data))
	pMat = np.hstack((pMat, pMati))
	return pMat, req, mus

	@abstractmethod
	def setupApproxPivoted(self, mus:paramList) -> int:
	if self.checkComputedApproxPivoted(): return -1
	RROMPyAssert(self._mode, message = "Cannot setup approximant.")
	vbMng(self, "INIT", "Setting up pivoted approximant.", 10)
	self._preSetupApproxPivoted()
	data = []
	pass
	self._postSetupApproxPivoted(mus, data)
	vbMng(self, "DEL", "Done setting up pivoted approximant.", 10)
	return 0

	def setupApprox(self, plotEst : str = "NONE") -> int:
	"""Compute greedy snapshots of solution map."""
	if self.checkComputedApprox(): return -1
	RROMPyAssert(self._mode, message = "Cannot start greedy algorithm.")
	vbMng(self, "INIT", "Starting computation of snapshots.", 3)
	max2ErrorEst, self.firstGreedyIterM = np.inf, True
	self._preliminaryTrainingMarginal()
	if self.errorEstimatorKindMarginal == "NONE":
	muidx = []
	else:#if self.errorEstimatorKindMarginal[: 10] == "LOOK_AHEAD":
	muidx = np.arange(len(self.trainedModel.data.musMarginal))
	self._musMarginalTestIdxs = np.array(muidx)
	while self.firstGreedyIterM or (max2ErrorEst > self.greedyTolMarginal
	and self.samplerMarginal.npoints < self.maxIterMarginal):
	errorEstTest, muidx, maxErrorEst, mu = \
	self.greedyNextSampleMarginal(muidx, plotEst)
	if maxErrorEst is None:
	max2ErrorEst = 1. + self.greedyTolMarginal
	else:
	if len(maxErrorEst) > 0:
	max2ErrorEst = np.max(maxErrorEst)
	else:
	max2ErrorEst = np.max(errorEstTest)
	vbMng(self, "MAIN", ("Uniform testing error estimate "
	"{:.4e}.").format(max2ErrorEst), 3)
	if plotEst == "LAST":
	self.plotEstimatorMarginal(errorEstTest, muidx, maxErrorEst)
	vbMng(self, "DEL", ("Done computing snapshots (final snapshot count: "
	"{}).").format(len(self.mus)), 3)
	if (self.errorEstimatorKindMarginal == "LOOK_AHEAD_RECOVER"
	and hasattr(self.trainedModel, "_idxExcl")
	and len(self.trainedModel._idxExcl) > 0):
	vbMng(self, "INIT", "Recovering {} test models.".format(
	len(self.trainedModel._idxExcl)), 7)
	for j, mu in zip(self.trainedModel._idxExcl,
	self.trainedModel._musMExcl):
	self.musMarginal.insert(mu, j)
	self._updateTrainedModelMarginalSamples()
	self._finalizeMarginalization()
	self._SMarginal = len(self.musMarginal)
	self._approxParameters["SMarginal"] = self.SMarginal
	self.trainedModel.data.approxParameters["SMarginal"] = (
	self.SMarginal)
	vbMng(self, "DEL", "Done recovering test models.", 7)
	return 0

	def checkComputedApproxPivoted(self) -> bool:
	return (super().checkComputedApprox()
	and len(self.musMarginal) == len(self.trainedModel.data.musMarginal))

	class GenericPivotedGreedyApproximantNoMatch(
	GenericPivotedGreedyApproximantBase,
	GenericPivotedApproximantNoMatch):
	"""
	ROM pivoted greedy interpolant computation for parametric problems (without
	pole matching) (ABSTRACT).

	Args:
	HFEngine: HF problem solver.
	mu0(optional): Default parameter. Defaults to 0.
	directionPivot(optional): Pivot components. Defaults to [0].
	approxParameters(optional): Dictionary containing values for main
	parameters of approximant. Recognized keys are:
	- 'POD': kind of snapshots orthogonalization; allowed values
	include 0, 1/2, and 1; defaults to 1, i.e. POD;
	- 'scaleFactorDer': scaling factors for derivative computation;
	defaults to 'AUTO';
	- 'matchingWeightError': weight for pole matching optimization in
	error estimation; defaults to 0;
	- 'S': total number of pivot samples current approximant relies
	upon;
	- 'samplerPivot': pivot sample point generator;
	- 'SMarginal': number of starting marginal samples;
	- 'samplerMarginal': marginal sample point generator via sparse
	grid;
	- 'errorEstimatorKindMarginal': kind of marginal error estimator;
	available values include 'LOOK_AHEAD', 'LOOK_AHEAD_RECOVER',
	and 'NONE'; defaults to 'NONE';
	- 'greedyTolMarginal': uniform error tolerance for marginal greedy
	algorithm; defaults to 1e-1;
	- 'maxIterMarginal': maximum number of marginal greedy steps;
	defaults to 1e2;
	- 'radialDirectionalWeightsMarginal': radial basis weights for
	marginal interpolant; defaults to 1.
	Defaults to empty dict.
	approx_state(optional): Whether to approximate state. Defaults to
	False.
	verbosity(optional): Verbosity level. Defaults to 10.

	Attributes:
	HFEngine: HF problem solver.
	mu0: Default parameter.
	directionPivot: Pivot components.
	mus: Array of snapshot parameters.
	musMarginal: Array of marginal snapshot parameters.
	approxParameters: Dictionary containing values for main parameters of
	approximant. Recognized keys are in parameterList.
	parameterListSoft: Recognized keys of soft approximant parameters:
	- 'POD': kind of snapshots orthogonalization;
	- 'scaleFactorDer': scaling factors for derivative computation;
	- 'matchingWeightError': weight for pole matching optimization in
	error estimation;
	- 'errorEstimatorKindMarginal': kind of marginal error estimator;
	- 'greedyTolMarginal': uniform error tolerance for marginal greedy
	algorithm;
	- 'maxIterMarginal': maximum number of marginal greedy steps;
	- 'radialDirectionalWeightsMarginal': radial basis weights for
	marginal interpolant.
	parameterListCritical: Recognized keys of critical approximant
	parameters:
	- 'S': total number of pivot samples current approximant relies
	upon;
	- 'samplerPivot': pivot sample point generator;
	- 'SMarginal': total number of marginal samples current approximant
	relies upon;
	- 'samplerMarginal': marginal sample point generator via sparse
	grid.
	approx_state: Whether to approximate state.
	verbosity: Verbosity level.
	POD: Kind of snapshots orthogonalization.
	scaleFactorDer: Scaling factors for derivative computation.
	matchingWeightError: Weight for pole matching optimization in error
	estimation.
	S: Total number of pivot samples current approximant relies upon.
	samplerPivot: Pivot sample point generator.
	SMarginal: Total number of marginal samples current approximant relies
	upon.
	samplerMarginal: Marginal sample point generator via sparse grid.
	errorEstimatorKindMarginal: Kind of marginal error estimator.
	greedyTolMarginal: Uniform error tolerance for marginal greedy
	algorithm.
	maxIterMarginal: Maximum number of marginal greedy steps.
	radialDirectionalWeightsMarginal: Radial basis weights for marginal
	interpolant.
	muBounds: list of bounds for pivot parameter values.
	muBoundsMarginal: list of bounds for marginal parameter values.
	samplingEngine: Sampling engine.
	uHF: High fidelity solution(s) with parameter(s) lastSolvedHF as
	sampleList.
	lastSolvedHF: Parameter(s) corresponding to last computed high fidelity
	solution(s) as parameterList.
	uApproxReduced: Reduced approximate solution(s) with parameter(s)
	lastSolvedApprox as sampleList.
	lastSolvedApproxReduced: Parameter(s) corresponding to last computed
	reduced approximate solution(s) as parameterList.
	uApprox: Approximate solution(s) with parameter(s) lastSolvedApprox as
	sampleList.
	lastSolvedApprox: Parameter(s) corresponding to last computed
	approximate solution(s) as parameterList.
	"""

	def _poleMatching(self):
	vbMng(self, "INIT", "Compressing poles.", 10)
	self.trainedModel.initializeFromRational()
	vbMng(self, "DEL", "Done compressing poles.", 10)

	def _updateTrainedModelMarginalSamples(self, idx : ListAny = []):
	self.trainedModel.updateEffectiveSamples(idx)

	class GenericPivotedGreedyApproximant(GenericPivotedGreedyApproximantBase,
	GenericPivotedApproximant):
	"""
	ROM pivoted greedy interpolant computation for parametric problems (with
	pole matching) (ABSTRACT).

	Args:
	HFEngine: HF problem solver.
	mu0(optional): Default parameter. Defaults to 0.
	directionPivot(optional): Pivot components. Defaults to [0].
	approxParameters(optional): Dictionary containing values for main
	parameters of approximant. Recognized keys are:
	- 'POD': kind of snapshots orthogonalization; allowed values
	include 0, 1/2, and 1; defaults to 1, i.e. POD;
	- 'scaleFactorDer': scaling factors for derivative computation;
	defaults to 'AUTO';
	- 'matchingWeight': weight for pole matching optimization; defaults
	to 1;
	- 'sharedRatio': required ratio of marginal points to share
	resonance; defaults to 1.;
	- 'matchingWeightError': weight for pole matching optimization in
	error estimation; defaults to 0;
	- 'S': total number of pivot samples current approximant relies
	upon;
	- 'samplerPivot': pivot sample point generator;
	- 'SMarginal': number of starting marginal samples;
	- 'samplerMarginal': marginal sample point generator via sparse
	grid;
	- 'errorEstimatorKindMarginal': kind of marginal error estimator;
	available values include 'LOOK_AHEAD', 'LOOK_AHEAD_RECOVER',
	and 'NONE'; defaults to 'NONE';
	- 'polybasisMarginal': type of polynomial basis for marginal
	interpolation; allowed values include 'MONOMIAL_*',
	'CHEBYSHEV_', 'LEGENDRE_', 'NEARESTNEIGHBOR', and
	'PIECEWISE_LINEAR_*'; defaults to 'MONOMIAL';
	- 'paramsMarginal': dictionary of parameters for marginal
	interpolation; include:
	. 'MMarginal': degree of marginal interpolant; defaults to
	'AUTO', i.e. maximum allowed; not for 'NEARESTNEIGHBOR' or
	'PIECEWISE_LINEAR_*';
	. 'nNeighborsMarginal': number of marginal nearest neighbors;
	defaults to 1; only for 'NEARESTNEIGHBOR';
	. 'polydegreetypeMarginal': type of polynomial degree for
	marginal; defaults to 'TOTAL'; not for 'NEARESTNEIGHBOR' or
	'PIECEWISE_LINEAR_*';
	. 'interpRcondMarginal': tolerance for marginal interpolation;
	defaults to None; not for 'NEARESTNEIGHBOR' or
	'PIECEWISE_LINEAR_*';
	. 'radialDirectionalWeightsMarginalAdapt': bounds for adaptive
	rescaling of marginal radial basis weights; only for
	radial basis.
	- 'greedyTolMarginal': uniform error tolerance for marginal greedy
	algorithm; defaults to 1e-1;
	- 'maxIterMarginal': maximum number of marginal greedy steps;
	defaults to 1e2;
	- 'radialDirectionalWeightsMarginal': radial basis weights for
	marginal interpolant; defaults to 1.
	Defaults to empty dict.
	approx_state(optional): Whether to approximate state. Defaults to
	False.
	verbosity(optional): Verbosity level. Defaults to 10.

	Attributes:
	HFEngine: HF problem solver.
	mu0: Default parameter.
	directionPivot: Pivot components.
	mus: Array of snapshot parameters.
	musMarginal: Array of marginal snapshot parameters.
	approxParameters: Dictionary containing values for main parameters of
	approximant. Recognized keys are in parameterList.
	parameterListSoft: Recognized keys of soft approximant parameters:
	- 'POD': kind of snapshots orthogonalization;
	- 'scaleFactorDer': scaling factors for derivative computation;
	- 'matchingWeight': weight for pole matching optimization;
	- 'sharedRatio': required ratio of marginal points to share
	resonance;
	- 'matchingWeightError': weight for pole matching optimization in
	error estimation;
	- 'errorEstimatorKindMarginal': kind of marginal error estimator;
	- 'polybasisMarginal': type of polynomial basis for marginal
	interpolation;
	- 'paramsMarginal': dictionary of parameters for marginal
	interpolation; include:
	. 'MMarginal': degree of marginal interpolant;
	. 'nNeighborsMarginal': number of marginal nearest neighbors;
	. 'polydegreetypeMarginal': type of polynomial degree for
	marginal;
	. 'interpRcondMarginal': tolerance for marginal interpolation;
	. 'radialDirectionalWeightsMarginalAdapt': bounds for adaptive
	rescaling of marginal radial basis weights.
	- 'greedyTolMarginal': uniform error tolerance for marginal greedy
	algorithm;
	- 'maxIterMarginal': maximum number of marginal greedy steps;
	- 'radialDirectionalWeightsMarginal': radial basis weights for
	marginal interpolant.
	parameterListCritical: Recognized keys of critical approximant
	parameters:
	- 'S': total number of pivot samples current approximant relies
	upon;
	- 'samplerPivot': pivot sample point generator;
	- 'SMarginal': total number of marginal samples current approximant
	relies upon;
	- 'samplerMarginal': marginal sample point generator via sparse
	grid.
	approx_state: Whether to approximate state.
	verbosity: Verbosity level.
	POD: Kind of snapshots orthogonalization.
	scaleFactorDer: Scaling factors for derivative computation.
	matchingWeight: Weight for pole matching optimization.
	sharedRatio: Required ratio of marginal points to share resonance.
	matchingWeightError: Weight for pole matching optimization in error
	estimation.
	S: Total number of pivot samples current approximant relies upon.
	samplerPivot: Pivot sample point generator.
	SMarginal: Total number of marginal samples current approximant relies
	upon.
	samplerMarginal: Marginal sample point generator via sparse grid.
	errorEstimatorKindMarginal: Kind of marginal error estimator.
	polybasisMarginal: Type of polynomial basis for marginal interpolation.
	paramsMarginal: Dictionary of parameters for marginal interpolation.
	greedyTolMarginal: Uniform error tolerance for marginal greedy
	algorithm.
	maxIterMarginal: Maximum number of marginal greedy steps.
	radialDirectionalWeightsMarginal: Radial basis weights for marginal
	interpolant.
	muBounds: list of bounds for pivot parameter values.
	muBoundsMarginal: list of bounds for marginal parameter values.
	samplingEngine: Sampling engine.
	uHF: High fidelity solution(s) with parameter(s) lastSolvedHF as
	sampleList.
	lastSolvedHF: Parameter(s) corresponding to last computed high fidelity
	solution(s) as parameterList.
	uApproxReduced: Reduced approximate solution(s) with parameter(s)
	lastSolvedApprox as sampleList.
	lastSolvedApproxReduced: Parameter(s) corresponding to last computed
	reduced approximate solution(s) as parameterList.
	uApprox: Approximate solution(s) with parameter(s) lastSolvedApprox as
	sampleList.
	lastSolvedApprox: Parameter(s) corresponding to last computed
	approximate solution(s) as parameterList.
	"""

	def _poleMatching(self):
	vbMng(self, "INIT", "Compressing and matching poles.", 10)
	self.trainedModel.initializeFromRational(self.matchingWeight,
	self.HFEngine, False)
	vbMng(self, "DEL", "Done compressing and matching poles.", 10)

	def _updateTrainedModelMarginalSamples(self, idx : ListAny = []):
	self.trainedModel.updateEffectiveSamples(idx, self.matchingWeight,
	self.HFEngine, False)

	def setupApprox(self, args, *kwargs) -> int:
	if self.checkComputedApprox(): return -1
	self.purgeparamsMarginal()
	_polybasisMarginal = self.polybasisMarginal
	self._polybasisMarginal = ("PIECEWISE_LINEAR_"
	+ self.samplerMarginal.kind)
	setupOK = super().setupApprox(args, *kwargs)
	self._polybasisMarginal = _polybasisMarginal
	self._finalizeMarginalization()
	return setupOK

generic_pivoted_greedy_approximant.pyNo OneTemporaryActions

File Metadata

generic_pivoted_greedy_approximant.pyView Options

Event Timeline

generic_pivoted_greedy_approximant.py
No OneTemporary
Actions

generic_pivoted_greedy_approximant.py
View Options