/usr/include/openturns/Simulation.hxx is in libopenturns-dev 1.5-7build2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 | // -*- C++ -*-
/**
* @file Simulation.hxx
* @brief Simulation is a generic view of simulation methods for computing
* probabilities and related quantities by sampling and estimation
*
* Copyright 2005-2015 Airbus-EDF-IMACS-Phimeca
*
* This library is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* @author schueller
* @date 2012-02-17 19:35:43 +0100 (Fri, 17 Feb 2012)
*/
#ifndef OPENTURNS_SIMULATION_HXX
#define OPENTURNS_SIMULATION_HXX
#include "PersistentObject.hxx"
#include "HistoryStrategy.hxx"
#include "Compact.hxx"
#include "Last.hxx"
#include "Graph.hxx"
#include "SimulationResult.hxx"
#include "Event.hxx"
BEGIN_NAMESPACE_OPENTURNS
/**
* @class Simulation
*/
class OT_API Simulation
: public PersistentObject
{
CLASSNAME;
public:
/** Constructor with parameters */
explicit Simulation(const Event & event,
const Bool verbose = true,
const HistoryStrategy & convergenceStrategy = Compact());
/** Virtual constructor */
virtual Simulation * clone() const;
/** Event accessor */
Event getEvent() const;
/** Result accessor */
SimulationResult getResult() const;
/** Maximum sample size accessor */
void setMaximumOuterSampling(const UnsignedInteger maximumOuterSampling);
UnsignedInteger getMaximumOuterSampling() const;
/** Maximum coefficient of variation accessor */
void setMaximumCoefficientOfVariation(const NumericalScalar maximumCoefficientOfVariation);
NumericalScalar getMaximumCoefficientOfVariation() const;
/** Maximum standard deviation accessor */
void setMaximumStandardDeviation(const NumericalScalar maximumStandardDeviation);
NumericalScalar getMaximumStandardDeviation() const;
/** Block size accessor */
void setBlockSize(const UnsignedInteger blockSize);
UnsignedInteger getBlockSize() const;
/** Verbosity accessor */
void setVerbose(const Bool verbose);
Bool getVerbose() const;
/** Convergence strategy accessor */
void setConvergenceStrategy(const HistoryStrategy & convergenceStrategy);
HistoryStrategy getConvergenceStrategy() const;
/** String converter */
String __repr__() const;
/** Performs the actual computation. */
virtual void run();
/** Draw the probability convergence at the given level */
Graph drawProbabilityConvergence(const NumericalScalar level = ResourceMap::GetAsNumericalScalar( "SimulationResultImplementation-DefaultConfidenceLevel" )) const;
/** Method save() stores the object through the StorageManager */
void save(Advocate & adv) const;
/** Method load() reloads the object from the StorageManager */
void load(Advocate & adv);
/** Progress callback */
typedef void (*ProgressCallback)(NumericalScalar, void * data);
void setProgressCallback(ProgressCallback callBack, void * data = 0);
/** Stop callback */
typedef Bool (*StopCallback)(void * data);
void setStopCallback(StopCallback callBack, void * data = 0);
protected:
/** Result accessor */
void setResult(const SimulationResult & result);
/** Compute the block sample and the points that realized the event */
virtual NumericalSample computeBlockSample();
/** For save/load mechanism*/
Simulation(const Bool verbose = true,
const HistoryStrategy & convergenceStrategy = Compact());
friend class Factory<Simulation>;
/** History strategy for the probability and variance estimate */
HistoryStrategy convergenceStrategy_;
// Size of the atomic blocks of computation
UnsignedInteger blockSize_;
// The event we are computing the probability of
Event event_;
// Result of the simulation
SimulationResult result_;
// callbacks
std::pair< ProgressCallback, void *> progressCallback_;
std::pair< StopCallback, void *> stopCallback_;
private:
// Maximum number of outer iteration allowed
UnsignedInteger maximumOuterSampling_;
// Maximum coefficient of variation allowed for convergence
NumericalScalar maximumCoefficientOfVariation_;
// Maximum standard deviation allowed for convergence
NumericalScalar maximumStandardDeviation_;
// Do we have to echo all the intermediate results?
Bool verbose_;
} ; /* class Simulation */
END_NAMESPACE_OPENTURNS
#endif /* OPENTURNS_SIMULATION_HXX */
|