generic_pivoted_approximant.py
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Fri, May 3, 23:20

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

	from os import mkdir, remove, rmdir
	import numpy as np
	from collections.abc import Iterable
	from copy import deepcopy as copy
	from rrompy.reduction_methods.base.generic_approximant import (
	GenericApproximant)
	from rrompy.utilities.base.data_structures import purgeDict, getNewFilename
	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.piecewise_linear import sparsekinds as sk
	from rrompy.utilities.base.types import Np2D, paramList, List, ListAny
	from rrompy.utilities.base import verbosityManager as vbMng
	from rrompy.utilities.numerical.degree import reduceDegreeN
	from rrompy.utilities.exception_manager import RROMPyException, RROMPyWarning
	from rrompy.parameter import checkParameterList
	from rrompy.utilities.parallel import poolRank, bcast

	__all__ = ['GenericPivotedApproximantNoMatch', 'GenericPivotedApproximant']

	class GenericPivotedApproximantBase(GenericApproximant):
	def __init__(self, directionPivot:ListAny, *args,
	storeAllSamples : bool = False, **kwargs):
	self._preInit()
	if len(directionPivot) > 1:
	raise RROMPyException(("Exactly 1 pivot parameter allowed in pole "
	"matching."))
	from rrompy.parameter.parameter_sampling import (EmptySampler as ES,
	SparseGridSampler as SG)
	self._addParametersToList(["radialDirectionalWeightsMarginal"], [1.],
	["samplerPivot", "SMarginal",
	"samplerMarginal"],
	[ES(), 1, SG([[-1.], [1.]])],
	toBeExcluded = ["sampler"])
	self._directionPivot = directionPivot
	self.storeAllSamples = storeAllSamples
	super().__init__(args, *kwargs)
	self._postInit()

	def setupSampling(self): super().setupSampling(False)

	def initializeModelData(self, datadict):
	if "directionPivot" in datadict.keys():
	from .trained_model.trained_model_pivoted_data import (
	TrainedModelPivotedData)
	return (TrainedModelPivotedData(datadict["mu0"], datadict["mus"],
	datadict.pop("projMat"),
	datadict["scaleFactor"],
	datadict.pop("parameterMap"),
	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

	def checkParameterListPivot(self, mu:paramList,
	check_if_single : bool = False) -> paramList:
	return checkParameterList(mu, self.nparPivot, check_if_single)

	def checkParameterListMarginal(self, mu:paramList,
	check_if_single : bool = False) -> paramList:
	return checkParameterList(mu, self.nparMarginal, check_if_single)

	def mapParameterList(self, args, *kwargs):
	if hasattr(self, "_temporaryPivot"):
	return self.mapParameterListPivot(args, *kwargs)
	return super().mapParameterList(args, *kwargs)

	def mapParameterListPivot(self, mu:paramList, direct : str = "F",
	idx : List[int] = None):
	if idx is None:
	idx = self.directionPivot
	else:
	idx = [self.directionPivot[j] for j in idx]
	return super().mapParameterList(mu, direct, idx)

	def mapParameterListMarginal(self, mu:paramList, direct : str = "F",
	idx : List[int] = None):
	if idx is None:
	idx = self.directionMarginal
	else:
	idx = [self.directionMarginal[j] for j in idx]
	return super().mapParameterList(mu, direct, idx)

	@property
	def mu0(self):
	"""Value of mu0."""
	if hasattr(self, "_temporaryPivot"):
	return self.checkParameterListPivot(self._mu0(self.directionPivot))
	return self._mu0
	@mu0.setter
	def mu0(self, mu0):
	GenericApproximant.mu0.fset(self, mu0)

	@property
	def mus(self):
	"""Value of mus. Its assignment may reset snapshots."""
	return self._mus
	@mus.setter
	def mus(self, mus):
	mus = self.checkParameterList(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 musMarginal(self):
	"""Value of musMarginal. Its assignment may reset snapshots."""
	return self._musMarginal
	@musMarginal.setter
	def musMarginal(self, musMarginal):
	musMarginal = self.checkParameterListMarginal(musMarginal)
	if hasattr(self, '_musMarginal'):
	musMOld = copy(self.musMarginal)
	else:
	musMOld = None
	if (musMOld is None or len(musMarginal) != len(musMOld)
	or not musMarginal == musMOld):
	self.resetSamples()
	self._musMarginal = musMarginal

	@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 radialDirectionalWeightsMarginal(self):
	"""Value of radialDirectionalWeightsMarginal."""
	return self._radialDirectionalWeightsMarginal
	@radialDirectionalWeightsMarginal.setter
	def radialDirectionalWeightsMarginal(self, radialDirWeightsMarg):
	if isinstance(radialDirWeightsMarg, Iterable):
	radialDirWeightsMarg = list(radialDirWeightsMarg)
	else:
	radialDirWeightsMarg = [radialDirWeightsMarg]
	self._radialDirectionalWeightsMarginal = radialDirWeightsMarg
	self._approxParameters["radialDirectionalWeightsMarginal"] = (
	self.radialDirectionalWeightsMarginal)

	@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 muBounds(self):
	"""Value of muBounds."""
	return self.samplerPivot.lims

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

	@property
	def sampler(self):
	"""Proxy of samplerPivot."""
	return self._samplerPivot

	@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
	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
	if not 'samplerOld' in locals() or samplerOld != self.samplerMarginal:
	self.resetSamples()

	def computeScaleFactor(self):
	"""Compute parameter rescaling factor."""
	self.scaleFactorPivot = .5 * np.abs((
	self.mapParameterListPivot(self.muBounds[0])
	- self.mapParameterListPivot(self.muBounds[1]))[0])
	self.scaleFactorMarginal = .5 * np.abs((
	self.mapParameterListMarginal(self.muBoundsMarginal[0])
	- self.mapParameterListMarginal(self.muBoundsMarginal[1]))[0])
	self.scaleFactor = np.empty(self.npar)
	self.scaleFactor[self.directionPivot] = self.scaleFactorPivot
	self.scaleFactor[self.directionMarginal] = self.scaleFactorMarginal

	def _setupTrainedModel(self, pMat:Np2D, pMatUpdate : bool = False,
	forceNew : bool = False):
	pMatEff = self.HFEngine.applyC(pMat) if self.approx_state else pMat
	if forceNew or self.trainedModel is None:
	self.trainedModel = self.tModelType()
	self.trainedModel.verbosity = self.verbosity
	self.trainedModel.timestamp = self.timestamp
	datadict = {"mu0": self.mu0, "mus": copy(self.mus),
	"projMat": pMatEff, "scaleFactor": self.scaleFactor,
	"parameterMap": self.HFEngine.parameterMap,
	"directionPivot": self.directionPivot}
	self.trainedModel.data = self.initializeModelData(datadict)[0]
	else:
	self.trainedModel = self.trainedModel
	if pMatUpdate:
	self.trainedModel.data.projMat = np.hstack(
	(self.trainedModel.data.projMat, pMatEff))
	else:
	self.trainedModel.data.projMat = copy(pMatEff)
	self.trainedModel.data.mus = copy(self.mus)
	self.trainedModel.data.musMarginal = copy(self.musMarginal)

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

	@property
	def storedSamplesFilenames(self) -> List[str]:
	if not hasattr(self, "_sampleBaseFilename"): return []
	return [self._sampleBaseFilename
	+ "{}_{}.pkl" .format(idx + 1, self.name())
	for idx in range(len(self.musMarginal))]

	def purgeStoredSamples(self):
	if not hasattr(self, "_sampleBaseFilename"): return
	for file in self.storedSamplesFilenames: remove(file)
	rmdir(self._sampleBaseFilename[: -8])

	def storeSamples(self, idx : int = None):
	"""Store samples to file."""
	if not hasattr(self, "_sampleBaseFilename"):
	filenameBase = None
	if poolRank() == 0:
	foldername = getNewFilename(self.name(), "samples")
	mkdir(foldername)
	filenameBase = foldername + "/sample_"
	self._sampleBaseFilename = bcast(filenameBase, force = True)
	if idx is not None:
	super().storeSamples(self._sampleBaseFilename + str(idx + 1),
	False)

	def loadTrainedModel(self, filename:str):
	"""Load trained reduced model from file."""
	super().loadTrainedModel(filename)
	self._musMarginal = self.trainedModel.data.musMarginal

	class GenericPivotedApproximantNoMatch(GenericPivotedApproximantBase):
	"""
	ROM pivoted approximant (without 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': 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';
	- '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;
	- '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;
	- '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.
	approx_state: Whether to approximate state.
	verbosity: Verbosity level.
	POD: Kind of snapshots orthogonalization.
	scaleFactorDer: Scaling factors for derivative computation.
	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.
	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.
	"""

	@property
	def tModelType(self):
	from .trained_model.trained_model_pivoted_rational_nomatch import (
	TrainedModelPivotedRationalNoMatch)
	return TrainedModelPivotedRationalNoMatch

	def _finalizeMarginalization(self):
	self.trainedModel.setupMarginalInterp(
	[self.radialDirectionalWeightsMarginal])
	self.trainedModel.data.approxParameters = copy(self.approxParameters)

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

	class GenericPivotedApproximant(GenericPivotedApproximantBase):
	"""
	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': 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.;
	- '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_', '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.
	- '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;
	- '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.
	- '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.
	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.
	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.
	paramsMarginal: Dictionary of parameters for marginal interpolation.
	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 __init__(self, args, *kwargs):
	self._preInit()
	self._addParametersToList(["matchingWeight", "sharedRatio",
	"polybasisMarginal", "paramsMarginal"],
	[1., 1., "MONOMIAL", {}])
	self.parameterMarginalList = ["MMarginal", "nNeighborsMarginal",
	"polydegreetypeMarginal",
	"interpRcondMarginal",
	"radialDirectionalWeightsMarginalAdapt"]
	super().__init__(args, *kwargs)
	self._postInit()

	@property
	def tModelType(self):
	from .trained_model.trained_model_pivoted_rational import (
	TrainedModelPivotedRational)
	return TrainedModelPivotedRational

	@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 sharedRatio(self):
	"""Value of sharedRatio."""
	return self._sharedRatio
	@sharedRatio.setter
	def sharedRatio(self, sharedRatio):
	if sharedRatio > 1.:
	RROMPyWarning("Shared ratio too large. Clipping to 1.")
	sharedRatio = 1.
	elif sharedRatio < 0.:
	RROMPyWarning("Shared ratio too small. Clipping to 0.")
	sharedRatio = 0.
	self._sharedRatio = sharedRatio
	self._approxParameters["sharedRatio"] = self.sharedRatio

	@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 + ["NEARESTNEIGHBOR"] + sk:
	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 paramsMarginal(self):
	"""Value of paramsMarginal."""
	return self._paramsMarginal
	@paramsMarginal.setter
	def paramsMarginal(self, paramsMarginal):
	paramsMarginal = purgeDict(paramsMarginal, self.parameterMarginalList,
	dictname = self.name() + ".paramsMarginal",
	baselevel = 1)
	keyList = list(paramsMarginal.keys())
	if not hasattr(self, "_paramsMarginal"): self._paramsMarginal = {}

	if "MMarginal" in keyList:
	MMarg = paramsMarginal["MMarginal"]
	elif ("MMarginal" in self.paramsMarginal
	and not hasattr(self, "_MMarginal_isauto")):
	MMarg = self.paramsMarginal["MMarginal"]
	else:
	MMarg = "AUTO"
	if isinstance(MMarg, str):
	MMarg = MMarg.strip().replace(" ","")
	if "-" not in MMarg: MMarg = MMarg + "-0"
	self._MMarginal_isauto = True
	self._MMarginal_shift = int(MMarg.split("-")[-1])
	MMarg = 0
	if MMarg < 0:
	raise RROMPyException("MMarginal must be non-negative.")
	self._paramsMarginal["MMarginal"] = MMarg

	if "nNeighborsMarginal" in keyList:
	self._paramsMarginal["nNeighborsMarginal"] = max(1,
	paramsMarginal["nNeighborsMarginal"])
	elif "nNeighborsMarginal" not in self.paramsMarginal:
	self._paramsMarginal["nNeighborsMarginal"] = 1

	if "polydegreetypeMarginal" in keyList:
	try:
	polydegtypeM = paramsMarginal["polydegreetypeMarginal"]\
	.upper().strip().replace(" ","")
	if polydegtypeM not in ["TOTAL", "FULL"]:
	raise RROMPyException(("Prescribed polydegreetypeMarginal "
	"not recognized."))
	self._paramsMarginal["polydegreetypeMarginal"] = polydegtypeM
	except:
	RROMPyWarning(("Prescribed polydegreetypeMarginal not "
	"recognized. Overriding to 'TOTAL'."))
	self._paramsMarginal["polydegreetypeMarginal"] = "TOTAL"
	elif "polydegreetypeMarginal" not in self.paramsMarginal:
	self._paramsMarginal["polydegreetypeMarginal"] = "TOTAL"

	if "interpRcondMarginal" in keyList:
	self._paramsMarginal["interpRcondMarginal"] = (
	paramsMarginal["interpRcondMarginal"])
	elif "interpRcondMarginal" not in self.paramsMarginal:
	self._paramsMarginal["interpRcondMarginal"] = -1

	if "radialDirectionalWeightsMarginalAdapt" in keyList:
	self._paramsMarginal["radialDirectionalWeightsMarginalAdapt"] = (
	paramsMarginal["radialDirectionalWeightsMarginalAdapt"])
	elif "radialDirectionalWeightsMarginalAdapt" not in self.paramsMarginal:
	self._paramsMarginal["radialDirectionalWeightsMarginalAdapt"] = [
	-1., -1.]
	self._approxParameters["paramsMarginal"] = self.paramsMarginal

	def _setMMarginalAuto(self):
	if (self.polybasisMarginal not in ppb + rbpb
	or "MMarginal" not in self.paramsMarginal
	or "polydegreetypeMarginal" not in self.paramsMarginal):
	raise RROMPyException(("Cannot set MMarginal if "
	"polybasisMarginal does not allow it."))
	self.paramsMarginal["MMarginal"] = max(0, reduceDegreeN(
	len(self.musMarginal), len(self.musMarginal),
	self.nparMarginal,
	self.paramsMarginal["polydegreetypeMarginal"])
	- self._MMarginal_shift)
	vbMng(self, "MAIN", ("Automatically setting MMarginal to {}.").format(
	self.paramsMarginal["MMarginal"]), 25)

	def purgeparamsMarginal(self):
	self.paramsMarginal = {}
	paramsMbadkeys = []
	if self.polybasisMarginal in ppb + rbpb + sk:
	paramsMbadkeys += ["nNeighborsMarginal"]
	if self.polybasisMarginal not in rbpb:
	paramsMbadkeys += ["radialDirectionalWeightsMarginalAdapt"]
	if self.polybasisMarginal in ["NEARESTNEIGHBOR"] + sk:
	paramsMbadkeys += ["MMarginal", "polydegreetypeMarginal",
	"interpRcondMarginal"]
	if hasattr(self, "_MMarginal_isauto"): del self._MMarginal_isauto
	if hasattr(self, "_MMarginal_shift"): del self._MMarginal_shift
	for key in paramsMbadkeys:
	if key in self._paramsMarginal: del self._paramsMarginal[key]
	self._approxParameters["paramsMarginal"] = self.paramsMarginal

	def _finalizeMarginalization(self):
	vbMng(self, "INIT", "Checking shared ratio.", 10)
	msg = self.trainedModel.checkSharedRatio(self.sharedRatio)
	vbMng(self, "DEL", "Done checking." + msg, 10)
	if self.polybasisMarginal in rbpb + ["NEARESTNEIGHBOR"]:
	self.computeScaleFactor()
	rDWMEff = np.array([w * f for w, f in zip(
	self.radialDirectionalWeightsMarginal,
	self.scaleFactorMarginal)])
	if self.polybasisMarginal in ppb + rbpb + sk:
	interpPars = [self.polybasisMarginal]
	if self.polybasisMarginal in ppb + rbpb:
	if self.polybasisMarginal in rbpb: interpPars += [rDWMEff]
	interpPars += [self.verbosity >= 5,
	self.paramsMarginal["polydegreetypeMarginal"] == "TOTAL"]
	if self.polybasisMarginal in ppb:
	interpPars += [{}]
	else: # if self.polybasisMarginal in rbpb:
	interpPars += [{"optimizeScalingBounds":self.paramsMarginal[
	"radialDirectionalWeightsMarginalAdapt"]}]
	interpPars += [
	{"rcond":self.paramsMarginal["interpRcondMarginal"]}]
	extraPar = hasattr(self, "_MMarginal_isauto")
	else: # if self.polybasisMarginal in sk:
	idxEff = [x for x in range(self.samplerMarginal.npoints)
	if not hasattr(self.trainedModel, "_idxExcl")
	or x not in self.trainedModel._idxExcl]
	extraPar = self.samplerMarginal.depth[idxEff]
	else: # if self.polybasisMarginal == "NEARESTNEIGHBOR":
	interpPars = [self.paramsMarginal["nNeighborsMarginal"], rDWMEff]
	extraPar = None
	self.trainedModel.setupMarginalInterp(self, interpPars, extraPar)
	self.trainedModel.data.approxParameters = copy(self.approxParameters)

	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 setupApprox(self, args, *kwargs) -> int:
	if self.checkComputedApprox(): return -1
	self.purgeparamsMarginal()
	return super().setupApprox(args, *kwargs)

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