generic_pivoted_approximant.py
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Thu, May 2, 01:34

generic_pivoted_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/>.
	#

	import numpy as np
	from copy import deepcopy as copy
	from rrompy.reduction_methods.base.generic_approximant import (
	GenericApproximant)
	from rrompy.utilities.poly_fitting.polynomial import polybases as ppb
	from rrompy.utilities.poly_fitting.radial_basis import polybases as rbpb
	from rrompy.utilities.poly_fitting.moving_least_squares import (
	polybases as mlspb)
	from rrompy.sampling import (SamplingEnginePivoted, SamplingEnginePivotedPOD,
	SamplingEnginePivotedPODGlobal)
	from rrompy.utilities.base.types import paramList, ListAny
	from rrompy.utilities.base import verbosityManager as vbMng
	from rrompy.utilities.numerical.degree import reduceDegreeN
	from rrompy.utilities.exception_manager import (RROMPyException, RROMPyAssert,
	RROMPyWarning)

	__all__ = ['GenericPivotedApproximant', 'PODGlobal']

	PODGlobal = 2

	class GenericPivotedApproximant(GenericApproximant):
	"""
	ROM pivoted approximant (with pole matching) computation for parametric
	problems (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': whether to compute POD of snapshots; defaults to True;
	- 'scaleFactorDer': scaling factors for derivative computation;
	defaults to 'AUTO';
	- 'matchingWeight': weight for pole matching optimization; defaults
	to 1;
	- 'cutOffTolerance': tolerance for ignoring parasitic poles;
	defaults to np.inf;
	- 'cutOffKind': kind of cut off strategy; available values
	include 'SOFT' and 'HARD'; defaults to 'HARD';
	- '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;
	- 'polybasisMarginal': type of polynomial basis for marginal
	interpolation; allowed values include 'MONOMIAL', 'CHEBYSHEV'
	and 'LEGENDRE'; defaults to 'MONOMIAL';
	- 'MMarginal': degree of marginal interpolant; defaults to 'AUTO',
	i.e. maximum allowed;
	- 'polydegreetypeMarginal': type of polynomial degree for marginal;
	defaults to 'TOTAL';
	- 'radialDirectionalWeightsMarginal': radial basis weights for
	marginal interpolant; defaults to 1;
	- 'nNearestNeighborMarginal': number of marginal nearest neighbors
	considered if polybasisMarginal allows; defaults to -1;
	- 'interpRcondMarginal': tolerance for marginal interpolation;
	defaults to None.
	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': whether to compute POD of snapshots;
	- 'scaleFactorDer': scaling factors for derivative computation;
	- 'matchingWeight': weight for pole matching optimization;
	- 'cutOffTolerance': tolerance for ignoring parasitic poles;
	- 'cutOffKind': kind of cut off strategy;
	- 'polybasisMarginal': type of polynomial basis for marginal
	interpolation;
	- 'MMarginal': degree of marginal interpolant;
	- 'polydegreetypeMarginal': type of polynomial degree for marginal;
	- 'radialDirectionalWeightsMarginal': radial basis weights for
	marginal interpolant;
	- 'nNearestNeighborMarginal': number of marginal nearest neighbors
	considered if polybasisMarginal allows;
	- 'interpRcondMarginal': tolerance for marginal interpolation.
	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.
	approx_state: Whether to approximate state.
	verbosity: Verbosity level.
	POD: Whether to compute POD of snapshots.
	scaleFactorDer: Scaling factors for derivative computation.
	matchingWeight: Weight for pole matching optimization.
	cutOffTolerance: Tolerance for ignoring parasitic poles.
	cutOffKind: Kind of cut off strategy.
	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.
	polybasisMarginal: Type of polynomial basis for marginal interpolation.
	MMarginal: Degree of marginal interpolant.
	polydegreetypeMarginal: Type of polynomial degree for marginal.
	radialDirectionalWeightsMarginal: Radial basis weights for marginal
	interpolant.
	nNearestNeighborMarginal: Number of marginal nearest neighbors
	considered if polybasisMarginal allows.
	interpRcondMarginal: Tolerance for marginal interpolation.
	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 __init__(self, directionPivot:ListAny, args, *kwargs):
	self._preInit()
	if len(directionPivot) > 1:
	raise RROMPyException(("Exactly 1 pivot parameter allowed in pole "
	"matching."))
	from rrompy.parameter.parameter_sampling import QuadratureSampler as QS
	QSBase = QS([[0], [1]], "UNIFORM")
	self._addParametersToList(["matchingWeight", "cutOffTolerance",
	"cutOffKind", "polybasisMarginal",
	"MMarginal", "polydegreetypeMarginal",
	"radialDirectionalWeightsMarginal",
	"nNearestNeighborMarginal",
	"interpRcondMarginal"],
	[1, np.inf, "HARD", "MONOMIAL", "AUTO",
	"TOTAL", [1], -1, -1], ["samplerPivot",
	"SMarginal", "samplerMarginal"],
	[QSBase, [1], QSBase])
	del QS
	self._directionPivot = directionPivot
	super().__init__(args, *kwargs)
	self._postInit()

	@property
	def tModelType(self):
	from .trained_model.trained_model_pivoted import TrainedModelPivoted
	return TrainedModelPivoted

	def setupSampling(self):
	"""Setup sampling engine."""
	RROMPyAssert(self._mode, message = "Cannot setup sampling engine.")
	if not hasattr(self, "_POD") or self._POD is None: return
	if self.POD:
	if self.POD == PODGlobal:
	SamplingEngine = SamplingEnginePivotedPODGlobal
	else:
	SamplingEngine = SamplingEnginePivotedPOD
	else:
	SamplingEngine = SamplingEnginePivoted
	self.samplingEngine = SamplingEngine(self.HFEngine,
	self.directionPivot,
	sample_state = self.approx_state,
	verbosity = self.verbosity)

	def initializeModelData(self, datadict):
	if "directionPivot" in datadict.keys():
	from .trained_model.trained_model_pivoted_data import (
	TrainedModelPivotedData)
	return (TrainedModelPivotedData(datadict["mu0"],
	datadict.pop("projMat"),
	datadict["scaleFactor"],
	datadict.pop("rescalingExp"),
	datadict["directionPivot"]),
	["mu0", "scaleFactor", "directionPivot", "mus"])
	else:
	return super().initializeModelData(datadict)

	@property
	def npar(self):
	"""Number of parameters."""
	if hasattr(self, "_temporaryPivot"): return self.nparPivot
	return super().npar

	@property
	def mus(self):
	"""Value of mus. Its assignment may reset snapshots."""
	return self._mus
	@mus.setter
	def mus(self, mus):
	musOld = copy(self.mus) if hasattr(self, '_mus') else None
	if (musOld is None or len(mus) != len(musOld) or not mus == musOld):
	self.resetSamples()
	self._mus = mus

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

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

	@property
	def cutOffKind(self):
	"""Value of cutOffKind."""
	return self._cutOffKind
	@cutOffKind.setter
	def cutOffKind(self, cutOffKind):
	cutOffKind = cutOffKind.upper()
	if cutOffKind not in ["SOFT", "HARD"]:
	RROMPyWarning(("Cut off kind not recognized. Overriding to "
	"'HARD'."))
	cutOffKind = "HARD"
	self._cutOffKind = cutOffKind
	self._approxParameters["cutOffKind"] = self.cutOffKind

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

	@property
	def polybasisMarginal(self):
	"""Value of polybasisMarginal."""
	return self._polybasisMarginal
	@polybasisMarginal.setter
	def polybasisMarginal(self, polybasisMarginal):
	try:
	polybasisMarginal = polybasisMarginal.upper().strip().replace(" ",
	"")
	if polybasisMarginal not in ppb + rbpb + mlspb:
	raise RROMPyException(
	"Prescribed marginal polybasis not recognized.")
	self._polybasisMarginal = polybasisMarginal
	except:
	RROMPyWarning(("Prescribed marginal polybasis not recognized. "
	"Overriding to 'MONOMIAL'."))
	self._polybasisMarginal = "MONOMIAL"
	self._approxParameters["polybasisMarginal"] = self.polybasisMarginal

	@property
	def MMarginal(self):
	"""Value of MMarginal."""
	return self._MMarginal
	@MMarginal.setter
	def MMarginal(self, MMarginal):
	if isinstance(MMarginal, str):
	MMarginal = MMarginal.strip().replace(" ","")
	if "-" not in MMarginal: MMarginal = MMarginal + "-0"
	self._MMarginal_isauto = True
	self._MMarginal_shift = int(MMarginal.split("-")[-1])
	MMarginal = 0
	if MMarginal < 0:
	raise RROMPyException("MMarginal must be non-negative.")
	self._MMarginal = MMarginal
	self._approxParameters["MMarginal"] = self.MMarginal

	def _setMMarginalAuto(self):
	self.MMarginal = max(0, reduceDegreeN(
	len(self.musMarginal), len(self.musMarginal),
	self.nparMarginal, self.polydegreetypeMarginal
	) - self._MMarginal_shift)
	vbMng(self, "MAIN", ("Automatically setting MMarginal to "
	"{}.").format(self.MMarginal), 25)

	@property
	def polydegreetypeMarginal(self):
	"""Value of polydegreetypeMarginal."""
	return self._polydegreetypeMarginal
	@polydegreetypeMarginal.setter
	def polydegreetypeMarginal(self, polydegreetypeM):
	try:
	polydegreetypeM = polydegreetypeM.upper().strip().replace(" ","")
	if polydegreetypeM not in ["TOTAL", "FULL"]:
	raise RROMPyException(("Prescribed polydegreetypeMarginal not "
	"recognized."))
	self._polydegreetypeMarginal = polydegreetypeM
	except:
	RROMPyWarning(("Prescribed polydegreetypeMarginal not recognized. "
	"Overriding to 'TOTAL'."))
	self._polydegreetypeMarginal = "TOTAL"
	self._approxParameters["polydegreetypeMarginal"] = (
	self.polydegreetypeMarginal)

	@property
	def radialDirectionalWeightsMarginal(self):
	"""Value of radialDirectionalWeightsMarginal."""
	return self._radialDirectionalWeightsMarginal
	@radialDirectionalWeightsMarginal.setter
	def radialDirectionalWeightsMarginal(self, radialDirWeightsMarginal):
	if not hasattr(radialDirWeightsMarginal, "__len__"):
	radialDirWeightsMarginal = [radialDirWeightsMarginal]
	self._radialDirectionalWeightsMarginal = radialDirWeightsMarginal
	self._approxParameters["radialDirectionalWeightsMarginal"] = (
	self.radialDirectionalWeightsMarginal)

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

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

	@property
	def directionPivot(self):
	"""Value of directionPivot. Its assignment may reset snapshots."""
	return self._directionPivot
	@directionPivot.setter
	def directionPivot(self, directionPivot):
	if hasattr(self, '_directionPivot'):
	directionPivotOld = copy(self.directionPivot)
	else:
	directionPivotOld = None
	if (directionPivotOld is None
	or len(directionPivot) != len(directionPivotOld)
	or not directionPivot == directionPivotOld):
	self.resetSamples()
	self._directionPivot = directionPivot

	@property
	def directionMarginal(self):
	return [x for x in range(self.HFEngine.npar) \
	if x not in self.directionPivot]

	@property
	def nparPivot(self):
	return len(self.directionPivot)

	@property
	def nparMarginal(self):
	return self.npar - self.nparPivot

	@property
	def rescalingExpPivot(self):
	return [self.HFEngine.rescalingExp[x] for x in self.directionPivot]

	@property
	def rescalingExpMarginal(self):
	return [self.HFEngine.rescalingExp[x] for x in self.directionMarginal]

	@property
	def muBounds(self):
	"""Value of muBounds."""
	return self.samplerPivot.lims

	@property
	def muBoundsMarginal(self):
	"""Value of muBoundsMarginal."""
	return self.samplerMarginal.lims

	@property
	def samplerPivot(self):
	"""Value of samplerPivot."""
	return self._samplerPivot
	@samplerPivot.setter
	def samplerPivot(self, samplerPivot):
	if 'generatePoints' not in dir(samplerPivot):
	raise RROMPyException("Pivot sampler type not recognized.")
	if hasattr(self, '_samplerPivot') and self._samplerPivot is not None:
	samplerOld = self.samplerPivot
	self._samplerPivot = samplerPivot
	self._approxParameters["samplerPivot"] = self.samplerPivot.__str__()
	if not 'samplerOld' in locals() or samplerOld != self.samplerPivot:
	self.resetSamples()

	@property
	def samplerMarginal(self):
	"""Value of samplerMarginal."""
	return self._samplerMarginal
	@samplerMarginal.setter
	def samplerMarginal(self, samplerMarginal):
	if 'generatePoints' not in dir(samplerMarginal):
	raise RROMPyException("Marginal sampler type not recognized.")
	if (hasattr(self, '_samplerMarginal')
	and self._samplerMarginal is not None):
	samplerOld = self.samplerMarginal
	self._samplerMarginal = samplerMarginal
	self._approxParameters["samplerMarginal"] = (
	self.samplerMarginal.__str__())
	if not 'samplerOld' in locals() or samplerOld != self.samplerMarginal:
	self.resetSamples()

	def setSamples(self, samplingEngine):
	"""Copy samplingEngine and samples."""
	self.mus = copy(samplingEngine.mus[0])
	for sEj in samplingEngine.mus[1:]:
	self.mus.append(sEj)
	super().setSamples(samplingEngine)

	def _finalizeMarginalization(self):
	vbMng(self, "INIT", "Recompressing by cut off.", 10)
	msg = self.trainedModel.recompressByCutOff(
	self.cutOffTolerance, self.cutOffKind,
	self.samplerPivot.normalFoci(),
	self.samplerPivot.groundPotential())
	vbMng(self, "DEL", "Done recompressing." + msg, 10)
	interpPars = [self.verbosity >= 5,
	self.polydegreetypeMarginal == "TOTAL", {}]
	if self.polybasisMarginal not in ppb:
	interpPars[-1]["nNearestNeighbor"] = self.nNearestNeighborMarginal
	if self.polybasisMarginal in ppb + rbpb:
	interpPars += [{"rcond": self.interpRcondMarginal}]
	self.trainedModel.setupMarginalInterp(self, interpPars,
	hasattr(self, "_MMarginal_isauto"),
	self.radialDirectionalWeightsMarginal,
	hasattr(self, "_reduceDegreeNNoWarn"))
	self.trainedModel.data.approxParameters = copy(self.approxParameters)

	def computeScaleFactor(self):
	"""Compute parameter rescaling factor."""
	RROMPyAssert(self._mode, message = "Cannot compute rescaling factor.")
	self.scaleFactorPivot = .5 * np.abs(
	self.muBounds[0] ** self.rescalingExpPivot
	- self.muBounds[1] ** self.rescalingExpPivot)
	self.scaleFactorMarginal = .5 * np.abs(
	self.muBoundsMarginal[0] ** self.rescalingExpMarginal
	- self.muBoundsMarginal[1] ** self.rescalingExpMarginal)
	self.scaleFactor = np.empty(self.npar)
	self.scaleFactor[self.directionPivot] = self.scaleFactorPivot
	self.scaleFactor[self.directionMarginal] = self.scaleFactorMarginal

	def normApprox(self, mu:paramList) -> float:
	_PODOld = self.POD
	self._POD = self.POD == PODGlobal
	result = super().normApprox(mu)
	self._POD = _PODOld
	return result

generic_pivoted_approximant.pyNo OneTemporaryActions

File Metadata

generic_pivoted_approximant.pyView Options

Event Timeline

generic_pivoted_approximant.py
No OneTemporary
Actions

generic_pivoted_approximant.py
View Options