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])