def __init__(self): self.dim = 2 self.D = 0.02 # Random variable : R self.muR = 3.0e6 self.sigmaR = 3.0e5 # Random variable : F self.muF = 750. self.sigmaF = 50. # create the limit state function model self.model = ot.SymbolicFunction(['R', 'F'], ['R-F/(pi_/10000.0)']) # Yield strength self.distribution_R = ot.LogNormalMuSigma(self.muR, self.sigmaR, 0.0).getDistribution() self.distribution_R.setName('Yield strength') self.distribution_R.setDescription('R') # Traction load self.distribution_F = ot.Normal(self.muF, self.sigmaF) self.distribution_F.setName('Traction_load') self.distribution_F.setDescription('F') # Joint distribution of the input parameters self.distribution = ot.ComposedDistribution( [self.distribution_R, self.distribution_F])
def define_distribution(): """ Define the distribution of the training example (beam). Return a ComposedDistribution object from openTURNS """ sample_E = ot.Sample.ImportFromCSVFile("sample_E.csv") kernel_smoothing = ot.KernelSmoothing(ot.Normal()) bandwidth = kernel_smoothing.computeSilvermanBandwidth(sample_E) E = kernel_smoothing.build(sample_E, bandwidth) E.setDescription(['Young modulus']) F = ot.LogNormal() F.setParameter(ot.LogNormalMuSigma()([30000, 9000, 15000])) F.setDescription(['Load']) L = ot.Uniform(250, 260) L.setDescription(['Length']) I = ot.Beta(2.5, 4, 310, 450) I.setDescription(['Inertia']) marginal_distributions = [F, E, L, I] SR_cor = ot.CorrelationMatrix(len(marginal_distributions)) SR_cor[2, 3] = -0.2 copula = ot.NormalCopula(ot.NormalCopula.GetCorrelationFromSpearmanCorrelation(SR_cor)) return(ot.ComposedDistribution(marginal_distributions, copula))
def __init__(self, threshold=0.0): """ Create a axial stressed beam reliability problem. The inputs are R, the Yield strength, and F, the traction load. The event is {g(X) < threshold} where g(R, F) = R - F/(pi_ * 100.0) We have R ~ LogNormalMuSigma() and F ~ Normal(). Parameters ---------- threshold : float The threshold. Example ------- problem = AxialStressedBeamReliability() """ limitStateFunction = ot.SymbolicFunction(["R", "F"], ["R - F/(pi_ * 100.0)"]) R_dist = ot.LogNormalMuSigma(300.0, 30.0, 0.0).getDistribution() R_dist.setName("Yield strength") R_dist.setDescription("R") F_dist = ot.Normal(75000.0, 5000.0) F_dist.setName("Traction load") F_dist.setDescription("F") myDistribution = ot.ComposedDistribution([R_dist, F_dist]) inputRandomVector = ot.RandomVector(myDistribution) outputRandomVector = ot.CompositeRandomVector( limitStateFunction, inputRandomVector ) thresholdEvent = ot.ThresholdEvent(outputRandomVector, ot.Less(), 0.0) name = "Axial stressed beam" diff = R_dist - F_dist / (np.pi * 100.0) probability = diff.computeCDF(threshold) super(AxialStressedBeamReliability, self).__init__( name, thresholdEvent, probability ) return None
def __init__(self): self.dim = 4 # number of inputs # Young's modulus E self.E = ot.Beta(0.9, 3.5, 65.0e9, 75.0e9) # in N/m^2 self.E.setDescription("E") self.E.setName("Young modulus") # Load F self.F = ot.LogNormal() # in N self.F.setParameter(ot.LogNormalMuSigma()([300.0, 30.0, 0.0])) self.F.setDescription("F") self.F.setName("Load") # Length L self.L = ot.Uniform(2.5, 2.6) # in m self.L.setDescription("L") self.L.setName("Length") # Moment of inertia I self.I = ot.Beta(2.5, 4.0, 1.3e-7, 1.7e-7) # in m^4 self.I.setDescription("I") self.I.setName("Inertia") # physical model self.model = ot.SymbolicFunction(['E', 'F', 'L', 'I'], ['F*L^3/(3*E*I)']) # correlation matrix self.R = ot.CorrelationMatrix(self.dim) self.R[2, 3] = -0.2 self.copula = ot.NormalCopula( ot.NormalCopula.GetCorrelationFromSpearmanCorrelation(self.R)) self.distribution = ot.ComposedDistribution( [self.E, self.F, self.L, self.I], self.copula) # special case of an independent copula self.independentDistribution = ot.ComposedDistribution( [self.E, self.F, self.L, self.I])
#!/usr/bin/env python # -*- coding: utf8 -*- import openturns as ot from analytical_functions import gfun_8 from simulation_methods import run_MonteCarlo # Distributions d'entrée # ~ dist_X1 = ot.Normal(0., 1.) # ~ dist_X2 = ot.Normal(0., 1.) # ~ myDistribution = ot.ComposedDistribution([dist_X1, dist_X2]) parameters1 = ot.LogNormalMuSigma(120, 12, 0.0) dist_X1 = ot.ParametrizedDistribution(parameters1) parameters2 = ot.LogNormalMuSigma(120, 12, 0.0) dist_X2 = ot.ParametrizedDistribution(parameters2) parameters3 = ot.LogNormalMuSigma(120, 12, 0.0) dist_X3 = ot.ParametrizedDistribution(parameters3) parameters4 = ot.LogNormalMuSigma(120, 12, 0.0) dist_X4 = ot.ParametrizedDistribution(parameters4) parameters5 = ot.LogNormalMuSigma(50, 10, 0.0) dist_X5 = ot.ParametrizedDistribution(parameters5) parameters6 = ot.LogNormalMuSigma(40, 8, 0.0) dist_X6 = ot.ParametrizedDistribution(parameters6) myDistribution = ot.ComposedDistribution(
#dimension dim = 2 #Analytical model definition limitState = ot.SymbolicFunction(['R', 'F'], ['R-F/(pi_*100)']) #Test of the limit state function x = [300, 75000] print('x=', x) print('G(x)=', limitState(x)) #Stochastic model definition #Create a first marginal : LogNormal distribution 1D, parametrized by #its mean and standard deviation R_dist = ot.LogNormalMuSigma(300, 30, 0).getDistribution() R_dist.setName('Yield strength') R_dist.setDescription('R') #Graphical output of the PDF R_dist.drawPDF() #Create a second marginal : Normal distribution 1D F_dist = ot.Normal(75000, 5000) F_dist.setName('Traction_load') F_dist.setDescription('F') #Graphical output of the PDF F_dist.drawPDF() #Create a copula : IndependentCopula (no correlation)
view = View(graph) # view.save('curve7.png') view.ShowAll(block=True) # Pie graph = ot.SobolIndicesAlgorithm.DrawImportanceFactors( [.4, .3, .2, .1], ['a0', 'a1', 'a2', 'a3'], 'Zou') # graph.draw('curve8.png') view = View(graph) # view.save('curve8.png') view.show() # Convergence graph curve aCollection = [] aCollection.append(ot.LogNormalFactory().build( ot.LogNormalMuSigma()([300.0, 30.0, 0.0]))) aCollection.append(ot.Normal(75e3, 5e3)) myDistribution = ot.ComposedDistribution(aCollection) vect = ot.RandomVector(myDistribution) LimitState = ot.SymbolicFunction(('R', 'F'), ('R-F/(pi_*100.0)', )) G = ot.CompositeRandomVector(LimitState, vect) myEvent = ot.ThresholdEvent(G, ot.Less(), 0.0) experiment = ot.MonteCarloExperiment() myAlgo = ot.ProbabilitySimulationAlgorithm(myEvent, experiment) myAlgo.setMaximumCoefficientOfVariation(0.05) myAlgo.setMaximumOuterSampling(int(1e5)) myAlgo.run() graph = myAlgo.drawProbabilityConvergence() # graph.draw('curve10.png') view = View(graph) # view.save('curve10.png')
#!/usr/bin/env python import openturns as ot import openturns.testing import persalys myStudy = persalys.Study('myStudy') # Model R = persalys.Input('R', 0., ot.LogNormalMuSigma( 300., 30.).getDistribution(), 'Yield strength') F = persalys.Input('F', 0., ot.Normal(75000., 5000.), 'Traction load') G = persalys.Output('G', 'deviation') code = 'from math import pi\n\ndef _exec(R, F):\n G = R-F/(pi*100.0)\n return G\n' model = persalys.PythonPhysicalModel('myPhysicalModel', [R, F], [G], code) myStudy.add(model) f = model.getFunction() print(f([300., 75000.])) # several outputs model.setCode( 'from math import pi\n\ndef _exec(R, F):\n G = 6*F\n H = 42.0\n return G, H\n') f = model.getFunction() print(f([300., 75000.])) # test operator() (sample) model.setCode( 'from math import pi\n\ndef _exec(R, F):\n G = 2*R-F/(pi*100.0)\n return G\n') f = model.getFunction()
from __future__ import print_function #§ Identifying the platform import platform key_platform = (platform.system(), platform.architecture()[0]) # Call to either 'platform.system' or 'platform.architecture' *after* # importing pyfmi causes a segfault. dict_platform = {("Linux", "64bit"):"linux64", ("Windows", "64bit"):"win64"} #§ Define the input distribution import numpy as np import openturns as ot E = ot.Beta(0.93, 3.2, 2.8e7, 4.8e7) F = ot.LogNormalMuSigma(3.0e4, 9000.0, 15000.0).getDistribution() L = ot.Uniform(250.0, 260.0) I = ot.Beta(2.5, 4.0, 310.0, 450.0) # Create the Spearman correlation matrix of the input random vector RS = ot.CorrelationMatrix(4) RS[2,3] = -0.2 # Evaluate the correlation matrix of the Normal copula from RS R = ot.NormalCopula.GetCorrelationFromSpearmanCorrelation(RS) # Create the Normal copula parametrized by R mycopula = ot.NormalCopula(R) # Create the input probability distribution of dimension 4 inputDistribution = ot.ComposedDistribution([E, F, L, I], mycopula)
# %% # We define the symbolic function which evaluates the output Y depending on the inputs E, F, L and I. # %% model = ot.SymbolicFunction(["E", "F", "L", "I"], ["F*L^3/(3*E*I)"]) # %% # Then we define the distribution of the input random vector. # %% # Young's modulus E E = ot.Beta(0.9, 3.5, 2.5e7, 5.0e7) # in N/m^2 E.setDescription("E") # Load F F = ot.LogNormal() # in N F.setParameter(ot.LogNormalMuSigma()([30.e3, 9e3, 15.e3])) F.setDescription("F") # Length L L = ot.Uniform(250., 260.) # in cm L.setDescription("L") # Moment of inertia I I = ot.Beta(2.5, 4, 310, 450) # in cm^4 I.setDescription("I") # %% # Finally, we define the dependency using a `NormalCopula`. # %% myDistribution = ot.ComposedDistribution([E, F, L, I]) # %%
#!/usr/bin/env python from __future__ import print_function import openturns as ot import openturns.testing import persalys myStudy = persalys.Study('myStudy') # Model R = persalys.Input('R', 0., ot.LogNormalMuSigma(300., 30.).getDistribution(), 'Yield strength') F = persalys.Input('F', 0., ot.Normal(75000., 5000.), 'Traction load') G = persalys.Output('G', 'deviation') code = 'from math import pi\n\ndef _exec(R, F):\n G = R-F/(pi*100.0)\n return G\n' model = persalys.PythonPhysicalModel('myPhysicalModel', [R, F], [G], code) myStudy.add(model) f = model.getFunction() print(f([300., 75000.])) # several outputs model.setCode( 'from math import pi\n\ndef _exec(R, F):\n G = 6*F\n H = 42.0\n return G, H\n' ) f = model.getFunction() print(f([300., 75000.])) # test operator() (sample)
#! /usr/bin/env python 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.GumbelLambdaGamma(0.6, 6.0)) distParams.append(ot.GumbelMuSigma(1.5, 1.3)) distParams.append(ot.LogNormalMuErrorFactor(0.63, 1.5, -0.5)) distParams.append(ot.LogNormalMuSigma(0.63, 3.3, -0.5)) distParams.append(ot.LogNormalMuSigmaOverMu(0.63, 5.24, -0.5)) distParams.append(ot.WeibullMaxMuSigma(1.3, 1.23, 3.1)) distParams.append(ot.WeibullMinMuSigma(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
#!/usr/bin/env python from __future__ import print_function import openturns as ot import openturns.testing as ott import persalys ot.RandomGenerator.SetSeed(0) myStudy = persalys.Study('myStudy') persalys.Study.Add(myStudy) R = persalys.Input('R', 700e6, ot.LogNormalMuSigma(750e6, 11e6).getDistribution(), 'Parameter R') C = persalys.Input('C', 2500e6, ot.Normal(2750e6, 250e6), 'Parameter C') gamma = persalys.Input('gam', 8., ot.Normal(10, 2), 'Parameter gamma') dist_strain = ot.Uniform(0, 0.07) strain = persalys.Input('strain', 0., dist_strain, 'Strain') sigma = persalys.Output('sigma', 'Stress (Pa)') fakeSigma = persalys.Output('fakeSigma', 'Stress (Pa)') formula = [ 'R + C * (1 - exp(-gam * strain))', '2*(R + C * (1 - exp(-gam * strain)))' ] model = persalys.SymbolicPhysicalModel('model1', [R, C, gamma, strain], [sigma, fakeSigma], formula) myStudy.add(model) # generate observations nbObs = 100
def __init__( self, threshold=0.0, mu1=120.0, sigma1=12.0, mu2=120.0, sigma2=12.0, mu3=120.0, sigma3=12.0, mu4=120.0, sigma4=12.0, mu5=50.0, sigma5=10.0, mu6=40.0, sigma6=8.0, ): """ Creates a reliability problem RP8. The event is {g(X) < threshold} where X = (x1, x2, x3, x4, x5, x6) g(X) = x1 + 2 * x2 + 2 * x3 + x4 - 5 * x5 - 5 * x6 We have : x1 ~ LogNormalMuSigma(mu1, sigma1) x2 ~ LogNormalMuSigma(mu2, sigma2) x3 ~ LogNormalMuSigma(mu3, sigma3) x4 ~ LogNormalMuSigma(mu4, sigma4) x5 ~ LogNormalMuSigma(mu5, sigma5) x6 ~ LogNormalMuSigma(mu6, sigma6) Parameters ---------- threshold : float The threshold. mu1 : float The mean of the LogNormal random variable X1. sigma1 : float The standard deviation of the LogNormal random variable X1. mu2 : float The mean of the LogNormal random variable X2. sigma2 : float The standard deviation of the LogNormal random variable X2. mu3 : float The mean of the LogNormal random variable X3. sigma3 : float The standard deviation of the LogNormal random variable X3. mu4 : float The mean of the LogNormal random variable X4. sigma4 : float The standard deviation of the LogNormal random variable X4. mu5 : float The mean of the LogNormal random variable X5. sigma5 : float The standard deviation of the LogNormal random variable X5. mu6 : float The mean of the LogNormal random variable X6. sigma6 : float The standard deviation of the LogNormal random variable X6. """ formula = "x1 + 2 * x2 + 2 * x3 + x4 - 5 * x5 - 5 * x6" limitStateFunction = ot.SymbolicFunction( ["x1", "x2", "x3", "x4", "x5", "x6"], [formula] ) parameters1 = ot.LogNormalMuSigma(mu1, sigma1, 0.0) X1 = ot.ParametrizedDistribution(parameters1) X1.setDescription(["X1"]) parameters2 = ot.LogNormalMuSigma(mu2, sigma2, 0.0) X2 = ot.ParametrizedDistribution(parameters2) X2.setDescription(["X2"]) parameters3 = ot.LogNormalMuSigma(mu3, sigma3, 0.0) X3 = ot.ParametrizedDistribution(parameters3) X3.setDescription(["X3"]) parameters4 = ot.LogNormalMuSigma(mu4, sigma4, 0.0) X4 = ot.ParametrizedDistribution(parameters4) X4.setDescription(["X4"]) parameters5 = ot.LogNormalMuSigma(mu5, sigma5, 0.0) X5 = ot.ParametrizedDistribution(parameters5) X5.setDescription(["X5"]) parameters6 = ot.LogNormalMuSigma(mu6, sigma6, 0.0) X6 = ot.ParametrizedDistribution(parameters6) X6.setDescription(["X6"]) myDistribution = ot.ComposedDistribution([X1, X2, X3, X4, X5, X6]) inputRandomVector = ot.RandomVector(myDistribution) outputRandomVector = ot.CompositeRandomVector( limitStateFunction, inputRandomVector ) thresholdEvent = ot.ThresholdEvent(outputRandomVector, ot.Less(), threshold) name = "RP8" Y = X1 + 2 * X2 + 2 * X3 + X4 - 5 * X5 - 5 * X6 probability = Y.computeCDF(threshold) super(ReliabilityProblem8, self).__init__(name, thresholdEvent, probability) return None
E = persalys.Input('E', 1.0, ot.Normal(), 'E description') F = persalys.Input('F', 1.0) I = persalys.Input('I', 1.0) L = persalys.Input('L', 1.0) y = persalys.Output('y', 'deviation') inputs = [E, F, I, L] outputs = [y] model = persalys.FMIPhysicalModel( 'myPhysicalModel', inputs, outputs, path_fmu) myStudy.add(model) # print(model.getCode()) E_d = ot.Beta(0.93, 3.2-0.93, 28000000.0, 48000000.0) F_d = ot.LogNormalMuSigma(30000.0, 9000.0, 15000.0).getDistribution() L_d = ot.Uniform(250.0, 260.0) I_d = ot.Beta(2.5, 4.0-2.5, 310.0, 450.0) distribution = ot.ComposedDistribution([E_d, F_d, I_d, L_d]) x = distribution.getMean() f = model.getFunction() y = f(x) ott.assert_almost_equal(y, [12.3369]) # script script = myStudy.getPythonScript() print('script=', script) exec(script)
def __init__( self, threshold=0.0, mu1=2200, sigma1=220, mu2=2100, sigma2=210, mu3=2300, sigma3=230, mu4=2000, sigma4=200, mu5=1200, sigma5=480, ): """ Creates a reliability problem RP60. The event is {g(X) < threshold} with: X = (x1, x2, x3, x4, x5) g1 = x1 - x5 g2 = x2 - x5 / 2 g3 = x3 - x5 / 2 g4 = x4 - x5 / 2 g5 = x2 - x5 g6 = x3 - x5 g7 = x4 - x5 g8 = min(g5, g6) g9 = max(g7, g8) g10 = min(g2, g3, g4) g11 = max(g10, g9) g(X) = min(g1, g11) We have : x1 ~ LogNormalMuSigma(mu1, sigma1) x2 ~ LogNormalMuSigma(mu2, sigma2) x3 ~ LogNormalMuSigma(mu3, sigma3) x4 ~ LogNormalMuSigma(mu4, sigma4) x5 ~ LogNormalMuSigma(mu5, sigma5) Parameters ---------- threshold : float The threshold. mu1 : float The mean of the LogNormal random variable X1. sigma1 : float The standard deviation of the LogNormal random variable X1. mu2 : float The mean of the LogNormal random variable X2. sigma2 : float The standard deviation of the LogNormal random variable X2. mu3 : float The mean of the LogNormal random variable X3. sigma3 : float The standard deviation of the LogNormal random variable X3. mu4 : float The mean of the LogNormal random variable X4. sigma4 : float The standard deviation of the LogNormal random variable X4. mu5 : float The mean of the LogNormal random variable X5. sigma5 : float The standard deviation of the LogNormal random variable X5. """ equations = ["var g1 := x1 - x5"] equations.append("var g2 := x2 - x5 / 2") equations.append("var g3 := x3 - x5 / 2") equations.append("var g4 := x4 - x5 / 2") equations.append("var g5 := x2 - x5") equations.append("var g6 := x3 - x5") equations.append("var g7 := x4 - x5") equations.append("var g8 := min(g5, g6)") equations.append("var g9 := max(g7, g8)") equations.append("var g10 := min(g2, g3, g4)") equations.append("var g11 := max(g10, g9)") equations.append("gsys := min(g1, g11)") formula = ";".join(equations) limitStateFunction = ot.SymbolicFunction( ["x1", "x2", "x3", "x4", "x5"], ["gsys"], formula ) parameters1 = ot.LogNormalMuSigma(mu1, sigma1, 0.0) X1 = ot.ParametrizedDistribution(parameters1) X1.setDescription(["X1"]) parameters2 = ot.LogNormalMuSigma(mu2, sigma2, 0.0) X2 = ot.ParametrizedDistribution(parameters2) X2.setDescription(["X2"]) parameters3 = ot.LogNormalMuSigma(mu3, sigma3, 0.0) X3 = ot.ParametrizedDistribution(parameters3) X3.setDescription(["X3"]) parameters4 = ot.LogNormalMuSigma(mu4, sigma4, 0.0) X4 = ot.ParametrizedDistribution(parameters4) X4.setDescription(["X4"]) parameters5 = ot.LogNormalMuSigma(mu5, sigma5, 0.0) X5 = ot.ParametrizedDistribution(parameters5) X5.setDescription(["X5"]) myDistribution = ot.ComposedDistribution([X1, X2, X3, X4, X5]) inputRandomVector = ot.RandomVector(myDistribution) outputRandomVector = ot.CompositeRandomVector( limitStateFunction, inputRandomVector ) thresholdEvent = ot.ThresholdEvent(outputRandomVector, ot.Less(), threshold) name = "RP60" probability = 0.0456 super(ReliabilityProblem60, self).__init__(name, thresholdEvent, probability) return None
#!/usr/bin/env python # coding: utf-8 from __future__ import print_function import openturns as ot import otguibase myStudy = otguibase.OTStudy('Study_CantileverBeam') ## Model dist_E = ot.Beta(0.9, 3.5, 2.5e7, 5.0e7) dist_F = ot.LogNormalMuSigma(30.e3, 9.e3, 15.e3).getDistribution() dist_L = ot.Uniform(250., 260.) dist_I = ot.Beta(2.5, 4., 310., 450.) E = otguibase.Input('E', 3e7, dist_E, 'Young\'s modulus (Pa)') F = otguibase.Input('F', 3e4, dist_F, 'Force applied (N)') L = otguibase.Input('L', 250, dist_L, 'Length (m)') I = otguibase.Input('I', 400, dist_I, 'Section modulus (m4)') y = otguibase.Output('y', 'Vertical deviation (m)') model = otguibase.SymbolicPhysicalModel('myPhysicalModel', [E, F, L, I], [y], ['F*L^3/(3*E*I)']) myStudy.add(model) # Create the Spearman correlation matrix of the input random vector RS = ot.CorrelationMatrix(4) RS[2,3] = -0.2 # Evaluate the correlation matrix of the Normal copula from RS R = ot.NormalCopula.GetCorrelationFromSpearmanCorrelation(RS) # Create the Normal copula parametrized by R copula = ot.NormalCopula(R)
# # In this example we are going to evaluate the min and max values of the output variable of interest from a sample and to evaluate the gradient of the limit state function defining the output variable of interest at a particular point. # %% from __future__ import print_function import openturns as ot import openturns.viewer as viewer from matplotlib import pylab as plt import math as m ot.Log.Show(ot.Log.NONE) # %% # Create the marginal distributions of the parameters dist_E = ot.Beta(0.93, 2.27, 2.8e7, 4.8e7) dist_F = ot.LogNormalMuSigma(30000, 9000, 15000).getDistribution() dist_L = ot.Uniform(250, 260) dist_I = ot.Beta(2.5, 1.5, 3.1e2, 4.5e2) marginals = [dist_E, dist_F, dist_L, dist_I] distribution = ot.ComposedDistribution(marginals) # %% # Sample inputs sampleX = distribution.getSample(100) # %% # Create the model model = ot.SymbolicFunction(['E', 'F', 'L', 'I'], ['F*L^3/(3*E*I)']) # %% # Evaluate outputs
# # Problem definition # # # Input probabilistic model # In[2]: sample_E = ot.Sample.ImportFromCSVFile("sample_E.csv") kernel_smoothing = ot.KernelSmoothing(ot.Normal()) bandwidth = kernel_smoothing.computeSilvermanBandwidth(sample_E) E = kernel_smoothing.build(sample_E, bandwidth) E.setDescription(['Young modulus']) # In[3]: F = ot.LogNormal() F.setParameter(ot.LogNormalMuSigma()([30000, 9000, 15000])) F.setDescription(['Load']) # In[4]: L = ot.Uniform(250, 260) L.setDescription(['Length']) # In[5]: I = ot.Beta(2.5, 4, 310, 450) I.setDescription(['Inertia']) # We now fix the order of the marginal distributions in the joint distribution. Order must match in the implementation of the physical model (to come). # In[6]:
# 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) # 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) # WeibullMinMuSigma parameter save wms_parameters = ot.WeibullMinMuSigma(1.3, 1.23, -0.5) myStudy.add('wms_parameters', wms_parameters) # MemoizeFunction f = ot.SymbolicFunction(['x1', 'x2'], ['x1*x2']) memoize = ot.MemoizeFunction(f) memoize([5, 6]) myStudy.add('memoize', memoize) # print ('Study = ' , myStudy)
# - the confidence interval # - the convergence graph of the estimator # - the stored input and output numerical samples # - importance factors # %% import openturns as ot import openturns.viewer as viewer from matplotlib import pylab as plt ot.Log.Show(ot.Log.NONE) # %% # Create the joint distribution of the parameters. # %% distribution_R = ot.LogNormalMuSigma(300.0, 30.0, 0.0).getDistribution() distribution_F = ot.Normal(75e3, 5e3) marginals = [distribution_R, distribution_F] distribution = ot.ComposedDistribution(marginals) # %% # Create the model. # %% model = ot.SymbolicFunction(['R', 'F'], ['R-F/(pi_*100.0)']) # %% modelCallNumberBefore = model.getEvaluationCallsNumber() modelGradientCallNumberBefore = model.getGradientCallsNumber() modelHessianCallNumberBefore = model.getHessianCallsNumber()
# %% maxDegree = 4 # %% # For real tests, we suggest using the following parameter value: # %% # maxDegree = 7 # %% # Let us define the parameters of the cantilever beam problem. # %% dist_E = ot.Beta(0.9, 2.2, 2.8e7, 4.8e7) dist_E.setDescription(["E"]) F_para = ot.LogNormalMuSigma(3.0e4, 9.0e3, 15.0e3) # in N dist_F = ot.ParametrizedDistribution(F_para) dist_F.setDescription(["F"]) dist_L = ot.Uniform(250.0, 260.0) # in cm dist_L.setDescription(["L"]) dist_I = ot.Beta(2.5, 1.5, 310.0, 450.0) # in cm^4 dist_I.setDescription(["I"]) myDistribution = ot.ComposedDistribution([dist_E, dist_F, dist_L, dist_I]) dim_input = 4 # dimension of the input dim_output = 1 # dimension of the output def function_beam(X): E, F, L, I = X
# Hard model hard_model_hparams = { 'model': var_dim, 'dim': 50, 'series': True # if series or parallel } # Surrogate model soft_model_hparams = { 'name': 'GP', 'kernel': None, 'n_restarts_optimizer': 0, 'normalize': False } # Distributions of random variables n = hard_model_hparams['dim'] dist_params = ot.LogNormalMuSigma(1.0, 0.2, 0.0) marginals = [ot.ParametrizedDistribution(dist_params)] * n dist = ot.ComposedDistribution(marginals) # Infill strategy infill_params_1 = { 'candidate': None, # 'uniform' 'num_pnt_re': 10000, 'num_neighbors': 1000, 'name': 'conv_comb', 'n_top': 1, 'decay_rate': None, 'metric': 'cosine', 'min_it': 40, 'max_it': 10000 }