← 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): Fabrice Coutadeur
  • Date: 2010-05-10 17:27:55 UTC
  • mfrom: (1.1.4 upstream) (5.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20100510172755-cb5ynskknqqi5rhp
Tags: 0.13.2-2ubuntu1
* Merge with Debian testing. No changes left.
* ubuntu_fix-python-2.6.patch: fix detection of python 2.6 libs, to not use
  LOCALMODLIBS. This pulls a dependency on SSL and makes the package FTBFS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/src/Uncertainty/Algorithm/Analytical/AnalyticalResult.cxx
3
3
 *  @file  AnalyticalResult.cxx
4
4
 *  @brief Result computes the results of an analytical Algorithm
5
5
 *
6
 
 *  (C) Copyright 2005-2007 EDF-EADS-Phimeca
 
6
 *  (C) Copyright 2005-2010 EDF-EADS-Phimeca
7
7
 *
8
8
 *  This library is free software; you can redistribute it and/or
9
9
 *  modify it under the terms of the GNU Lesser General Public
20
20
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21
21
 *
22
22
 *  @author: $LastChangedBy: dutka $
23
 
 *  @date:   $LastChangedDate: 2009-05-28 14:47:53 +0200 (jeu. 28 mai 2009) $
24
 
 *  Id:      $Id: AnalyticalResult.cxx 1262 2009-05-28 12:47:53Z dutka $
 
23
 *  @date:   $LastChangedDate: 2010-02-04 16:44:49 +0100 (jeu. 04 févr. 2010) $
 
24
 *  Id:      $Id: AnalyticalResult.cxx 1473 2010-02-04 15:44:49Z dutka $
25
25
 */
26
26
#include <iomanip>
27
27
#include <cstdlib>
77
77
       * @brief  Standard constructor
78
78
       */
79
79
      AnalyticalResult::AnalyticalResult(const NumericalPoint & standardSpaceDesignPoint,
80
 
                                         const Event & limitStateVariable,
81
 
                                         const Bool isStandardPointOriginInFailureSpace,
82
 
                                         const String & name):
83
 
        PersistentObject(name),
 
80
                                         const Event & limitStateVariable,
 
81
                                         const Bool isStandardPointOriginInFailureSpace,
 
82
                                         const String & name):
 
83
        PersistentObject(name),
84
84
        physicalSpaceDesignPoint_(standardSpaceDesignPoint.getDimension()),
85
 
        limitStateVariable_(limitStateVariable),
86
 
        isStandardPointOriginInFailureSpace_(isStandardPointOriginInFailureSpace),
87
 
        hasoferReliabilityIndex_(0.0),
88
 
        importanceFactors_(standardSpaceDesignPoint.getDimension()),
89
 
        hasoferReliabilityIndexSensitivity_(0),
90
 
        isAlreadyComputedImportanceFactors_(false),
91
 
        isAlreadyComputedHasoferReliabilityIndexSensitivity_(false)
 
85
        limitStateVariable_(limitStateVariable),
 
86
        isStandardPointOriginInFailureSpace_(isStandardPointOriginInFailureSpace),
 
87
        hasoferReliabilityIndex_(0.0),
 
88
        importanceFactors_(standardSpaceDesignPoint.getDimension()),
 
89
        hasoferReliabilityIndexSensitivity_(0),
 
90
        isAlreadyComputedImportanceFactors_(false),
 
91
        isAlreadyComputedHasoferReliabilityIndexSensitivity_(false)
92
92
      {
93
 
        /* we use the attribute accessor in order to compute automatically all the other attributes */
94
 
        setStandardSpaceDesignPoint(standardSpaceDesignPoint);
 
93
        /* we use the attribute accessor in order to compute automatically all the other attributes */
 
94
        setStandardSpaceDesignPoint(standardSpaceDesignPoint);
95
95
      }
96
96
 
97
97
      /* Default constructor, needed by SWIG */
98
98
      AnalyticalResult::AnalyticalResult():
99
 
        PersistentObject(),
100
 
        standardSpaceDesignPoint_(0),
101
 
        physicalSpaceDesignPoint_(0),
102
 
        // Fake event based on a fake 1D composite random vector, which requires a fake 1D NumericalMathFunction
103
 
        limitStateVariable_(RandomVector(new CompositeRandomVector(NumericalMathFunction(Description(0),Description(1),Description(1)),
104
 
                                                                                 new ConstantRandomVector(NumericalPoint(0)))),
105
 
                            Less(), 0.0),
106
 
        isStandardPointOriginInFailureSpace_(false),
107
 
        hasoferReliabilityIndex_(0.0),
108
 
        importanceFactors_(0),
109
 
        hasoferReliabilityIndexSensitivity_(0),
110
 
        isAlreadyComputedImportanceFactors_(false),
111
 
        isAlreadyComputedHasoferReliabilityIndexSensitivity_(false)
 
99
        PersistentObject(),
 
100
        standardSpaceDesignPoint_(0),
 
101
        physicalSpaceDesignPoint_(0),
 
102
        // Fake event based on a fake 1D composite random vector, which requires a fake 1D NumericalMathFunction
 
103
        limitStateVariable_(RandomVector(CompositeRandomVector(NumericalMathFunction(Description(0),Description(1),Description(1)),
 
104
                                                               ConstantRandomVector(NumericalPoint(0)))),
 
105
                            Less(), 0.0),
 
106
        isStandardPointOriginInFailureSpace_(false),
 
107
        hasoferReliabilityIndex_(0.0),
 
108
        importanceFactors_(0),
 
109
        hasoferReliabilityIndexSensitivity_(0),
 
110
        isAlreadyComputedImportanceFactors_(false),
 
111
        isAlreadyComputedHasoferReliabilityIndexSensitivity_(false)
112
112
      {
113
 
        // Nothing to do
 
113
        // Nothing to do
114
114
      }
115
115
 
116
116
      /* Virtual constructor */
117
117
      AnalyticalResult * AnalyticalResult::clone() const
118
118
      {
119
 
        return new AnalyticalResult(*this);
 
119
        return new AnalyticalResult(*this);
120
120
      }
121
121
 
122
122
      /* StandardSpaceDesignPoint accessor */
123
123
      AnalyticalResult::NumericalPoint AnalyticalResult::getStandardSpaceDesignPoint() const
124
124
      {
125
 
        return standardSpaceDesignPoint_;
 
125
        return standardSpaceDesignPoint_;
126
126
      }
127
127
 
128
128
 
129
129
      /* StandardSpaceDesignPoint accessor */
130
130
      void AnalyticalResult::setStandardSpaceDesignPoint(const NumericalPoint & standardSpaceDesignPoint)
131
131
      {
132
 
        standardSpaceDesignPoint_ = standardSpaceDesignPoint;
133
 
        computePhysicalSpaceDesignPoint();
134
 
        computeHasoferReliabilityIndex();
 
132
        standardSpaceDesignPoint_ = standardSpaceDesignPoint;
 
133
        computePhysicalSpaceDesignPoint();
 
134
        computeHasoferReliabilityIndex();
135
135
      }
136
136
 
137
137
      /* PhysicalSpaceDesignPoint evaluation */
138
138
      void AnalyticalResult::computePhysicalSpaceDesignPoint()
139
139
      {
140
 
        /* Compute the physical design point */
141
 
        physicalSpaceDesignPoint_ = limitStateVariable_.getImplementation()->getAntecedent()->getDistribution().getInverseIsoProbabilisticTransformation().operator()(standardSpaceDesignPoint_);
142
 
        /* we give to the physical space design point the description of the input random vector */
143
 
        //physicalSpaceDesignPoint_.setDescription(limitStateVariable_.getImplementation()->getAntecedent()->getDescription());
 
140
        /* Compute the physical design point */
 
141
        physicalSpaceDesignPoint_ = limitStateVariable_.getImplementation()->getAntecedent()->getDistribution().getInverseIsoProbabilisticTransformation().operator()(standardSpaceDesignPoint_);
 
142
        /* we give to the physical space design point the description of the input random vector */
 
143
        //physicalSpaceDesignPoint_.setDescription(limitStateVariable_.getImplementation()->getAntecedent()->getDescription());
144
144
 
145
 
        /* we give to the physical space design point the name Physical Design Point */
146
 
        physicalSpaceDesignPoint_.setName("Physical Space Design Point");
 
145
        /* we give to the physical space design point the name Physical Design Point */
 
146
        physicalSpaceDesignPoint_.setName("Physical Space Design Point");
147
147
      }
148
148
 
149
149
      /* PhysicalSpaceDesignPoint accessor */
150
150
      void AnalyticalResult::setPhysicalSpaceDesignPoint(const NumericalPoint & physicalSpaceDesignPoint)
151
151
      {
152
 
        physicalSpaceDesignPoint_ = physicalSpaceDesignPoint;
 
152
        physicalSpaceDesignPoint_ = physicalSpaceDesignPoint;
153
153
      }
154
154
 
155
155
      /* PhysicalSpaceDesignPoint accessor */
156
156
      AnalyticalResult::NumericalPoint AnalyticalResult::getPhysicalSpaceDesignPoint() const
157
157
      {
158
 
        return physicalSpaceDesignPoint_;
 
158
        return physicalSpaceDesignPoint_;
159
159
      }
160
160
 
161
161
      /* LimitStateVariable accessor */
162
162
      AnalyticalResult::Event AnalyticalResult::getLimitStateVariable() const
163
163
      {
164
 
        return limitStateVariable_;
 
164
        return limitStateVariable_;
165
165
      }
166
166
 
167
167
      /* IsStandardPointOriginInFailureSpace  accessor */
168
168
      Bool AnalyticalResult::getIsStandardPointOriginInFailureSpace() const
169
169
      {
170
 
        return isStandardPointOriginInFailureSpace_;
 
170
        return isStandardPointOriginInFailureSpace_;
171
171
      }
172
172
 
173
173
      /* IsStandardPointOriginInFailureSpace  accessor */
174
174
      void AnalyticalResult::setIsStandardPointOriginInFailureSpace(const Bool isStandardPointOriginInFailureSpace)
175
175
      {
176
 
        isStandardPointOriginInFailureSpace_ = isStandardPointOriginInFailureSpace;
 
176
        isStandardPointOriginInFailureSpace_ = isStandardPointOriginInFailureSpace;
177
177
      }
178
178
 
179
179
      /* ImportanceFactors evaluation */
180
180
      void AnalyticalResult::computeImportanceFactors()
181
181
      {
182
 
        const UnsignedLong dimension(standardSpaceDesignPoint_.getDimension());
183
 
        importanceFactors_ = NumericalPoint(dimension, -1.0);
184
 
        /* First, check that the importance factors are well-defined */
185
 
        if (standardSpaceDesignPoint_.norm() > 0.0)
186
 
          {
187
 
            /* get the input distribution */
188
 
            const Distribution inputDistribution(limitStateVariable_.getImplementation()->getAntecedent()->getDistribution());
189
 
            /* get the input standard distribution */
190
 
            const Distribution standardDistribution(inputDistribution.getStandardDistribution());
191
 
            /* get the marginal 1D from in the standard space where all marginals are identical */
192
 
            const Distribution standardMarginalDistribution(standardDistribution.getMarginal(0));
193
 
 
194
 
            /* evaluate the corresponding vector in the importance factors space */
195
 
            /* if Generalised Nataf Transformation : Z = E1^(-1)o F_{Xi}(Xi*) */
196
 
            /* if Rosenblatt  Transformation : Z = Phi^(-1)o F_{Xi}(Xi*) */
197
 
            // for each marginals */
198
 
            for (UnsignedLong marginalIndex = 0; marginalIndex < dimension; ++marginalIndex)
199
 
              {
200
 
                const NumericalScalar y(inputDistribution.getMarginal(marginalIndex).computeCDF(NumericalPoint(1, physicalSpaceDesignPoint_[marginalIndex])));
201
 
                importanceFactors_[marginalIndex] = standardMarginalDistribution.computeQuantile(y)[0];
202
 
              }
203
 
            /* compute  square norm of importanceFactors vector */
204
 
            const NumericalScalar inorm2(1.0 / importanceFactors_.norm2());
205
 
            /* compute final importance factors */
206
 
            for (UnsignedLong marginalIndex = 0; marginalIndex < dimension; ++marginalIndex)
207
 
              {
208
 
                importanceFactors_[marginalIndex] *= importanceFactors_[marginalIndex] * inorm2;
209
 
              }
210
 
          }
211
 
        /* we give a name to the importance factors vector */
212
 
        importanceFactors_.setName("Importance Factors");
213
 
 
214
 
        /* we give to the importance factors vector the description of the input random vector */
215
 
        importanceFactors_.setDescription(limitStateVariable_.getImplementation()->getAntecedent()->getDescription());
216
 
 
217
 
        isAlreadyComputedImportanceFactors_ = true;
 
182
        const UnsignedLong dimension(standardSpaceDesignPoint_.getDimension());
 
183
        importanceFactors_ = NumericalPoint(dimension, -1.0);
 
184
        /* First, check that the importance factors are well-defined */
 
185
        if (standardSpaceDesignPoint_.norm() > 0.0)
 
186
          {
 
187
            /* get the input distribution */
 
188
            const Distribution inputDistribution(limitStateVariable_.getImplementation()->getAntecedent()->getDistribution());
 
189
            /* get the input standard distribution */
 
190
            const Distribution standardDistribution(inputDistribution.getStandardDistribution());
 
191
            /* get the marginal 1D from in the standard space where all marginals are identical */
 
192
            const Distribution standardMarginalDistribution(standardDistribution.getMarginal(0));
 
193
            /* evaluate the corresponding vector in the importance factors space */
 
194
            /* if Generalised Nataf Transformation : Z = E1^(-1)o F_{Xi}(Xi*) */
 
195
            /* if Rosenblatt  Transformation : Z = Phi^(-1)o F_{Xi}(Xi*) */
 
196
            // for each marginals */
 
197
            for (UnsignedLong marginalIndex = 0; marginalIndex < dimension; ++marginalIndex)
 
198
              {
 
199
                const NumericalScalar y(inputDistribution.getMarginal(marginalIndex).computeCDF(NumericalPoint(1, physicalSpaceDesignPoint_[marginalIndex])));
 
200
                importanceFactors_[marginalIndex] = standardMarginalDistribution.computeQuantile(y)[0];
 
201
              }
 
202
            /* compute  square norm of importanceFactors vector */
 
203
            const NumericalScalar inorm2(1.0 / importanceFactors_.norm2());
 
204
            /* compute final importance factors */
 
205
            for (UnsignedLong marginalIndex = 0; marginalIndex < dimension; ++marginalIndex)
 
206
              {
 
207
                importanceFactors_[marginalIndex] *= importanceFactors_[marginalIndex] * inorm2;
 
208
              }
 
209
          }
 
210
        /* we give a name to the importance factors vector */
 
211
        importanceFactors_.setName("Importance Factors");
 
212
 
 
213
        /* we give to the importance factors vector the description of the input random vector */
 
214
        importanceFactors_.setDescription(limitStateVariable_.getImplementation()->getAntecedent()->getDescription());
 
215
 
 
216
        isAlreadyComputedImportanceFactors_ = true;
218
217
      }
219
218
 
220
219
      /* ImportanceFactors accessor */
221
220
      AnalyticalResult::NumericalPoint AnalyticalResult::getImportanceFactors()
222
221
      {
223
 
        if (!isAlreadyComputedImportanceFactors_)
224
 
          {
225
 
            computeImportanceFactors();
226
 
          }
227
 
        return importanceFactors_;
 
222
        if (!isAlreadyComputedImportanceFactors_)
 
223
          {
 
224
            computeImportanceFactors();
 
225
          }
 
226
        return importanceFactors_;
228
227
      }
229
228
 
230
229
      /* ImportanceFactors graph */
231
230
      AnalyticalResult::Graph AnalyticalResult::drawImportanceFactors()
232
231
      {
233
 
        // To ensure that the importance factors are up to date
234
 
        if (!isAlreadyComputedImportanceFactors_)
235
 
          {
236
 
            computeImportanceFactors();
237
 
          }
238
 
        const UnsignedLong dimension(importanceFactors_.getDimension());
239
 
        NumericalSample data(dimension, 1);
240
 
 
241
 
        /* build data for the pie */
242
 
        for (UnsignedLong i = 0; i < dimension; ++i)
243
 
          {
244
 
            data[i]=NumericalPoint(1, importanceFactors_[i]);
245
 
          }
246
 
        /* we build the pie */
247
 
        Pie importanceFactorsPie(data);
248
 
 
249
 
        /* build labels and colors for the pie */
250
 
        Description palette(dimension);
251
 
        Description labels(dimension);
252
 
        const Description colors(DrawableImplementation::GetValidColors());
253
 
        Description::const_iterator colorsIterator;
254
 
        colorsIterator = colors.begin();
255
 
        Description description(importanceFactors_.getDescription());
256
 
        // If no description has been given for the input distribution components, give standard ones
257
 
        if (description.getSize() != dimension)
258
 
          {
259
 
            description = Description(dimension);
260
 
            for (UnsignedLong i = 0; i < dimension; ++i)
261
 
              {
262
 
                OSS oss;
263
 
                oss << "Component " << i;
264
 
                description[i] = oss;
265
 
              }
266
 
          }
267
 
        for (UnsignedLong i = 0; i < dimension; ++i)
268
 
          {
269
 
            OSS oss;
270
 
            oss << description[i] << " : " << std::fixed;
271
 
            oss.setPrecision(1);
272
 
            oss << 100.0 * data[i][0] << "%";
273
 
            labels[i] = oss;
274
 
            palette[i] = (*colorsIterator);
275
 
            ++colorsIterator;
276
 
            if (colorsIterator == colors.end())
277
 
              {
278
 
                colorsIterator == colors.begin();
279
 
              }
280
 
          }
281
 
        /* we complete the pie */
282
 
        importanceFactorsPie.setLabels(labels);
283
 
        importanceFactorsPie.setPalette(palette);
284
 
 
285
 
        /* we build the graph with a title */
286
 
        OSS oss;
287
 
        oss << "Importance Factors from Design Point - " << limitStateVariable_.getName();
288
 
        Graph importanceFactorsGraph(oss, "", "", false,"");
289
 
 
290
 
        /* we embed the pie into the graph */
291
 
        importanceFactorsGraph.addDrawable(importanceFactorsPie);
292
 
        return importanceFactorsGraph;
 
232
        // To ensure that the importance factors are up to date
 
233
        if (!isAlreadyComputedImportanceFactors_)
 
234
          {
 
235
            computeImportanceFactors();
 
236
          }
 
237
        const UnsignedLong dimension(importanceFactors_.getDimension());
 
238
        NumericalSample data(dimension, 1);
 
239
 
 
240
        /* build data for the pie */
 
241
        for (UnsignedLong i = 0; i < dimension; ++i)
 
242
          {
 
243
            data[i]=NumericalPoint(1, importanceFactors_[i]);
 
244
          }
 
245
        /* we build the pie */
 
246
        Pie importanceFactorsPie(data);
 
247
 
 
248
        /* build labels and colors for the pie */
 
249
        Description palette(dimension);
 
250
        Description labels(dimension);
 
251
        const Description colors(DrawableImplementation::GetValidColors());
 
252
        Description::const_iterator colorsIterator;
 
253
        colorsIterator = colors.begin();
 
254
        Description description(importanceFactors_.getDescription());
 
255
        // If no description has been given for the input distribution components, give standard ones
 
256
        if (description.getSize() != dimension)
 
257
          {
 
258
            description = Description(dimension);
 
259
            for (UnsignedLong i = 0; i < dimension; ++i)
 
260
              {
 
261
                OSS oss;
 
262
                oss << "Component " << i;
 
263
                description[i] = oss;
 
264
              }
 
265
          }
 
266
        for (UnsignedLong i = 0; i < dimension; ++i)
 
267
          {
 
268
            OSS oss;
 
269
            oss << description[i] << " : " << std::fixed;
 
270
            oss.setPrecision(1);
 
271
            oss << 100.0 * data[i][0] << "%";
 
272
            labels[i] = oss;
 
273
            palette[i] = (*colorsIterator);
 
274
            ++colorsIterator;
 
275
            if (colorsIterator == colors.end())
 
276
              {
 
277
                colorsIterator == colors.begin();
 
278
              }
 
279
          }
 
280
        /* we complete the pie */
 
281
        importanceFactorsPie.setLabels(labels);
 
282
        importanceFactorsPie.setPalette(palette);
 
283
 
 
284
        /* we build the graph with a title */
 
285
        OSS oss;
 
286
        oss << "Importance Factors from Design Point - " << limitStateVariable_.getName();
 
287
        Graph importanceFactorsGraph(oss, "", "", false,"");
 
288
 
 
289
        /* we embed the pie into the graph */
 
290
        importanceFactorsGraph.addDrawable(importanceFactorsPie);
 
291
        return importanceFactorsGraph;
293
292
      }
294
293
 
295
294
 
296
295
      /* ImportanceFactors accessor */
297
296
      void AnalyticalResult::setImportanceFactors(const NumericalPoint & importanceFactors)
298
297
      {
299
 
        importanceFactors_ = importanceFactors;
300
 
        isAlreadyComputedImportanceFactors_ = true;
 
298
        importanceFactors_ = importanceFactors;
 
299
        isAlreadyComputedImportanceFactors_ = true;
301
300
      }
302
301
 
303
302
 
304
303
      /* HasoferReliabilityIndex evaluation */
305
304
      void AnalyticalResult::computeHasoferReliabilityIndex()
306
305
      {
307
 
        /* evaluate the HasoferReliabilityIndex */
308
 
        if (standardSpaceDesignPoint_.getDimension() > 0) hasoferReliabilityIndex_ = standardSpaceDesignPoint_.norm();
 
306
        /* evaluate the HasoferReliabilityIndex */
 
307
        if (standardSpaceDesignPoint_.getDimension() > 0) hasoferReliabilityIndex_ = standardSpaceDesignPoint_.norm();
309
308
      }
310
309
 
311
310
      /*  HasoferReliabilityIndex accessor */
312
311
      NumericalScalar AnalyticalResult::getHasoferReliabilityIndex() const
313
312
      {
314
 
        return hasoferReliabilityIndex_;
 
313
        return hasoferReliabilityIndex_;
315
314
      }
316
315
 
317
316
 
318
317
      /* HasoferReliabilityIndex accessor */
319
318
      void AnalyticalResult::setHasoferReliabilityIndex(const NumericalScalar & hasoferReliabilityIndex)
320
319
      {
321
 
        hasoferReliabilityIndex_ = hasoferReliabilityIndex;
 
320
        hasoferReliabilityIndex_ = hasoferReliabilityIndex;
322
321
      }
323
322
 
324
323
      /* HasoferReliabilityIndex evaluation */
325
324
      void AnalyticalResult::computeHasoferReliabilityIndexSensitivity()
326
325
      {
327
 
        /* get Set1 : parameters of the physical distribution */
328
 
        const Distribution physicalDistribution(limitStateVariable_.getImplementation()->getAntecedent()->getDistribution());
329
 
        const NumericalPointWithDescriptionCollection set1(physicalDistribution.getParametersCollection());
330
 
        /* get Set2 : parameters of the physical model */
331
 
        const NumericalMathFunction physicalModel(limitStateVariable_.getImplementation()->getFunction());
332
 
        const NumericalPointWithDescription set2(physicalModel.getParameters());
333
 
        const Bool isSet2Empty(set2.getDimension() == 0);
334
 
 
335
 
        /* get SetIso : parameters included in the isoprobabilistic transformation which is a subset of Set1 */
336
 
        const InverseIsoProbabilisticTransformation inverseIsoProbabilisticTransformation(physicalDistribution.getInverseIsoProbabilisticTransformation());
337
 
        const NumericalPointWithDescription setIso(inverseIsoProbabilisticTransformation.getParameters());
338
 
        /* scaling factor between sensitivity and gradients (ref doc : factor = -lambda/beta) */
339
 
        /* gradient of the standard limite state function */
340
 
        const Matrix physicalGradientMatrix(physicalModel.gradient(physicalSpaceDesignPoint_));
341
 
        const NumericalPoint standardFunctionGradient(inverseIsoProbabilisticTransformation.gradient(standardSpaceDesignPoint_) * (physicalGradientMatrix * NumericalPoint(1, 1.0)));
342
 
        const NumericalScalar gradientToSensitivity(-(limitStateVariable_.getOperator().compare(1.0, 0.0) ? 1.0 : -1.0) / standardFunctionGradient.norm());
343
 
        /* evaluate the gradients of the physical model with respect to Set2 (ref doc : K2) */
344
 
        NumericalPoint physicalGradient;
345
 
        if (!isSet2Empty)
346
 
          {
347
 
            physicalGradient = physicalModel.parametersGradient(physicalSpaceDesignPoint_) * NumericalPoint(1, 1.0);
348
 
          }
349
 
        /* evaluate the gradients of the isoprobabilistic transformation with respect to SetIso (ref doc : KS) */
350
 
        NumericalPoint isoProbabilisticGradient;
351
 
        if (setIso.getDimension() > 0)
352
 
          {
353
 
            isoProbabilisticGradient = inverseIsoProbabilisticTransformation.parametersGradient(standardSpaceDesignPoint_) * (physicalGradientMatrix * NumericalPoint(1, 1.0));
354
 
          }
355
 
        /* associate to each element of Set1 the gradient value */
356
 
 
357
 
        /* hasoferReliabilityIndexSensitivity is the collection Set1 + one other collection wich is Set2 */
358
 
        const UnsignedLong set1Size(set1.getSize());
359
 
        const UnsignedLong size(set1Size + (isSet2Empty ? 0 : 1));
360
 
        hasoferReliabilityIndexSensitivity_ = Sensitivity(size);
361
 
 
362
 
        for (UnsignedLong sensitivityIndex = 0; sensitivityIndex < set1Size; ++sensitivityIndex)
363
 
          {
364
 
            const NumericalPointWithDescription currentParameters(set1[sensitivityIndex]);
365
 
            const UnsignedLong currentDimension(currentParameters.getDimension());
366
 
            NumericalPointWithDescription currentSensitivity(currentDimension);
367
 
            const Description currentDescription(currentParameters.getDescription());
368
 
            // the currentSensitivity gets the description and the name from set1
369
 
            currentSensitivity.setDescription(currentDescription);
370
 
            const String currentName(currentParameters.getName());
371
 
            currentSensitivity.setName(currentName);
372
 
            const Description isoDescription(setIso.getDescription());
373
 
            for (UnsignedLong currentIndex = 0; currentIndex < currentDimension; ++currentIndex)
374
 
              {
375
 
                const UnsignedLong position(computePosition(currentName, currentDescription[currentIndex], isoDescription));
376
 
                /* if currentParameters[currentIndex] is into setIso, then we get the sensitivity value in the corresponding isoProbabilisticGradient */
377
 
                if (position < setIso.getDimension())
378
 
                  {
379
 
                    currentSensitivity[currentIndex] = gradientToSensitivity * isoProbabilisticGradient[position];
380
 
                  }
381
 
                /* else the  sensitivity value is null */
382
 
              } // currentIndex
383
 
            hasoferReliabilityIndexSensitivity_[sensitivityIndex] = currentSensitivity;
384
 
          } // sensitivityIndex
385
 
 
386
 
        /* if set2 is not empty : convert the matrix isoProbabilisticGradient, which has n rows and 1 column, into a NumericalPoint */
387
 
        if (size > set1Size)
388
 
          {
389
 
            hasoferReliabilityIndexSensitivity_[set1Size] = gradientToSensitivity * physicalGradient;
390
 
            hasoferReliabilityIndexSensitivity_[set1Size].setName(physicalGradient.getName());
391
 
          }
 
326
        /* get Set1 : parameters of the physical distribution */
 
327
        const Distribution physicalDistribution(limitStateVariable_.getImplementation()->getAntecedent()->getDistribution());
 
328
        const NumericalPointWithDescriptionCollection set1(physicalDistribution.getParametersCollection());
 
329
        /* get Set2 : parameters of the physical model */
 
330
        const NumericalMathFunction physicalModel(limitStateVariable_.getImplementation()->getFunction());
 
331
        const NumericalPointWithDescription set2(physicalModel.getParameters());
 
332
        const Bool isSet2Empty(set2.getDimension() == 0);
 
333
 
 
334
        /* get SetIso : parameters included in the isoprobabilistic transformation which is a subset of Set1 */
 
335
        const InverseIsoProbabilisticTransformation inverseIsoProbabilisticTransformation(physicalDistribution.getInverseIsoProbabilisticTransformation());
 
336
        const NumericalPointWithDescription setIso(inverseIsoProbabilisticTransformation.getParameters());
 
337
        /* scaling factor between sensitivity and gradients (ref doc : factor = -lambda/beta) */
 
338
        /* gradient of the standard limite state function */
 
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());
 
342
        /* evaluate the gradients of the physical model with respect to Set2 (ref doc : K2) */
 
343
        NumericalPoint physicalGradient;
 
344
        if (!isSet2Empty)
 
345
          {
 
346
            physicalGradient = physicalModel.parametersGradient(physicalSpaceDesignPoint_) * NumericalPoint(1, 1.0);
 
347
          }
 
348
        /* evaluate the gradients of the isoprobabilistic transformation with respect to SetIso (ref doc : KS) */
 
349
        NumericalPoint isoProbabilisticGradient;
 
350
        if (setIso.getDimension() > 0)
 
351
          {
 
352
            isoProbabilisticGradient = inverseIsoProbabilisticTransformation.parametersGradient(standardSpaceDesignPoint_) * (physicalGradientMatrix * NumericalPoint(1, 1.0));
 
353
          }
 
354
        /* associate to each element of Set1 the gradient value */
 
355
 
 
356
        /* hasoferReliabilityIndexSensitivity is the collection Set1 + one other collection wich is Set2 */
 
357
        const UnsignedLong set1Size(set1.getSize());
 
358
        const UnsignedLong size(set1Size + (isSet2Empty ? 0 : 1));
 
359
        hasoferReliabilityIndexSensitivity_ = Sensitivity(size);
 
360
 
 
361
        for (UnsignedLong sensitivityIndex = 0; sensitivityIndex < set1Size; ++sensitivityIndex)
 
362
          {
 
363
            const NumericalPointWithDescription currentParameters(set1[sensitivityIndex]);
 
364
            const UnsignedLong currentDimension(currentParameters.getDimension());
 
365
            NumericalPointWithDescription currentSensitivity(currentDimension);
 
366
            const Description currentDescription(currentParameters.getDescription());
 
367
            // the currentSensitivity gets the description and the name from set1
 
368
            currentSensitivity.setDescription(currentDescription);
 
369
            const String currentName(currentParameters.getName());
 
370
            currentSensitivity.setName(currentName);
 
371
            const Description isoDescription(setIso.getDescription());
 
372
            for (UnsignedLong currentIndex = 0; currentIndex < currentDimension; ++currentIndex)
 
373
              {
 
374
                const UnsignedLong position(computePosition(currentName, currentDescription[currentIndex], isoDescription));
 
375
                /* if currentParameters[currentIndex] is into setIso, then we get the sensitivity value in the corresponding isoProbabilisticGradient */
 
376
                if (position < setIso.getDimension())
 
377
                  {
 
378
                    currentSensitivity[currentIndex] = gradientToSensitivity * isoProbabilisticGradient[position];
 
379
                  }
 
380
                /* else the  sensitivity value is null */
 
381
              } // currentIndex
 
382
            hasoferReliabilityIndexSensitivity_[sensitivityIndex] = currentSensitivity;
 
383
          } // sensitivityIndex
 
384
 
 
385
        /* if set2 is not empty : convert the matrix isoProbabilisticGradient, which has n rows and 1 column, into a NumericalPoint */
 
386
        if (size > set1Size)
 
387
          {
 
388
            hasoferReliabilityIndexSensitivity_[set1Size] = gradientToSensitivity * physicalGradient;
 
389
            hasoferReliabilityIndexSensitivity_[set1Size].setName(physicalGradient.getName());
 
390
          }
392
391
        isAlreadyComputedHasoferReliabilityIndexSensitivity_ = true;
393
392
      } // end computeHasoferReliabilityIndexSensitivity()
394
393
 
396
395
      /* Returns the position of the given (value, name) into the NumericalPoint or the dimension of the NumericalPoint if failed */
397
396
      UnsignedLong AnalyticalResult::computePosition(const String & marginalName, const String & marginalParameterName, const Description & parameterSetNames) const
398
397
      {
399
 
        const UnsignedLong dimension(parameterSetNames.getSize());
400
 
        const String fullName(OSS() << marginalName << "_" << marginalParameterName);
401
 
        for (UnsignedLong index = 0; index < dimension; ++index)
402
 
          {
403
 
            if ( parameterSetNames[index] == fullName ) return index;
404
 
          }
405
 
        return dimension;
 
398
        const UnsignedLong dimension(parameterSetNames.getSize());
 
399
        const String fullName(OSS() << marginalName << "_" << marginalParameterName);
 
400
        for (UnsignedLong index = 0; index < dimension; ++index)
 
401
          {
 
402
            if ( parameterSetNames[index] == fullName ) return index;
 
403
          }
 
404
        return dimension;
406
405
      }
407
406
 
408
407
 
410
409
      /* HasoferReliabilityIndexSensitivity Graph */
411
410
      AnalyticalResult::GraphCollection AnalyticalResult::drawHasoferReliabilityIndexSensitivity(NumericalScalar width)
412
411
      {
413
 
        GraphCollection hasoferReliabilityIndexSensitivityGraphCollection(0);
414
 
        // To ensure that the hasoferReliabilityIndexSensitivity_ are up to date
415
 
        if (! isAlreadyComputedHasoferReliabilityIndexSensitivity_)
416
 
          {
417
 
            computeHasoferReliabilityIndexSensitivity();
418
 
          }
419
 
        const UnsignedLong dimension(standardSpaceDesignPoint_.getDimension());
420
 
        const UnsignedLong size(hasoferReliabilityIndexSensitivity_.getSize());
421
 
        // The first graph shows the sensitivities with respect to the marginal parameters if there exist
422
 
        // in the cas where the distribution or some marginals are defined by user, it may not have parameters : we create a empty sensitivity graph
423
 
        Sensitivity marginalSensitivity(dimension);
424
 
        for(UnsignedLong i = 0; i < dimension; ++i)
425
 
          {
426
 
            marginalSensitivity[i] = hasoferReliabilityIndexSensitivity_[i];
427
 
          }
 
412
        GraphCollection hasoferReliabilityIndexSensitivityGraphCollection(0);
 
413
        // To ensure that the hasoferReliabilityIndexSensitivity_ are up to date
 
414
        if (! isAlreadyComputedHasoferReliabilityIndexSensitivity_)
 
415
          {
 
416
            computeHasoferReliabilityIndexSensitivity();
 
417
          }
 
418
        const UnsignedLong dimension(standardSpaceDesignPoint_.getDimension());
 
419
        const UnsignedLong size(hasoferReliabilityIndexSensitivity_.getSize());
 
420
        // The first graph shows the sensitivities with respect to the marginal parameters if there exist
 
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
 
422
        Sensitivity marginalSensitivity(dimension);
 
423
        for(UnsignedLong i = 0; i < dimension; ++i)
 
424
          {
 
425
            marginalSensitivity[i] = hasoferReliabilityIndexSensitivity_[i];
 
426
          }
428
427
        Graph hasoferReliabilityIndexSensitivityGraphMarginal(drawSensitivity(marginalSensitivity, width));
429
 
        OSS oss1;
430
 
        oss1 << "Hasofer Reliability Index Sensitivities - Marginal parameters - " << limitStateVariable_.getName();
431
 
        hasoferReliabilityIndexSensitivityGraphMarginal.setTitle(oss1);
432
 
        hasoferReliabilityIndexSensitivityGraphCollection.add(hasoferReliabilityIndexSensitivityGraphMarginal);
433
 
        // The second graph shows the sensitivities with respect to the other parameters if there exist
434
 
        if (size > dimension)
435
 
          {
436
 
            Sensitivity otherSensitivity(size - dimension);
437
 
            for(UnsignedLong i = dimension; i < size; ++i)
438
 
              {
439
 
                otherSensitivity[i - dimension] = hasoferReliabilityIndexSensitivity_[i];
440
 
              }
441
 
            Graph hasoferReliabilityIndexSensitivityGraphOther(drawSensitivity(otherSensitivity, width));
442
 
            OSS oss2;
443
 
            oss2 << "Hasofer Reliability Index Sensitivities - Other parameters - " << limitStateVariable_.getName();
444
 
            hasoferReliabilityIndexSensitivityGraphOther.setTitle(oss2);
445
 
            hasoferReliabilityIndexSensitivityGraphCollection.add(hasoferReliabilityIndexSensitivityGraphOther);
446
 
          }
447
 
        return hasoferReliabilityIndexSensitivityGraphCollection;
 
428
        OSS oss1;
 
429
        oss1 << "Hasofer Reliability Index Sensitivities - Marginal parameters - " << limitStateVariable_.getName();
 
430
        hasoferReliabilityIndexSensitivityGraphMarginal.setTitle(oss1);
 
431
        hasoferReliabilityIndexSensitivityGraphCollection.add(hasoferReliabilityIndexSensitivityGraphMarginal);
 
432
        // The second graph shows the sensitivities with respect to the other parameters if there exist
 
433
        if (size > dimension)
 
434
          {
 
435
            Sensitivity otherSensitivity(size - dimension);
 
436
            for(UnsignedLong i = dimension; i < size; ++i)
 
437
              {
 
438
                otherSensitivity[i - dimension] = hasoferReliabilityIndexSensitivity_[i];
 
439
              }
 
440
            Graph hasoferReliabilityIndexSensitivityGraphOther(drawSensitivity(otherSensitivity, width));
 
441
            OSS oss2;
 
442
            oss2 << "Hasofer Reliability Index Sensitivities - Other parameters - " << limitStateVariable_.getName();
 
443
            hasoferReliabilityIndexSensitivityGraphOther.setTitle(oss2);
 
444
            hasoferReliabilityIndexSensitivityGraphCollection.add(hasoferReliabilityIndexSensitivityGraphOther);
 
445
          }
 
446
        return hasoferReliabilityIndexSensitivityGraphCollection;
448
447
      }
449
448
 
450
449
      /* Sensitivity Graph */
451
450
      AnalyticalResult::Graph AnalyticalResult::drawSensitivity(const Sensitivity & sensitivity, NumericalScalar width) const
452
451
      {
453
 
        // shift position of the barplots
454
 
        NumericalScalar shift(0.0);
455
 
 
456
 
        // Create an empty graph
457
 
        Graph sensitivityGraph("Sensitivity", "parameters", "sensitivities", true, "topright");
458
 
 
459
 
        BarPlot sensitivityBarPlot(NumericalSample(0, 2), shift, "");
460
 
 
461
 
        const Description colors(DrawableImplementation::GetValidColors());
462
 
        Description::const_iterator colorsIterator;
463
 
        colorsIterator = colors.begin();
464
 
 
465
 
        // Create the barplots
466
 
        const UnsignedLong sensitivitySize(sensitivity.getSize());
467
 
        for (UnsignedLong collectionIndex = 0; collectionIndex < sensitivitySize; ++collectionIndex)
468
 
          {
469
 
            NumericalSample data(sensitivity[collectionIndex].getDimension(), 2);
470
 
            const UnsignedLong dataSize(data.getSize());
471
 
            for (UnsignedLong sensitivityIndex = 0; sensitivityIndex < dataSize; ++sensitivityIndex)
472
 
              {
473
 
                data[sensitivityIndex][0] = width;
474
 
                data[sensitivityIndex][1] = sensitivity[collectionIndex][sensitivityIndex];
475
 
              }
476
 
            // Add the barplot to the graph
477
 
            OSS oss;
478
 
            oss << sensitivity[collectionIndex].getName() << " " << sensitivity[collectionIndex].getDescription();
479
 
            sensitivityGraph.addDrawable(BarPlot(data, shift, (*colorsIterator), "solid", "solid", oss));
480
 
            ++colorsIterator;
481
 
            if (colorsIterator == colors.end())
482
 
              {
483
 
                colorsIterator == colors.begin();
484
 
              }
485
 
            shift += width * (1 + dataSize);
486
 
          }
487
 
        return sensitivityGraph;
 
452
        // shift position of the barplots
 
453
        NumericalScalar shift(0.0);
 
454
 
 
455
        // Create an empty graph
 
456
        Graph sensitivityGraph("Sensitivity", "parameters", "sensitivities", true, "topright");
 
457
 
 
458
        BarPlot sensitivityBarPlot(NumericalSample(0, 2), shift, "");
 
459
 
 
460
        const Description colors(DrawableImplementation::GetValidColors());
 
461
        Description::const_iterator colorsIterator;
 
462
        colorsIterator = colors.begin();
 
463
 
 
464
        // Create the barplots
 
465
        const UnsignedLong sensitivitySize(sensitivity.getSize());
 
466
        for (UnsignedLong collectionIndex = 0; collectionIndex < sensitivitySize; ++collectionIndex)
 
467
          {
 
468
            NumericalSample data(sensitivity[collectionIndex].getDimension(), 2);
 
469
            const UnsignedLong dataSize(data.getSize());
 
470
            for (UnsignedLong sensitivityIndex = 0; sensitivityIndex < dataSize; ++sensitivityIndex)
 
471
              {
 
472
                data[sensitivityIndex][0] = width;
 
473
                data[sensitivityIndex][1] = sensitivity[collectionIndex][sensitivityIndex];
 
474
              }
 
475
            // Add the barplot to the graph
 
476
            OSS oss;
 
477
            oss << sensitivity[collectionIndex].getName() << " " << sensitivity[collectionIndex].getDescription();
 
478
            sensitivityGraph.addDrawable(BarPlot(data, shift, (*colorsIterator), "solid", "solid", oss));
 
479
            ++colorsIterator;
 
480
            if (colorsIterator == colors.end())
 
481
              {
 
482
                colorsIterator == colors.begin();
 
483
              }
 
484
            shift += width * (1 + dataSize);
 
485
          }
 
486
        return sensitivityGraph;
488
487
      } //drawSensitivity
489
488
 
490
489
 
491
490
      /*  HasoferReliabilityIndexSensitivity accessor */
492
491
      AnalyticalResult::Sensitivity AnalyticalResult::getHasoferReliabilityIndexSensitivity()
493
492
      {
494
 
        if (! isAlreadyComputedHasoferReliabilityIndexSensitivity_)
495
 
          {
496
 
            computeHasoferReliabilityIndexSensitivity();
497
 
          }
498
 
        return hasoferReliabilityIndexSensitivity_;
 
493
        if (! isAlreadyComputedHasoferReliabilityIndexSensitivity_)
 
494
          {
 
495
            computeHasoferReliabilityIndexSensitivity();
 
496
          }
 
497
        return hasoferReliabilityIndexSensitivity_;
499
498
      }
500
499
 
501
500
      /* String converter */
502
501
      String AnalyticalResult::__repr__() const
503
502
      {
504
 
        OSS oss;
505
 
        oss << "class=" << AnalyticalResult::GetClassName()
506
 
            << " standardSpaceDesignPoint=" << standardSpaceDesignPoint_
507
 
            << " physicalSpaceDesignPoint=" << physicalSpaceDesignPoint_
508
 
            << " limitStateVariable=" << limitStateVariable_
509
 
            << " isStandardPointOriginInFailureSpace=" << isStandardPointOriginInFailureSpace_
510
 
            << " hasoferReliabilityIndex=" << hasoferReliabilityIndex_
511
 
            << " importanceFactors=" << importanceFactors_
512
 
            << " hasoferReliabilityIndexSensitivity=" << hasoferReliabilityIndexSensitivity_;
513
 
        return oss;
 
503
        OSS oss;
 
504
        oss << "class=" << AnalyticalResult::GetClassName()
 
505
            << " standardSpaceDesignPoint=" << standardSpaceDesignPoint_
 
506
            << " physicalSpaceDesignPoint=" << physicalSpaceDesignPoint_
 
507
            << " limitStateVariable=" << limitStateVariable_
 
508
            << " isStandardPointOriginInFailureSpace=" << isStandardPointOriginInFailureSpace_
 
509
            << " hasoferReliabilityIndex=" << hasoferReliabilityIndex_
 
510
            << " importanceFactors=" << importanceFactors_
 
511
            << " hasoferReliabilityIndexSensitivity=" << hasoferReliabilityIndexSensitivity_;
 
512
        return oss;
514
513
      }
515
514
 
516
515
      /* Method save() stores the object through the StorageManager */
517
 
      void AnalyticalResult::save(const StorageManager::Advocate & adv) const
 
516
      void AnalyticalResult::save(StorageManager::Advocate & adv) const
518
517
      {
519
 
        PersistentObject::save(adv);
520
 
        adv.writeValue(standardSpaceDesignPoint_, StorageManager::MemberNameAttribute, "standardSpaceDesignPoint_");
521
 
        adv.writeValue(physicalSpaceDesignPoint_, StorageManager::MemberNameAttribute, "physicalSpaceDesignPoint_");
522
 
        adv.writeValue(limitStateVariable_, StorageManager::MemberNameAttribute, "limitStateVariable_");
523
 
        adv.writeValue("isStandardPointOriginInFailureSpace_", isStandardPointOriginInFailureSpace_);
524
 
        adv.writeValue("hasoferReliabilityIndex_", hasoferReliabilityIndex_);
525
 
        adv.writeValue(importanceFactors_, StorageManager::MemberNameAttribute, "importanceFactors_");
526
 
        PersistentSensitivity sensitivity(hasoferReliabilityIndexSensitivity_);
527
 
        adv.writeValue(sensitivity, StorageManager::MemberNameAttribute, "hasoferReliabilityIndexSensitivity_");
528
 
        adv.writeValue("isAlreadyComputedImportanceFactors_", isAlreadyComputedImportanceFactors_);
529
 
        adv.writeValue("isAlreadyComputedHasoferReliabilityIndexSensitivity_", isAlreadyComputedHasoferReliabilityIndexSensitivity_);
 
518
        PersistentSensitivity sensitivity(hasoferReliabilityIndexSensitivity_ );
 
519
        PersistentObject::save(adv);
 
520
        adv.saveAttribute( "standardSpaceDesignPoint_", standardSpaceDesignPoint_ );
 
521
        adv.saveAttribute( "physicalSpaceDesignPoint_", physicalSpaceDesignPoint_ );
 
522
        adv.saveAttribute( "limitStateVariable_", limitStateVariable_ );
 
523
        adv.saveAttribute( "isStandardPointOriginInFailureSpace_", isStandardPointOriginInFailureSpace_ );
 
524
        adv.saveAttribute( "hasoferReliabilityIndex_", hasoferReliabilityIndex_ );
 
525
        adv.saveAttribute( "importanceFactors_", importanceFactors_ );
 
526
        adv.saveAttribute( "hasoferReliabilityIndexSensitivity_", sensitivity );
 
527
        adv.saveAttribute( "isAlreadyComputedImportanceFactors_", isAlreadyComputedImportanceFactors_ );
 
528
        adv.saveAttribute( "isAlreadyComputedHasoferReliabilityIndexSensitivity_", isAlreadyComputedHasoferReliabilityIndexSensitivity_ );
530
529
      }
531
530
 
532
531
      /* Method load() reloads the object from the StorageManager */
533
 
      void AnalyticalResult::load(const StorageManager::Advocate & adv)
 
532
      void AnalyticalResult::load(StorageManager::Advocate & adv)
534
533
      {
535
 
        PersistentObject::load(adv);
536
 
        adv.readValue(standardSpaceDesignPoint_, StorageManager::MemberNameAttribute, "standardSpaceDesignPoint_");
537
 
        adv.readValue(physicalSpaceDesignPoint_, StorageManager::MemberNameAttribute, "physicalSpaceDesignPoint_");
538
 
        adv.readValue(limitStateVariable_, StorageManager::MemberNameAttribute, "limitStateVariable_");
539
 
        adv.readValue(importanceFactors_, StorageManager::MemberNameAttribute, "importanceFactors_");
540
 
        PersistentSensitivity sensitivity;
541
 
        adv.readValue(sensitivity, StorageManager::MemberNameAttribute, "hasoferReliabilityIndexSensitivity_");
542
 
        hasoferReliabilityIndexSensitivity_ = sensitivity;
543
 
        String name;
544
 
        NumericalScalar scalarValue;
545
 
        StorageManager::List objList = adv.getList(StorageManager::NumericalScalarEntity);
546
 
        for(objList.firstValueToRead(); objList.moreValuesToRead(); objList.nextValueToRead()) {
547
 
          if (objList.readValue(name, scalarValue)) {
548
 
            if (name == "hasoferReliabilityIndex_") hasoferReliabilityIndex_ = scalarValue;
549
 
          }
550
 
        }
551
 
        Bool boolValue;
552
 
        objList = adv.getList(StorageManager::BoolEntity);
553
 
        for(objList.firstValueToRead(); objList.moreValuesToRead(); objList.nextValueToRead()) {
554
 
          if (objList.readValue(name, boolValue)) {
555
 
            if (name == "isStandardPointOriginInFailureSpace_") isStandardPointOriginInFailureSpace_ = boolValue;
556
 
            if (name == "isAlreadyComputedImportanceFactors_") isAlreadyComputedImportanceFactors_ = boolValue;
557
 
            if (name == "isAlreadyComputedHasoferReliabilityIndexSensitivity_") isAlreadyComputedHasoferReliabilityIndexSensitivity_ = boolValue;
558
 
          }
559
 
        }
 
534
        PersistentSensitivity sensitivity;
 
535
        PersistentObject::load(adv);
 
536
        adv.loadAttribute( "standardSpaceDesignPoint_", standardSpaceDesignPoint_ );
 
537
        adv.loadAttribute( "physicalSpaceDesignPoint_", physicalSpaceDesignPoint_ );
 
538
        adv.loadAttribute( "limitStateVariable_", limitStateVariable_ );
 
539
        adv.loadAttribute( "isStandardPointOriginInFailureSpace_", isStandardPointOriginInFailureSpace_ );
 
540
        adv.loadAttribute( "hasoferReliabilityIndex_", hasoferReliabilityIndex_ );
 
541
        adv.loadAttribute( "importanceFactors_", importanceFactors_ );
 
542
        adv.loadAttribute( "hasoferReliabilityIndexSensitivity_", sensitivity );
 
543
        adv.loadAttribute( "isAlreadyComputedImportanceFactors_", isAlreadyComputedImportanceFactors_ );
 
544
        adv.loadAttribute( "isAlreadyComputedHasoferReliabilityIndexSensitivity_", isAlreadyComputedHasoferReliabilityIndexSensitivity_ );
 
545
        hasoferReliabilityIndexSensitivity_ = sensitivity;
560
546
      }
561
547
 
562
548
    } /* namespace  Algorithm*/