# 1. The function G
def functionCrue(X):
Q, Ks, Zv, Zm = X
alpha = (Zm - Zv) / 5.0e3
H = (Q / (Ks * 300.0 * sqrt(alpha)))**(3.0 / 5.0)
S = [H + Zv]
return S
# Creation of the problem function
g = ot.PythonFunction(4, 1, functionCrue)
g = ot.MemoizeFunction(g)
# 2. Random vector definition
myParamQ = ot.GumbelAB(1013., 558.)
Q = ot.ParametrizedDistribution(myParamQ)
otLOW = ot.TruncatedDistribution.LOWER
Q = ot.TruncatedDistribution(Q, 0, otLOW)
Ks = ot.Normal(30.0, 7.5)
Ks = ot.TruncatedDistribution(Ks, 0, otLOW)
Zv = ot.Uniform(49.0, 51.0)
Zm = ot.Uniform(54.0, 56.0)
# 3. View the PDF
Q.setDescription(["Q (m3/s)"])
Ks.setDescription(["Ks (m^(1/3)/s)"])
Zv.setDescription(["Zv (m)"])
Zm.setDescription(["Zm (m)"])
View(Q.drawPDF()).show()
from __future__ import print_function
import openturns as ot
distribution = ot.Gumbel(2.0, 2.5)
size = 10000
sample = distribution.getSample(size)
factory = ot.GumbelFactory()
print('Distribution =', repr(distribution))
result = factory.buildEstimator(sample)
estimatedDistribution = result.getDistribution()
print('Estimated distribution =', repr(estimatedDistribution))
parameterDistribution = result.getParameterDistribution()
print('Parameter distribution =', parameterDistribution)
defaultDistribution = factory.build()
print('Default distribution =', defaultDistribution)
fromParameterDistribution = factory.build(distribution.getParameter())
print('Distribution from parameters =', fromParameterDistribution)
typedEstimatedDistribution = factory.buildAsGumbel(sample)
print('Typed estimated distribution =', typedEstimatedDistribution)
defaultTypedDistribution = factory.buildAsGumbel()
print('Default typed distribution =', defaultTypedDistribution)
typedFromParameterDistribution = factory.buildAsGumbel(
distribution.getParameter())
print('Typed distribution from parameters=', typedFromParameterDistribution)
result = factory.buildEstimator(sample, ot.GumbelAB())
estimatedDistribution = result.getDistribution()
print('Estimated distribution (AB) =', repr(estimatedDistribution))
parameterDistribution = result.getParameterDistribution()
print('Parameter distribution (AB) =', parameterDistribution)
from openturns.viewer import View
ot.RandomGenerator.SetSeed(0)
def flooding(X) :
Hd = 3.0; Zb = 55.5
L = 5.0e3; B = 300.0
Zd = Zb + Hd
Q, Ks, Zv, Zm = X
alpha = (Zm - Zv)/L
H = (Q/(Ks*B*alpha**0.5))**0.6
Zc = H + Zv
S = Zc - Zd
return [S]
myFunction = ot.PythonFunction(4, 1, flooding)
myParam = ot.GumbelAB(1013.0, 558.0)
Q = ot.ParametrizedDistribution(myParam)
Q = ot.TruncatedDistribution(Q, 0.0, ot.SpecFunc.MaxScalar)
Ks = ot.Normal(30.0, 7.5)
Ks = ot.TruncatedDistribution(Ks, 0.0, ot.SpecFunc.MaxScalar)
Zv = ot.Uniform(49.0, 51.0)
Zm = ot.Uniform(54.0, 56.0)
inputX = ot.ComposedDistribution([Q, Ks, Zv, Zm])
inputX.setDescription(["Q","Ks", "Zv", "Zm"])
size = 5000
computeSO = True
inputDesign = ot.SobolIndicesExperiment(inputX, size, computeSO).generate()
outputDesign = myFunction(inputDesign)
sensitivityAnalysis = ot.MartinezSensitivityAlgorithm(inputDesign, outputDesign, size)
tensorIn = [0.4]
tensorRef = tensorResult.getMetaModel()(tensorIn)
# Distribution parameters
# ArcsineMuSigma parameter ave
ams_parameters = ot.ArcsineMuSigma(8.4, 2.25)
myStudy.add('ams_parameters', ams_parameters)
# BetaMuSigma parameter save
bms_parameters = ot.BetaMuSigma(0.2, 0.6, -1, 2)
myStudy.add('bms_parameters', bms_parameters)
# GammaMuSigma parameter save
gmms_parameters = ot.GammaMuSigma(1.5, 2.5, -0.5)
myStudy.add('gmms_parameters', gmms_parameters)
# GumbelAB parameter save
gab_parameters = ot.GumbelAB(-0.5, 0.5)
myStudy.add('gab_parameters', gab_parameters)
# GumbelMuSigma parameter save
gms_parameters = ot.GumbelMuSigma(1.5, 1.3)
myStudy.add('gms_parameters', gms_parameters)
# LogNormalMuSigma parameter save
lnms_parameters = ot.LogNormalMuSigma(30000.0, 9000.0, 15000)
myStudy.add('lnms_parameters', lnms_parameters)
# LogNormalMuSigmaOverMu parameter save
lnmsm_parameters = ot.LogNormalMuSigmaOverMu(0.63, 5.24, -0.5)
myStudy.add('lnmsm_parameters', lnmsm_parameters)
# WeibullMuSigma parameter save
wms_parameters = ot.WeibullMuSigma(1.3, 1.23, -0.5)
myStudy.add('wms_parameters', wms_parameters)
# print ('Study = ' , myStudy)
Cons3 = Constraint([49, 51], dic3)
Cons4 = Constraint([54, 55], dic4)
constraints = Constraints([Cons1, Cons2, Cons3, Cons4])
# =============================================================================
# ========================== INITIAL DISTRIBUTION =============================
# =============================================================================
distribution = []
lower = constraints.Lower()
upper = constraints.Upper()
# Variable #10 Q
distribution.append(ot.Gumbel(0.00524, 626.14))
distribution[0].setParameter(ot.GumbelAB()([1013, 558]))
distribution[0] = ot.TruncatedDistribution(distribution[0], float(lower[0]),
float(upper[0]))
# Variable #22 Ks
distribution.append(ot.Normal(30, 7.5))
distribution[1] = ot.TruncatedDistribution(distribution[1], float(lower[1]),
float(upper[1]))
# Variable #25 Zv
distribution.append(ot.Triangular(49, 50, 51))
# Variable #2 Zm
distribution.append(ot.Triangular(54, 54.5, 55))
# =============================================================================
# ================================= RUN =======================================
# =============================================================================
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
distParams = []
distParams.append(ot.ArcsineMuSigma(8.4, 2.25))
distParams.append(ot.BetaMuSigma(0.2, 0.6, -1, 2))
distParams.append(ot.GammaMuSigma(1.5, 2.5, -0.5))
distParams.append(ot.GumbelAB(-0.5, 0.5))
distParams.append(ot.GumbelMuSigma(1.5, 1.3))
distParams.append(ot.LogNormalMuSigma(0.63, 3.3, -0.5))
distParams.append(ot.LogNormalMuSigmaOverMu(0.63, 5.24, -0.5))
distParams.append(ot.WeibullMuSigma(1.3, 1.23, -0.5))
for distParam in distParams:
print('Distribution Parameters ', repr(distParam))
print('Distribution Parameters ', distParam)
non_native = distParam.getValues()
desc = distParam.getDescription()
print('non-native=', non_native, desc)
native = distParam.evaluate()
print('native=', native)
non_native = distParam.inverse(native)
print('non-native=', non_native)
print('built dist=', distParam.getDistribution())
# derivative of the native parameters with regards the parameters of the
# distribution
