Documentation / Manuel utilisateur en Python :

First, it is necessary to build a dataserver containing the uncertain parameters . These parameters are represented by random variables which follow one of these statistical laws:

For other laws, it is necessary to use TAttributeFormula and to configure them from Uniform and Normal laws.

Example 1:

Within the framework of our case-test example, we are going to build a TDataServer containing 3 attributes which follow a uniform law on the interval [-π,+π].

import math
tds = DataServer.TDataServer("tdsishigami", "Ex. Ishigami")
tds.addAttribute(DataServer.TUniformDistribution("x1", -1*math.pi, math.pi))
tds.addAttribute(DataServer.TUniformDistribution("x2", -1*math.pi, math.pi))
tds.addAttribute(DataServer.TUniformDistribution("x3", -1*math.pi, math.pi))

Example 2 (using a TAttributeFormula):

We are going to build a TDataServer containing 3 attributes, the first 2 follow a uniform law on the interval [-1/2,+1/2] and the third is a TAttributeFormula. As a consequence follows Log-Uniform on the interval [exp(-1/2),exp(+1/2)].

tdsVenise = DataServer.TDataServer("tdsVenise","Ex. Venise")
tdsVenise.addAttribute(DataServer.TUniformDistribution("x1", -0.5, 0.5))
tdsVenise.addAttribute(DataServer.TUniformDistribution("x2", -0.5, 0.5))
tdsVenise.addAttribute(DataServer.TAttributeFormula("x3","ROOT.TMath.Exp(x2)")) 

Now, we create the TAnisp object by using one of the two constructors: TAnisp(TDataServer* ,const char *, TString, TString, Option_t *) and TAnisp(TDataServer* ,TCode *, Option_t *). The first constructor is when we want to approximate a function (see TLauncherFunction) and the second when it's a numerical code (see TCode and TLauncher).

Example:

In our example, we use the first constructor because Ishigami is an analytic function. The first TString argument indicates the names and order (according to the TDataServer attributes) of the input arguments for the function and the second TString the name of the output argument:

#Definition of the TAnisp object 
tanisp = Modeler.TAnisp(tds, "FctIshigami", "x1:x2:x3", "Ishigami")

Now, we can specify some of the parameters of the Anisp method, if the defaults are not adapted to the case. The parameters we can specify are:

For each of these parameters there is a method to set the value, in order: setTolerance, setNumberMaxOfSimulations, setKMin, setGreaterIndice, setMaxIndices, setlog, setDegreeMax and setRootFilename.

There is also three methods which allow to set several parameters:

Example:

# Tolerance of the algorithm 
tol = 1.0E-2
# Maximum number of simulations
max = 200
# minimum level of interactions
kmin = 1
# setting these parameters
tanisp.setLightAnispParameters(tol, kmin, max)

# root name 
racine = "IshigamiAnisp_"
tanisp.setRootFilename(racine)

# set graphical outputs
tanisp.setlog(True)

The construction of the associated stochastic variables ξ_i, the generation of the adaptive sampling and the adapted polynomial chaos expansion are automatically handled by the Anisp method. Once the TAnisp object is created and new parameters set (if necessary), the user is left with the runAnisp method of the class TAnisp.

Example:

# run of Anisp
tanisp.runAnisp()

After using the runAnisp method, it's possible for the user to set new parameters and then restart the algorithm where it has stopped by using the method restartAnisp of the class TAnisp.

Example:

# new parameters
tol = 1.0E-6
max = 1000 
kmin = 2
tanisp.setLightAnispParameters(tol, kmin, max)
# restart of Anisp
tanisp.restartAnisp()

Now, we can do the uncertainty and sensitivity analysis. With the Anisp library, we have access to the functionality of the Nisp library.

Indeed the TAnisp object create a TPolynomialChaos object during the call of the runAnisp and restartAnisp methods. The user can then use the getTPolynomialChaos method to get back the TPolynomialChaos object and perform the uncertainty and sensitivity analysis by using the dedicated method of this class.

Another way is to use the exportFunction method which creates a C++ file containing the polynomial under the form of a C++ function. The user can then perform on it any statistical analysis.

Example:

# getting the TPolynomialChaos object
pc = Modeler.TPolynomialChaos(tanisp.getTPolynomialChaos())

# Uncertainty and sensitivity analysis using TPolynomialChaos functionality
print("")
print("Mean = %g" % (pc.getMean(0)))
print("Variance = %g" % (pc.getVariance(0)))
print("")
print("First Order[1] = %g" % (pc.getIndexFirstOrder(0,0)))
print("First Order[2] = %g" % (pc.getIndexFirstOrder(1,0)))
print("First Order[3] = %g" % (pc.getIndexFirstOrder(2,0)))
print("")
print("Total Order[1] = %g" % (pc.getIndexTotalOrder(0,0)))
print("Total Order[2] = %g" % (pc.getIndexTotalOrder(1,0)))
print("Total Order[3] = %g" % (pc.getIndexTotalOrder(2,0)))
print("")
print("Ordered functionnal ANOVA")
seuil = 0.98
pc.getAnovaOrdered(seuil, 0)

# Export of the polynomial in a C++ file
tanisp.exportFunction("c++", "AnispIshigami.C", "AnispIshigami")