Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F63662733
generic_approximant_lagrange.py
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Tue, May 21, 17:01
Size
8 KB
Mime Type
text/x-python
Expires
Thu, May 23, 17:01 (2 d)
Engine
blob
Format
Raw Data
Handle
17803194
Attached To
R6746 RationalROMPy
generic_approximant_lagrange.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
rrompy.reduction_methods.base.generic_approximant
import
(
GenericApproximant
)
from
rrompy.utilities.base.types
import
DictAny
,
HFEng
from
rrompy.utilities.base
import
purgeDict
,
verbosityDepth
from
rrompy.utilities.exception_manager
import
RROMPyException
,
modeAssert
__all__
=
[
'GenericApproximantLagrange'
]
class
GenericApproximantLagrange
(
GenericApproximant
):
"""
ROM Lagrange interpolant computation for parametric problems (ABSTRACT).
Args:
HFEngine: HF problem solver.
mu0(optional): Default parameter. Defaults to 0.
approxParameters(optional): Dictionary containing values for main
parameters of approximant. Recognized keys are:
- 'POD': whether to compute POD of snapshots; defaults to True;
- 'S': total number of samples current approximant relies upon.
Defaults to empty dict.
homogeneized: Whether to homogeneize Dirichlet BCs. Defaults to False.
verbosity(optional): Verbosity level. Defaults to 10.
Attributes:
HFEngine: HF problem solver.
mu0: Default parameter.
mus: Array of snapshot parameters.
ws: Array of snapshot weigths.
homogeneized: Whether to homogeneize Dirichlet BCs.
approxParameters: Dictionary containing values for main parameters of
approximant. Recognized keys are in parameterList.
parameterList: Recognized keys of approximant parameters:
- 'POD': whether to compute POD of snapshots;
- 'S': total number of snapshots current approximant relies upon.
extraApproxParameters: List of approxParameters keys in addition to
mother class's.
S: Number of solution snapshots over which current approximant is
based upon.
sampler: Sample point generator.
POD: Whether to compute POD of snapshots.
samplingEngine: Sampling engine.
uHF: High fidelity solution with wavenumber lastSolvedHF as numpy
complex vector.
lastSolvedHF: Wavenumber corresponding to last computed high fidelity
solution.
uApp: Last evaluated approximant as numpy complex vector.
"""
def
__init__
(
self
,
HFEngine
:
HFEng
,
mu0
:
complex
=
0.
,
approxParameters
:
DictAny
=
{},
homogeneized
:
bool
=
False
,
verbosity
:
int
=
10
,
timestamp
:
bool
=
True
):
self
.
_preInit
()
self
.
_addParametersToList
([
"S"
])
super
()
.
__init__
(
HFEngine
=
HFEngine
,
mu0
=
mu0
,
approxParameters
=
approxParameters
,
homogeneized
=
homogeneized
,
verbosity
=
verbosity
,
timestamp
=
timestamp
)
from
rrompy.utilities.parameter_sampling
import
QuadratureSampler
self
.
sampler
=
QuadratureSampler
([
0.
,
1.
],
"UNIFORM"
)
del
QuadratureSampler
self
.
_postInit
()
def
setupSampling
(
self
):
"""Setup sampling engine."""
modeAssert
(
self
.
_mode
,
message
=
"Cannot setup sampling engine."
)
if
not
hasattr
(
self
,
"_POD"
)
or
self
.
_POD
is
None
:
return
if
self
.
POD
:
from
rrompy.sampling.linear_problem.sampling_engine_lagrange_pod
\
import
SamplingEngineLagrangePOD
super
()
.
setupSampling
(
SamplingEngineLagrangePOD
)
else
:
from
rrompy.sampling.linear_problem.sampling_engine_lagrange
\
import
SamplingEngineLagrange
super
()
.
setupSampling
(
SamplingEngineLagrange
)
@property
def
mus
(
self
):
"""Value of mus. Its assignment may reset snapshots."""
return
self
.
_mus
@mus.setter
def
mus
(
self
,
mus
):
musOld
=
self
.
mus
if
hasattr
(
self
,
'_mus'
)
else
None
self
.
_mus
=
np
.
array
(
mus
)
# _, musCounts = np.unique(self._mus, return_counts = True)
# if len(np.where(musCounts > 1)[0]) > 0:
# raise RROMPyException("Repeated sample points not allowed.")
if
(
musOld
is
None
or
len
(
self
.
mus
)
!=
len
(
musOld
)
or
not
np
.
allclose
(
self
.
mus
,
musOld
,
1e-14
)):
self
.
resetSamples
()
self
.
autoNode
=
None
@property
def
approxParameters
(
self
):
"""Value of approximant parameters. Its assignment may change S."""
return
self
.
_approxParameters
@approxParameters.setter
def
approxParameters
(
self
,
approxParams
):
approxParameters
=
purgeDict
(
approxParams
,
self
.
parameterList
,
dictname
=
self
.
name
()
+
".approxParameters"
,
baselevel
=
1
)
approxParametersCopy
=
purgeDict
(
approxParameters
,
[
"S"
],
True
,
True
,
baselevel
=
1
)
GenericApproximant
.
approxParameters
.
fset
(
self
,
approxParametersCopy
)
keyList
=
list
(
approxParameters
.
keys
())
if
"S"
in
keyList
:
self
.
S
=
approxParameters
[
"S"
]
elif
not
hasattr
(
self
,
"_S"
)
or
self
.
_S
is
None
:
self
.
S
=
2
@property
def
S
(
self
):
"""Value of S."""
return
self
.
_S
@S.setter
def
S
(
self
,
S
):
if
S
<=
0
:
raise
RROMPyException
(
"S must be positive."
)
if
hasattr
(
self
,
"_S"
)
and
self
.
_S
is
not
None
:
Sold
=
self
.
S
else
:
Sold
=
-
1
self
.
_S
=
S
self
.
_approxParameters
[
"S"
]
=
self
.
S
if
Sold
!=
self
.
S
:
self
.
resetSamples
()
@property
def
sampler
(
self
):
"""Value of sampler."""
return
self
.
_sampler
@sampler.setter
def
sampler
(
self
,
sampler
):
if
'generatePoints'
not
in
dir
(
sampler
):
raise
RROMPyException
(
"Sampler type not recognized."
)
if
hasattr
(
self
,
'_sampler'
)
and
self
.
_sampler
is
not
None
:
samplerOld
=
self
.
sampler
self
.
_sampler
=
sampler
self
.
_approxParameters
[
"sampler"
]
=
self
.
sampler
.
__str__
()
if
not
'samplerOld'
in
locals
()
or
samplerOld
!=
self
.
sampler
:
self
.
resetSamples
()
def
computeSnapshots
(
self
):
"""Compute snapshots of solution map."""
modeAssert
(
self
.
_mode
,
message
=
"Cannot start snapshot computation."
)
if
self
.
samplingEngine
.
samples
is
None
:
if
self
.
verbosity
>=
5
:
verbosityDepth
(
"INIT"
,
"Starting computation of snapshots."
,
timestamp
=
self
.
timestamp
)
self
.
mus
,
self
.
ws
=
self
.
sampler
.
generatePoints
(
self
.
S
)
self
.
samplingEngine
.
iterSample
(
self
.
mus
,
homogeneized
=
self
.
homogeneized
)
if
self
.
verbosity
>=
5
:
verbosityDepth
(
"DEL"
,
"Done computing snapshots."
,
timestamp
=
self
.
timestamp
)
def
normApprox
(
self
,
mu
:
complex
,
homogeneized
:
bool
=
False
)
->
float
:
"""
Compute norm of approximant at arbitrary parameter.
Args:
mu: Target parameter.
homogeneized(optional): Whether to remove Dirichlet BC. Defaults to
False.
Returns:
Target norm of approximant.
"""
if
not
self
.
POD
or
self
.
homogeneized
!=
homogeneized
:
return
super
()
.
normApprox
(
mu
,
homogeneized
)
return
np
.
linalg
.
norm
(
self
.
getApproxReduced
(
mu
))
def
computeScaleFactor
(
self
):
"""Compute parameter rescaling factor."""
modeAssert
(
self
.
_mode
,
message
=
"Cannot compute rescaling factor."
)
self
.
scaleFactor
=
.
5
*
np
.
abs
(
np
.
power
(
self
.
sampler
.
lims
[
0
],
self
.
HFEngine
.
rescalingExp
)
-
np
.
power
(
self
.
sampler
.
lims
[
1
],
self
.
HFEngine
.
rescalingExp
))
Event Timeline
Log In to Comment