def __init__(self):
# Length of the river in meters
self.L = 5000.0
# Width of the river in meters
self.B = 300.0
self.dim = 4 # number of inputs
# Q
self.Q = ot.TruncatedDistribution(ot.Gumbel(558., 1013.), 0, ot.TruncatedDistribution.LOWER)
self.Q.setDescription(["Q (m3/s)"])
self.Q.setName("Q")
# Ks
self.Ks = ot.TruncatedDistribution(ot.Normal(30.0, 7.5), 0, ot.TruncatedDistribution.LOWER)
self.Ks.setName("Ks")
# Zv
self.Zv = ot.Uniform(49.0, 51.0)
self.Zv.setName("Zv")
# Zm
self.Zm = ot.Uniform(54.0, 56.0)
#Zm.setDescription(["Zm (m)"])
self.Zm.setName("Zm")
self.model = ot.SymbolicFunction(['Q', 'Ks', 'Zv', 'Zm'],
['(Q/(Ks*300.*sqrt((Zm-Zv)/5000)))^(3.0/5.0)+Zv-58.5'])
self.distribution = ot.ComposedDistribution([self.Q, self.Ks, self.Zv, self.Zm])
self.distribution.setDescription(['Q', 'Ks', 'Zv', 'Zm'])
def cleanCovariance(inCovariance):
dim = inCovariance.getDimension()
for j in range(dim):
for i in range(dim):
if (m.fabs(inCovariance[i, j]) < 1.e-10):
inCovariance[i, j] = 0.0
return inCovariance
# Instanciate one distribution object
referenceDistribution = [ot.TruncatedNormal(2.0, 1.5, 1.0, 4.0),
ot.TruncatedNormal(2.0, 1.5, 1.0, 200.0),
ot.TruncatedNormal(2.0, 1.5, -200.0, 4.0),
ot.TruncatedNormal(2.0, 1.5, 1.0, 4.0)]
distribution = [ot.TruncatedDistribution(ot.Normal(2.0, 1.5), 1.0, 4.0),
ot.TruncatedDistribution(
ot.Normal(2.0, 1.5), 1.0, ot.TruncatedDistribution.LOWER),
ot.TruncatedDistribution(
ot.Normal(2.0, 1.5), 4.0, ot.TruncatedDistribution.UPPER),
ot.TruncatedDistribution(ot.Normal(2.0, 1.5), ot.Interval([1.0], [4.0], [True], [True]))]
# add a 2-d test
dimension = 2
# This distribution takes too much time for the test
#size = 70
#ref = ot.Normal(dimension)
#sample = ref.getSample(size)
#ks = ot.KernelSmoothing().build(sample)
# Use a multivariate Normal distribution instead
ks = ot.Normal(2)
#!/usr/bin/env python
# coding: utf-8
from __future__ import print_function
import openturns as ot
import openturns.testing
import persalys
myStudy = persalys.Study('myStudy')
# Model
dist_Q = ot.TruncatedDistribution(
ot.Gumbel(1. / 558., 1013.), 0, ot.TruncatedDistribution.LOWER)
dist_Ks = ot.TruncatedDistribution(
ot.Normal(30.0, 7.5), 0, ot.TruncatedDistribution.LOWER)
dist_Zv = ot.Uniform(49.0, 51.0)
dist_Zm = ot.Uniform(54.0, 56.0)
Q = persalys.Input('Q', 1000., dist_Q, 'Débit maximal annuel (m3/s)')
Ks = persalys.Input('Ks', 30., dist_Ks, 'Strickler (m^(1/3)/s)')
Zv = persalys.Input('Zv', 50., dist_Zv, 'Côte de la rivière en aval (m)')
Zm = persalys.Input('Zm', 55., dist_Zm, 'Côte de la rivière en amont (m)')
S = persalys.Output('S', 'Surverse (m)')
model = persalys.SymbolicPhysicalModel('myPhysicalModel', [Q, Ks, Zv, Zm], [
S], ['(Q/(Ks*300.*sqrt((Zm-Zv)/5000)))^(3.0/5.0)+Zv-55.5-3.'])
myStudy.add(model)
# limit state ##
limitState = persalys.LimitState('limitState1', model, 'S', ot.Greater(), 0.)
myStudy.add(limitState)
dim = inNumericalPoint.getDimension()
for i in range(dim):
if (m.fabs(inNumericalPoint[i]) < 1.e-10):
inNumericalPoint[i] = 0.0
return inNumericalPoint
# Instanciate one distribution object
referenceDistribution = [
ot.TruncatedNormal(2.0, 1.5, 1.0, 4.0),
ot.TruncatedNormal(2.0, 1.5, 1.0, 200.0),
ot.TruncatedNormal(2.0, 1.5, -200.0, 4.0),
ot.TruncatedNormal(2.0, 1.5, 1.0, 4.0)
]
distribution = [
ot.TruncatedDistribution(ot.Normal(2.0, 1.5), 1.0, 4.0),
ot.TruncatedDistribution(ot.Normal(2.0, 1.5), 1.0,
ot.TruncatedDistribution.LOWER),
ot.TruncatedDistribution(ot.Normal(2.0, 1.5), 4.0,
ot.TruncatedDistribution.UPPER),
ot.TruncatedDistribution(ot.Normal(2.0, 1.5),
ot.Interval([1.0], [4.0], [True], [True]))
]
for testCase in range(len(distribution)):
print('Distribution ', distribution[testCase])
# Is this distribution elliptical ?
print('Elliptical = ', distribution[testCase].isElliptical())
# Is this distribution continuous ?
#!/usr/bin/env python
import openturns as ot
import openturns.testing
import persalys
myStudy = persalys.Study('myStudy')
# Model
dist_Q = ot.Gumbel(1. / 558., 1013.)
dist_Ks = ot.TruncatedDistribution(
ot.Normal(30.0, 7.5), 0, ot.TruncatedDistribution.LOWER)
dist_Zv = ot.Uniform(49.0, 51.0)
dist_Zm = ot.Uniform(54.0, 56.0)
Q = persalys.Input('Q', 1000., dist_Q, 'Débit maximal annuel (m3/s)')
Ks = persalys.Input('Ks', 30., dist_Ks, 'Strickler (m^(1/3)/s)')
Zv = persalys.Input('Zv', 50., dist_Zv, 'Côte de la rivière en aval (m)')
Zm = persalys.Input('Zm', 55., dist_Zm, 'Côte de la rivière en amont (m)')
S = persalys.Output('S', 'Surverse (m)')
model = persalys.SymbolicPhysicalModel('myPhysicalModel', [Q, Ks, Zv, Zm], [
S], ['(Q/(Ks*300.*sqrt((Zm-Zv)/5000)))^(3.0/5.0)+Zv-55.5-3.'])
myStudy.add(model)
# limit state ##
limitState = persalys.LimitState('limitState1', model, 'S', ot.Greater(), -1.)
myStudy.add(limitState)
# Monte Carlo ##
montecarlo = persalys.MonteCarloReliabilityAnalysis(
for j in range(dim):
for i in range(dim):
if (m.fabs(inCovariance[i, j]) < 1.e-10):
inCovariance[i, j] = 0.0
return inCovariance
# Instantiate one distribution object
referenceDistribution = [
ot.TruncatedNormal(2.0, 1.5, 1.0, 4.0),
ot.TruncatedNormal(2.0, 1.5, 1.0, 200.0),
ot.TruncatedNormal(2.0, 1.5, -200.0, 4.0),
ot.TruncatedNormal(2.0, 1.5, 1.0, 4.0)
]
distribution = [
ot.TruncatedDistribution(ot.Normal(2.0, 1.5), 1.0, 4.0),
ot.TruncatedDistribution(ot.Normal(2.0, 1.5), 1.0,
ot.TruncatedDistribution.LOWER),
ot.TruncatedDistribution(ot.Normal(2.0, 1.5), 4.0,
ot.TruncatedDistribution.UPPER),
ot.TruncatedDistribution(ot.Normal(2.0, 1.5),
ot.Interval([1.0], [4.0], [True], [True]))
]
# add a 2-d test
dimension = 2
# This distribution takes too much time for the test
#size = 70
#ref = ot.Normal(dimension)
#sample = ref.getSample(size)
#ks = ot.KernelSmoothing().build(sample)
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)
graph = sensitivityAnalysis.draw()
L = 5000. # m
B = 300. # m
Q = X[0] # m^3.s^-1
Ks = X[1] # m^1/3.s^-1
Zv = X[2] # m
Zm = X[3] # m
Hd = 0. # m
Zb = 55.5 # m
S = Zv + (Q / (Ks * B * m.sqrt((Zm - Zv) / L)))**(3. / 5) - (Hd + Zb)
return [S]
function = ot.PythonFunction(dim, 1, flood_model)
Q_law = ot.TruncatedDistribution(
ot.Gumbel(1. / 558., 1013., ot.Gumbel.ALPHABETA), 0.,
ot.TruncatedDistribution.LOWER)
# alpha=1/b, beta=a | you can use Gumbel(a, b, Gumbel.AB) starting from OT 1.2
Ks_law = ot.TruncatedDistribution(ot.Normal(30.0, 7.5), 0.,
ot.TruncatedDistribution.LOWER)
Zv_law = ot.Triangular(49., 50., 51.)
Zm_law = ot.Triangular(54., 55., 56.)
coll = ot.DistributionCollection([Q_law, Ks_law, Zv_law, Zm_law])
distribution = ot.ComposedDistribution(coll)
x = list(map(lambda dist: dist.computeQuantile(0.5)[0], coll))
fx = function(x)
for k in [0.0, 2.0, 5.0, 8.][0:1]:
randomVector = ot.RandomVector(distribution)
composite = ot.RandomVector(function, randomVector)
return [H] # Creation of the problem function f = ot.PythonFunction(4, 1, functionCrue) f.enableHistory() # 2. Random vector definition Q = ot.Gumbel(1. / 558., 1013.) print(Q) ''' Q = ot.Gumbel() Q.setParameter(ot.GumbelAB()([1013., 558.])) print(Q) ''' Q = ot.TruncatedDistribution(Q, 0, inf) unknownKs = 30.0 unknownZv = 50.0 unknownZm = 55.0 K_s = ot.Dirac(unknownKs) Z_v = ot.Dirac(unknownZv) Z_m = ot.Dirac(unknownZm) # 3. View the PDF Q.setDescription(["Q (m3/s)"]) K_s.setDescription(["Ks (m^(1/3)/s)"]) Z_v.setDescription(["Zv (m)"]) Z_m.setDescription(["Zm (m)"]) # 4. Create the joint distribution function inputRandomVector = ot.ComposedDistribution([Q, K_s, Z_v, Z_m])
import math as m
import sys
ot.TESTPREAMBLE()
def flooding(X):
L, B = 5.0e3, 300.0
Q, K_s, Z_v, Z_m = X
alpha = (Z_m - Z_v) / L
H = (Q / (K_s * B * m.sqrt(alpha)))**(3.0 / 5.0)
return [H]
g = ot.PythonFunction(4, 1, flooding)
Q = ot.TruncatedDistribution(ot.Gumbel(558.0, 1013.0),
ot.TruncatedDistribution.LOWER)
K_s = ot.Dirac(30.0)
Z_v = ot.Dirac(50.0)
Z_m = ot.Dirac(55.0)
inputRandomVector = ot.ComposedDistribution([Q, K_s, Z_v, Z_m])
nbobs = 100
inputSample = inputRandomVector.getSample(nbobs)
outputH = g(inputSample)
Hobs = outputH + ot.Normal(0.0, 0.1).getSample(nbobs)
Qobs = inputSample[:, 0]
thetaPrior = [20, 49, 51]
model = ot.ParametricFunction(g, [1, 2, 3], thetaPrior)
errorCovariance = ot.CovarianceMatrix([[0.5**2]])
sigma = ot.CovarianceMatrix(3)
sigma[0, 0] = 5.**2
sigma[1, 1] = 1.**2
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
if (ot.TruncatedDistribution().__class__.__name__ == 'ComposedDistribution'):
correlation = ot.CorrelationMatrix(2)
correlation[1, 0] = 0.25
aCopula = ot.NormalCopula(correlation)
marginals = [ot.Normal(1.0, 2.0), ot.Normal(2.0, 3.0)]
distribution = ot.ComposedDistribution(marginals, aCopula)
elif (ot.TruncatedDistribution().__class__.__name__ ==
'CumulativeDistributionNetwork'):
distribution = ot.CumulativeDistributionNetwork(
[ot.Normal(2), ot.Dirichlet([0.5, 1.0, 1.5])],
ot.BipartiteGraph([[0, 1], [0, 1]]))
elif (ot.TruncatedDistribution().__class__.__name__ == 'Histogram'):
distribution = ot.Histogram([-1.0, 0.5, 1.0, 2.0], [0.45, 0.4, 0.15])
else:
distribution = ot.TruncatedDistribution()
dimension = distribution.getDimension()
if dimension <= 2:
if distribution.getDimension() == 1:
distribution.setDescription(['$x$'])
pdf_graph = distribution.drawPDF()
cdf_graph = distribution.drawCDF()
fig = plt.figure(figsize=(10, 4))
plt.suptitle(str(distribution))
pdf_axis = fig.add_subplot(121)
cdf_axis = fig.add_subplot(122)
View(pdf_graph, figure=fig, axes=[pdf_axis], add_legend=False)
View(cdf_graph, figure=fig, axes=[cdf_axis], add_legend=False)
else:
else:
CS = 1
if (Hd < 8):
CH = 8. / 20.
else:
CH = Hd / 20.
C = CS + CH
return [H, S, C]
myFunction = ot.PythonFunction(8, 3, functionCrue)
# 2. Create the Input and Output random variables
myParam = ot.GumbelAB(1013., 558.)
QGumbel = ot.ParametrizedDistribution(myParam)
Q = ot.TruncatedDistribution(QGumbel, 0, ot.TruncatedDistribution.LOWER)
KsNormal = ot.Normal(30.0, 7.5)
Ks = ot.TruncatedDistribution(KsNormal, 0, ot.TruncatedDistribution.LOWER)
Zv = ot.Uniform(49.0, 51.0)
Zm = ot.Uniform(54.0, 56.0)
#
Hd = ot.Uniform(7., 9.) # Hd = 3.0;
Zb = ot.Triangular(55.0, 55.5, 56.0) # Zb = 55.5
L = ot.Triangular(4990, 5000., 5010.) # L = 5.0e3;
B = ot.Triangular(295., 300., 305.) # B = 300.0
Q.setDescription(["Q (m3/s)"])
Ks.setDescription(["Ks (m^(1/3)/s)"])
Zv.setDescription(["Zv (m)"])
Zm.setDescription(["Zm (m)"])
Hd.setDescription(["Hd (m)"])
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 =======================================
# =============================================================================
# Denote the input index
indexNumber = 3
dim = inPoint.getDimension()
for i in range(dim):
if (m.fabs(inPoint[i]) < 1.e-10):
inPoint[i] = 0.0
return inPoint
# Instanciate one distribution object
referenceDistribution = [
ot.TruncatedNormal(2.0, 1.5, 1.0, 4.0),
ot.TruncatedNormal(2.0, 1.5, 1.0, 200.0),
ot.TruncatedNormal(2.0, 1.5, -200.0, 4.0),
ot.TruncatedNormal(2.0, 1.5, 1.0, 4.0)
]
distribution = [
ot.TruncatedDistribution(ot.Normal(2.0, 1.5), 1.0, 4.0),
ot.TruncatedDistribution(ot.Normal(2.0, 1.5), 1.0,
ot.TruncatedDistribution.LOWER),
ot.TruncatedDistribution(ot.Normal(2.0, 1.5), 4.0,
ot.TruncatedDistribution.UPPER),
ot.TruncatedDistribution(ot.Normal(2.0, 1.5),
ot.Interval([1.0], [4.0], [True], [True]))
]
# add a 2-d test
dimension = 2
size = 70
ref = ot.Normal([2.0] * dimension, ot.CovarianceMatrix(2))
sample = ref.getSample(size)
ks = ot.KernelSmoothing().build(sample)
truncatedKS = ot.TruncatedDistribution(
# %%
import openturns as ot
import openturns.viewer as viewer
from matplotlib import pylab as plt
ot.Log.Show(ot.Log.NONE)
# the original distribution
distribution = ot.Gumbel(0.45, 0.6)
graph = distribution.drawPDF()
view = viewer.View(graph)
# %%
# truncate on the left
truncated = ot.TruncatedDistribution(distribution, 0.2,
ot.TruncatedDistribution.LOWER)
graph = truncated.drawPDF()
view = viewer.View(graph)
# %%
# truncate on the right
truncated = ot.TruncatedDistribution(distribution, 1.5,
ot.TruncatedDistribution.UPPER)
graph = truncated.drawPDF()
view = viewer.View(graph)
# %%
# truncated on both bounds
truncated = ot.TruncatedDistribution(distribution, 0.2, 1.5)
graph = truncated.drawPDF()
view = viewer.View(graph)
# # if :math:`y\in[a,b]` and :math:`f_Y(y)=0` otherwise. # %% # Consider for example the log-normal variable :math:`X` with mean :math:`\mu=0` and standard deviation :math:`\sigma=1`. # %% X = ot.LogNormal() graph = X.drawPDF() view = viewer.View(graph) # %% # We can truncate this distribution to the :math:`[1,2]` interval. We see that the PDF of the distribution becomes discontinuous at the truncation points 1 and 2. # %% Y = ot.TruncatedDistribution(X, 1., 2.) graph = Y.drawPDF() view = viewer.View(graph) # %% # We can also also truncate it with only a lower bound. # %% Y = ot.TruncatedDistribution(X, 1., ot.TruncatedDistribution.LOWER) graph = Y.drawPDF() view = viewer.View(graph) # %% # We can finally truncate a distribution with an upper bound. # %%
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
if ot.TruncatedDistribution().__class__.__name__ == 'ComposedDistribution':
correlation = ot.CorrelationMatrix(2)
correlation[1, 0] = 0.25
aCopula = ot.NormalCopula(correlation)
marginals = [ot.Normal(1.0, 2.0), ot.Normal(2.0, 3.0)]
distribution = ot.ComposedDistribution(marginals, aCopula)
elif ot.TruncatedDistribution(
).__class__.__name__ == 'CumulativeDistributionNetwork':
distribution = ot.CumulativeDistributionNetwork(
[ot.Normal(2), ot.Dirichlet([0.5, 1.0, 1.5])],
ot.BipartiteGraph([[0, 1], [0, 1]]))
elif ot.TruncatedDistribution().__class__.__name__ == 'Histogram':
distribution = ot.Histogram([-1.0, 0.5, 1.0, 2.0], [0.45, 0.4, 0.15])
else:
distribution = ot.TruncatedDistribution()
dimension = distribution.getDimension()
if dimension == 1:
distribution.setDescription(['$x$'])
pdf_graph = distribution.drawPDF()
cdf_graph = distribution.drawCDF()
fig = plt.figure(figsize=(10, 4))
plt.suptitle(str(distribution))
pdf_axis = fig.add_subplot(121)
cdf_axis = fig.add_subplot(122)
View(pdf_graph, figure=fig, axes=[pdf_axis], add_legend=False)
View(cdf_graph, figure=fig, axes=[cdf_axis], add_legend=False)
elif dimension == 2:
distribution.setDescription(['$x_1$', '$x_2$'])
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
if ot.TruncatedDistribution().__class__.__name__ == 'Bernoulli':
distribution = ot.Bernoulli(0.7)
elif ot.TruncatedDistribution().__class__.__name__ == 'Binomial':
distribution = ot.Binomial(5, 0.2)
elif ot.TruncatedDistribution().__class__.__name__ == 'ComposedDistribution':
copula = ot.IndependentCopula(2)
marginals = [ot.Uniform(1.0, 2.0), ot.Normal(2.0, 3.0)]
distribution = ot.ComposedDistribution(marginals, copula)
elif ot.TruncatedDistribution().__class__.__name__ == 'CumulativeDistributionNetwork':
coll = [ot.Normal(2),ot.Dirichlet([0.5, 1.0, 1.5])]
distribution = ot.CumulativeDistributionNetwork(coll, ot.BipartiteGraph([[0,1], [0,1]]))
elif ot.TruncatedDistribution().__class__.__name__ == 'Histogram':
distribution = ot.Histogram([-1.0, 0.5, 1.0, 2.0], [0.45, 0.4, 0.15])
elif ot.TruncatedDistribution().__class__.__name__ == 'KernelMixture':
kernel = ot.Uniform()
sample = ot.Normal().getSample(5)
bandwith = [1.0]
distribution = ot.KernelMixture(kernel, bandwith, sample)
elif ot.TruncatedDistribution().__class__.__name__ == 'MaximumDistribution':
coll = [ot.Uniform(2.5, 3.5), ot.LogUniform(1.0, 1.2), ot.Triangular(2.0, 3.0, 4.0)]
distribution = ot.MaximumDistribution(coll)
elif ot.TruncatedDistribution().__class__.__name__ == 'Multinomial':
distribution = ot.Multinomial(5, [0.2])
elif ot.TruncatedDistribution().__class__.__name__ == 'RandomMixture':
coll = [ot.Triangular(0.0, 1.0, 5.0), ot.Uniform(-2.0, 2.0)]
weights = [0.8, 0.2]
cst = 3.0
distribution = ot.RandomMixture(coll, weights, cst)
def flood_model(X):
L = 5000. # m
B = 300. # m
Q = X[0] # m^3.s^-1
Ks = X[1] # m^1/3.s^-1
Zv = X[2] # m
Zm = X[3] # m
Hd = 0. # m
Zb = 55.5 # m
S = Zv + (Q / (Ks * B * m.sqrt((Zm - Zv) / L)))**(3. / 5) - (Hd + Zb)
return [S]
function = ot.PythonFunction(dim, 1, flood_model)
Q_law = ot.TruncatedDistribution(ot.Gumbel(1.0 / 558.0, 1013.0), 0.0,
ot.TruncatedDistribution.LOWER)
# alpha=1/b, beta=a | you can use Gumbel(a, b, Gumbel.AB) starting from OT 1.2
Ks_law = ot.TruncatedDistribution(ot.Normal(30.0, 7.5), 0.,
ot.TruncatedDistribution.LOWER)
Zv_law = ot.Triangular(49., 50., 51.)
Zm_law = ot.Triangular(54., 55., 56.)
coll = ot.DistributionCollection([Q_law, Ks_law, Zv_law, Zm_law])
distribution = ot.ComposedDistribution(coll)
x = list(map(lambda dist: dist.computeQuantile(0.5)[0], coll))
fx = function(x)
for k in [0.0, 2.0, 5.0, 8.][0:1]:
randomVector = ot.RandomVector(distribution)
composite = ot.RandomVector(function, randomVector)
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()
pl.savefig("Q.pdf")
View(Ks.drawPDF()).show()
graph = mixture.drawPDF()
graph = mixture.drawCDF()
# Test computeQuantile for the specific case of an analytical 1D mixture
case1 = 0.1 * ot.ChiSquare()
q = case1.computeQuantile(0.95)[0]
print("case 1, q=%.6f" % q)
q = case1.computeQuantile(0.95, True)[0]
print("case 1, q comp=%.6f" % q)
case2 = -0.1 * ot.ChiSquare()
q = case2.computeQuantile(0.95)[0]
print("case 2, q=%.6f" % q)
q = case2.computeQuantile(0.95, True)[0]
print("case 2, q comp=%.6f" % q)
# For ticket 953
atom1 = ot.TruncatedDistribution(ot.Uniform(0.0, 1.0), 0.0, 1.0)
atom2 = ot.Uniform(0.0, 2.0)
sum = atom1 + atom2
print("sum=", sum)
print("CDF=%.6g" % sum.computeCDF(2.0))
print("quantile=", sum.computeQuantile(0.2))
minS = 0.2
maxS = 10.0
muS = (log(minS) + log(maxS)) / 2.0
sigma = (log(maxS) - muS) / 3.0
atom1 = ot.TruncatedDistribution(ot.LogNormal(muS, sigma), minS, maxS)
atom2 = ot.Uniform(0.0, 2.0)
sum = atom1 + atom2
print("sum=", sum)
print("CDF=%.6g" % sum.computeCDF(2.0))
print("quantile=", sum.computeQuantile(0.2))
kernel = ot.Uniform()
sample = ot.Normal().getSample(5)
bandwith = [1.0]
distribution = ot.KernelMixture(kernel, bandwith, sample)
elif ot.LogNormal().__class__.__name__ == 'MaximumDistribution':
coll = [ot.Uniform(2.5, 3.5), ot.LogUniform(1.0, 1.2), ot.Triangular(2.0, 3.0, 4.0)]
distribution = ot.MaximumDistribution(coll)
elif ot.LogNormal().__class__.__name__ == 'Multinomial':
distribution = ot.Multinomial(5, [0.2])
elif ot.LogNormal().__class__.__name__ == 'RandomMixture':
coll = [ot.Triangular(0.0, 1.0, 5.0), ot.Uniform(-2.0, 2.0)]
weights = [0.8, 0.2]
cst = 3.0
distribution = ot.RandomMixture(coll, weights, cst)
elif ot.LogNormal().__class__.__name__ == 'TruncatedDistribution':
distribution = ot.TruncatedDistribution(ot.Normal(2.0, 1.5), 1.0, 4.0)
elif ot.LogNormal().__class__.__name__ == 'UserDefined':
distribution = ot.UserDefined([[0.0], [1.0], [2.0]], [0.2, 0.7, 0.1])
elif ot.LogNormal().__class__.__name__ == 'ZipfMandelbrot':
distribution = ot.ZipfMandelbrot(10, 2.5, 0.3)
else:
distribution = ot.LogNormal()
dimension = distribution.getDimension()
title = str(distribution)[:100].split('\n')[0]
if dimension == 1:
distribution.setDescription(['$x$'])
pdf_graph = distribution.drawPDF()
cdf_graph = distribution.drawCDF()
fig = plt.figure(figsize=(10, 4))
pdf_axis = fig.add_subplot(121)
cdf_axis = fig.add_subplot(122)
return [H] # Creation of the problem function f = ot.PythonFunction(4, 1, functionCrue) f = ot.MemoizeFunction(f) # 2. Random vector definition Q = ot.Gumbel(1. / 558., 1013.) print(Q) ''' Q = ot.Gumbel() Q.setParameter(ot.GumbelAB()([1013., 558.])) print(Q) ''' Q = ot.TruncatedDistribution(Q, 0, ot.TruncatedDistribution.LOWER) unknownKs = 30.0 unknownZv = 50.0 unknownZm = 55.0 K_s = ot.Dirac(unknownKs) Z_v = ot.Dirac(unknownZv) Z_m = ot.Dirac(unknownZm) # 3. View the PDF Q.setDescription(["Q (m3/s)"]) K_s.setDescription(["Ks (m^(1/3)/s)"]) Z_v.setDescription(["Zv (m)"]) Z_m.setDescription(["Zm (m)"]) # 4. Create the joint distribution function inputRandomVector = ot.ComposedDistribution([Q, K_s, Z_v, Z_m])
