← Back to branch summary

~ubuntu-branches/ubuntu/maverick/openturns/maverick

« back to all changes in this revision

Viewing changes to lib/src/Uncertainty/Algorithm/Analytical/AnalyticalResult.cxx

  • Committer: Bazaar Package Importer
  • Author(s): Christophe Prud'homme
  • Date: 2008-11-18 06:32:22 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20081118063222-pa0qncclrerrqkg2
Tags: 0.12.2-1
http://bugs.debian.org/506005
* New upstream release
* Bug fix: "New upstream release available (0.12.2)", thanks to Jerome
  Robert (Closes: #506005).
* Applied patch by J. Robert.
* debian/control: build-depends on libxml2

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/src/Uncertainty/Algorithm/Analytical/AnalyticalResult.cxx
20
20
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21
21
 *
22
22
 *  @author: $LastChangedBy: dutka $
23
 
 *  @date:   $LastChangedDate: 2008-06-26 13:50:17 +0200 (jeu, 26 jun 2008) $
24
 
 *  Id:      $Id: AnalyticalResult.cxx 862 2008-06-26 11:50:17Z dutka $
 
23
 *  @date:   $LastChangedDate: 2008-10-31 11:52:04 +0100 (ven 31 oct 2008) $
 
24
 *  Id:      $Id: AnalyticalResult.cxx 995 2008-10-31 10:52:04Z dutka $
25
25
 */
26
26
#include <iomanip>
27
27
 
29
29
#include "Distribution.hxx"
30
30
#include "Pie.hxx"
31
31
#include "NumericalSample.hxx"
 
32
#include "NumericalMathFunction.hxx"
32
33
#include "BarPlot.hxx"
33
34
#include "Description.hxx"
34
35
#include "CompositeRandomVector.hxx"
36
37
#include "RandomVector.hxx"
37
38
#include "Less.hxx"
38
39
#include "PersistentObjectFactory.hxx"
 
40
#include "ComparisonOperatorImplementation.hxx"
39
41
 
40
42
 
41
43
namespace OpenTURNS
48
50
    {
49
51
      typedef Base::Type::Description                             Description;
50
52
      typedef Base::Stat::NumericalSample                         NumericalSample;
 
53
 
51
54
      typedef Base::Graph::Pie                                    Pie;
52
55
      typedef Base::Graph::BarPlot                                BarPlot;
53
56
      typedef Base::Graph::DrawableImplementation                 DrawableImplementation;
54
57
      typedef DrawableImplementation::Description                 Description;
55
 
      typedef Analytical::NumericalMathFunction::Matrix           Matrix;
 
58
      typedef Base::Func::NumericalMathFunction                   NumericalMathFunction;
 
59
      typedef NumericalMathFunction::Matrix                       Matrix;
56
60
      typedef Base::Common::Less                                  Less;
57
61
      typedef Model::RandomVector                                 RandomVector;
58
62
      typedef Model::ConstantRandomVector           ConstantRandomVector;
62
66
      typedef Distribution::InverseIsoProbabilisticTransformation InverseIsoProbabilisticTransformation;
63
67
      typedef Base::Type::PersistentCollection<Base::Type::NumericalPointWithDescription> PersistentSensitivity;
64
68
 
65
 
      const NumericalScalar Analytical::Result::DefaultWidth;
66
 
 
67
 
      CLASSNAMEINIT(Analytical::Result);
68
 
 
69
 
      static Base::Common::Factory<Analytical::Result> RegisteredFactory("Analytical::Result");
 
69
      const NumericalScalar AnalyticalResult::DefaultWidth;
 
70
 
 
71
      CLASSNAMEINIT(AnalyticalResult);
 
72
 
 
73
      static Base::Common::Factory<AnalyticalResult> RegisteredFactory("AnalyticalResult");
70
74
 
71
75
      /*
72
76
       * @brief  Standard constructor
73
77
       */
74
 
      Analytical::Result::Result(const NumericalPoint & standardSpaceDesignPoint,
75
 
                                 const Event & limitStateVariable,
76
 
                                 const Bool isStandardPointOriginInFailureSpace,
77
 
                                 const String & name):
 
78
      AnalyticalResult::AnalyticalResult(const NumericalPoint & standardSpaceDesignPoint,
 
79
                                         const Event & limitStateVariable,
 
80
                                         const Bool isStandardPointOriginInFailureSpace,
 
81
                                         const String & name):
78
82
        PersistentObject(name),
79
 
        physicalSpaceDesignPoint_(NumericalPoint(standardSpaceDesignPoint.getDimension(), 0.0)),
 
83
        physicalSpaceDesignPoint_(standardSpaceDesignPoint.getDimension()),
80
84
        limitStateVariable_(limitStateVariable),
81
85
        isStandardPointOriginInFailureSpace_(isStandardPointOriginInFailureSpace),
82
 
        hasoferReliabilityIndex_(0.),
83
 
        importanceFactors_(NumericalPoint(standardSpaceDesignPoint.getDimension(), 0.0)),
84
 
        hasoferReliabilityIndexSensitivity_(Sensitivity(0)),
 
86
        hasoferReliabilityIndex_(0.0),
 
87
        importanceFactors_(standardSpaceDesignPoint.getDimension()),
 
88
        hasoferReliabilityIndexSensitivity_(0),
85
89
        isAlreadyComputedImportanceFactors_(false),
86
90
        isAlreadyComputedHasoferReliabilityIndexSensitivity_(false)
87
91
      {
90
94
      }
91
95
 
92
96
      /* Default constructor, needed by SWIG */
93
 
      Analytical::Result::Result():
 
97
      AnalyticalResult::AnalyticalResult():
94
98
        PersistentObject(),
95
 
        standardSpaceDesignPoint_(NumericalPoint(0)),
96
 
        physicalSpaceDesignPoint_(NumericalPoint(0)),
 
99
        standardSpaceDesignPoint_(0),
 
100
        physicalSpaceDesignPoint_(0),
97
101
        // Fake event based on a fake 1D composite random vector, which requires a fake 1D NumericalMathFunction
98
102
        limitStateVariable_(RandomVector(new CompositeRandomVector(NumericalMathFunction(Description(0),Description(1),Description(1)),
99
103
                                                                                 new ConstantRandomVector(NumericalPoint(0)))),
100
 
                            Less(), 0.),
 
104
                            Less(), 0.0),
101
105
        isStandardPointOriginInFailureSpace_(false),
102
 
        hasoferReliabilityIndex_(0.),
103
 
        importanceFactors_(NumericalPoint(0)),
104
 
        hasoferReliabilityIndexSensitivity_(Sensitivity(0)),
 
106
        hasoferReliabilityIndex_(0.0),
 
107
        importanceFactors_(0),
 
108
        hasoferReliabilityIndexSensitivity_(0),
105
109
        isAlreadyComputedImportanceFactors_(false),
106
110
        isAlreadyComputedHasoferReliabilityIndexSensitivity_(false)
107
111
      {
109
113
      }
110
114
 
111
115
      /* Virtual constructor */
112
 
      Analytical::Result * Analytical::Result::clone() const
113
 
      {
114
 
        return new Result(*this);
115
 
      }
116
 
 
117
 
      /* Destructor */
118
 
      Analytical::Result::~Result()
119
 
      {
120
 
        // Nothing to do
 
116
      AnalyticalResult * AnalyticalResult::clone() const
 
117
      {
 
118
        return new AnalyticalResult(*this);
121
119
      }
122
120
 
123
121
      /* StandardSpaceDesignPoint accessor */
124
 
      Analytical::NumericalPoint Analytical::Result::getStandardSpaceDesignPoint() const
 
122
      AnalyticalResult::NumericalPoint AnalyticalResult::getStandardSpaceDesignPoint() const
125
123
      {
126
124
        return standardSpaceDesignPoint_;
127
125
      }
128
126
 
129
127
 
130
128
      /* StandardSpaceDesignPoint accessor */
131
 
      void Analytical::Result::setStandardSpaceDesignPoint(const NumericalPoint & standardSpaceDesignPoint)
 
129
      void AnalyticalResult::setStandardSpaceDesignPoint(const NumericalPoint & standardSpaceDesignPoint)
132
130
      {
133
131
        standardSpaceDesignPoint_ = standardSpaceDesignPoint;
134
132
        computePhysicalSpaceDesignPoint();
136
134
      }
137
135
 
138
136
      /* PhysicalSpaceDesignPoint evaluation */
139
 
      void Analytical::Result::computePhysicalSpaceDesignPoint()
 
137
      void AnalyticalResult::computePhysicalSpaceDesignPoint()
140
138
      {
141
139
        /* Compute the physical design point */
142
140
        physicalSpaceDesignPoint_ = limitStateVariable_.getImplementation()->getAntecedent()->getDistribution().getInverseIsoProbabilisticTransformation().operator()(standardSpaceDesignPoint_);
148
146
      }
149
147
 
150
148
      /* PhysicalSpaceDesignPoint accessor */
151
 
      void Analytical::Result::setPhysicalSpaceDesignPoint(const NumericalPoint & physicalSpaceDesignPoint)
 
149
      void AnalyticalResult::setPhysicalSpaceDesignPoint(const NumericalPoint & physicalSpaceDesignPoint)
152
150
      {
153
151
        physicalSpaceDesignPoint_ = physicalSpaceDesignPoint;
154
152
      }
155
153
 
156
154
      /* PhysicalSpaceDesignPoint accessor */
157
 
      Analytical::NumericalPoint Analytical::Result::getPhysicalSpaceDesignPoint() const
 
155
      AnalyticalResult::NumericalPoint AnalyticalResult::getPhysicalSpaceDesignPoint() const
158
156
      {
159
157
        return physicalSpaceDesignPoint_;
160
158
      }
161
159
 
162
160
      /* LimitStateVariable accessor */
163
 
      Analytical::Event Analytical::Result::getLimitStateVariable() const
 
161
      AnalyticalResult::Event AnalyticalResult::getLimitStateVariable() const
164
162
      {
165
163
        return limitStateVariable_;
166
164
      }
167
165
 
168
166
      /* IsStandardPointOriginInFailureSpace  accessor */
169
 
      Bool Analytical::Result::getIsStandardPointOriginInFailureSpace() const
 
167
      Bool AnalyticalResult::getIsStandardPointOriginInFailureSpace() const
170
168
      {
171
169
        return isStandardPointOriginInFailureSpace_;
172
170
      }
173
171
 
174
172
      /* IsStandardPointOriginInFailureSpace  accessor */
175
 
      void Analytical::Result::setIsStandardPointOriginInFailureSpace(const Bool isStandardPointOriginInFailureSpace)
 
173
      void AnalyticalResult::setIsStandardPointOriginInFailureSpace(const Bool isStandardPointOriginInFailureSpace)
176
174
      {
177
175
        isStandardPointOriginInFailureSpace_ = isStandardPointOriginInFailureSpace;
178
176
      }
179
177
 
180
178
      /* ImportanceFactors evaluation */
181
 
      void Analytical::Result::computeImportanceFactors()
 
179
      void AnalyticalResult::computeImportanceFactors()
182
180
      {
183
 
        UnsignedLong dimension(standardSpaceDesignPoint_.getDimension());
 
181
        const UnsignedLong dimension(standardSpaceDesignPoint_.getDimension());
184
182
        importanceFactors_ = NumericalPoint(dimension, -1.0);
185
183
        /* First, check that the importance factors are well-defined */
186
184
        if (standardSpaceDesignPoint_.norm() > 0.0)
187
185
          {
188
186
            /* get the input distribution */
189
 
            Distribution inputDistribution(limitStateVariable_.getImplementation()->getAntecedent()->getDistribution());
 
187
            const Distribution inputDistribution(limitStateVariable_.getImplementation()->getAntecedent()->getDistribution());
190
188
            /* get the input standard distribution */
191
 
            Distribution standardDistribution(inputDistribution.getStandardDistribution());
 
189
            const Distribution standardDistribution(inputDistribution.getStandardDistribution());
192
190
            /* get the marginal 1D from in the standard space where all marginals are identical */
193
 
            Distribution standardMarginalDistribution(standardDistribution.getMarginal(0));
 
191
            const Distribution standardMarginalDistribution(standardDistribution.getMarginal(0));
194
192
 
195
193
            /* evaluate the corresponding vector in the importance factors space */
196
194
            /* if Generalised Nataf Transformation : Z = E1^(-1)o F_{Xi}(Xi*) */
197
195
            /* if Rosenblatt  Transformation : Z = Phi^(-1)o F_{Xi}(Xi*) */
198
196
            // for each marginals */
199
 
            for (UnsignedLong marginalIndex = 0; marginalIndex < dimension; marginalIndex++)
 
197
            for (UnsignedLong marginalIndex = 0; marginalIndex < dimension; ++marginalIndex)
200
198
              {
201
 
                NumericalScalar y = inputDistribution.getMarginal(marginalIndex).computeCDF(NumericalPoint(1, physicalSpaceDesignPoint_[marginalIndex]));
 
199
                const NumericalScalar y(inputDistribution.getMarginal(marginalIndex).computeCDF(NumericalPoint(1, physicalSpaceDesignPoint_[marginalIndex])));
202
200
                importanceFactors_[marginalIndex] = standardMarginalDistribution.computeQuantile(y)[0];
203
201
              }
204
202
            /* compute  square norm of importanceFactors vector */
205
 
            NumericalScalar inorm2(1.0 / importanceFactors_.norm2());
 
203
            const NumericalScalar inorm2(1.0 / importanceFactors_.norm2());
206
204
            /* compute final importance factors */
207
 
            for (UnsignedLong marginalIndex = 0; marginalIndex < dimension; marginalIndex++)
 
205
            for (UnsignedLong marginalIndex = 0; marginalIndex < dimension; ++marginalIndex)
208
206
              {
209
207
                importanceFactors_[marginalIndex] *= importanceFactors_[marginalIndex] * inorm2;
210
208
              }
219
217
      }
220
218
 
221
219
      /* ImportanceFactors accessor */
222
 
      Analytical::NumericalPoint Analytical::Result::getImportanceFactors()
 
220
      AnalyticalResult::NumericalPoint AnalyticalResult::getImportanceFactors()
223
221
      {
224
222
        if (!isAlreadyComputedImportanceFactors_)
225
223
          {
229
227
      }
230
228
 
231
229
      /* ImportanceFactors graph */
232
 
      Analytical::Result::Graph Analytical::Result::drawImportanceFactors()
 
230
      AnalyticalResult::Graph AnalyticalResult::drawImportanceFactors()
233
231
      {
234
232
        // To ensure that the importance factors are up to date
235
233
        if (!isAlreadyComputedImportanceFactors_)
236
234
          {
237
235
            computeImportanceFactors();
238
236
          }
239
 
        UnsignedLong dimension(importanceFactors_.getDimension());
 
237
        const UnsignedLong dimension(importanceFactors_.getDimension());
240
238
        NumericalSample data(dimension, 1);
241
239
 
242
240
        /* build data for the pie */
243
 
        for (UnsignedLong i = 0; i < dimension; i++)
 
241
        for (UnsignedLong i = 0; i < dimension; ++i)
244
242
          {
245
243
            data[i]=NumericalPoint(1, importanceFactors_[i]);
246
244
          }
250
248
        /* build labels and colors for the pie */
251
249
        Description palette(dimension);
252
250
        Description labels(dimension);
253
 
        Description colors(DrawableImplementation::GetValidColors());
 
251
        const Description colors(DrawableImplementation::GetValidColors());
254
252
        Description::const_iterator colorsIterator;
255
253
        colorsIterator = colors.begin();
256
254
        Description description(importanceFactors_.getDescription());
258
256
        if (description.getSize() != dimension)
259
257
          {
260
258
            description = Description(dimension);
261
 
            for (UnsignedLong i = 0; i < dimension; i++)
 
259
            for (UnsignedLong i = 0; i < dimension; ++i)
262
260
              {
263
261
                OSS oss;
264
262
                oss << "Component " << i;
265
263
                description[i] = oss;
266
264
              }
267
265
          }
268
 
        for (UnsignedLong i = 0; i < dimension; i++)
 
266
        for (UnsignedLong i = 0; i < dimension; ++i)
269
267
          {
270
268
            OSS oss;
271
269
            oss << description[i] << " : " << std::fixed;
273
271
            oss << 100.0 * data[i][0] << "%";
274
272
            labels[i] = oss;
275
273
            palette[i] = (*colorsIterator);
276
 
            colorsIterator++;
 
274
            ++colorsIterator;
277
275
            if (colorsIterator == colors.end())
278
276
              {
279
277
                colorsIterator == colors.begin();
295
293
 
296
294
 
297
295
      /* ImportanceFactors accessor */
298
 
      void Analytical::Result::setImportanceFactors(const NumericalPoint & importanceFactors)
 
296
      void AnalyticalResult::setImportanceFactors(const NumericalPoint & importanceFactors)
299
297
      {
300
298
        importanceFactors_ = importanceFactors;
301
299
        isAlreadyComputedImportanceFactors_ = true;
303
301
 
304
302
 
305
303
      /* HasoferReliabilityIndex evaluation */
306
 
      void Analytical::Result::computeHasoferReliabilityIndex()
 
304
      void AnalyticalResult::computeHasoferReliabilityIndex()
307
305
      {
308
306
        /* evaluate the HasoferReliabilityIndex */
309
307
        if (standardSpaceDesignPoint_.getDimension() > 0) hasoferReliabilityIndex_ = standardSpaceDesignPoint_.norm();
310
308
      }
311
309
 
312
310
      /*  HasoferReliabilityIndex accessor */
313
 
      NumericalScalar Analytical::Result::getHasoferReliabilityIndex() const
 
311
      NumericalScalar AnalyticalResult::getHasoferReliabilityIndex() const
314
312
      {
315
313
        return hasoferReliabilityIndex_;
316
314
      }
317
315
 
318
316
 
319
317
      /* HasoferReliabilityIndex accessor */
320
 
      void Analytical::Result::setHasoferReliabilityIndex(const NumericalScalar & hasoferReliabilityIndex)
 
318
      void AnalyticalResult::setHasoferReliabilityIndex(const NumericalScalar & hasoferReliabilityIndex)
321
319
      {
322
320
        hasoferReliabilityIndex_ = hasoferReliabilityIndex;
323
321
      }
324
322
 
325
323
      /* HasoferReliabilityIndex evaluation */
326
 
      void Analytical::Result::computeHasoferReliabilityIndexSensitivity()
 
324
      void AnalyticalResult::computeHasoferReliabilityIndexSensitivity()
327
325
      {
328
326
        /* get Set1 : parameters of the physical distribution */
329
 
        Distribution physicalDistribution(limitStateVariable_.getImplementation()->getAntecedent()->getDistribution());
330
 
        NumericalPointWithDescriptionCollection set1(physicalDistribution.getParametersCollection());
 
327
        const Distribution physicalDistribution(limitStateVariable_.getImplementation()->getAntecedent()->getDistribution());
 
328
        const NumericalPointWithDescriptionCollection set1(physicalDistribution.getParametersCollection());
331
329
        /* get Set2 : parameters of the physical model */
332
 
        NumericalMathFunction physicalModel(limitStateVariable_.getImplementation()->getFunction());
333
 
        NumericalPoint set2(physicalModel.getParameters());
334
 
        Bool isSet2Empty(set2.getDimension() == 0);
 
330
        const NumericalMathFunction physicalModel(limitStateVariable_.getImplementation()->getFunction());
 
331
        const NumericalPointWithDescription set2(physicalModel.getParameters());
 
332
        const Bool isSet2Empty(set2.getDimension() == 0);
335
333
 
336
334
        /* get SetIso : parameters included in the isoprobabilistic transformation which is a subset of Set1 */
337
 
        InverseIsoProbabilisticTransformation inverseIsoProbabilisticTransformation(physicalDistribution.getInverseIsoProbabilisticTransformation());
338
 
        NumericalPointWithDescription setIso(inverseIsoProbabilisticTransformation.getParameters());
 
335
        const InverseIsoProbabilisticTransformation inverseIsoProbabilisticTransformation(physicalDistribution.getInverseIsoProbabilisticTransformation());
 
336
        const NumericalPointWithDescription setIso(inverseIsoProbabilisticTransformation.getParameters());
339
337
        /* scaling factor between sensitivity and gradients (ref doc : factor = -lambda/beta) */
340
338
        /* gradient of the standard limite state function */
341
 
        Matrix physicalGradientMatrix(physicalModel.gradient(physicalSpaceDesignPoint_));
342
 
        NumericalPoint standardFunctionGradient(inverseIsoProbabilisticTransformation.gradient(standardSpaceDesignPoint_) * (physicalGradientMatrix * NumericalPoint(1, 1.0)));
343
 
        NumericalScalar gradientToSensitivity(-(limitStateVariable_.getOperator().compare(1.0, 0.0) ? 1.0 : -1.0) / standardFunctionGradient.norm());
 
339
        const Matrix physicalGradientMatrix(physicalModel.gradient(physicalSpaceDesignPoint_));
 
340
        const NumericalPoint standardFunctionGradient(inverseIsoProbabilisticTransformation.gradient(standardSpaceDesignPoint_) * (physicalGradientMatrix * NumericalPoint(1, 1.0)));
 
341
        const NumericalScalar gradientToSensitivity(-(limitStateVariable_.getOperator().compare(1.0, 0.0) ? 1.0 : -1.0) / standardFunctionGradient.norm());
344
342
        /* evaluate the gradients of the physical model with respect to Set2 (ref doc : K2) */
345
343
        NumericalPoint physicalGradient;
346
344
        if (!isSet2Empty)
351
349
        NumericalPoint isoProbabilisticGradient;
352
350
        if (setIso.getDimension() > 0)
353
351
          {
354
 
            isoProbabilisticGradient =inverseIsoProbabilisticTransformation.parametersGradient(standardSpaceDesignPoint_) * (physicalGradientMatrix * NumericalPoint(1, 1.0));
 
352
            isoProbabilisticGradient = inverseIsoProbabilisticTransformation.parametersGradient(standardSpaceDesignPoint_) * (physicalGradientMatrix * NumericalPoint(1, 1.0));
355
353
          }
356
354
        /* associate to each element of Set1 the gradient value */
357
355
 
358
356
        /* hasoferReliabilityIndexSensitivity is the collection Set1 + one other collection wich is Set2 */
359
 
        UnsignedLong set1Size(set1.getSize());
360
 
        UnsignedLong size(set1Size + (isSet2Empty ? 0 : 1));
 
357
        const UnsignedLong set1Size(set1.getSize());
 
358
        const UnsignedLong size(set1Size + (isSet2Empty ? 0 : 1));
361
359
        hasoferReliabilityIndexSensitivity_ = Sensitivity(size);
362
360
 
363
 
        for (UnsignedLong sensitivityIndex = 0; sensitivityIndex < set1Size; sensitivityIndex++)
 
361
        for (UnsignedLong sensitivityIndex = 0; sensitivityIndex < set1Size; ++sensitivityIndex)
364
362
          {
365
 
            NumericalPointWithDescription currentParameters(set1[sensitivityIndex]);
366
 
            UnsignedLong currentDimension(currentParameters.getDimension());
 
363
            const NumericalPointWithDescription currentParameters(set1[sensitivityIndex]);
 
364
            const UnsignedLong currentDimension(currentParameters.getDimension());
367
365
            NumericalPointWithDescription currentSensitivity(currentDimension);
368
 
            Description currentDescription(currentParameters.getDescription());
 
366
            const Description currentDescription(currentParameters.getDescription());
369
367
            // the currentSensitivity gets the description and the name from set1
370
368
            currentSensitivity.setDescription(currentDescription);
371
 
            String currentName(currentParameters.getName());
 
369
            const String currentName(currentParameters.getName());
372
370
            currentSensitivity.setName(currentName);
373
 
            Description isoDescription(setIso.getDescription());
374
 
            for (UnsignedLong currentIndex = 0; currentIndex < currentDimension; currentIndex++)
 
371
            const Description isoDescription(setIso.getDescription());
 
372
            for (UnsignedLong currentIndex = 0; currentIndex < currentDimension; ++currentIndex)
375
373
              {
376
 
                UnsignedLong position(computePosition(currentName, currentDescription[currentIndex], isoDescription));
 
374
                const UnsignedLong position(computePosition(currentName, currentDescription[currentIndex], isoDescription));
377
375
                /* if currentParameters[currentIndex] is into setIso, then we get the sensitivity value in the corresponding isoProbabilisticGradient */
378
376
                if (position < setIso.getDimension())
379
377
                  {
395
393
 
396
394
 
397
395
      /* Returns the position of the given (value, name) into the NumericalPoint or the dimension of the NumericalPoint if failed */
398
 
      UnsignedLong Analytical::Result::computePosition(const String & marginalName, const String & marginalParameterName, const Description & parameterSetNames) const
 
396
      UnsignedLong AnalyticalResult::computePosition(const String & marginalName, const String & marginalParameterName, const Description & parameterSetNames) const
399
397
      {
400
 
        UnsignedLong dimension(parameterSetNames.getSize());
401
 
        String fullName(OSS() << marginalName << "_" << marginalParameterName);
402
 
        for (UnsignedLong index = 0; index < dimension; index++)
 
398
        const UnsignedLong dimension(parameterSetNames.getSize());
 
399
        const String fullName(OSS() << marginalName << "_" << marginalParameterName);
 
400
        for (UnsignedLong index = 0; index < dimension; ++index)
403
401
          {
404
402
            if ( parameterSetNames[index] == fullName ) return index;
405
403
          }
409
407
 
410
408
 
411
409
      /* HasoferReliabilityIndexSensitivity Graph */
412
 
      Analytical::Result::GraphCollection Analytical::Result::drawHasoferReliabilityIndexSensitivity(NumericalScalar width)
 
410
      AnalyticalResult::GraphCollection AnalyticalResult::drawHasoferReliabilityIndexSensitivity(NumericalScalar width)
413
411
      {
414
412
        GraphCollection hasoferReliabilityIndexSensitivityGraphCollection(0);
415
413
        // To ensure that the hasoferReliabilityIndexSensitivity_ are up to date
417
415
          {
418
416
            computeHasoferReliabilityIndexSensitivity();
419
417
          }
420
 
        UnsignedLong dimension(standardSpaceDesignPoint_.getDimension());
421
 
        UnsignedLong size(hasoferReliabilityIndexSensitivity_.getSize());
 
418
        const UnsignedLong dimension(standardSpaceDesignPoint_.getDimension());
 
419
        const UnsignedLong size(hasoferReliabilityIndexSensitivity_.getSize());
422
420
        // The first graph shows the sensitivities with respect to the marginal parameters if there exist
423
421
        // in the cas where the distribution or some marginals are defined by user, it may not have parameters : we create a empty sensitivity graph
424
422
        Sensitivity marginalSensitivity(dimension);
425
 
        for(UnsignedLong i = 0; i < dimension; i++)
 
423
        for(UnsignedLong i = 0; i < dimension; ++i)
426
424
          {
427
425
            marginalSensitivity[i] = hasoferReliabilityIndexSensitivity_[i];
428
426
          }
435
433
        if (size > dimension)
436
434
          {
437
435
            Sensitivity otherSensitivity(size - dimension);
438
 
            for(UnsignedLong i = dimension; i < size; i++)
 
436
            for(UnsignedLong i = dimension; i < size; ++i)
439
437
              {
440
438
                otherSensitivity[i - dimension] = hasoferReliabilityIndexSensitivity_[i];
441
439
              }
449
447
      }
450
448
 
451
449
      /* Sensitivity Graph */
452
 
      Analytical::Result::Graph Analytical::Result::drawSensitivity(const Sensitivity & sensitivity, NumericalScalar width) const
 
450
      AnalyticalResult::Graph AnalyticalResult::drawSensitivity(const Sensitivity & sensitivity, NumericalScalar width) const
453
451
      {
454
452
        // shift position of the barplots
455
453
        NumericalScalar shift(0.0);
459
457
 
460
458
        BarPlot sensitivityBarPlot(NumericalSample(0, 2), shift, "");
461
459
 
462
 
        Description colors(DrawableImplementation::GetValidColors());
 
460
        const Description colors(DrawableImplementation::GetValidColors());
463
461
        Description::const_iterator colorsIterator;
464
462
        colorsIterator = colors.begin();
465
463
 
466
464
        // Create the barplots
467
 
        UnsignedLong sensitivitySize(sensitivity.getSize());
468
 
        for (UnsignedLong collectionIndex = 0; collectionIndex < sensitivitySize; collectionIndex++)
 
465
        const UnsignedLong sensitivitySize(sensitivity.getSize());
 
466
        for (UnsignedLong collectionIndex = 0; collectionIndex < sensitivitySize; ++collectionIndex)
469
467
          {
470
468
            NumericalSample data(sensitivity[collectionIndex].getDimension(), 2);
471
 
            UnsignedLong dataSize(data.getSize());
472
 
            for (UnsignedLong sensitivityIndex = 0; sensitivityIndex < dataSize; sensitivityIndex++)
 
469
            const UnsignedLong dataSize(data.getSize());
 
470
            for (UnsignedLong sensitivityIndex = 0; sensitivityIndex < dataSize; ++sensitivityIndex)
473
471
              {
474
472
                data[sensitivityIndex][0] = width;
475
473
                data[sensitivityIndex][1] = sensitivity[collectionIndex][sensitivityIndex];
478
476
            OSS oss;
479
477
            oss << sensitivity[collectionIndex].getName() << " " << sensitivity[collectionIndex].getDescription();
480
478
            sensitivityGraph.addDrawable(BarPlot(data, shift, (*colorsIterator), "solid", "solid", oss));
481
 
            colorsIterator++;
 
479
            ++colorsIterator;
482
480
            if (colorsIterator == colors.end())
483
481
              {
484
482
                colorsIterator == colors.begin();
490
488
 
491
489
 
492
490
      /*  HasoferReliabilityIndexSensitivity accessor */
493
 
      Analytical::Sensitivity Analytical::Result::getHasoferReliabilityIndexSensitivity()
 
491
      AnalyticalResult::Sensitivity AnalyticalResult::getHasoferReliabilityIndexSensitivity()
494
492
      {
495
493
        if (! isAlreadyComputedHasoferReliabilityIndexSensitivity_)
496
494
          {
500
498
      }
501
499
 
502
500
      /* String converter */
503
 
      String Analytical::Result::str() const
 
501
      String AnalyticalResult::str() const
504
502
      {
505
503
        OSS oss;
506
 
        oss << "class=" << Analytical::Result::GetClassName()
 
504
        oss << "class=" << AnalyticalResult::GetClassName()
507
505
            << " standardSpaceDesignPoint=" << standardSpaceDesignPoint_
508
506
            << " physicalSpaceDesignPoint=" << physicalSpaceDesignPoint_
509
507
            << " limitStateVariable=" << limitStateVariable_
515
513
      }
516
514
 
517
515
      /* Method save() stores the object through the StorageManager */
518
 
      void Analytical::Result::save(const StorageManager::Advocate & adv) const
 
516
      void AnalyticalResult::save(const StorageManager::Advocate & adv) const
519
517
      {
520
518
        PersistentObject::save(adv);
521
519
        adv.writeValue(standardSpaceDesignPoint_, StorageManager::MemberNameAttribute, "standardSpaceDesignPoint_");
531
529
      }
532
530
 
533
531
      /* Method load() reloads the object from the StorageManager */
534
 
      void Analytical::Result::load(const StorageManager::Advocate & adv)
 
532
      void AnalyticalResult::load(const StorageManager::Advocate & adv)
535
533
      {
536
534
        PersistentObject::load(adv);
537
535
        adv.readValue(standardSpaceDesignPoint_, StorageManager::MemberNameAttribute, "standardSpaceDesignPoint_");