/usr/include/openturns/Simulation.hxx is in libopenturns-dev 0.15-2.
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 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 | // -*- C++ -*-
/**
* @file Simulation.hxx
* @brief Simulation is a generic view of simulation methods for computing
* probabilities and related quantities by sampling and estimation
*
* (C) Copyright 2005-2011 EDF-EADS-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 2.1 of the License.
*
* 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
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* @author: $LastChangedBy: schueller $
* @date: $LastChangedDate: 2011-04-11 12:32:27 +0200 (Mon, 11 Apr 2011) $
* Id: $Id: Simulation.hxx 1866 2011-04-11 10:32:27Z schueller $
*/
#ifndef OPENTURNS_SIMULATION_HXX
#define OPENTURNS_SIMULATION_HXX
#include "PersistentObject.hxx"
#include "Exception.hxx"
#include "HistoryStrategy.hxx"
#include "Compact.hxx"
#include "Last.hxx"
#include "Graph.hxx"
#include "SimulationResult.hxx"
#include "Event.hxx"
namespace OpenTURNS
{
namespace Uncertainty
{
namespace Algorithm
{
/**
* @class Simulation
*/
class Simulation
: public Base::Common::PersistentObject
{
CLASSNAME;
public:
static const UnsignedLong DefaultMaximumOuterSampling;
static const NumericalScalar DefaultMaximumCoefficientOfVariation;
static const NumericalScalar DefaultMaximumStandardDeviation;
static const UnsignedLong DefaultBlockSize;
typedef Base::Common::InvalidArgumentException InvalidArgumentException;
typedef Model::Event Event;
typedef Base::Stat::NumericalSample NumericalSample;
typedef Base::Stat::HistoryStrategy HistoryStrategy;
typedef Base::Stat::Compact Compact;
typedef Base::Stat::Last Last;
typedef Base::Graph::Graph Graph;
typedef Base::Common::StorageManager StorageManager;
/** Constructor with parameters */
explicit Simulation(const Event & event,
const Bool verbose = true,
const HistoryStrategy & convergenceStrategy = Compact(),
const HistoryStrategy & inputOutputStrategy = Last());
/** Event accessor */
Event getEvent() const;
/** Result accessor */
SimulationResult getResult() const;
/** Maximum sample size accessor */
void setMaximumOuterSampling(const UnsignedLong maximumOuterSampling);
UnsignedLong getMaximumOuterSampling() const;
/** Maximum coefficient of variation accessor */
void setMaximumCoefficientOfVariation(const NumericalScalar maximumCoefficientOfVariation)
/* throw(InvalidArgumentException) */;
NumericalScalar getMaximumCoefficientOfVariation() const;
/** Maximum standard deviation accessor */
void setMaximumStandardDeviation(const NumericalScalar maximumStandardDeviation)
/* throw(InvalidArgumentException) */;
NumericalScalar getMaximumStandardDeviation() const;
/** Block size accessor */
void setBlockSize(const UnsignedLong blockSize) /* throw(InvalidArgumentException) */;
UnsignedLong getBlockSize() const;
/** Verbosity accessor */
void setVerbose(const Bool verbose);
Bool getVerbose() const;
/** Convergence strategy accessor */
void setConvergenceStrategy(const HistoryStrategy & convergenceStrategy);
HistoryStrategy getConvergenceStrategy() const;
/** Input output strategy accessor */
void setInputOutputStrategy(const HistoryStrategy & inputOutputStrategy);
HistoryStrategy getInputStrategy() const;
HistoryStrategy getOutputStrategy() 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 = SimulationResultImplementation::DefaultConfidenceLevel) const;
/** Method save() stores the object through the StorageManager */
void save(StorageManager::Advocate & adv) const;
/** Method load() reloads the object from the StorageManager */
void load(StorageManager::Advocate & adv);
protected:
/** Result accessor */
void setResult(const SimulationResult & result);
/** Compute the block sample and the points that realized the event */
virtual NumericalSample computeBlockSample(NumericalSample & realizedEventSample) = 0;
protected:
/** For save/load mechanism*/
Simulation(const Bool verbose = true,
const HistoryStrategy & convergenceStrategy = Compact(),
const HistoryStrategy & inputOutputStrategy = Last()) {};
friend class Base::Common::Factory<Simulation>;
/** History strategy for the probability and variance estimate */
HistoryStrategy convergenceStrategy_;
/** History strategy for the input and the output of the model */
HistoryStrategy inputStrategy_;
HistoryStrategy outputStrategy_;
// Size of the atomic blocks of computation
UnsignedLong blockSize_;
// The event we are computing the probability of
Event event_;
// Result of the simulation
SimulationResult result_;
private:
// Maximum number of outer iteration allowed
UnsignedLong 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 */
} /* namespace Algorithm */
} /* namespace Uncertainty */
} /* namespace OpenTURNS */
#endif /* OPENTURNS_SIMULATION_HXX */
|