CompositeProcess¶

class CompositeProcess(*args)¶

Process obtained by transformation.

Parameters:

fdynFieldFunction: A field function.
inputProcProcess: The input process.

Notes

A composite process is the image of process $X: \Omega \times\cD \mapsto \Rset^d$ by the field function $f_{dyn}:\cD \times \Rset^d \rightarrow \cD' \times \Rset^q$ :

Y = fdyn(X)

where $\cD \in \Rset^n$ and $\cD' \in \Rset^p$ , defined by:

$f_{dyn}(\vect{t}, \vect{x}) = (t'(\vect{t}), v'(\vect{t}, \vect{x}))$

with $t': \cD \rightarrow \cD'$ and $v': \cD \times \Rset^d \rightarrow \Rset^q$ .

The process $Y: \Omega \times \cD' \rightarrow \Rset^q$ is defined on the domain $\cD'$ associated to the mesh $\cM'$ .

Examples

Create the process X:

>>> import openturns as ot
>>> amplitude = [1.0, 1.0]
>>> scale = [0.2, 0.3]
>>> myCovModel = ot.ExponentialModel(scale, amplitude)
>>> myMesh = ot.IntervalMesher([100]*2).build(ot.Interval([0.0]*2, [1.0]*2))
>>> myXProcess = ot.GaussianProcess(myCovModel, myMesh)

Create a spatial field function $g_{dyn}$ associated to $g: \Rset^2 \mapsto \Rset^2$ where $g(x_1,x_2)= (x_1^2, x_1+x_2)$ :

>>> g = ot.SymbolicFunction(['x1', 'x2'],  ['x1^2', 'x1+x2'])
>>> nSpat = 2
>>> gdyn = ot.ValueFunction(g, myMesh)

Create the Y process $Y = g_{dyn}(X)$ :

>>> myYProcess = ot.CompositeProcess(gdyn, myXProcess)

Add the trend $f_{trend}: \Rset^2 \mapsto \Rset^2$ where $f_{trend}(x_1,x_2)= (1+2x_1, 1+3x_2^2)$ :

>>> f = ot.SymbolicFunction(['x1', 'x2'], ['1+2*x1', '1+3*x2^2'])
>>> fTrend = ot.TrendTransform(f, myMesh)

Create the process $Y(\omega, \vect{t}) = X(\omega, \vect{t}) + f_{trend}(\vect{t})$ :

>>> myYProcess2 = ot.CompositeProcess(fTrend, myXProcess)

Apply the Box Cox transformation $h=(h_1,h_2): \Rset\mapsto \Rset^2$ where $h_i(x) = \dfrac{x^3-1}{3}$ :

>>> h = ot.BoxCoxTransform([3.0, 0.0])
>>> hBoxCox = ot.ValueFunction(h, myMesh)

Create the Y process $Y = hBoxCox(X)$ :

>>> myYProcess3 = ot.CompositeProcess(hBoxCox,  myXProcess)

Methods

`getAntecedent`()	Get the antecedent process.
`getClassName`()	Accessor to the object's name.
`getContinuousRealization`()	Get a continuous realization.
`getCovarianceModel`()	Accessor to the covariance model.
`getDescription`()	Get the description of the process.
`getFunction`()	Get the field function.
`getFuture`(*args)	Prediction of the $N$ future iterations of the process.
`getId`()	Accessor to the object's id.
`getInputDimension`()	Get the dimension of the domain $\cD$ .
`getMarginal`(indices)	Get the $k^{th}$ marginal of the random process.
`getMesh`()	Get the mesh.
`getName`()	Accessor to the object's name.
`getOutputDimension`()	Get the dimension of the domain $\cD$ .
`getRealization`()	Get a realization of the process.
`getSample`(size)	Get $n$ realizations of the process.
`getShadowedId`()	Accessor to the object's shadowed id.
`getTimeGrid`()	Get the time grid of observation of the process.
`getTrend`()	Accessor to the trend.
`getVisibility`()	Accessor to the object's visibility state.
`hasName`()	Test if the object is named.
`hasVisibleName`()	Test if the object has a distinguishable name.
`isComposite`()	Test whether the process is composite or not.
`isNormal`()	Test whether the process is normal or not.
`isStationary`()	Test whether the process is stationary or not.
`setDescription`(description)	Set the description of the process.
`setMesh`(mesh)	Set the mesh.
`setName`(name)	Accessor to the object's name.
`setShadowedId`(id)	Accessor to the object's shadowed id.
`setTimeGrid`(timeGrid)	Set the time grid of observation of the process.
`setVisibility`(visible)	Accessor to the object's visibility state.

__init__(*args)¶

getAntecedent()¶

Get the antecedent process.

Returns:

XProcessProcess: The process $X$ .

getClassName()¶

Accessor to the object’s name.

Returns:

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

getContinuousRealization()¶

Get a continuous realization.

Returns:

realizationFunction

According to the process, the continuous realizations are built:

either using a dedicated functional model if it exists: e.g. a functional basis process.
or using an interpolation from a discrete realization of the process on $\cM$ : in dimension $d=1$ , a linear interpolation and in dimension $d \geq 2$ , a piecewise constant function (the value at a given position is equal to the value at the nearest vertex of the mesh of the process).

getCovarianceModel()¶

Accessor to the covariance model.

Returns:

cov_modelCovarianceModel: Covariance model, if any.

getDescription()¶

Get the description of the process.

Returns:

descriptionDescription: Description of the process.

getFunction()¶

Get the field function.

Returns:

fdynFieldFunction: The field function $f_{dyn}$ .

getFuture(*args)¶

Prediction of the $N$ future iterations of the process.

Parameters:

stepNumberint, $N \geq 0$: Number of future steps.
sizeint, $size \geq 0$ , optional: Number of futures needed. Default is 1.

Returns:

predictionProcessSample or TimeSeries: $N$ future iterations of the process. If $size = 1$ , prediction is a TimeSeries. Otherwise, it is a ProcessSample.

getId()¶

Accessor to the object’s id.

Returns:

idint: Internal unique identifier.

getInputDimension()¶

Get the dimension of the domain $\cD$ .

Returns:

nint: Dimension of the domain $\cD$ : $n$ .

getMarginal(indices)¶

Get the $k^{th}$ marginal of the random process.

Parameters:

kint or list of ints $0 \leq k < d$: Index of the marginal(s) needed.

Returns:

marginalsProcess: Process defined with marginal(s) of the random process.

getMesh()¶

Get the mesh.

Returns:

meshMesh: Mesh over which the domain $\cD$ is discretized.

getName()¶

Accessor to the object’s name.

Returns:

namestr: The name of the object.

getOutputDimension()¶

Get the dimension of the domain $\cD$ .

Returns:

dint: Dimension of the domain $\cD$ .

getRealization()¶

Get a realization of the process.

Returns:

realizationField: Contains a mesh over which the process is discretized and the values of the process at the vertices of the mesh.

getSample(size)¶

Get $n$ realizations of the process.

Parameters:

nint, $n \geq 0$: Number of realizations of the process needed.

Returns:

processSampleProcessSample: $n$ realizations of the random process. A process sample is a collection of fields which share the same mesh $\cM \in \Rset^n$ .

getShadowedId()¶

Accessor to the object’s shadowed id.

Returns:

idint: Internal unique identifier.

getTimeGrid()¶

Get the time grid of observation of the process.

Returns:

timeGridRegularGrid: Time grid of a process when the mesh associated to the process can be interpreted as a RegularGrid. We check if the vertices of the mesh are scalar and are regularly spaced in $\Rset$ but we don’t check if the connectivity of the mesh is conform to the one of a regular grid (without any hole and composed of ordered instants).

getTrend()¶

Accessor to the trend.

Returns:

trendTrendTransform: Trend, if any.

getVisibility()¶

Accessor to the object’s visibility state.

Returns:

visiblebool: Visibility flag.

hasName()¶

Test if the object is named.

Returns:

hasNamebool: True if the name is not empty.

hasVisibleName()¶

Test if the object has a distinguishable name.

Returns:

hasVisibleNamebool: True if the name is not empty and not the default one.

isComposite()¶

Test whether the process is composite or not.

Returns:

isCompositebool: True if the process is composite (built upon a function and a process).

isNormal()¶

Test whether the process is normal or not.

Returns:

isNormalbool: True if the process is normal.

Notes

A stochastic process is normal if all its finite dimensional joint distributions are normal, which means that for all $k \in \Nset$ and $I_k \in \Nset^*$ , with $cardI_k=k$ , there is $\vect{m}_1, \dots, \vect{m}_k \in \Rset^d$ and $\mat{C}_{1,\dots,k}\in\mathcal{M}_{kd,kd}(\Rset)$ such that:

$\Expect{\exp\left\{i\Tr{\vect{X}}_{I_k} \vect{U}_{k} \right\}} = \exp{\left\{i\Tr{\vect{U}}_{k}\vect{M}_{k}-\frac{1}{2}\Tr{\vect{U}}_{k}\mat{C}_{1,\dots,k}\vect{U}_{k}\right\}}$

where $\Tr{\vect{X}}_{I_k} = (\Tr{X}_{\vect{t}_1}, \hdots, \Tr{X}_{\vect{t}_k})$ , $\\Tr{vect{U}}_{k} = (\Tr{\vect{u}}_{1}, \hdots, \Tr{\vect{u}}_{k})$ and $\Tr{\vect{M}}_{k} = (\Tr{\vect{m}}_{1}, \hdots, \Tr{\vect{m}}_{k})$ and $\mat{C}_{1,\dots,k}$ is the symmetric matrix:

$\mat{C}_{1,\dots,k} = \left( \begin{array}{cccc} C(\vect{t}_1, \vect{t}_1) &C(\vect{t}_1, \vect{t}_2) & \hdots & C(\vect{t}_1, \vect{t}_{k}) \\ \hdots & C(\vect{t}_2, \vect{t}_2) & \hdots & C(\vect{t}_2, \vect{t}_{k}) \\ \hdots & \hdots & \hdots & \hdots \\ \hdots & \hdots & \hdots & C(\vect{t}_{k}, \vect{t}_{k}) \end{array} \right)$

A Gaussian process is entirely defined by its mean function $m$ and its covariance function $C$ (or correlation function $R$ ).

isStationary()¶

Test whether the process is stationary or not.

Returns:

isStationarybool: True if the process is stationary.

Notes

A process $X$ is stationary if its distribution is invariant by translation: $\forall k \in \Nset$ , $\forall (\vect{t}_1, \dots, \vect{t}_k) \in \cD$ , $\forall \vect{h}\in \Rset^n$ , we have:

$(X_{\vect{t}_1}, \dots, X_{\vect{t}_k}) \stackrel{\mathcal{D}}{=} (X_{\vect{t}_1+\vect{h}}, \dots, X_{\vect{t}_k+\vect{h}})$

setDescription(description)¶

Set the description of the process.

Parameters:

descriptionsequence of str: Description of the process.

setMesh(mesh)¶

Set the mesh.

Parameters:

meshMesh: Mesh over which the domain $\cD$ is discretized.

setName(name)¶

Accessor to the object’s name.

Parameters:

namestr: The name of the object.

setShadowedId(id)¶

Accessor to the object’s shadowed id.

Parameters:

idint: Internal unique identifier.

setTimeGrid(timeGrid)¶

Set the time grid of observation of the process.

Returns:

timeGridRegularGrid: Time grid of observation of the process when the mesh associated to the process can be interpreted as a RegularGrid. We check if the vertices of the mesh are scalar and are regularly spaced in $\Rset$ but we don’t check if the connectivity of the mesh is conform to the one of a regular grid (without any hole and composed of ordered instants).

setVisibility(visible)¶

Accessor to the object’s visibility state.

Parameters: