def _runMonteCarlo(self, defect):
# set a parametric function where the first parameter = given defect
g = ot.NumericalMathFunction(self._metamodel, [0], [defect])
g.enableHistory()
g.clearHistory()
g.clearCache()
output = ot.RandomVector(g, ot.RandomVector(self._distribution))
event = ot.Event(output, ot.Greater(), self._detectionBoxCox)
##### Monte Carlo ########
algo_MC = ot.MonteCarlo(event)
algo_MC.setMaximumOuterSampling(self._samplingSize)
# set negative coef of variation to be sure the stopping criterion is the sampling size
algo_MC.setMaximumCoefficientOfVariation(-1)
algo_MC.run()
return algo_MC.getResult()
mean[3] = 5.0
sigma = [1.0] * dim
R = ot.IdentityMatrix(dim)
myDistribution = ot.Normal(mean, sigma, R)
# We create a 'usual' RandomVector from the Distribution
vect = ot.RandomVector(myDistribution)
# We create a composite random vector
output = ot.RandomVector(myFunction, vect)
# We create an Event from this RandomVector
myEvent = ot.Event(output, ot.Less(), -3.0)
# We create a Monte Carlo algorithm
myAlgo = ot.MonteCarlo(myEvent)
myAlgo.setMaximumOuterSampling(250)
myAlgo.setBlockSize(4)
myAlgo.setMaximumCoefficientOfVariation(0.1)
print("MonteCarlo=", myAlgo)
# Perform the simulation
myAlgo.run()
# Stream out the result
print("MonteCarlo result=", myAlgo.getResult())
# Use the standard deviation as a stoping rule
myAlgo = ot.MonteCarlo(myEvent)
myAlgo.setMaximumOuterSampling(250)
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)
print('--------------------')
print('model flood S <', k, 'gamma=', end=' ')
print('f(', ot.NumericalPoint(x), ')=', fx)
event = ot.Event(composite, ot.Greater(), k)
for n in [100, 1000, 5000][1:2]:
for gamma1 in [0.25, 0.5, 0.75][1:2]:
algo = ot.MonteCarlo(event)
algo.setMaximumOuterSampling(100 * n)
# algo.setMaximumCoefficientOfVariation(-1.)
algo.run()
result = algo.getResult()
print(result)
algo = otads.AdaptiveDirectionalSampling(event)
algo.setMaximumOuterSampling(n)
algo.setGamma([gamma1, 1.0 - gamma1])
calls0 = function.getEvaluationCallsNumber()
algo.run()
calls = function.getEvaluationCallsNumber() - calls0
result = algo.getResult()
pf = result.getProbabilityEstimate()
var = result.getVarianceEstimate()
cov = result.getCoefficientOfVariation()
# Limit state ########################################################################## vect = ot.RandomVector(myDistribution) output = ot.RandomVector(limitState, vect) myEvent = ot.Event(output, ot.Less(), 0.0) ########################################################################## # Computation ########################################################################## bs = 1 # Monte Carlo myMC = ot.MonteCarlo(myEvent) myMC.setMaximumOuterSampling(int(1e6) // bs) myMC.setBlockSize(bs) myMC.setMaximumCoefficientOfVariation(-1.0) myMC.run() ########################################################################## # SubsetSampling mySS = ot.SubsetSampling(myEvent) mySS.setMaximumOuterSampling(10000 // bs) mySS.setBlockSize(bs) mySS.run() ########################################################################## # Results ##########################################################################