Deconditioned

lib/src/InverseFORM.cxx

@@ -23,13 +23,20 @@
 #include <openturns/Normal.hxx>
 #include <openturns/StandardEvent.hxx>
 #include <openturns/LinearFunction.hxx>
-#include <openturns/ComposedDistribution.hxx>
-#include <openturns/ConditionalDistribution.hxx>
+#include <openturns/JointDistribution.hxx>
 #include <openturns/CompositeRandomVector.hxx>
 #include <openturns/ThresholdEvent.hxx>
 #include <openturns/ComposedFunction.hxx>
 #include <openturns/SpecFunc.hxx>
 
+#if OPENTURNS_VERSION >= 102400
+#include <openturns/DeconditionedDistribution.hxx>
+#else
+#include <openturns/ConditionalDistribution.hxx>
+#define DeconditionedDistribution ConditionalDistribution
+#endif
+
+
 using namespace OT;
 
 namespace OTROBOPT {
@@ -163,7 +170,7 @@ void InverseFORM::run()
     // direction
     du = -(betaC / dgdunorm) * dgdu - u;
     dp = (fabs(dgdp) < (SpecFunc::ScalarEpsilon * SpecFunc::ScalarEpsilon)) ? 0.0 : (u.dot(dgdu) - g + betaC * dgdunorm) / dgdp;
-    LOGINFO(OSS() << "InverseFORM::run i=" << iteration << " u="<<u.__str__() <<" dgdu="<<dgdu.__str__()<<" du="<<du<<" dgdp="<< dgdp<< " dp="<<dp);
+    LOGTRACE(OSS() << "InverseFORM::run i=" << iteration << " u="<<u.__str__() <<" dgdu="<<dgdu.__str__()<<" du="<<du<<" dgdp="<< dgdp<< " dp="<<dp);
 
     // update according to the step
     Scalar step = fixedStep_ ? fixedStepValue_ : 1.0;
@@ -178,7 +185,7 @@ void InverseFORM::run()
       mnew = meritFunction(unew, gnew);
       step *= 0.5;
       ++ stepIteration;
-      LOGINFO(OSS() << "InverseFORM::run i=" << iteration << " step=" << step<< "pnew="<<pnew<<" unew="<<unew);
+      LOGTRACE(OSS() << "InverseFORM::run i=" << iteration << " step=" << step<< "pnew="<<pnew<<" unew="<<unew);
     }
     while ((!fixedStep_) && (mnew > m) && (stepIteration < variableStepMaxIterations_));
 
@@ -187,10 +194,10 @@ void InverseFORM::run()
                 &&( fabs(gnew) < limitStateConvergence_)
                 &&( fabs(unew.norm()-fabs(betaC)) < betaConvergence_);
 
-    LOGINFO(OSS() << "InverseFORM::run i=" << iteration << " var=" << p <<" beta="<<beta<<" g/go="<<g/g0);
-    LOGINFO(OSS() << "InverseFORM::run i=" << iteration << " convergence.var=" << fabs(pnew - p) <<" <? "<<variableConvergence_);
-    LOGINFO(OSS() << "InverseFORM::run i=" << iteration << " convergence.g=" << fabs(gnew) <<" <? "<<limitStateConvergence_);
-    LOGINFO(OSS() << "InverseFORM::run i=" << iteration << " convergence.beta=" <<fabs(unew.norm()-fabs(betaC)) <<" <? "<<betaConvergence_);
+    LOGTRACE(OSS() << "InverseFORM::run i=" << iteration << " var=" << p <<" beta="<<beta<<" g/go="<<g/g0);
+    LOGTRACE(OSS() << "InverseFORM::run i=" << iteration << " convergence.var=" << fabs(pnew - p) <<" <? "<<variableConvergence_);
+    LOGTRACE(OSS() << "InverseFORM::run i=" << iteration << " convergence.g=" << fabs(gnew) <<" <? "<<limitStateConvergence_);
+    LOGTRACE(OSS() << "InverseFORM::run i=" << iteration << " convergence.beta=" <<fabs(unew.norm()-fabs(betaC)) <<" <? "<<betaConvergence_);
 
     // for next iteration
     m = mnew;
@@ -199,7 +206,7 @@ void InverseFORM::run()
     g = gnew;
 
     beta = signBetaT*u.norm();
-    LOGINFO(OSS() << "InverseFORM::run i="<<iteration<<" g="<<g<<" du="<<du<<" u="<<u<<" beta="<<betaC<<" dp="<<dp<<" p="<<p<< "m="<<m<<" dgdp="<<dgdp<<" dgdu="<<dgdu<<" dgdunorm="<<dgdunorm<<" rel="<<rel<<" delta="<<delta);
+    LOGTRACE(OSS() << "InverseFORM::run i="<<iteration<<" g="<<g<<" du="<<du<<" u="<<u<<" beta="<<betaC<<" dp="<<dp<<" p="<<p<< "m="<<m<<" dgdp="<<dgdp<<" dgdu="<<dgdu<<" dgdunorm="<<dgdunorm<<" rel="<<rel<<" delta="<<delta);
 
     ++ iteration;
   }
@@ -219,28 +226,23 @@ void InverseFORM::run()
 
 Function InverseFORM::getG(const Scalar p)
 {
-  const Scalar threshold = event_.getThreshold();
-  const ComparisonOperator op(event_.getOperator());
   Function newFunction(event_.getImplementation()->getFunction());
-
   PointWithDescription params(event_.getImplementation()->getFunction().getParameter());
   params[parameterIndex_] = p;
   newFunction.setParameter(params);
   RandomVector antecedent(event_.getImplementation()->getAntecedent().getImplementation()->clone());
   const Distribution distribution(antecedent.getDistribution());
-#if OPENTURNS_VERSION >= 102300
   const JointDistribution * p_joint = dynamic_cast<JointDistribution *>(distribution.getImplementation().get());
-#else
-  const ComposedDistribution * p_joint = dynamic_cast<ComposedDistribution *>(distribution.getImplementation().get());
-#endif
   if (p_joint)
   {
-    ComposedDistribution::DistributionCollection distributionCollection(p_joint->getDistributionCollection());
-    for (UnsignedInteger i = 0; i < distributionCollection.getSize(); ++ i)
+    JointDistribution::DistributionCollection coll(p_joint->getDistributionCollection());
+    for (UnsignedInteger i = 0; i < coll.getSize(); ++ i)
     {
-      if (distributionCollection[i].getImplementation()->getClassName() == "ConditionalDistribution")
+      const DeconditionedDistribution * p_conditional = dynamic_cast<DeconditionedDistribution
+        *>(coll[i].getImplementation().get());
+      if (p_conditional)
       {
-        DistributionImplementation::PointWithDescriptionCollection parametersCollection(distributionCollection[i].getParametersCollection());
+        DistributionImplementation::PointWithDescriptionCollection parametersCollection(coll[i].getParametersCollection());
         for (UnsignedInteger j = 0; j < parametersCollection.getSize(); ++ j)
         {
           const String marginalName(parametersCollection[j].getName());
@@ -253,21 +255,17 @@ Function InverseFORM::getG(const Scalar p)
             }
           }
         }
-        const ConditionalDistribution * p_conditional = dynamic_cast<ConditionalDistribution *>(distributionCollection[i].getImplementation().get());
-        if (p_conditional)
-        {
-          Distribution conditioning(p_conditional->getConditioningDistribution());
-          conditioning.setParametersCollection(parametersCollection);
-          ConditionalDistribution newConditional(p_conditional->getConditionedDistribution(), conditioning);
-          distributionCollection[i] = newConditional;
-          ComposedDistribution newDistribution(distributionCollection);
-          antecedent = RandomVector(newDistribution);
-        } // if p_conditional
+        Distribution conditioning(p_conditional->getConditioningDistribution());
+        conditioning.setParametersCollection(parametersCollection);
+        coll[i] = DeconditionedDistribution(p_conditional->getConditionedDistribution(), conditioning);
       } // if conditional
     } // i
+    antecedent = RandomVector(JointDistribution(coll));
   } // if p_joint
 
   const CompositeRandomVector composite(newFunction, antecedent);
+  const Scalar threshold = event_.getThreshold();
+  const ComparisonOperator op(event_.getOperator());
   const ThresholdEvent event(composite, op, threshold);
   const StandardEvent standardEvent(event);
   const Scalar gsign = op(1.0, 2.0) ? 1.0 : -1.0;

lib/src/SequentialMonteCarloRobustAlgorithm.cxx

@@ -24,7 +24,7 @@
 #include <openturns/PersistentObjectFactory.hxx>
 #include <openturns/FixedExperiment.hxx>
 #include <openturns/IdentityFunction.hxx>
-#include <openturns/ComposedDistribution.hxx>
+#include <openturns/JointDistribution.hxx>
 #include <openturns/LHSExperiment.hxx>
 #include <openturns/SpecFunc.hxx>
 #include <openturns/Uniform.hxx>
@@ -143,10 +143,10 @@ void SequentialMonteCarloRobustAlgorithm::run()
       if (!getProblem().hasBounds())
         throw InvalidArgumentException(HERE) << "Cannot perform multi-start without bounds";
 
-      ComposedDistribution::DistributionCollection coll(dimension);
+      JointDistribution::DistributionCollection coll(dimension);
       for (UnsignedInteger j = 0; j < dimension; ++ j)
         coll[j] = Uniform(getProblem().getBounds().getLowerBound()[j], getProblem().getBounds().getUpperBound()[j]);
-      LHSExperiment initialExperiment(ComposedDistribution(coll), initialSearch_);
+      LHSExperiment initialExperiment(JointDistribution(coll), initialSearch_);
       initialStartingPoints_ = initialExperiment.generate();
 
       MultiStart multiStart(solver, initialStartingPoints_);

lib/src/SubsetInverseSampling.cxx

@@ -25,7 +25,7 @@
 #include <openturns/KernelSmoothing.hxx>
 #include <openturns/Normal.hxx>
 #include <openturns/ChiSquare.hxx>
-#include <openturns/ComposedDistribution.hxx>
+#include <openturns/JointDistribution.hxx>
 #include <openturns/SpecFunc.hxx>
 #include <openturns/DistFunc.hxx>
 #include <openturns/Uniform.hxx>
@@ -449,7 +449,7 @@ void SubsetInverseSampling::generatePoints(Scalar threshold)
 {  
   UnsignedInteger maximumOuterSampling = getMaximumOuterSampling();
   UnsignedInteger blockSize = getBlockSize();
-  Distribution randomWalk(ComposedDistribution(ComposedDistribution::DistributionCollection(dimension_, Uniform(-0.5*proposalRange_, 0.5*proposalRange_))));
+  Distribution randomWalk(JointDistribution(JointDistribution::DistributionCollection(dimension_, Uniform(-0.5*proposalRange_, 0.5*proposalRange_))));
   UnsignedInteger N = currentPointSample_.getSize(); // total sample size
   UnsignedInteger Nc = conditionalProbability_ * N; //number of seeds (also = maximumOuterSampling*blockSize)
 

lib/test/t_InverseFORM_sphere.cxx

@@ -24,16 +24,19 @@ int main()
 
     Dirac mulog_eDist(L0);
     mulog_eDist.setDescription(Description(1, "mulog_e"));
-    ComposedDistribution::DistributionCollection eColl; eColl.add(mulog_eDist); eColl.add(Dirac(0.1));  eColl.add(Dirac(0.));
-    ComposedDistribution eParams(eColl);
+    JointDistribution::DistributionCollection eColl; eColl.add(mulog_eDist); eColl.add(Dirac(0.1));  eColl.add(Dirac(0.));
+    JointDistribution eParams(eColl);
 
-    ComposedDistribution::DistributionCollection coll;
+    JointDistribution::DistributionCollection coll;
     coll.add(Beta(0.117284, 0.117284, 2.9, 3.1));//R
+#if OPENTURNS_VERSION >= 102400
+    DeconditionedDistribution eDist(LogNormal(L0, 0.1, 0.), eParams);
+#else
     ConditionalDistribution eDist(LogNormal(L0, 0.1, 0.), eParams);
-
+#endif
     coll.add(eDist);//e
     coll.add(WeibullMin(3.16471, 9.21097, 0.0));//p
-    ComposedDistribution myDistribution(coll);
+    JointDistribution myDistribution(coll);
 
     Point median(dim);
     for(UnsignedInteger i = 0; i < dim; ++ i)
@@ -61,10 +64,14 @@ int main()
 
     // FORM must yield the same probability on the limit state with parameter set to the optimum
     eColl[0] = Dirac(result.getParameter()[0]);
-    eParams = ComposedDistribution(eColl);
+    eParams = JointDistribution(eColl);
+#if OPENTURNS_VERSION >= 102400
+    eDist = DeconditionedDistribution(LogNormal(result.getParameter()[0], 0.1, 0.0), eParams);
+#else
     eDist = ConditionalDistribution(LogNormal(result.getParameter()[0], 0.1, 0.0), eParams);
+#endif
     coll[1] = eDist;
-    myDistribution = ComposedDistribution(coll);
+    myDistribution = JointDistribution(coll);
     vect = RandomVector(myDistribution);
     parametric.setParameter(result.getParameter());
     output = CompositeRandomVector(parametric, vect);

lib/test/t_InverseFORM_std.cxx

@@ -21,13 +21,13 @@ int main()
     const SymbolicFunction function(Description({"E", "F", "L", "b", "h"}), Description({"F*L^3/(48.*E*b*h^3/12.)"}));
     ParametricFunction parametric(function, Indices({2}), Point({5.0}));
 
-    ComposedDistribution::DistributionCollection coll;
+    JointDistribution::DistributionCollection coll;
     coll.add(LogNormalMuSigmaOverMu(30000., 0.12, 0.).getDistribution());//E
     coll.add(LogNormalMuSigmaOverMu(0.1, 0.2, 0.).getDistribution());//F
     coll.add(LogNormalMuSigmaOverMu(0.2, 0.05, 0.).getDistribution());//b
     coll.add(LogNormalMuSigmaOverMu(0.4, 0.05, 0.).getDistribution());//h
 
-    const ComposedDistribution myDistribution(coll);
+    const JointDistribution myDistribution(coll);
 
     Point median(dim);
     for(UnsignedInteger i = 0; i < dim; ++ i)

lib/test/t_MeasureEvaluation_std.cxx

@@ -72,8 +72,8 @@ int main()
     Collection <MeasureEvaluation> measures;
     measures.add(MeanMeasure(f, thetaDist));
     measures.add(VarianceMeasure(f, thetaDist));
-    measures.add(WorstCaseMeasure(f, ComposedDistribution(Collection<Distribution>(2, Uniform(-1.0, 4.0)))));
-    measures.add(WorstCaseMeasure(f, ComposedDistribution(Collection<Distribution>(2, Uniform(-1.0, 4.0))), false));
+    measures.add(WorstCaseMeasure(f, JointDistribution(Collection<Distribution>(2, Uniform(-1.0, 4.0)))));
+    measures.add(WorstCaseMeasure(f, JointDistribution(Collection<Distribution>(2, Uniform(-1.0, 4.0))), false));
     measures.add(JointChanceMeasure(f, thetaDist, GreaterOrEqual(), 0.5));
     measures.add(IndividualChanceMeasure(f, thetaDist, GreaterOrEqual(), Point(1, 0.5)));
     measures.add(MeanStandardDeviationTradeoffMeasure(f, thetaDist, Point(1, 0.8)));

python/test/sequential_mc.py

@@ -178,7 +178,7 @@ def solve(self):
                 newPoint = self.solver_.getResult().getOptimalPoint()
                 bestValue = self.solver_.getResult().getOptimalValue()[0]
             else:
-                startingPoints = ot.LHSExperiment(ot.ComposedDistribution(
+                startingPoints = ot.LHSExperiment(ot.JointDistribution(
                     [ot.Uniform(self.bounds_.getLowerBound()[i], self.bounds_.getUpperBound()[i])
                         for i in range(self.bounds_.getDimension())]), self.initialSearch_).generate()
                 bestValue = ot.SpecFunc.MaxScalar

python/test/t_InverseFORM_std.py

@@ -16,7 +16,7 @@
 coll.append(ot.LogNormalMuSigmaOverMu(0.2, 0.05, 0.).getDistribution())  # b
 coll.append(ot.LogNormalMuSigmaOverMu(0.4, 0.05, 0.).getDistribution())  # h
 
-distribution = ot.ComposedDistribution(coll)
+distribution = ot.JointDistribution(coll)
 
 x0 = [coll[i].computeQuantile(0.5)[0] for i in range(len(coll))]
 

python/test/t_MeasureEvaluation_std.py

@@ -47,9 +47,9 @@
 measures = [otrobopt.MeanMeasure(f, thetaDist),
             otrobopt.VarianceMeasure(f, thetaDist),
             otrobopt.WorstCaseMeasure(
-                f, ot.ComposedDistribution([ot.Uniform(-1.0, 4.0)] * 2)),
+                f, ot.JointDistribution([ot.Uniform(-1.0, 4.0)] * 2)),
             otrobopt.WorstCaseMeasure(
-                f, ot.ComposedDistribution(
+                f, ot.JointDistribution(
                     [ot.Uniform(-1.0, 4.0)] * 2), False),
             otrobopt.JointChanceMeasure(
                 f, thetaDist, ot.GreaterOrEqual(), 0.95),