P1LagrangeEvaluation¶

(Source code, png)

class P1LagrangeEvaluation(*args)¶

Evaluation of a P1 Lagrange interpolation over a field.

Available constructors:

P1LagrangeEvaluation(field)

Parameters:

fieldField: Field $\cF$ defining the parameters of a P1 Lagrange interpolation function.

Methods

`draw`(*args)	Draw the output of function as a `Graph`.
`drawCrossCuts`(*args)	Draw the 2D and 1D cross cuts of a 1D output function as a `GridLayout`.
`getCallsNumber`()	Accessor to the number of times the function has been called.
`getCheckOutput`()	Accessor to the output verification flag.
`getClassName`()	Accessor to the object's name.
`getDescription`()	Accessor to the description of the inputs and outputs.
`getEnclosingSimplexAlgorithm`()	Accessor to the algorithm used to find the simplex containing a given point.
`getField`()	Accessor to the field defining the functions.
`getInputDescription`()	Accessor to the description of the inputs.
`getInputDimension`()	Accessor to the number of the inputs.
`getMarginal`(*args)	Accessor to marginal.
`getMesh`()	Accessor to the mesh over which the interpolation is defined.
`getName`()	Accessor to the object's name.
`getNearestNeighbourAlgorithm`()	Accessor to the algorithm used to find the vertex nearest to a given point.
`getOutputDescription`()	Accessor to the description of the outputs.
`getOutputDimension`()	Accessor to the number of the outputs.
`getParameter`()	Accessor to the parameter values.
`getParameterDescription`()	Accessor to the parameter description.
`getParameterDimension`()	Accessor to the dimension of the parameter.
`getValues`()	Accessor to the values in which the interpolation is done.
`hasName`()	Test if the object is named.
`isActualImplementation`()	Accessor to the validity flag.
`isLinear`()	Accessor to the linearity of the evaluation.
`isLinearlyDependent`(index)	Accessor to the linearity of the evaluation with regard to a specific variable.
`parameterGradient`(inP)	Gradient against the parameters.
`setCheckOutput`(checkOutput)	Accessor to the output verification flag.
`setDescription`(description)	Accessor to the description of the inputs and outputs.
`setEnclosingSimplexAlgorithm`(enclosingSimplex)	Accessor to the algorithm used to find the simplex containing a given point.
`setField`(field)	Accessor to the field defining the functions.
`setInputDescription`(inputDescription)	Accessor to the description of the inputs.
`setMesh`(mesh)	Accessor to the mesh over which the interpolation is defined.
`setName`(name)	Accessor to the object's name.
`setNearestNeighbourAlgorithm`(nearestNeighbour)	Accessor to the algorithm used to find the vertex nearest to a given point.
`setOutputDescription`(outputDescription)	Accessor to the description of the outputs.
`setParameter`(parameters)	Accessor to the parameter values.
`setParameterDescription`(description)	Accessor to the parameter description.
`setStopCallback`(callBack[, state])	Set up a stop callback.
`setValues`(values)	Accessor to the values in which the interpolation is done.

See also

Function, AggregatedEvaluation, DualLinearCombinationEvaluation
LinearFunction

Notes

It returns a Function that implements the P1 Lagrange interpolation function $f : \cD_N \rightarrow \Rset^p$ :

$\forall \vect{x} \in \Rset^n, f(\vect{x}) = \sum_{\vect{\xi}_i\in\cV(\vect{x})}\alpha_i f(\vect{\xi}_i)$

where $\cD_N$ is a Mesh, $\cV(\vect{x})$ is the simplex in $\cD_N$ that contains $\vect{x}$ , $\alpha_i$ are the barycentric coordinates of $\vect{x}$ wrt the vertices $\vect{\xi}_i$ of $\cV(\vect{x})$ :

$\vect{x}=\sum_{\vect{\xi}_i\in\cV(\vect{x})}\alpha_i\vect{\xi}_i$

Examples

Create a P1 Lagrange evaluation:

>>> import openturns as ot
>>> field = ot.Field(ot.RegularGrid(0.0, 1.0, 4), [[0.5], [1.5], [1.0], [-0.5]])
>>> evaluation = ot.P1LagrangeEvaluation(field)
>>> print(evaluation([2.3]))
[0.55]

__init__(*args)¶

draw(*args)¶

Draw the output of function as a Graph.

Available usages:

draw(inputMarg, outputMarg, CP, xiMin, xiMax, ptNb, scale)

draw(firstInputMarg, secondInputMarg, outputMarg, CP, xiMin_xjMin, xiMax_xjMax, ptNbs, scale, isFilled)

draw(xiMin, xiMax, ptNb, scale)

draw(xiMin_xjMin, xiMax_xjMax, ptNbs, scale)

Parameters:

outputMarg, inputMargint, $outputMarg, inputMarg \geq 0$

outputMarg is the index of the marginal to draw as a function of the marginal with index inputMarg.

firstInputMarg, secondInputMargint, $firstInputMarg, secondInputMarg \geq 0$

In the 2D case, the marginal outputMarg is drawn as a function of the two marginals with indexes firstInputMarg and secondInputMarg.

CPsequence of float

Central point.

xiMin, xiMaxfloat

Define the interval where the curve is plotted.

xiMin_xjMin, xiMax_xjMaxsequence of float of dimension 2.

In the 2D case, define the intervals where the curves are plotted.

ptNbint $ptNb > 0$

The number of points to draw the curves.

ptNbssequence of int of dimension 2 $ptNbs_k > 0, k=1,2$

The number of points to draw the contour in the 2D case.

scalebool

scale indicates whether the logarithmic scale is used either for one or both axes:

ot.GraphImplementation.NONE or 0: no log scale is used,
ot.GraphImplementation.LOGX or 1: log scale is used only for horizontal data,
ot.GraphImplementation.LOGY or 2: log scale is used only for vertical data,
ot.GraphImplementation.LOGXY or 3: log scale is used for both data.

isFilledbool

isFilled indicates whether the contour graph is filled or not

Notes

We note $f: \Rset^n \rightarrow \Rset^p$ where $\vect{x} = (x_1, \dots, x_n)$ and $f(\vect{x}) = (f_1(\vect{x}), \dots,f_p(\vect{x}))$ , with $n\geq 1$ and $p\geq 1$ .

In the first usage:

Draws graph of the given 1D outputMarg marginal $f_k: \Rset^n \rightarrow \Rset$ as a function of the given 1D inputMarg marginal with respect to the variation of $x_i$ in the interval $[x_i^{min}, x_i^{max}]$ , when all the other components of $\vect{x}$ are fixed to the corresponding ones of the central point CP. Then it draws the graph: $t\in [x_i^{min}, x_i^{max}] \mapsto f_k(CP_1, \dots, CP_{i-1}, t, CP_{i+1} \dots, CP_n)$ .

In the second usage:

Draws the iso-curves of the given outputMarg marginal $f_k$ as a function of the given 2D firstInputMarg and secondInputMarg marginals with respect to the variation of $(x_i, x_j)$ in the interval $[x_i^{min}, x_i^{max}] \times [x_j^{min}, x_j^{max}]$ , when all the other components of $\vect{x}$ are fixed to the corresponding ones of the central point CP. Then it draws the graph: $(t,u) \in [x_i^{min}, x_i^{max}] \times [x_j^{min}, x_j^{max}] \mapsto f_k(CP_1, \dots, CP_{i-1}, t, CP_{i+1}, \dots, CP_{j-1}, u, CP_{j+1} \dots, CP_n)$ .

In the third usage:

The same as the first usage but only for function $f: \Rset \rightarrow \Rset$ .

In the fourth usage:

The same as the second usage but only for function $f: \Rset^2 \rightarrow \Rset$ .

Examples

>>> import openturns as ot
>>> from openturns.viewer import View
>>> f = ot.SymbolicFunction(['x'], ['sin(2*pi_*x)*exp(-x^2/2)'])
>>> graph = f.draw(-1.2, 1.2, 100)
>>> View(graph).show()

drawCrossCuts(*args)¶

Draw the 2D and 1D cross cuts of a 1D output function as a GridLayout.

Parameters:

centralPointsequence of float: Central point with dimension equal to the input dimension of the function.
xMin, xMaxsequence of float: Define the interval where the curve is plotted.
pointNumbersequence of int: The number of points to draw the contours and the curves.
withMonoDimensionalCutsbool, optional: withMonoDimensionalCuts indicates whether the mono dimension cuts are drawn or not Default value is specified in the CrossCuts-DefaultWithMonoDimensionalCuts ResourceMap key.
isFilledbool, optional: isFilled indicates whether the contour graphs are filled or not Default value is specified in the Contour-DefaultIsFilled ResourceMap key
vMin, vMaxfloat, optional: Define the interval used to build the color map for the contours If not specified, these values are computed to best fit the graphs. Either specify both values or do not specify any.

Notes

We note $f: \Rset^n \rightarrow \Rset^p$ where $\vect{x} = (x_1, \dots, x_n)$ and $f(\vect{x}) = (f_1(\vect{x}), \dots, f_p(\vect{x}))$ , with $n\geq 1$ and $p\geq 1$ .

In all usages, draw the 1D and 2D cross cuts of $f_k: \Rset^n \rightarrow \Rset$ as a function of all input coordinates for 1D cuts and all couples of coordinates for 2D cuts. Variable coordinates $x_i$ are sampled regularly using $ptNb[i]$ points in the interval $[x_i^{min}, x_i^{max}]$ , when all the other components of $\vect{x}$ are fixed to the corresponding components of the centralPoint $\vect{c}$ . In the first usage, vMin and vMax are evaluated as the min and max of all samples of the function value calculated in all cross cuts performed.

For 1D cross cuts:

OpenTURNS draws the graph:

$y = f_k^{(i)}(s)$

for any $s \in [x_i^{min}, x_i^{max}]$ where $f_k^{(i)}(s)$ is defined by the equation:

$f_k^{(i)}(s) = f_k(c_1, \dots, c_{i-1}, s, c_{i+1} \dots, c_n).$

For 2D cross cuts:

$y = f_k^{(i,j)}(s, t)$

for any $(s, t) \in [x_i^{min}, x_i^{max}] \times [x_j^{min}, x_j^{max}]$ where $f_k^{(i,j)}$ is defined by the equation:

$f_k^{(i,j)}(s,t) = f_k(c_1, \dots, c_{i-1}, s, c_{i+1}, \dots, c_{j-1}, t, c_{j+1} \dots, c_n).$

Examples

>>> import openturns as ot
>>> from openturns.viewer import View
>>> f = ot.SymbolicFunction(['x0', 'x1', 'x2'], ['sin(1*pi_*x0) + x1 - x2 ^ 2'])
>>> grid = f.drawCrossCuts([0., 0., 0.], [-3., -3, -3], [3, 3, 3], [100, 20, 20], True, True)
>>> View(grid).show()

getCallsNumber()¶

Accessor to the number of times the function has been called.

Returns:

calls_numberint: Integer that counts the number of times the function has been called since its creation.

getCheckOutput()¶

Accessor to the output verification flag.

Returns:

check_outputbool: Whether to check return values for nan or inf.

getClassName()¶

Accessor to the object’s name.

Returns:

class_namestr: The object class name (object.__class__.__name__).

getDescription()¶

Accessor to the description of the inputs and outputs.

Returns:

descriptionDescription: Description of the inputs and the outputs.

Examples

>>> import openturns as ot
>>> f = ot.SymbolicFunction(['x1', 'x2'],
...                         ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getDescription())
[x1,x2,y0]

getEnclosingSimplexAlgorithm()¶

Accessor to the algorithm used to find the simplex containing a given point.

Returns:

algoEnclosingSimplexAlgorithm: The algorithm used to find the simplex containing a given point.

getField()¶

Accessor to the field defining the functions.

Returns:

fieldField: The field defining the function.

getInputDescription()¶

Accessor to the description of the inputs.

Returns:

descriptionDescription: Description of the inputs.

Examples

>>> import openturns as ot
>>> f = ot.SymbolicFunction(['x1', 'x2'],
...                         ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getInputDescription())
[x1,x2]

getInputDimension()¶

Accessor to the number of the inputs.

Returns:

number_inputsint: Number of inputs.

Examples

>>> import openturns as ot
>>> f = ot.SymbolicFunction(['x1', 'x2'],
...                         ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getInputDimension())
2

getMarginal(*args)¶

Accessor to marginal.

Parameters:

indicesint or sequence of ints: Set of indices for which the marginal is extracted.

Returns:

marginalFunction: Function corresponding to either $f_i$ or $(f_i)_{i \in indices}$ , with $f:\Rset^n \rightarrow \Rset^p$ and $f=(f_0 , \dots, f_{p-1})$ .

getMesh()¶

Accessor to the mesh over which the interpolation is defined.

Returns:

meshMesh: The mesh over which the interpolation is defined.

getName()¶

Accessor to the object’s name.

Returns:

namestr: The name of the object.

getNearestNeighbourAlgorithm()¶

Accessor to the algorithm used to find the vertex nearest to a given point.

Returns:

algoNearestNeighbourAlgorithm: The algorithm used to find the vertex nearest to a given point.

getOutputDescription()¶

Accessor to the description of the outputs.

Returns:

descriptionDescription: Description of the outputs.

Examples

>>> import openturns as ot
>>> f = ot.SymbolicFunction(['x1', 'x2'],
...                         ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getOutputDescription())
[y0]

getOutputDimension()¶

Accessor to the number of the outputs.

Returns:

number_outputsint: Number of outputs.

Examples

>>> import openturns as ot
>>> f = ot.SymbolicFunction(['x1', 'x2'],
...                         ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getOutputDimension())
1

getParameter()¶

Accessor to the parameter values.

Returns:

parameterPoint: The parameter values.

getParameterDescription()¶

Accessor to the parameter description.

Returns:

parameterDescription: The parameter description.

getParameterDimension()¶

Accessor to the dimension of the parameter.

Returns:

parameter_dimensionint: Dimension of the parameter.

getValues()¶

Accessor to the values in which the interpolation is done.

Returns:

valuesSample: The values in which the interpolation is done.

hasName()¶

Test if the object is named.

Returns:

hasNamebool: True if the name is not empty.

isActualImplementation()¶

Accessor to the validity flag.

Returns:

is_implbool: Whether the implementation is valid.

isLinear()¶

Accessor to the linearity of the evaluation.

Returns:

linearbool: True if the evaluation is linear, False otherwise.

isLinearlyDependent(index)¶

Accessor to the linearity of the evaluation with regard to a specific variable.

Parameters:

indexint: The index of the variable with regard to which linearity is evaluated.

Returns:

linearbool: True if the evaluation is linearly dependent on the specified variable, False otherwise.

parameterGradient(inP)¶

Gradient against the parameters.

Parameters:

xsequence of float: Input point

Returns:

parameter_gradientMatrix: The parameters gradient computed at x.

setCheckOutput(checkOutput)¶

Accessor to the output verification flag.

Parameters:

check_outputbool: Whether to check return values for nan or inf.

setDescription(description)¶

Accessor to the description of the inputs and outputs.

Parameters:

descriptionsequence of str: Description of the inputs and the outputs.

Examples

>>> import openturns as ot
>>> f = ot.SymbolicFunction(['x1', 'x2'],
...                         ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getDescription())
[x1,x2,y0]
>>> f.setDescription(['a','b','y'])
>>> print(f.getDescription())
[a,b,y]

setEnclosingSimplexAlgorithm(enclosingSimplex)¶

Accessor to the algorithm used to find the simplex containing a given point.

Parameters:

algoEnclosingSimplexAlgorithm: The algorithm used to find the simplex containing a given point.

setField(field)¶

Accessor to the field defining the functions.

Parameters:

fieldField: The field defining the function.

setInputDescription(inputDescription)¶

Accessor to the description of the inputs.

Returns:

descriptionDescription: Description of the inputs.

setMesh(mesh)¶

Accessor to the mesh over which the interpolation is defined.

Parameters:

meshMesh: The mesh over which the interpolation is defined.

setName(name)¶

Accessor to the object’s name.

Parameters:

namestr: The name of the object.

setNearestNeighbourAlgorithm(nearestNeighbour)¶

Accessor to the algorithm used to find the vertex nearest to a given point.

Parameters:

algoNearestNeighbourAlgorithm: The algorithm used to find the vertex nearest to a given point.

setOutputDescription(outputDescription)¶

Accessor to the description of the outputs.

Returns:

descriptionDescription: Description of the outputs.

setParameter(parameters)¶

Accessor to the parameter values.

Parameters:

parametersequence of float: The parameter values.

setParameterDescription(description)¶

Accessor to the parameter description.

Parameters:

parameterDescription: The parameter description.

setStopCallback(callBack, state=None)¶

Set up a stop callback.

Can be used to programmatically stop an evaluation.

Parameters:

callbackcallable: Returns a bool deciding whether to stop or continue.

setValues(values)¶

Accessor to the values in which the interpolation is done.

Parameters:

mesh2-d sequence of floats: The values in which the interpolation is done.

OpenTURNS

An Open source initiative for the Treatment of Uncertainties, Risks'N Statistics

Previous topic

Next topic

This Page

P1LagrangeEvaluation¶