def getRange(self): return ot.Interval(-1.0, 1.0)
def test_one_input_one_output(): sampleSize = 6 dimension = 1 f = ot.SymbolicFunction(['x0'], ['x0 * sin(x0)']) X = ot.Sample(sampleSize, dimension) X2 = ot.Sample(sampleSize, dimension) for i in range(sampleSize): X[i, 0] = 3.0 + i X2[i, 0] = 2.5 + i X[0, 0] = 1.0 X[1, 0] = 3.0 X2[0, 0] = 2.0 X2[1, 0] = 4.0 Y = f(X) Y2 = f(X2) # create covariance model basis = ot.ConstantBasisFactory(dimension).build() covarianceModel = ot.SquaredExponential() # create algorithm algo = ot.KrigingAlgorithm(X, Y, covarianceModel, basis) # set sensible optimization bounds and estimate hyperparameters algo.setOptimizationBounds(ot.Interval(X.getMin(), X.getMax())) algo.run() # perform an evaluation result = algo.getResult() ott.assert_almost_equal(result.getMetaModel()(X), Y) ott.assert_almost_equal(result.getResiduals(), [1.32804e-07], 1e-3, 1e-3) ott.assert_almost_equal(result.getRelativeErrors(), [5.20873e-21]) # Kriging variance is 0 on learning points covariance = result.getConditionalCovariance(X) nullMatrix = ot.Matrix(sampleSize, sampleSize) ott.assert_almost_equal(covariance, nullMatrix, 0.0, 1e-14) # Kriging variance is non-null on validation points validCovariance = result.getConditionalCovariance(X2) values = ot.Matrix([[0.81942182, -0.35599947,-0.17488593, 0.04622401, -0.03143555, 0.04054783], [-0.35599947, 0.20874735, 0.10943841, -0.03236419, 0.02397483, -0.03269184], [-0.17488593, 0.10943841, 0.05832917, -0.01779918, 0.01355719, -0.01891618], [0.04622401, -0.03236419, -0.01779918, 0.00578327, -0.00467674, 0.00688697], [-0.03143555, 0.02397483, 0.01355719, -0.00467674, 0.0040267, -0.00631173], [0.04054783, -0.03269184, -0.01891618, 0.00688697, -0.00631173, 0.01059488]]) ott.assert_almost_equal(validCovariance - values, nullMatrix, 0.0, 1e-7) # Covariance per marginal & extract variance component coll = result.getConditionalMarginalCovariance(X) var = [mat[0, 0] for mat in coll] ott.assert_almost_equal(var, [0]*sampleSize, 1e-14, 1e-14) # Variance per marginal var = result.getConditionalMarginalVariance(X) ott.assert_almost_equal(var, ot.Point(sampleSize), 1e-14, 1e-14) # Prediction accuracy ott.assert_almost_equal(Y2, result.getMetaModel()(X2), 0.3, 0.0)
#! /usr/bin/env python import openturns as ot ot.TESTPREAMBLE() dim = 2 interval = ot.Interval([0.0] * dim, [10.0] * dim) mesh = ot.IntervalMesher([30] * dim).build(interval) f = ot.SymbolicFunction(["x", "y"], ["x + 0.5*sin(y)", "y-0.1*x*sin(x)"]) mesh.setVertices(f(mesh.getVertices())) simplices = mesh.getSimplices() nrSimplices = len(simplices) naive = ot.NaiveEnclosingSimplex(mesh.getVertices(), simplices) print("naive=", naive) ot.RandomGenerator.SetSeed(0) test = ot.ComposedDistribution([ot.Uniform(-1.0, 11.0)] * dim).getSample(100) for i, vertex in enumerate(test): index = naive.query(vertex) if index >= nrSimplices: print(i, "is outside") else: found, coordinates = mesh.checkPointInSimplexWithCoordinates( vertex, index) if not found: print("Wrong simplex found for", vertex, "(index=", index, simplices[index], "barycentric coordinates=", coordinates)
# %% # Evaluate the survival function at the mean point dist_2.computeSurvivalFunction(dist_2.getMean()) # %% # Evaluate the PDF on a sample dist_2.computePDF(dist_2.getSample(5)) # %% # Evaluate the CDF on a sample dist_2.computeCDF(dist_2.getSample(5)) # %% # Evaluate the probability content of an 1-d interval interval = ot.Interval(-2.0, 3.0) dist_1.computeProbability(interval) # %% # Evaluate the probability content of a 2-d interval interval = ot.Interval([0.4, -1], [3.4, 2]) dist_2.computeProbability(interval) # %% # Evaluate the quantile of order p=90% dist_2.computeQuantile(0.90) # %% # and the quantile of order 1-p dist_2.computeQuantile(0.90, True)
# 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) # Use a multivariate Normal distribution instead ks = ot.Normal(2) truncatedKS = ot.TruncatedDistribution( ks, ot.Interval([-0.5] * dimension, [2.0] * dimension)) distribution.append(truncatedKS) referenceDistribution.append(ks) # N/A
#! /usr/bin/env python from __future__ import print_function import openturns as ot try: mesh = ot.IntervalMesher([9]).build(ot.Interval(-1.0, 1.0)) cov1D = ot.AbsoluteExponential([1.0]) algo = ot.KarhunenLoeveP1Algorithm(mesh, cov1D, 0.0) algo.run() result = algo.getResult() lambd = result.getEigenValues() KLModes = result.getModesAsProcessSample() print("KL modes=", KLModes) print("KL eigenvalues=", lambd) process = ot.TemporalNormalProcess(cov1D, KLModes.getMesh()) coefficients = result.project(process.getSample(10)) print("KL coefficients=", coefficients) KLFunctions = result.getModes() print("KL functions=", KLFunctions) print("KL lift=", result.lift(coefficients[0])) print("KL lift as field=", result.liftAsField(coefficients[0])) R = ot.CorrelationMatrix(2) R[0, 1] = 0.5 scale = [1.0] amplitude = [1.0, 2.0] cov2D = ot.ExponentialModel(scale, amplitude, R) algo = ot.KarhunenLoeveP1Algorithm(mesh, cov2D, 0.0) algo.run() result = algo.getResult() lambd = result.getEigenValues()
algo.setMaximumConstraintError(1.0e-10) algo.run() print('algo=', algo) algo.run() result = algo.getResult() print('x^=', printPoint(result.getOptimalPoint(), 4)) print('f(x^)=', printPoint(result.getOptimalValue(), 4)) print('lambda^=', printPoint(result.getLagrangeMultipliers(), 4)) # bounds linear = ot.SymbolicFunction(['x1', 'x2', 'x3', 'x4'], ['x1+2*x2-3*x3+4*x4']) dim = 4 startingPoint = [0.] * dim bounds = ot.Interval([-3.] * dim, [5.] * dim) for minimization in [True, False]: problem = ot.OptimizationProblem(linear, ot.Function(), ot.Function(), bounds) problem.setMinimization(minimization) algo = ot.Cobyla(problem) algo.setMaximumIterationNumber(150) algo.setStartingPoint(startingPoint) print('algo=', algo) algo.run() result = algo.getResult() print('x^=', printPoint(result.getOptimalPoint(), 4)) print('f(x^)=', printPoint(result.getOptimalValue(), 4)) print('lambda^=', printPoint(result.getLagrangeMultipliers(), 4))
model = ot.SymbolicFunction(['a', 'b', 'c', 'x'], ['a + b * exp(min(500, c * x))']) p_ref = [2.8, 1.2, 0.5] # a, b, c modelx = ot.ParametricFunction(model, [0, 1, 2], p_ref) y = modelx(x) def residualFunction_py(p): modelx = ot.ParametricFunction(model, [0, 1, 2], p) return [modelx(x[i])[0] - y[i, 0] for i in range(m)] residualFunction = ot.PythonFunction(n, m, residualFunction_py) bounds = ot.Interval([0, 0, 0], [2.5, 8.0, 19]) for algoName in algoNames: line_search = not (algoName in ['LEVENBERG_MARQUARDT', 'DOGLEG']) for bound in [True, False]: if bound and line_search: # line search do not support bound constraints continue print('algoName=', algoName, 'bound=', bound) problem = ot.LeastSquaresProblem(residualFunction) if bound: problem.setBounds(bounds) startingPoint = [1.0] * n algo = ot.Ceres(problem, algoName) algo.setStartingPoint(startingPoint) # algo.setProgressCallback(progress)
# variables dist_z0 = ot.Uniform(100, 150) z0 = persalys.Input('z0', 100, dist_z0, '') dist_v0 = ot.Normal(55, 10) v0 = persalys.Input('v0', 55, dist_v0, '') dist_m = ot.Normal(80, 8) m = persalys.Input('m', 80, dist_m, '') dist_c = ot.Uniform(0, 30) c = persalys.Input('c', 16, dist_c, '') z1 = persalys.Output('z1', '') z2 = persalys.Output('z2', 'fake output') inputs = [z0, v0, m, c] outputs = [z1, z2] # mesh model meshModel = persalys.GridMeshModel(ot.Interval(0., 12.), [20]) # Python model code = 'from math import exp\n\ndef _exec(z0,v0,m,c):\n g = 9.81\n zmin = 0.\n tau = m / c\n vinf = -m * g / c\n\n # mesh nodes\n t = getMesh().getVertices()\n\n z = [max(z0 + vinf * t_i[0] + tau * (v0 - vinf) * (1 - exp(-t_i[0] / tau)), zmin) for t_i in t]\n z2 = [2*max(z0 + vinf * t_i[0] + tau * (v0 - vinf) * (1 - exp(-t_i[0] / tau)), zmin) for t_i in t]\n\n return z, z2' PhysicalModel_1 = persalys.PythonFieldModel('PhysicalModel_1', meshModel, inputs, outputs, code) Study_0.add(PhysicalModel_1) # central tendency mcAnalysis1 = persalys.FieldMonteCarloAnalysis("mcAnalysis", PhysicalModel_1) mcAnalysis1.setMaximumCalls(10) mcAnalysis1.setMaximumElapsedTime(1000) mcAnalysis1.setBlockSize(5) mcAnalysis1.setSeed(2) mcAnalysis1.setInterestVariables(['z']) mcAnalysis1.setKarhunenLoeveThreshold(2e-5) Study_0.add(mcAnalysis1)
#! /usr/bin/env python import openturns as ot ot.PlatformInfo.SetNumericalPrecision(6) dim = 2 # First domain: [0,2]x[0,2] cube = ot.Interval([0.0] * dim, [2.0] * dim) # Second domain: sphere center=(0,0) r=1 function = ot.SymbolicFunction(["x", "y"], ["x^2 + y^2"]) sphere = ot.LevelSet(function, ot.LessOrEqual(), 1.0) # Inside sphere but not cube p0 = [-0.25, 0.25] # Inside cube and sphere p1 = [0.25, 0.25] # Inside cube but not sphere p2 = [1.8, 1.8] # Outside p3 = [4.0, 4.0] domain = ot.DomainDisjunctiveUnion(cube, sphere) print("cube=", cube) print("sphere=", sphere) print("disjunctive union=", domain) # Accessors print("Dimension=", domain.getDimension()) # Contains
def PlotDesign(design, bounds=None, subdivisions=None, figure=None, axes=[], plot_kwargs=None, axes_kwargs=None, text_kwargs=None, enableTicks=True): """ Plot a design using a scatter plot. If the dimension is equal to 2, then plots the 2D projection. If the dimension is greater or equal to 3, then plots all 2D projections. In addition, the function plots a grid, i.e. horizontal and vertical lines to see the dispersion of the points. This allows to see how the sample fills the space. Parameters ---------- design : 2-d sequence of float The sample. figure : a Matplotlib figure. If this is not None, then create a new figure. Otherwise, use the existing figure. axes : a Matplotlib axis. If empty, then create new axes. bounds: :class:`~openturns.Interval` Bounds of the plot. By default, compute the bounds from the sample. subdivisions : a list of integers Number of subdivisions in the each direction. By default, set the number of subdivisions in each direction as equal to the sample size. enableTicks : A boolean. If True, then the ticks are plotted. Returns ------- fig : matplotlib figure Figure representing the sample. Examples -------- Plot a sample in 2 dimensions. >>> import openturns as ot >>> from openturns.viewer import PlotDesign >>> dim = 20 >>> X = [ot.Uniform()] * dim >>> distribution = ot.ComposedDistribution(X) >>> sampleSize = 10 >>> sample = distribution.getSample(sampleSize) >>> fig = PlotDesign(sample) Plot a sample in 5 dimensions. >>> import openturns as ot >>> from openturns.viewer import PlotDesign >>> dim = 5 >>> size = 10 >>> distribution = ot.ComposedDistribution([ot.Uniform(0.0, 1.0)]*dim) >>> bounds = distribution.getRange() >>> lhs = ot.LHSExperiment(distribution, size) >>> sample = lhs.generate() >>> subdivisions = [size]*dim >>> fig = PlotDesign(sample, bounds, subdivisions) """ # check that arguments are dictionnaries axes_kwargs = View._CheckDict(axes_kwargs) plot_kwargs = View._CheckDict(plot_kwargs) text_kwargs = View._CheckDict(text_kwargs) # retrieve data data = ot.Sample(design) dim = data.getDimension() if dim < 2: raise TypeError('Expected designs of dimension >=2') # Get the bounds if bounds is None: lowerBound = data.getMin() upperBound = data.getMax() bounds = ot.Interval(lowerBound, upperBound) if bounds.getDimension() != dim: raise ValueError( 'Dimension of bounds %d do not match the dimension of the sample %d' % (bounds.getDimension(), dim)) # Check the subdivisions if subdivisions is None: size = data.getSize() subdivisions = [size] * dim if len(subdivisions) != dim: raise ValueError( 'Number of subdivisions %d does not match the dimension of the sample %d' % (len(subdivisions), dim)) # Get description labels = data.getDescription() # adjust font if (not 'fontsize' in text_kwargs) and (not 'size' in text_kwargs): text_kwargs['fontsize'] = max(16 - dim, 4) text_kwargs.setdefault('horizontalalignment', 'center') text_kwargs.setdefault('verticalalignment', 'center') # set marker pointStyleDict = { 'square': 's', 'circle': 'o', 'triangleup': '2', 'plus': '+', 'times': '+', 'diamond': '+', 'triangledown': 'v', 'star': '*', 'fsquare': 's', 'fcircle': 'o', 'ftriangleup': '2', 'fdiamond': 'D', 'bullet': '.', 'dot': ',', 'none': 'None' } if not 'marker' in plot_kwargs: plot_kwargs['marker'] = pointStyleDict["square"] if not enableTicks: axes_kwargs['xticks'] = [] axes_kwargs['yticks'] = [] # set figure if figure is None: figure = plt.figure() axes = figure.axes else: # Figure exists: get the axes axes = figure.axes # Special case of dim=2 if dim == 2: Nx = subdivisions[0] Ny = subdivisions[1] axes = [figure.add_subplot(111, **axes_kwargs)] if not enableTicks: axes[0].axison = False x = data.getMarginal(0) y = data.getMarginal(1) # x axis x_min = bounds.getLowerBound()[0] x_max = bounds.getUpperBound()[0] dx = x_max - x_min # y axis y_min = bounds.getLowerBound()[1] y_max = bounds.getUpperBound()[1] dy = y_max - y_min # Draw horizontal lines dydiv = float(Ny) xk = [x_min, x_max] for k in range(Ny): yk = [y_min + k * dy / dydiv, y_min + k * dy / dydiv] axes[0].plot(xk, yk, 'k') yk = [y_max, y_max] axes[0].plot(xk, yk, 'k') # Draw vertical lines dxdiv = float(Nx) yk = [y_min, y_max] for k in range(Nx): xk = [x_min + k * dx / dxdiv, x_min + k * dx / dxdiv] axes[0].plot(xk, yk, 'k-') xk = [x_max, x_max] axes[0].plot(xk, yk, 'k-') plot_kwargs['linestyle'] = 'None' axes[0].plot(x, y, **plot_kwargs) axes[0].set_xlabel(labels[0]) axes[0].set_ylabel(labels[1]) axes[0].set_xlim(x_min, x_max) axes[0].set_ylim(y_min, y_max) return figure # General case # For the diagonal of a multidimensional plot, # disable the ticks, always diagonal_axes_kwargs = axes_kwargs.copy() # An independent copy diagonal_axes_kwargs['xticks'] = [] diagonal_axes_kwargs['yticks'] = [] # Graph of type Pairs + horizontal/vertical lines # to illustrate the cells index_axis = -1 for i in range(dim): Ny = subdivisions[i] # y axis y = data.getMarginal(i) y_min = bounds.getLowerBound()[i] y_max = bounds.getUpperBound()[i] dy = y_max - y_min for j in range(dim): Nx = subdivisions[j] index_axis += 1 if i == j: axes.append( figure.add_subplot(dim, dim, index_axis + 1, **diagonal_axes_kwargs)) text_kwargs['transform'] = axes[index_axis].transAxes axes[index_axis].text(0.5, 0.5, labels[i], **text_kwargs) else: axes.append( figure.add_subplot(dim, dim, index_axis + 1, **axes_kwargs)) # disable axis : grid, ticks, axis? if not enableTicks: axes[index_axis].axison = False # x axis x = data.getMarginal(j) x_min = bounds.getLowerBound()[j] x_max = bounds.getUpperBound()[j] dx = x_max - x_min # Draw horizontal lines dydiv = float(Ny) for k in range(Ny): xk = [x_min, x_max] yk = [y_min + k * dy / dydiv, y_min + k * dy / dydiv] axes[index_axis].plot(xk, yk, 'k-') # Draw vertical lines dxdiv = float(Nx) for k in range(Nx): xk = [x_min + k * dx / dxdiv, x_min + k * dx / dxdiv] yk = [y_min, y_max] axes[index_axis].plot(xk, yk, 'k-') plot_kwargs['linestyle'] = 'None' axes[index_axis].plot(x, y, **plot_kwargs) axes[index_axis].set_xlim(x_min, x_max) axes[index_axis].set_ylim(y_min, y_max) # Finally get the figure return figure
#! /usr/bin/env python import openturns as ot import matplotlib import matplotlib.pyplot as plt from matplotlib.backends.backend_pdf import PdfPages from openturns.viewer import View import time ot.RandomGenerator.SetSeed(0) ot.Log.Show(ot.Log.INFO) # Bounds are [0,1]^dimension dimension = 2 bounds = ot.Interval(dimension) # Size of sample size = 10 # Factory: lhs generates lhsDesign = ot.LHSExperiment( ot.ComposedDistribution([ot.Uniform(0.0, 1.0)] * dimension), size) lhsDesign.setAlwaysShuffle(True) # randomized geomProfile = ot.GeometricProfile(10.0, 0.999, 50000) c2 = ot.SpaceFillingC2() sa = ot.SimulatedAnnealingLHS(lhsDesign, geomProfile, c2) tic = time.time() result = sa.generate() toc = time.time() dt1 = toc - tic
def _estimKrigingTheta(self, algoKriging, lowerBound, upperBound, size): """ Estimate the kriging theta values with an initial random search using a Sobol sequence of size samples. """ # get input parameters of the kriging algorithm X = algoKriging.getInputSample() Y = algoKriging.getOutputSample() algoKriging.run() krigingResult = algoKriging.getResult() covarianceModel = krigingResult.getCovarianceModel() basis = krigingResult.getBasisCollection() if LooseVersion(ot.__version__) == '1.9': llf = algoKriging.getReducedLogLikelihoodFunction() else: llf = algoKriging.getLogLikelihoodFunction() # create uniform distribution of the parameters bounds dim = len(lowerBound) distBoundCol = [] for i in range(dim): distBoundCol += [ot.Uniform(lowerBound[i], upperBound[i])] distBound = ot.ComposedDistribution(distBoundCol) if size > 0: # Generate starting points with a low discrepancy sequence thetaStart = ot.LowDiscrepancyExperiment(ot.SobolSequence(), distBound, size).generate() # Get the best theta from the maximum llf value llfValue = llf(thetaStart) indexMax = int(np.argmax(llfValue)) bestTheta = thetaStart[indexMax] # update theta after random search if LooseVersion(ot.__version__) == '1.6': covarianceModel.setScale(bestTheta) elif LooseVersion(ot.__version__) > '1.6': # optimize theta and sigma in ot 1.8 covarianceModel.setScale(bestTheta[:-1]) covarianceModel.setAmplitude([bestTheta[-1]]) # Now the KrigingAlgorithm is used to optimize the likelihood using a # good starting point if LooseVersion(ot.__version__) == "1.9": algoKriging = ot.KrigingAlgorithm(X, Y, covarianceModel, basis) else: algoKriging = ot.KrigingAlgorithm(X, Y, basis, covarianceModel, True) # set TNC optim searchInterval = ot.Interval(lowerBound, upperBound) if LooseVersion(ot.__version__) == '1.6': optimizer = ot.TNC() optimizer.setBoundConstraints(searchInterval) algoKriging.setOptimizer(optimizer) elif LooseVersion(ot.__version__) in ['1.7', '1.8']: optimizer = algoKriging.getOptimizationSolver() problem = optimizer.getProblem() problem.setBounds(searchInterval) optimizer.setProblem(problem) algoKriging.setOptimizationSolver(optimizer) elif LooseVersion(ot.__version__) == '1.9': algoKriging.setOptimizationBounds(searchInterval) return algoKriging
import openturns.testing as ott # Define the objective function objectiveFun = ot.SymbolicFunction( ["x", "y", "z", "t"], ["-(15*x + 12*y + 4*z + 2*t)"]) constraintFun = ot.SymbolicFunction( ["x", "y", "z", "t"], ["-(8*x + 5*y + 3*z + 2*t -10)"]) x = [0, 1, 1, 1] print("Evaluate f at x=", x) print("f(x)=", objectiveFun(x)) print("g(x)=", constraintFun(x)) # Define problem problem = ot.OptimizationProblem(objectiveFun) problem.setInequalityConstraint(constraintFun) bounds = ot.Interval([0., 0., 0., 0.], [1., 1., 1., 1.]) problem.setBounds(bounds) problem.setMinimization(True) problem.setVariablesType([ot.OptimizationProblemImplementation.BINARY, ot.OptimizationProblemImplementation.BINARY, ot.OptimizationProblemImplementation.BINARY, ot.OptimizationProblemImplementation.BINARY]) # Define OptimizationAlgorithm x0 = [0., 0., 0., 0.] algo = ot.Bonmin(problem, "B-BB") algo.setStartingPoint(x0) algo.setMaximumEvaluationNumber(10000) algo.setMaximumIterationNumber(1000) ot.ResourceMap.AddAsScalar('Bonmin-bonmin.time_limit', 60) algo.run() # Retrieve result
# 2. covariance model cov = ot.MaternModel([1.], [2.5], 1.5) print(cov) # 3. kriging algorithm algokriging = ot.KrigingAlgorithm(x, y, cov, basis) ## error measure #algokriging.setNoise([5*1e-1]*n_pt) # 4. Optimization # algokriging.setOptimizationAlgorithm(ot.NLopt('GN_DIRECT')) lhsExperiment = ot.LHSExperiment(ot.Uniform(1e-1, 1e2), 50) algokriging.setOptimizationAlgorithm( ot.MultiStart(ot.TNC(), lhsExperiment.generate())) algokriging.setOptimizationBounds(ot.Interval([0.1], [1e2])) # if we choose not to optimize parameters #algokriging.setOptimizeParameters(False) # 5. run the algorithm algokriging.run() # %% # Results # ------- # %% # get some results krigingResult = algokriging.getResult() print('residual = ', krigingResult.getResiduals())
pt1 = self.vertices[i] pt2 = self.vertices[j] difference = pt1 - pt2 val = m.exp(-difference.norm() / self.scaling) return val ot.ResourceMap.SetAsBool('HMatrix-ForceSequential', True) ot.ResourceMap.SetAsUnsignedInteger('HMatrix-MaxLeafSize', 10) ot.PlatformInfo.SetNumericalPrecision(3) n = 2 indices = [n, n] intervalMesher = ot.IntervalMesher(indices) interval = ot.Interval([0.0] * 2, [1.0] * 2) mesh2D = intervalMesher.build(interval) vertices = mesh2D.getVertices() factory = ot.HMatrixFactory() parameters = ot.HMatrixParameters() parameters.setAssemblyEpsilon(1.e-6) parameters.setRecompressionEpsilon(1.e-6) # HMatrix must be symmetric in order to perform Cholesky decomposition hmat = factory.build(vertices, 1, True, parameters) simpleAssembly = TestHMatrixRealAssemblyFunction(vertices, 0.1) hmat.assembleReal(simpleAssembly, 'L') hmatRef = ot.HMatrix(hmat)
ot.ResourceMap.SetAsScalar( 'SimulationAlgorithm-DefaultMaximumCoefficientOfVariation', 0.0) ot.ResourceMap.SetAsScalar( 'SimulationAlgorithm-DefaultMaximumStandardDeviation', 0.0) ot.ResourceMap.SetAsScalar('RootStrategy-DefaultStepSize', 0.1) algorithms = ['MonteCarlo', 'LHS', 'QuasiMonteCarlo', 'DirectionalSampling'] inDim = 4 X = ot.RandomVector(ot.Normal(inDim)) inVars = ot.Description.BuildDefault(inDim, 'x') low = 1.0 up = 2.0 intervals = [ ot.Interval([low], [up], [True], [False]), ot.Interval([low], [up], [False], [True]), ot.Interval([low], [up], [True], [True]), ot.Interval([low], [up], [False], [False]), ot.Interval([low] * 2, [up] * 2, [True, True], [True, True]), ot.Interval([low] * 2, [up] * 2, [True, True], [True, False]), ot.Interval([low] * 2, [up] * 2, [True, True], [False, True]), ot.Interval([low] * 2, [up] * 2, [True, True], [False, False]), ot.Interval([low] * 2, [up] * 2, [True, False], [True, True]), ot.Interval([low] * 2, [up] * 2, [True, False], [True, False]), ot.Interval([low] * 2, [up] * 2, [True, False], [False, True]), ot.Interval([low] * 2, [up] * 2, [True, False], [False, False]), ot.Interval([low] * 2, [up] * 2, [False, True], [True, True]), ot.Interval([low] * 2, [up] * 2, [False, True], [True, False]), ot.Interval([low] * 2, [up] * 2, [False, True], [False, True]), ot.Interval([low] * 2, [up] * 2, [False, True], [False, False]),
# *InverseBoxCoxTransform* that can be evaluated on a field. # The new field based shares the same mesh than the initial field. # # %% from __future__ import print_function import openturns as ot import openturns.viewer as viewer from matplotlib import pylab as plt ot.Log.Show(ot.Log.NONE) # %% # Define a process myIndices = ot.Indices([10, 5]) myMesher = ot.IntervalMesher(myIndices) myInterval = ot.Interval([0.0, 0.0], [2.0, 1.0]) myMesh = myMesher.build(myInterval) amplitude = [1.0] scale = [0.2, 0.2] myCovModel = ot.ExponentialModel(scale, amplitude) myXproc = ot.GaussianProcess(myCovModel, myMesh) g = ot.SymbolicFunction(['x1'], ['exp(x1)']) myDynTransform = ot.ValueFunction(g, myMesh) myXtProcess = ot.CompositeProcess(myDynTransform, myXproc) # %% # Draw a field field = myXtProcess.getRealization() graph = field.drawMarginal(0) view = viewer.View(graph)
timeStep = 0.1 n = 100 tgrid = ot.RegularGrid(tMin, timeStep, n) # %% # Create a normal process amplitude = [5.0] scale = [3.0] model = ot.ExponentialModel(scale, amplitude) process = ot.GaussianProcess(model, tgrid) # %% # Create the 1-d domain A: [2.,5.] lowerBound = [2.0] upperBound = [5.0] domain = ot.Interval(lowerBound, upperBound) # %% # Create an event from a Process and a Domain event = ot.ProcessEvent(process, domain) # %% # Create the Monte-Carlo algorithm montecarlo = ot.ProbabilitySimulationAlgorithm(event) # Define the maximum number of simulations montecarlo.setMaximumOuterSampling(1000) # Define the block size montecarlo.setBlockSize(100)
# branin dim = 2 # model branin = ot.SymbolicFunction(['x1', 'x2'], [ '((x2-(5.1/(4*_pi^2))*x1^2+5*x1/_pi-6)^2+10*(1-1/8*_pi)*cos(x1)+10-54.8104)/51.9496', '0.96' ]) transfo = ot.SymbolicFunction(['u1', 'u2'], ['15*u1-5', '15*u2']) model = ot.ComposedFunction(branin, transfo) # problem problem = ot.OptimizationProblem() problem.setObjective(model) bounds = ot.Interval([0.0] * dim, [1.0] * dim) problem.setBounds(bounds) # design experiment = ot.Box([1, 1]) inputSample = experiment.generate() modelEval = model(inputSample) outputSample = modelEval.getMarginal(0) # first kriging model covarianceModel = ot.SquaredExponential([0.3007, 0.2483], [0.981959]) basis = ot.ConstantBasisFactory(dim).build() kriging = ot.KrigingAlgorithm(inputSample, outputSample, covarianceModel, basis) noise = list(map(lambda x: x[1], modelEval)) kriging.setNoise(noise)
covarianceModel = ot.SquaredExponential(dimension) # %% # Typically, the optimization algorithm is quite good at setting sensible optimization bounds. # In this case, however, the range of the input domain is extreme. # %% print("Lower and upper bounds of X_train:") print(X_train.getMin(), X_train.getMax()) # %% # We need to manually define sensible optimization bounds. # Note that since the amplitude parameter is computed analytically (this is possible when the output dimension is 1), we only need to set bounds on the scale parameter. # %% scaleOptimizationBounds = ot.Interval( [1.0, 1.0, 1.0, 1.0e-10], [1.0e11, 1.0e3, 1.0e1, 1.0e-5]) # %% # Finally, we use the `KrigingAlgorithm` class to create the Kriging metamodel. # It requires a training sample, a covariance kernel and a trend basis as input arguments. # We need to set the initial scale parameter for the optimization. The upper bound of the input domain is a sensible choice here. # We must not forget to actually set the optimization bounds defined above. # %% covarianceModel.setScale(X_train.getMax()) algo = ot.KrigingAlgorithm(X_train, Y_train, covarianceModel, basis) algo.setOptimizationBounds(scaleOptimizationBounds) # %% # Run the algorithm and get the result.
# %% # # In this example we are going to assess a Karhunen-Loeve decomposition # # %% from __future__ import print_function import openturns as ot import openturns.viewer as viewer from matplotlib import pylab as plt ot.Log.Show(ot.Log.NONE) # %% # Create a Gaussian process numberOfVertices = 20 interval = ot.Interval(-1.0, 1.0) mesh = ot.IntervalMesher([numberOfVertices - 1]).build(interval) covariance = ot.SquaredExponential() process = ot.GaussianProcess(covariance, mesh) # %% # decompose it using KL-SVD sampleSize = 100 processSample = process.getSample(sampleSize) threshold = 1.0e-7 algo = ot.KarhunenLoeveSVDAlgorithm(processSample, threshold) algo.run() klresult = algo.getResult() # %% # Instanciate the validation service
rastrigin = ot.MemoizeFunction(rastrigin) # %% # This example is academic and the point achieving the global minimum of the function is known. # %% xexact = [0.0] * dim print(xexact) # %% # The optimization bounds must be specified. # %% lowerbound = [-4.4] * dim upperbound = [5.12] * dim bounds = ot.Interval(lowerbound, upperbound) # %% # Plot the iso-values of the objective function # --------------------------------------------- # %% graph = rastrigin.draw(lowerbound, upperbound, [100]*dim) graph.setTitle("Rastrigin function") view = viewer.View(graph, legend_kw={ 'bbox_to_anchor': (1, 1), 'loc': "upper left"}) view.getFigure().tight_layout() # %% # We see that the Rastrigin function has several local minima. However, there is only one single global minimum at :math:`\vect{x}^\star=(0, 0)`.
f = ot.PythonFunction(3, 2, flow) phi = ot.ParametricFunction(f, [2], [0.0]) solver = ot.RungeKutta(phi) initialState = [2.0, 2.0] nt = 47 dt = 0.1 timeGrid = ot.RegularGrid(0.0, dt, nt) result = solver.solve(initialState, timeGrid) xMin = result.getMin() xMax = result.getMax() delta = 0.2 * (xMax - xMin) mesh = ot.IntervalMesher([12] * 2).build( ot.Interval(xMin - delta, xMax + delta)) field = ot.Field(mesh, phi(mesh.getVertices())) ot.ResourceMap.SetAsScalar("Field-ArrowScaling", 0.1) graph = field.draw() cloud = ot.Cloud(mesh.getVertices()) cloud.setColor("black") graph.add(cloud) curve = ot.Curve(result) curve.setColor("red") curve.setLineWidth(2) graph.add(curve) fig = plt.figure() ax = fig.add_subplot(111) View(graph, figure=fig) plt.suptitle("Lotka-Volterra ODE system")
# It can be built from a mesh and values or as a realization of a stochastic process. # %% 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) # %% # First, we define a regular 2-d mesh discretization = [10, 5] mesher = ot.IntervalMesher(discretization) lowerBound = [0.0, 0.0] upperBound = [2.0, 1.0] interval = ot.Interval(lowerBound, upperBound) mesh = mesher.build(interval) graph = mesh.draw() graph.setTitle('Regular 2-d mesh') view = viewer.View(graph) # %% # We now create a field from a mesh and some values values = ot.Normal([0.0] * 2, [1.0] * 2, ot.CorrelationMatrix(2)).getSample(len(mesh.getVertices())) for i in range(len(values)): x = values[i] values[i] = 0.05 * x / x.norm() field = ot.Field(mesh, values) # %%
# ------------------------- # # We now perform the target analysis which consists in using a filter function over the # output. # %% # Defining a filter function # ^^^^^^^^^^^^^^^^^^^^^^^^^^ # # We define a filter function on the output variable for the target # analysis. In this example we use the function :math:`\exp{(-d/s)}` where :math:`d` is the distance # to a well-chosen interval. # %% # We first define a critical domain: in our case that is the :math:`[5,+\infty[` interval. criticalDomain = ot.Interval(5, float('inf')) # %% # We have access to the distance to this domain thanks to the # :class:`~openturns.DistanceToDomainFunction` class. dist2criticalDomain = ot.DistanceToDomainFunction(criticalDomain) # %% # We define the parameters in our function from the output sample s = 0.1 * Y.computeStandardDeviation()[0] # %% # We now define our filter function by composition of the parametrized function and # the distance function. f = ot.SymbolicFunction(["x", "s"], ["exp(-x/s)"]) phi = ot.ParametricFunction(f, [1], [s])
#! /usr/bin/env python from __future__ import print_function import openturns as ot try: ot.ResourceMap.SetAsScalar( "LinearCombinationEvaluation-SmallCoefficient", 1.0e-10) domain = ot.Interval(-1.0, 1.0) basis = ot.OrthogonalProductPolynomialFactory([ot.LegendreFactory()]) basisSize = 5 experiment = ot.LHSExperiment(basis.getMeasure(), 100) mustScale = False threshold = 0.0001 model = ot.AbsoluteExponential([1.0]) algo = ot.KarhunenLoeveQuadratureAlgorithm( domain, model, experiment, basis, basisSize, mustScale, threshold) algo.run() result = algo.getResult() lambd = result.getEigenValues() KLModes = result.getModesAsProcessSample() print("KL modes=", KLModes) print("KL eigenvalues=", lambd) process = ot.GaussianProcess(model, KLModes.getMesh()) sample = process.getSample(10) coefficients = result.project(sample) print("KL coefficients=", coefficients) KLFunctions = result.getModes() print("KL functions=", KLFunctions) print("KL lift=", result.lift(coefficients[0])) print("KL lift as field=", result.liftAsField(coefficients[0]))
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View f = ot.SymbolicFunction(['x'], ['sin(x)']) a = -2.5 b = 4.5 algo = ot.Fejer1([20]) value, nodes = algo.integrateWithNodes(f, ot.Interval(a, b)) g = f.draw(a, b, 512) lower = ot.Cloud(nodes, ot.Sample(nodes.getSize(), 1)) lower.setColor("magenta") lower.setPointStyle('circle') g.add(lower) g.setTitle(r"GaussLegendre example: $\int_{-5/2}^{9/2}\sin(t)\,dt=$" + str(value[0])) fig = plt.figure(figsize=(8, 4)) axis = fig.add_subplot(111) axis.set_xlim(auto=True) View(g, figure=fig, axes=[axis], add_legend=False)
graph2 = mesh2D.draw() graph2.setTitle('Bidimensional mesh') graph2.setLegendPosition('bottomright') view = viewer.View(graph2) # %% # We can also define a mesh which is a regularly meshed box in dimension 1 or 2. # We define the number of intervals in each direction of the box : myIndices = [5, 10] myMesher = ot.IntervalMesher(myIndices) # %% # We then create the mesh of the box :math:`[0, 2] \times [0, 4]` : lowerBound = [0., 0.] upperBound = [2., 4.] myInterval = ot.Interval(lowerBound, upperBound) myMeshBox = myMesher.build(myInterval) mygraph3 = myMeshBox.draw() mygraph3.setTitle('Bidimensional mesh on a box') view = viewer.View(mygraph3) # %% # It is possible to perform a transformation on a regularly meshed box. myIndices = [20, 20] mesher = ot.IntervalMesher(myIndices) # r in [1., 2.] and theta in (0., pi] lowerBound2 = [1.0, 0.0] upperBound2 = [2.0, m.pi] myInterval = ot.Interval(lowerBound2, upperBound2) meshBox2 = mesher.build(myInterval)
import openturns.testing as ott ot.TESTPREAMBLE() f = ot.SymbolicFunction(["x"], ["sin(x)"]) a = -2.5 b = 4.5 # Integrate sin(t) between a & b --> cos(b) - sin(b) ref = math.cos(a) - math.cos(b) all_methods = [ot.FejerAlgorithm.FEJERTYPE1, ot.FejerAlgorithm.FEJERTYPE2, ot.FejerAlgorithm.CLENSHAWCURTIS] # 1D checking for method in all_methods: algo = ot.FejerAlgorithm([100], method) value, adaptedNodes = algo.integrateWithNodes(f, ot.Interval(a, b)) ott.assert_almost_equal(value[0], ref, 1e-10, 1e-10) g = ot.SymbolicFunction(["x", "y"], ["cos(pi_ * x / 2) * sin(pi_ * y)"]) ref = 8 / (math.pi * math.pi) interval = ot.Interval([-1, 0], [1, 1]) for method in all_methods: algo = ot.FejerAlgorithm([64, 64], method) value, adaptedNodes = algo.integrateWithNodes(g, interval) ott.assert_almost_equal(value[0], ref, 1e-10, 1e-10) # Now we use the same calculus using variables changes h = ot.SymbolicFunction( ["x", "y"], ["cos(pi_ * x / 2) * sin(pi_ * y / 2 + pi_/2 ) / 2"]) interval = ot.Interval([-1, -1], [1, 1]) for method in all_methods: