generic_pivoted_approximant.py
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, May 11, 11:40

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
	import numpy as np
	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.sampling import SamplingEngineStandard, SamplingEngineStandardPOD
	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, ListAny
	from rrompy.utilities.base import verbosityManager as vbMng
	from rrompy.utilities.numerical import dot
	from rrompy.utilities.numerical.degree import reduceDegreeN
	from rrompy.utilities.exception_manager import (RROMPyException, RROMPyAssert,
	RROMPyWarning)
	from rrompy.parameter import checkParameterList
	from rrompy.utilities.parallel import poolRank, bcastForce

	__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 QuadratureSampler as QS
	from rrompy.parameter.parameter_sampling import SparseGridSampler as SG
	QSBase = QS([[0.], [1.]], "UNIFORM")
	SGBase = SG([[0.], [1.]], "UNIFORM")
	self._addParametersToList(["cutOffTolerance",
	"radialDirectionalWeightsMarginal"],
	[np.inf, [1.]], ["samplerPivot", "SMarginal",
	"samplerMarginal"], [QSBase, 1, SGBase])
	del QS, SG
	self._directionPivot = directionPivot
	self.storeAllSamples = storeAllSamples
	super().__init__(args, *kwargs)
	self._postInit()

	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:
	SamplingEngine = SamplingEngineStandardPOD
	else:
	SamplingEngine = SamplingEngineStandard
	self.samplingEngine = SamplingEngine(self.HFEngine,
	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["mus"],
	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):
	mus = checkParameterList(mus)[0]
	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 = checkParameterList(musMarginal)[0]
	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 cutOffTolerance(self):
	"""Value of cutOffTolerance."""
	return self._cutOffTolerance
	@cutOffTolerance.setter
	def cutOffTolerance(self, cutOffTolerance):
	self._cutOffTolerance = cutOffTolerance
	self._approxParameters["cutOffTolerance"] = self.cutOffTolerance

	@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, radialDirWeightsMarginal):
	if hasattr(radialDirWeightsMarginal, "__len__"):
	radialDirWeightsMarginal = list(radialDirWeightsMarginal)
	else:
	radialDirWeightsMarginal = [radialDirWeightsMarginal]
	self._radialDirectionalWeightsMarginal = radialDirWeightsMarginal
	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 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 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.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 _setupTrainedModel(self, pMat:Np2D, pMatUpdate : bool = False,
	forceNew : bool = False):
	pMatEff = dot(self.HFEngine.C, 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,
	"rescalingExp": self.HFEngine.rescalingExp,
	"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 = False
	result = super().normApprox(mu)
	self._POD = _PODOld
	return result

	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 = bcastForce(filenameBase)
	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': whether to compute POD of snapshots; defaults to True;
	- 'scaleFactorDer': scaling factors for derivative computation;
	defaults to 'AUTO';
	- 'cutOffTolerance': tolerance for ignoring parasitic poles;
	defaults to np.inf;
	- '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': whether to compute POD of snapshots;
	- 'scaleFactorDer': scaling factors for derivative computation;
	- 'cutOffTolerance': tolerance for ignoring parasitic poles;
	- '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: Whether to compute POD of snapshots.
	scaleFactorDer: Scaling factors for derivative computation.
	cutOffTolerance: Tolerance for ignoring parasitic poles.
	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):
	vbMng(self, "INIT", "Recompressing by cut off.", 10)
	msg = self.trainedModel.recompressByCutOff(self.cutOffTolerance,
	self.samplerPivot.normalFoci(),
	self.samplerPivot.groundPotential())
	vbMng(self, "DEL", "Done recompressing." + msg, 10)
	self.trainedModel.setupMarginalInterp(
	self.radialDirectionalWeightsMarginal)
	self.trainedModel.data.approxParameters = copy(self.approxParameters)

	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': 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;
	- 'matchingMode': mode for pole matching optimization; allowed
	values include 'NONE' and 'SHIFT'; defaults to 'NONE';
	- 'cutOffTolerance': tolerance for ignoring parasitic poles;
	defaults to np.inf;
	- 'cutOffSharedRatio': required ratio of marginal points to share
	resonance in cut off strategy; 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' or
	'PIECEWISE_LINEAR_*';
	. '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'.
	- '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': whether to compute POD of snapshots;
	- 'scaleFactorDer': scaling factors for derivative computation;
	- 'matchingWeight': weight for pole matching optimization;
	- 'matchingMode': mode for pole matching optimization;
	- 'cutOffTolerance': tolerance for ignoring parasitic poles;
	- 'cutOffSharedRatio': required ratio of marginal points to share
	resonance in cut off strategy;
	- '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.
	- '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: Whether to compute POD of snapshots.
	scaleFactorDer: Scaling factors for derivative computation.
	matchingWeight: Weight for pole matching optimization.
	matchingMode: Mode for pole matching optimization.
	cutOffTolerance: Tolerance for ignoring parasitic poles.
	cutOffSharedRatio: Required ratio of marginal points to share resonance
	in 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.
	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", "matchingMode",
	"cutOffSharedRatio", "polybasisMarginal",
	"paramsMarginal"],
	[1., "NONE", 1., "MONOMIAL", {}])
	self.parameterMarginalList = ["MMarginal", "nNeighborsMarginal",
	"polydegreetypeMarginal",
	"interpRcondMarginal"]
	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 matchingMode(self):
	"""Value of matchingMode."""
	return self._matchingMode
	@matchingMode.setter
	def matchingMode(self, matchingMode):
	matchingMode = matchingMode.upper().strip().replace(" ", "")
	if matchingMode != "NONE" and matchingMode[: 5] != "SHIFT":
	raise RROMPyException("Prescribed matching mode not recognized.")
	self._matchingMode = matchingMode
	self._approxParameters["matchingMode"] = self.matchingMode

	@property
	def cutOffSharedRatio(self):
	"""Value of cutOffSharedRatio."""
	return self._cutOffSharedRatio
	@cutOffSharedRatio.setter
	def cutOffSharedRatio(self, cutOffSharedRatio):
	if cutOffSharedRatio > 1.:
	RROMPyWarning("Cut off shared ratio too large. Clipping to 1.")
	cutOffSharedRatio = 1.
	elif cutOffSharedRatio < 0.:
	RROMPyWarning("Cut off shared ratio too small. Clipping to 0.")
	cutOffSharedRatio = 0.
	self._cutOffSharedRatio = cutOffSharedRatio
	self._approxParameters["cutOffSharedRatio"] = self.cutOffSharedRatio

	@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
	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 in ["NEARESTNEIGHBOR"] + sk:
	paramsMbadkeys += ["MMarginal", "polydegreetypeMarginal"]
	if hasattr(self, "_MMarginal_isauto"): del self._MMarginal_isauto
	if hasattr(self, "_MMarginal_shift"): del self._MMarginal_shift
	if self.polybasisMarginal == "NEARESTNEIGHBOR":
	paramsMbadkeys += ["interpRcondMarginal"]
	for key in paramsMbadkeys:
	if key in self._paramsMarginal: del self._paramsMarginal[key]
	self._approxParameters["paramsMarginal"] = self.paramsMarginal

	def _finalizeMarginalization(self):
	vbMng(self, "INIT", "Recompressing by cut off.", 10)
	msg = self.trainedModel.recompressByCutOff(self.cutOffTolerance,
	self.cutOffSharedRatio,
	self.samplerPivot.normalFoci(),
	self.samplerPivot.groundPotential())
	vbMng(self, "DEL", "Done recompressing." + msg, 10)
	if self.polybasisMarginal == "NEARESTNEIGHBOR":
	interpPars = [self.paramsMarginal["nNeighborsMarginal"]]
	else:
	interpPars = [{"rcond":self.paramsMarginal["interpRcondMarginal"]}]
	if self.polybasisMarginal in ppb + rbpb:
	interpPars = [self.verbosity >= 5,
	self.paramsMarginal["polydegreetypeMarginal"] == "TOTAL",
	{}] + interpPars
	extraPar = hasattr(self, "_reduceDegreeNNoWarn")
	if self.polybasisMarginal in ppb:
	rDWMEff = None
	else: #if self.polybasisMarginal in rbpb + ["NEARESTNEIGHBOR"] + sk:
	self.computeScaleFactor()
	rDWMEff = [w * f for w, f in zip(
	self.radialDirectionalWeightsMarginal,
	self.scaleFactorMarginal)]
	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]
	self.trainedModel.setupMarginalInterp(self, interpPars,
	hasattr(self, "_MMarginal_isauto"),
	rDWMEff, extraPar)
	self.trainedModel.data.approxParameters = copy(self.approxParameters)

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