import openturns as ot
import persalys
myStudy = persalys.Study('myStudy')
# Model
X0 = persalys.Input('X0', ot.Normal(1, 1))
X1 = persalys.Input('X1', ot.Normal(1, 1))
Y00 = persalys.Output('fake_Y0')
Y00.setIsSelected(False)
Y0 = persalys.Output('Y0')
formula_Y00 = 'X0'
formula_Y0 = 'sin(X0) + 8*X1'
model = persalys.SymbolicPhysicalModel('aModelPhys', [X0, X1], [Y00, Y0],
[formula_Y00, formula_Y0])
myStudy.add(model)
# Monte Carlo ##
analysis = persalys.MonteCarloAnalysis('myMonteCarlo', model)
analysis.setLevelConfidenceInterval(0.93)
analysis.setMaximumCalls(1000)
analysis.setMaximumCoefficientOfVariation(-1)
analysis.setMaximumElapsedTime(30)
analysis.setSeed(2)
myStudy.add(analysis)
print(analysis)
analysis.run()
result = analysis.getResult()
#! /usr/bin/env python
import openturns as ot
import persalys
import os
anOTStudy = persalys.Study('anOTStudy')
# Model
X0 = persalys.Input('X0', 1, ot.Normal())
X1 = persalys.Input('X1', 2, ot.Normal())
Y0 = persalys.Output('Y0')
model = persalys.SymbolicPhysicalModel('aModelPhys', [X0, X1], [Y0],
['sin(X0)+8*X1'])
anOTStudy.add(model)
# Design of Experiment ##
aDesign = persalys.GridDesignOfExperiment('aDesign_1', model,
[[0.9, 1.1], [1.8, 2.2]])
anOTStudy.add(aDesign)
aDesign.run()
print('outs=', aDesign.getResult().getDesignOfExperiment().getOutputSample())
# Design of Experiment ##
filename = 'normal.csv'
ot.Normal(3).getSample(10).exportToCSVFile(filename)
aDesign2 = persalys.ImportedDesignOfExperiment('aDesign_2', model, filename,
[0, 2])
anOTStudy.add(aDesign2)
myStudy = persalys.Study('myStudy')
# data
filename = 'données.csv'
ot.RandomGenerator_SetSeed(0)
ot.Normal(3).getSample(10).exportToCSVFile(filename)
inColumns = [0, 2]
# Model 1
model = persalys.DataModel('myDataModel', filename, inColumns)
myStudy.add(model)
print(model)
# Model 2
model2 = persalys.SymbolicPhysicalModel(
'SM', [persalys.Input('A'), persalys.Input('B')], [persalys.Output('S')],
['A+B+2'])
myStudy.add(model2)
importedDOE = persalys.ImportedDesignOfExperiment('doeI', model2, filename,
inColumns)
myStudy.add(importedDOE)
# script
script = myStudy.getPythonScript()
print(script)
# save
xmlFileName = 'file_with_données.xml'
myStudy.save(xmlFileName)
# open
myStudy = persalys.Study('myStudy')
# Model
xi1 = persalys.Input('xi1', ot.Uniform(0., 10.))
xi2 = persalys.Input('xi2', ot.Uniform(0., 10.))
xi3 = persalys.Input('xi3', 0.5)
y00 = persalys.Output('fake_y0')
y00.setIsSelected(False)
y0 = persalys.Output('y0')
y1 = persalys.Output('y1')
formula_y00 = "xi1"
formula_y0 = "cos(0.5*xi1) + sin(xi2)"
formula_y1 = "cos(0.5*xi1) + sin(xi2) + xi3"
model = persalys.SymbolicPhysicalModel('model', [xi1, xi2, xi3], [y00, y0, y1], [
formula_y00, formula_y0, formula_y1])
myStudy.add(model)
# Design of Experiment ##
aDesign = persalys.FixedDesignOfExperiment('design', model)
inputSample = ot.LHSExperiment(model.getDistribution(), 50).generate()
inputSample.stack(ot.Sample(50, [0.5]))
aDesign.setOriginalInputSample(inputSample)
myStudy.add(aDesign)
aDesign.run()
# Chaos 1 ##
analysis = persalys.FunctionalChaosAnalysis('chaos_0', aDesign)
analysis.setChaosDegree(4)
analysis.setSparseChaos(True)
# 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)
# Monte Carlo ##
montecarlo = persalys.MonteCarloReliabilityAnalysis(
'myMonteCarlo', limitState)
montecarlo.setMaximumCalls(10000)
myStudy.add(montecarlo)
montecarlo.run()
montecarloResult = montecarlo.getResult()
import os
ot.RandomGenerator.SetSeed(0)
anOTStudy = persalys.Study('anOTStudy')
# Model
X0 = persalys.Input('X0', 1, ot.Normal())
X1 = persalys.Input('X1', 2)
X2 = persalys.Input('X2', 2)
X3 = persalys.Input('X3', 2)
Y0 = persalys.Output('Y0')
Y1 = persalys.Output('Y1')
Y2 = persalys.Output('Y2')
model = persalys.SymbolicPhysicalModel('aModelPhys', [X0, X1, X2, X3],
[Y0, Y1, Y2], ['sin(X0)+8*X1'] * 3)
anOTStudy.add(model)
# Observations ##
filename = 'normal2.csv'
sample = ot.Normal(8).getSample(10)
sample.exportToCSVFile(filename)
obs = persalys.Observations("obs", model, filename, [7, 3], [6, 2],
["X3", "X1"], ["Y2", "Y1"])
anOTStudy.add(obs)
print('obs=', obs)
openturns.testing.assert_almost_equal(obs.getSample(),
sample.getMarginal([3, 7, 2, 6]), 1e-16)
# Models
x1 = persalys.Input('x1', 0.2)
x2 = persalys.Input('x2', 1.2)
x3 = persalys.Input('x3', 1.0)
fake_var = persalys.Output('fake_var')
fake_var.setIsSelected(False)
y0 = persalys.Output('y0')
fake_y0 = persalys.Output('fake_y0')
y1 = persalys.Output('y1')
# symboilc model ##
formula_fake_var = 'x1'
formula_y0 = 'cos(0.5*x1) + sin(x2)'
formula_y1 = 'cos(0.5*x1) + sin(x2) + x3'
symbolicModel = persalys.SymbolicPhysicalModel('symbolicModel', [x1, x2, x3], [fake_var, y0, fake_y0, y1], [
formula_fake_var, formula_y0, formula_y0, formula_y1])
myStudy.add(symbolicModel)
# python model ##
code = 'from math import cos, sin, sqrt\n\ndef _exec(x1, x2, x3):\n y0 = cos(0.5*x1) + sin(x2) + sqrt(x3)\n return y0\n'
pythonModel = persalys.PythonPhysicalModel('pythonModel', [x1, x2, x3], [y0], code)
myStudy.add(pythonModel)
filename = 'data.csv'
cDist = ot.ComposedDistribution([ot.Normal(), ot.Gumbel(), ot.Normal(), ot.Uniform()],
ot.ComposedCopula([ot.IndependentCopula(2), ot.GumbelCopula()]))
sample = cDist.getSample(200)
sample.exportToCSVFile(filename, ' ')
# Designs of Experiment ##
import openturns as ot
import persalys
from math import pi
myStudy = persalys.Study('myStudy')
# Model
x0 = persalys.Input('x0', ot.Normal())
x1 = persalys.Input('x1', ot.Normal())
y00 = persalys.Output('fake_y0')
y00.setIsSelected(False)
y0 = persalys.Output('y0')
formula_y00 = 'x0'
formula_y0 = '10+3*x0+x1'
model = persalys.SymbolicPhysicalModel('aModel', [x0, x1], [y00, y0],
[formula_y00, formula_y0])
myStudy.add(model)
# Sobol ##
analysis = persalys.SobolAnalysis('aSobol', model)
analysis.setMaximumCalls(1000)
analysis.setMaximumConfidenceIntervalLength(-1)
analysis.setMaximumElapsedTime(30)
analysis.setSeed(2)
analysis.setReplicationSize(250)
analysis.setBlockSize(4)
myStudy.add(analysis)
print(analysis)
analysis.run()
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
strainObs = dist_strain.getSample(nbObs)
strainObs.setDescription(['strain'])
stressSampleNoise = ot.Normal(0., 40.e6).getSample(nbObs)
stressSample = ot.ParametricFunction(model.getFunction('sigma'), [0, 1, 2],
[750e6, 2750e6, 10.])(strainObs)
stressObs = stressSample + stressSampleNoise
stressObs.setDescription(['sigma'])
observations = persalys.Observations('obs1', model, strainObs, stressObs)
#! /usr/bin/env python
import openturns as ot
import persalys
myStudy = persalys.Study('myStudy')
# Model
X0 = persalys.Input('X0', 1, ot.Normal(), 'aDescription')
X1 = persalys.Input('X1', 2)
Y0 = persalys.Output('Y0', 'output_1')
inputs = [X0, X1]
outputs = [Y0]
formulas = ['sin(X0)+8*X1']
model = persalys.SymbolicPhysicalModel('aModelPhys', inputs, outputs, formulas)
myStudy.add(model)
print(model)
# get attributs values
print('function=', model.getFunction())
print('formulas=', model.getFormulas())
print('formula_Y0=', model.getFormula('Y0'))
print('stochastic var=', model.getStochasticInputNames())
print('distribution=', model.getDistribution())
print('copula=', model.getCopula())
print('output_YO=', model.getOutputByName('Y0'))
print('input_XO=', model.getInputByName('X0'))
print('inputs names=', model.getInputNames())
print('outputs names=', model.getOutputNames())
print('hasY0', model.hasOutputNamed('Y0'))
print('hasX0', model.hasInputNamed('X0'))
import openturns.testing
import persalys
myStudy = persalys.Study('myStudy')
# Model
dist_Q = ot.Normal(10200, 100)
dist_E = ot.Normal(3000, 15)
dist_C = ot.Normal(4000, 60)
Q = persalys.Input('Q', 10200, dist_Q, 'Primary energy (W.h)')
E = persalys.Input('E', 3000, dist_E, 'Produced electric energy (W.h)')
C = persalys.Input('C', 4000, dist_C, 'Valued thermal energy (W.h)')
Ep = persalys.Output('Ep', 'Primary energy savings (W.h)')
model = persalys.SymbolicPhysicalModel('myPhysicalModel', [Q, E, C], [Ep],
['1-(Q/((E/((1-0.05)*0.54))+(C/0.8)))'])
myStudy.add(model)
outputSample = [[0.060036508072], [0.0812679132055], [0.0684295269203],
[0.0892876773294], [0.0292238907867], [0.0511512752497],
[0.0378920382755], [0.0594339324804]]
# Design of Experiment - Parametric analysis ##
bounds = persalys.GridDesignOfExperiment.GetDefaultBounds(model)
values = [[bounds.getLowerBound()[i],
bounds.getUpperBound()[i]] for i in range(3)]
aDesign = persalys.GridDesignOfExperiment('aDesign_0', model, values)
myStudy.add(aDesign)
aDesign.run()
# Comparaison
myStudy = persalys.Study('myStudy')
# Model
dist_E = ot.Beta(0.93, 3.2, 2.8e7, 4.8e7)
dist_F = ot.LogNormalMuSigma(30000., 9000., 15000).getDistribution()
dist_L = ot.Uniform(250, 260)
dist_I = ot.Beta(2.5, 4., 3.1e2, 4.5e2)
E = persalys.Input('E', 3e7, dist_E, 'Young\'s modulus (Pa)')
F = persalys.Input('F', 3e4, dist_F, 'Force applied (N)')
L = persalys.Input('L', 250, dist_L, 'Length (m4)')
I = persalys.Input('I', 400, dist_I, 'Section modulus (m4)')
y = persalys.Output('y', 'Vertical deviation (m)')
model = persalys.SymbolicPhysicalModel('myPhysicalModel', [E, F, L, I], [y],
['F*L^3/(3*E*I)'])
myStudy.add(model)
f = model.getFunction()
print(f([3e7, 3e4, 250, 400]))
# Sobol ##
sobol = persalys.SobolAnalysis('mySobol', model)
sobol.setMaximumConfidenceIntervalLength(-1)
sobol.setMaximumCalls(1000)
sobol.setReplicationSize(166)
myStudy.add(sobol)
sobol.run()
sobolResult = sobol.getResult()
# SRC ##
import openturns as ot
import persalys
# proba
dist_X0 = ot.Normal(0, 1)
X0 = persalys.Input('X0', 0, dist_X0, '')
dist_X1 = ot.Normal(0, 1)
X1 = persalys.Input('X1', 0, dist_X1, '')
X2 = persalys.Input('X2', 0, '')
X3 = persalys.Input('X3', 0, '')
Y0 = persalys.Output('Y0', '')
inputs = [X0, X1, X2, X3]
outputs = [Y0]
formulas = ['X0+X1+X2+X3']
SymbolicModel_0 = persalys.SymbolicPhysicalModel('SymbolicModel_0', inputs, outputs, formulas)
values = [[0],
[0],
[-0.1, 0.1],
[-0.1, 0.1]]
design_0 = persalys.GridDesignOfExperiment('design_0', SymbolicModel_0, values)
design_0.setBlockSize(1)
interestVariables = ['Y0']
design_0.setInterestVariables(interestVariables)
design_0.run()
metaModel_0 = persalys.FunctionalChaosAnalysis('metaModel_0', design_0)
metaModel_0.setChaosDegree(1)
metaModel_0.setSparseChaos(False)
metaModel_0.setAnalyticalValidation(True)
metaModel_0.setTestSampleValidation(False)
metaModel_0.setKFoldValidation(False)
