def __init__(self): self.dim = 6 self.model = ot.SymbolicFunction(["F", "L", "a", "De", "di", "E"], [ "g1", "g2", "g3"], "var I:=pi_*(De^4-di^4)/32; var b:=L-a; g1:=-F*a^2*(L-a)^2/(3*E*L*I); g2:=-F*b*(L^2-b^2)/(6*E*L*I); g3:=F*a*(L^2-a^2)/(6*E*L*I)") self.model.setOutputDescription( ["Deflection", "Left angle", "Right angle"]) self.XF = ot.Normal(1, 0.1) self.XF.setDescription(["Force"]) self.XE = ot.Normal(200000, 2000) self.XE.setDescription(["Young Modulus"]) self.XL = ot.Dirac(1.5) self.XL.setDescription(["Length"]) self.Xa = ot.Dirac(1.0) self.Xa.setDescription(["Location"]) self.XD = ot.Dirac(0.8) self.XD.setDescription(["External diameter"]) self.Xd = ot.Dirac(0.1) self.Xd.setDescription(["Internal diameter"]) self.inputDistribution = ot.ComposedDistribution( [self.XF, self.XL, self.Xa, self.XD, self.Xd, self.XE])
def _computePODSamplePerDefect(self, defect, detection, krigingResult, transformation, distribution, simulationSize, samplingSize): """ Compute the POD sample for a defect size. """ dim = distribution.getDimension() # create a distibution with a dirac distribution for the defect size diracDist = [ot.Dirac(defect)] diracDist += [distribution.getMarginal(i + 1) for i in range(dim - 1)] distribution = ot.ComposedDistribution(diracDist) # create a sample for the Monte Carlo simulation and confidence interval MC_sample = distribution.getSample(samplingSize) # Kriging_RV = ot.KrigingRandomVector(krigingResult, MC_sample) # Y_sample = Kriging_RV.getSample(simulationSize) Y_sample = self._randomVectorSampling(krigingResult, transformation(MC_sample), simulationSize, samplingSize) # compute the POD for all simulation size POD_MCPG_a = np.mean(Y_sample > detection, axis=1) # compute the variance of the MC simulation using TCL VAR_TCL = np.array(POD_MCPG_a) * ( 1 - np.array(POD_MCPG_a)) / Y_sample.shape[1] # Create distribution of the POD estimator for all simulation POD_PG_dist = [] for i in range(simulationSize): if VAR_TCL[i] > 0: POD_PG_dist += [ot.Normal(POD_MCPG_a[i], np.sqrt(VAR_TCL[i]))] else: if POD_MCPG_a[i] < 1: POD_PG_dist += [ot.Dirac([0.])] else: POD_PG_dist += [ot.Dirac([1.])] POD_PG_alea = ot.Mixture(POD_PG_dist) # get a sample of these distributions POD_PG_sample = POD_PG_alea.getSample(simulationSize * samplingSize) return POD_PG_sample
def __init__(self): self.dim = 4 # number of inputs self.Strain = ot.Uniform(0.0, 0.07) self.Strain.setDescription(["Strain"]) self.unknownR = 750.0e6 self.R = ot.Dirac(self.unknownR) self.R.setDescription(["R"]) self.unknownC = 2750.0e6 self.C = ot.Dirac(self.unknownC) self.C.setDescription(["C"]) self.unknownGamma = 10.0 self.Gamma = ot.Dirac(self.unknownGamma) self.Gamma.setDescription(["Gamma"]) self.inputDistribution = ot.ComposedDistribution([self.Strain, self.R, self.C, self.Gamma]) self.model = ot.PythonFunction(4, 1, g)
# a- observations nbObs = 100 inObs = ot.Uniform(0., 10.).getSample(nbObs) inObs.setDescription(['x1']) y0Noise = ot.Normal(0, 0.1).getSample(nbObs) y0Sample = ot.ParametricFunction(symbolicModel.getFunction('y0'), [1, 2], [1.2, 1.])(inObs) y0Obs = y0Sample + y0Noise y0Obs.setDescription(['y0']) obs = persalys.Observations("observations", symbolicModel, inObs, y0Obs) myStudy.add(obs) # b- calibrationAnalysis calibration = persalys.CalibrationAnalysis('calibration', obs) calibration.setCalibratedInputs(['x2'], ot.Dirac([1.2]), ['x3'], [1.1]) calibration.setMethodName('GaussianNonlinear') sigma = 0.15 errorCovariance = ot.CovarianceMatrix(1) errorCovariance[0, 0] = sigma**2 calibration.setErrorCovariance(errorCovariance) calibration.setBootStrapSize(25) calibration.setConfidenceIntervalLength(0.99) optimAlgo = calibration.getOptimizationAlgorithm() optimAlgo.setMaximumEvaluationNumber(50) optimAlgo.setMaximumAbsoluteError(1e-6) optimAlgo.setMaximumRelativeError(1e-6) optimAlgo.setMaximumResidualError(1e-6) optimAlgo.setMaximumConstraintError(1e-6) calibration.setOptimizationAlgorithm(optimAlgo)
"a + -1.0 * b + 1.0 * c", "a + -0.6 * b + 0.36 * c", "a + -0.2 * b + 0.04 * c", "a + 0.2 * b + 0.04 * c", "a + 0.6 * b + 0.36 * c", "a + 1.0 * b + 1.0 * c", ], ) inputDimension = g.getInputDimension() outputDimension = g.getOutputDimension() trueParameter = ot.Point([12.0, 7.0, -8]) parameterDimension = trueParameter.getDimension() Theta1 = ot.Dirac(trueParameter[0]) Theta2 = ot.Dirac(trueParameter[1]) Theta3 = ot.Dirac(trueParameter[2]) inputRandomVector = ot.ComposedDistribution([Theta1, Theta2, Theta3]) candidate = ot.Point([8.0, 9.0, -6.0]) calibratedIndices = [0, 1, 2] model = ot.ParametricFunction(g, calibratedIndices, candidate) outputObservationNoiseSigma = 0.01 meanNoise = ot.Point(outputDimension) covarianceNoise = ot.Point(outputDimension, outputObservationNoiseSigma) R = ot.IdentityMatrix(outputDimension) observationOutputNoise = ot.Normal(meanNoise, covarianceNoise, R)
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]) # 5. Create the Monte-Carlo algorithm sampleSize = 100 inputSample = inputRandomVector.getSample(sampleSize)
print("kurtosis (ref)=", distributionReference.getKurtosis()) covariance = distribution.getCovariance() print("covariance =", covariance) print("covariance (ref)=", distributionReference.getCovariance()) parameters = distribution.getParametersCollection() print("parameters=", parameters) print("Standard representative=", distribution.getStandardRepresentative()) print("blockMin=", distribution.getBlockMin()) print("blockMax=", distribution.getBlockMax()) print("maxSize=", distribution.getMaxSize()) print("alpha=", distribution.getAlpha()) print("beta=", distribution.getBeta()) # Tests of the simplification mechanism weights = ot.Point(0) coll = ot.DistributionCollection(0) coll.add(ot.Dirac(0.5)) weights.add(1.0) coll.add(ot.Normal(1.0, 2.0)) weights.add(2.0) coll.add(ot.Normal(2.0, 1.0)) weights.add(-3.0) coll.add(ot.Uniform(-2.0, 2.0)) weights.add(-1.0) coll.add(ot.Uniform(2.0, 4.0)) weights.add(2.0) coll.add(ot.Exponential(2.0, -3.0)) weights.add(1.5) rm = ot.RandomMixture(coll, weights) coll.add(rm) weights.add(-2.5) coll.add(ot.Gamma(3.0, 4.0, -2.0))
def CostFunction(func, p, m, lower, upper, N, mode, threshold, design, MinMax): ''' Return the probability of failure correponding to the sequence of Canonical in the general case where the input distribution can be continuous. Should be used with the NoisyDE solver. ''' dim = len(lower) # We concatenate p per block of variable if len(m) == dim: pp = [] t = 0 for i in range(dim): pp.append(p[t:t + len(m[i]) + 1]) t = t + len(m[i]) + 1 else: print('error size of moment vector') Z = [[]] * dim Wgt = [[]] * dim NewMom = [[]] * dim m_copy = m.copy() for i in range(dim): if mode[i] is not None: m_copy[i] = np.append([1], m_copy[i]) NewMom[i] = [ (j + 1) * m_copy[i][j] - (j) * mode[i] * m_copy[i][j - 1] for j in range(1, len(m_copy[i])) ] Z[i], Wgt[i] = Canonical_to_Position( [lower[i]], [upper[i]], QD_Algorithm( Affine_Transformation(lower[i], upper[i], NewMom[i])) + pp[i]) else: Z[i], Wgt[i] = Canonical_to_Position( [lower[i]], [upper[i]], QD_Algorithm( Affine_Transformation(lower[i], upper[i], m_copy[i])) + pp[i]) if not np.any([type(Z[i]) == int for i in range(len(Z))]): if design == 'MC': PERT = [] for i in range(dim): if mode[i] is not None: U = [] for j in range(len(m[i]) + 1): U.append( ot.Uniform(float(min(mode[i], Z[i][j])), float(max(mode[i], Z[i][j])))) PERT.append(ot.Mixture(U, Wgt[i])) else: U = [] for j in range(len(m[i]) + 1): U.append(ot.Dirac(Z[i][j])) PERT.append(ot.Mixture(U, Wgt[i])) DIST = ot.ComposedDistribution(PERT) Sample = DIST.getSample(N) return MinMax * sum(func(Sample) <= threshold) / N elif design == 'LHS': Sample = LHSdesign(Z, Wgt, mode, N) return MinMax * sum(func(Sample) <= threshold) / N else: return 1
# 1. The function G def modeleChaboche(X): strain, R, C, gamma = X stress = R + C * (1 - np.exp(-gamma * strain)) return [stress] # Creation of the problem function f = ot.PythonFunction(4, 1, modeleChaboche) # 2. Random vector definition Strain = ot.Uniform(0, 0.07) unknownR = 750e6 unknownC = 2750e6 unknownGamma = 10 R = ot.Dirac(unknownR) C = ot.Dirac(unknownC) Gamma = ot.Dirac(unknownGamma) # 3. View the PDF Strain.setDescription(["Strain"]) R.setDescription(["R"]) C.setDescription(["C"]) Gamma.setDescription(["Gamma"]) # 4. Create the joint distribution function inputRandomVector = ot.ComposedDistribution([Strain, R, C, Gamma]) # 5. Create the Monte-Carlo algorithm sampleSize = 100 inputSample = inputRandomVector.getSample(sampleSize)
print( "with automatic lower/user defined upper boundaries correction, pdf(left)=%.6g" % ks8.computePDF(left), ", pdf(right)=%.6g" % ks8.computePDF(right)) algo9 = ot.KernelSmoothing(ot.Normal(), False) algo9.setBoundingOption(ot.KernelSmoothing.BOTH) algo9.setLowerBound(-1.0) algo9.setUpperBound(1.0) ks9 = algo9.build(sample) print( "with user defined boundaries correction, pdf(left)=%.6g" % ks9.computePDF(left), ", pdf(right)=%.6g" % ks9.computePDF(right)) # full degenerate case sample = ot.ComposedDistribution( [ot.Dirac(-7.0), ot.Dirac(0.0), ot.Dirac(8.0)]).getSample(50) smoothed = ot.KernelSmoothing().build(sample) print(smoothed.getSample(3)) # n-d degenerate case sample = ot.ComposedDistribution( [ot.Dirac(-7.0), ot.Arcsine(2.0, 3.0), ot.Dirac(8.0)]).getSample(50) sample.setDescription(['d7', 'a23', 'd8']) smoothed = ot.KernelSmoothing().build(sample) print(smoothed.getSample(3)) # Test with reduced Cutoff - generates non positive phiGammaH distribution = ot.Normal() kernel = ot.Normal()
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View if (ot.Dirac().__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.Dirac().__class__.__name__ == 'CumulativeDistributionNetwork'): distribution = ot.CumulativeDistributionNetwork( [ot.Normal(2), ot.Dirichlet([0.5, 1.0, 1.5])], ot.BipartiteGraph([[0, 1], [0, 1]])) else: distribution = ot.Dirac() 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: distribution.setDescription(['$x_1$', '$x_2$']) pdf_graph = distribution.drawPDF() fig = plt.figure(figsize=(10, 5))
from __future__ import print_function import openturns as ot observationsSize = 5 # Create a collection of distribution conditionedDistribution = ot.Normal() conditioningDistributionCollection = [] # First conditioning distribution: continuous/continuous atoms = [ot.Uniform(0.0, 1.0), ot.Uniform(1.0, 2.0)] conditioningDistributionCollection.append(ot.ComposedDistribution(atoms)) # Second conditioning distribution: discrete/continuous atoms = [ot.Binomial(3, 0.5), ot.Uniform(1.0, 2.0)] #conditioningDistributionCollection.append(ot.ComposedDistribution(atoms)) # Third conditioning distribution: dirac/continuous atoms = [ot.Dirac(0.0), ot.Uniform(1.0, 2.0)] conditioningDistributionCollection.append(ot.ComposedDistribution(atoms)) for conditioning in conditioningDistributionCollection: print("conditioning distribution=", conditioning) observationsDistribution = ot.Distribution(conditionedDistribution) observationsDistribution.setParameter(conditioning.getMean()) observations = observationsDistribution.getSample(observationsSize) distribution = ot.PosteriorDistribution(ot.ConditionalDistribution(conditionedDistribution, conditioning), observations) dim = distribution.getDimension() print("Distribution ", distribution) print("Distribution ", distribution) print("range=", distribution.getRange()) mean = distribution.getMean() print("Mean ", mean)
# prior distribution mu0 = 25. sigma0s = [0.1, 1.0] # sigma0s.append(2.0) # play with the variance of the prior: # if the prior variance is low (information concernig the mu parameter is strong) # then the posterior mean will be equal to the prior mean # if large, the the posterior distribution is equivalent to the # distribution of the sample mean for i in range(len(sigma0s)): sigma0 = sigma0s[i] mean_prior = ot.Normal(mu0, sigma0) std_prior = ot.Dirac(2.0) # standard dev is known prior = ot.ComposedDistribution([mean_prior, std_prior]) # choose the initial state within the prior initialState = prior.getRealization() # conditional distribution conditional = ot.Normal() # create a metropolis-hastings sampler sampler = ot.RandomWalkMetropolisHastings( prior, conditional, data, initialState, proposalColl) sampler.setVerbose(True) sampler.setThinning(2) sampler.setBurnIn(500) sampler.setCalibrationStrategyPerComponent(calibrationColl)
stressObs.setDescription(['sigma']) observations = persalys.Observations('obs1', model, strainObs, stressObs) myStudy.add(observations) # Least Squares linear analysis = persalys.CalibrationAnalysis('myAnalysis', observations) analysis.run() myStudy.add(analysis) print("analysis=", analysis) print("result=", analysis.getResult()) # Least Squares Non linear analysis2 = persalys.CalibrationAnalysis('myAnalysis2', observations) analysis2.setMethodName('LeastSquaresNonlinear') analysis2.setCalibratedInputs(['R', 'C'], ot.Dirac([700e6, 2400e6]), ['gam'], [7.]) analysis2.run() myStudy.add(analysis2) print("analysis=", analysis2) # Gaussian linear calibration analysis3 = persalys.CalibrationAnalysis('myAnalysis3', observations) sigmaStress = 1.e7 # (Pa) errorCovariance = ot.CovarianceMatrix(1) errorCovariance[0, 0] = sigmaStress**2 analysis3.setMethodName('GaussianLinear') analysis3.setErrorCovariance(errorCovariance) analysis3.run() myStudy.add(analysis3) print("analysis=", analysis3)
print("isoprobabilistic transformation (general normal)=", distribution.getIsoProbabilisticTransformation()) # General case with non-normal standard distribution collection[0] = ot.SklarCopula(ot.Student( 3.0, [1.0]*2, [3.0]*2, ot.CorrelationMatrix(2))) collection.append(ot.Triangular(2.0, 3.0, 4.0)) distribution = ot.BlockIndependentDistribution(collection) print("isoprobabilistic transformation (general non-normal)=", distribution.getIsoProbabilisticTransformation()) dim = distribution.getDimension() x = 0.6 y = [0.2] * (dim - 1) print("conditional PDF=%.5f" % distribution.computeConditionalPDF(x, y)) print("conditional CDF=%.5f" % distribution.computeConditionalCDF(x, y)) print("conditional quantile=%.5f" % distribution.computeConditionalQuantile(x, y)) pt = ot.Point(dim) for i in range(dim): pt[i] = 0.1 * i + 0.05 print("sequential conditional PDF=", distribution.computeSequentialConditionalPDF(pt)) resCDF = distribution.computeSequentialConditionalCDF(pt) print("sequential conditional CDF(", pt, ")=", resCDF) print("sequential conditional quantile(", resCDF, ")=", distribution.computeSequentialConditionalQuantile(resCDF)) print('range=', distribution.getRange()) # getStandardDeviation vs Dirac distribution2 = ot.BlockIndependentDistribution([ot.Normal(), ot.Dirac(1800)]) ott.assert_almost_equal(distribution2.getStandardDeviation(), [1, 0])
# prior distribution mu0 = 25. sigma0s = [0.1, 1.0] # sigma0s.append(2.0) # play with the variance of the prior: # if the prior variance is low (information concernig the mu parameter is strong) # then the posterior mean will be equal to the prior mean # if large, the the posterior distribution is equivalent to the # distribution of the sample mean for i in range(len(sigma0s)): sigma0 = sigma0s[i] mean_prior = ot.Normal(mu0, sigma0) std_prior = ot.Dirac(2.0) # standard dev is known prior = ot.ComposedDistribution([mean_prior, std_prior]) # choose the initial state within the prior initialState = prior.getRealization() # conditional distribution conditional = ot.Normal() # create a Gibbs sampler mean_sampler = ot.RandomWalkMetropolisHastings(prior, initialState, mean_instrumental, [0]) mean_sampler.setLikelihood(conditional, data) std_sampler = ot.RandomWalkMetropolisHastings(prior, initialState, std_instrumental, [1]) std_sampler.setLikelihood(conditional, data) sampler = ot.Gibbs([mean_sampler, std_sampler])
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View if ot.Dirac().__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.Dirac().__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.Dirac().__class__.__name__ == 'Histogram': distribution = ot.Histogram([-1.0, 0.5, 1.0, 2.0], [0.45, 0.4, 0.15]) else: distribution = ot.Dirac() 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$']) pdf_graph = distribution.drawPDF()
def CostSobol(MyModel, p, m, lower, upper, distribution, indexNumber, indexChoice, NSobol, MINMAX): ''' Return the associated sobol index to the measure recovered from the canonical moment sequences ''' dim = len(lower) # We concatenate p per block of variable if len(m) == dim: pp = [] t = 0 for i in range(dim): pp.append(p[t:t + len(m[i]) + 1]) t = t + len(m[i]) + 1 else: print('error size of moment vector') if indexChoice == 1: P = list( QD_Algorithm( Affine_Transformation(lower[indexNumber], upper[indexNumber], m[indexNumber]))) + list(pp[indexNumber]) Position, Weight = Canonical_to_Position([lower[indexNumber]], [upper[indexNumber]], P) distribution[indexNumber] = ot.Mixture( [ot.Dirac(Position[i]) for i in range(len(Position))], Weight) composedDistribution = ot.ComposedDistribution(distribution) ot.RandomGenerator.SetSeed(0) inputDesign = ot.SobolIndicesExperiment(composedDistribution, NSobol, True).generate() outputDesign = MyModel(inputDesign) sensitivityAnalysis = ot.SaltelliSensitivityAlgorithm( inputDesign, outputDesign, NSobol) firstOrder = sensitivityAnalysis.getFirstOrderIndices() return MINMAX * firstOrder[indexNumber] elif indexChoice == 0: t = 0 P = [[]] * (dim - 1) Position = [[]] * (dim - 1) Weight = [[]] * (dim - 1) for i in range(dim): if i != indexNumber: P[t] = list( QD_Algorithm( Affine_Transformation(lower[i], upper[i], m[i]))) + list(pp[i]) Position[t], Weight[t] = Canonical_to_Position([lower[i]], [upper[i]], P[t]) distribution[i] = ot.Mixture([ ot.Dirac(Position[t][j]) for j in range(len(Position[t])) ], Weight[t]) t += 1 composedDistribution = ot.ComposedDistribution(distribution) ot.RandomGenerator.SetSeed(0) inputDesign = ot.SobolIndicesExperiment(composedDistribution, NSobol, True).generate() outputDesign = MyModel(inputDesign) sensitivityAnalysis = ot.SaltelliSensitivityAlgorithm( inputDesign, outputDesign, NSobol) totalOrder = sensitivityAnalysis.getTotalOrderIndices() return MINMAX * totalOrder[indexNumber]
# .. math:: # \begin{aligned} # \forall t_k \in \mathcal{D}, \forall i,j < p , \> m_{i+1,j+1} = \mathbb{P} (X_{t_{k+1}} = j \> | \> X_{t_{k}} = i) # \end{aligned} # # The library proposes to model it through the object *DiscreteMarkovChain* defined thanks to the origin :math:`X_{t_0}` (which can be either deterministic or uncertain), the transition matrix :math:`\mathcal{M}` and the time grid. # %% import openturns as ot import openturns.viewer as viewer from matplotlib import pylab as plt ot.Log.Show(ot.Log.NONE) # %% # Define the origin origin = ot.Dirac(0.0) # %% # Define the transition matrix transition = ot.SquareMatrix([[0.1, 0.3, 0.6], [0.7, 0.1, 0.2], [0.5, 0.3, 0.2]]) # %% # Define an 1-d mesh tgrid = ot.RegularGrid(0.0, 1.0, 50) # %% # Markov chain definition and realization process = ot.DiscreteMarkovChain(origin, transition, tgrid) real = process.getRealization() graph = real.drawMarginal(0)
z = z0 + vinf * t + tau * (v0 - vinf) * (1 - np.exp(-t / tau)) z = np.maximum(z, zmin) altitude = [[zeta] for zeta in z] return altitude inputDim = 5 outputDim = 1 alti = ot.PythonPointToFieldFunction(inputDim, mesh, outputDim, AltiFunc) # Creation of the input distribution distZ0 = ot.Uniform(100.0, 150.0) distV0 = ot.Normal(55.0, 10.0) distM = ot.Normal(80.0, 8.0) distC = ot.Uniform(0.0, 30.0) distZmin = ot.Dirac([0.0]) distX = ot.ComposedDistribution([distZ0, distV0, distM, distC, distZmin]) # Sample the model samplesize = 1000 inputSample = distX.getSample(samplesize) outputSample = alti(inputSample) # Draw some curves graph = outputSample.drawMarginal(0) graph.setTitle('chute visqueuse') graph.setXTitle(r'$t$') graph.setYTitle(r'$z$') graph.setColors([ ot.Drawable.ConvertFromHSV(i * (360.0 / samplesize), 1.0, 1.0) for i in range(len(graph.getDrawables()))
g = ot.PythonFunction(4, 1, functionFlooding) g = ot.MemoizeFunction(g) g.setOutputDescription(["H (m)"]) # %% # We load the input distribution for :math:`Q` : # %% Q = fm.Q print(Q) # %% # Set the parameters to be calibrated. # %% K_s = ot.Dirac(30.0) Z_v = ot.Dirac(50.0) Z_m = ot.Dirac(55.0) K_s.setDescription(["Ks (m^(1/3)/s)"]) Z_v.setDescription(["Zv (m)"]) Z_m.setDescription(["Zm (m)"]) # %% # Create the joint input distribution. # %% inputRandomVector = ot.ComposedDistribution([Q, K_s, Z_v, Z_m]) # %% # Create a Monte-Carlo sample of the output H.
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View if ot.Dirac().__class__.__name__ == 'Bernoulli': distribution = ot.Bernoulli(0.7) elif ot.Dirac().__class__.__name__ == 'Binomial': distribution = ot.Binomial(5, 0.2) elif ot.Dirac().__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.Dirac().__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.Dirac().__class__.__name__ == 'Histogram': distribution = ot.Histogram([-1.0, 0.5, 1.0, 2.0], [0.45, 0.4, 0.15]) elif ot.Dirac().__class__.__name__ == 'KernelMixture': kernel = ot.Uniform() sample = ot.Normal().getSample(5) bandwith = [1.0] distribution = ot.KernelMixture(kernel, bandwith, sample) elif ot.Dirac().__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.Dirac().__class__.__name__ == 'Multinomial': distribution = ot.Multinomial(5, [0.2])