build infrastructure for switching between multi objective model checking methods

src/storm/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.cpp

@@ -2,7 +2,7 @@
 
 #include "storm/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.h"
 
-#include "storm/modelchecker/multiobjective/pcaa.h"
+#include "storm/modelchecker/multiobjective/multiObjectiveModelChecking.h"
 
 #include "storm/models/sparse/StandardRewardModel.h"
 
@@ -121,7 +121,7 @@ namespace storm {
         
         template<typename SparseMarkovAutomatonModelType>
         std::unique_ptr<CheckResult> SparseMarkovAutomatonCslModelChecker<SparseMarkovAutomatonModelType>::checkMultiObjectiveFormula(CheckTask<storm::logic::MultiObjectiveFormula, ValueType> const& checkTask) {
-            return multiobjective::performPcaa(this->getModel(), checkTask.getFormula());
+            return multiobjective::performMultiObjectiveModelChecking(this->getModel(), checkTask.getFormula());
         }
         
         template class SparseMarkovAutomatonCslModelChecker<storm::models::sparse::MarkovAutomaton<double>>;

src/storm/modelchecker/multiobjective/MultiObjectiveModelCheckingMethod.cpp

@@ -0,0 +1,19 @@
+#include "storm/modelchecker/multiobjective/MultiObjectiveModelCheckingMethod.h"
+
+
+namespace storm {
+    namespace modelchecker {
+        namespace multiobjective {
+            
+            std::string toString(MultiObjectiveMethod m) {
+                switch (m) {
+                    case MultiObjectiveMethod::Pcaa:
+                        return "Pareto Curve Approximation Algorithm";
+                    case MultiObjectiveMethod::ConstraintBased:
+                        return "Constraint Based Algorithm";
+                }
+                return "invalid";
+            }
+        }
+    }
+}

src/storm/modelchecker/multiobjective/MultiObjectiveModelCheckingMethod.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "storm/utility/ExtendSettingEnumWithSelectionField.h"
+
+namespace storm {
+    namespace modelchecker {
+        namespace multiobjective {
+            ExtendEnumsWithSelectionField(MultiObjectiveMethod, Pcaa, ConstraintBased)
+        }
+    }
+} 
+
+

src/storm/modelchecker/multiobjective/constraintBased/SparseCbAchievabilityQuery.cpp

@@ -0,0 +1,50 @@
+#include "storm/modelchecker/multiobjective/constraintbased/SparseCbAchievabilityQuery.h"
+
+#include "storm/adapters/CarlAdapter.h"
+#include "storm/models/sparse/Mdp.h"
+#include "storm/models/sparse/MarkovAutomaton.h"
+#include "storm/models/sparse/StandardRewardModel.h"
+#include "storm/modelchecker/results/ExplicitQualitativeCheckResult.h"
+#include "storm/utility/constants.h"
+#include "storm/utility/vector.h"
+#include "storm/settings/SettingsManager.h"
+#include "storm/settings/modules/GeneralSettings.h"
+#include "storm/settings/modules/MultiObjectiveSettings.h"
+
+#include "storm/exceptions/InvalidOperationException.h"
+
+namespace storm {
+    namespace modelchecker {
+        namespace multiobjective {
+            
+            
+            template <class SparseModelType>
+            SparseCbAchievabilityQuery<SparseModelType>::SparseCbAchievabilityQuery(SparseMultiObjectivePreprocessorReturnType<SparseModelType>& preprocessorResult) : SparseCbQuery<SparseModelType>(preprocessorResult) {
+                STORM_LOG_ASSERT(preprocessorResult.queryType==SparseMultiObjectivePreprocessorReturnType<SparseModelType>::QueryType::Achievability, "Invalid query Type");
+                
+            }
+
+            template <class SparseModelType>
+            std::unique_ptr<CheckResult> SparseCbAchievabilityQuery<SparseModelType>::check() {
+               
+                bool result = this->checkAchievability();
+                
+                return std::unique_ptr<CheckResult>(new ExplicitQualitativeCheckResult(this->originalModel.getInitialStates().getNextSetIndex(0), result));
+                
+            }
+            
+            template <class SparseModelType>
+            bool SparseCbAchievabilityQuery<SparseModelType>::checkAchievability() {
+                return false;
+            }
+
+#ifdef STORM_HAVE_CARL
+            template class SparseCbAchievabilityQuery<storm::models::sparse::Mdp<double>>;
+            template class SparseCbAchievabilityQuery<storm::models::sparse::MarkovAutomaton<double>>;
+            
+            template class SparseCbAchievabilityQuery<storm::models::sparse::Mdp<storm::RationalNumber>>;
+         //   template class SparseCbAchievabilityQuery<storm::models::sparse::MarkovAutomaton<storm::RationalNumber>>;
+#endif
+        }
+    }
+}

src/storm/modelchecker/multiobjective/constraintBased/SparseCbAchievabilityQuery.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "storm/modelchecker/multiobjective/constraintbased/SparseCbQuery.h"
+
+namespace storm {
+    namespace modelchecker {
+        namespace multiobjective {
+            
+            /*
+             * This class represents an achievability query for the constraint based approach (using SMT or LP solvers).
+             */
+            template <class SparseModelType>
+            class SparseCbAchievabilityQuery : public SparseCbQuery<SparseModelType> {
+            public:
+                
+                SparseCbAchievabilityQuery(SparseMultiObjectivePreprocessorReturnType<SparseModelType>& preprocessorResult);
+                
+                virtual ~SparseCbAchievabilityQuery() = default;
+
+                /*
+                 * Invokes the computation and retrieves the result
+                 */
+                virtual std::unique_ptr<CheckResult> check() override;
+                
+            private:
+                
+                /*
+                 * Returns whether the given thresholds are achievable.
+                 */
+                bool checkAchievability();
+                
+            };
+            
+        }
+    }
+}

src/storm/modelchecker/multiobjective/constraintBased/SparseCbQuery.cpp

@@ -0,0 +1,36 @@
+#include "storm/modelchecker/multiobjective/constraintbased/SparseCbQuery.h"
+
+#include "storm/adapters/CarlAdapter.h"
+#include "storm/models/sparse/Mdp.h"
+#include "storm/models/sparse/MarkovAutomaton.h"
+#include "storm/models/sparse/StandardRewardModel.h"
+#include "storm/modelchecker/multiobjective/Objective.h"
+#include "storm/settings/SettingsManager.h"
+#include "storm/settings/modules/MultiObjectiveSettings.h"
+#include "storm/utility/constants.h"
+#include "storm/utility/vector.h"
+
+#include "storm/exceptions/UnexpectedException.h"
+
+namespace storm {
+    namespace modelchecker {
+        namespace multiobjective {
+            
+            
+            template <class SparseModelType>
+            SparseCbQuery<SparseModelType>::SparseCbQuery(SparseMultiObjectivePreprocessorReturnType<SparseModelType>& preprocessorResult) :
+                originalModel(preprocessorResult.originalModel), originalFormula(preprocessorResult.originalFormula),
+                preprocessedModel(std::move(*preprocessorResult.preprocessedModel)), objectives(std::move(preprocessorResult.objectives)) {
+                
+            }
+            
+            
+#ifdef STORM_HAVE_CARL
+            template class SparseCbQuery<storm::models::sparse::Mdp<double>>;
+            template class SparseCbQuery<storm::models::sparse::MarkovAutomaton<double>>;
+            
+            template class SparseCbQuery<storm::models::sparse::Mdp<storm::RationalNumber>>;
+#endif
+        }
+    }
+}

src/storm/modelchecker/multiobjective/constraintBased/SparseCbQuery.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "storm/modelchecker/results/CheckResult.h"
+#include "storm/modelchecker/multiobjective/SparseMultiObjectivePreprocessorReturnType.h"
+
+namespace storm {
+    namespace modelchecker {
+        namespace multiobjective {
+            
+            /*
+             * This class represents a multi-objective  query for the constraint based approach (using SMT or LP solvers).
+             */
+            template <class SparseModelType>
+            class SparseCbQuery {
+            public:
+                
+                
+                virtual ~SparseCbQuery() = default;
+                
+                /*
+                 * Invokes the computation and retrieves the result
+                 */
+                virtual std::unique_ptr<CheckResult> check() = 0;
+                
+            protected:
+                
+                SparseCbQuery(SparseMultiObjectivePreprocessorReturnType<SparseModelType>& preprocessorResult);
+                
+                SparseModelType const& originalModel;
+                storm::logic::MultiObjectiveFormula const& originalFormula;
+                
+                SparseModelType preprocessedModel;
+                std::vector<Objective<typename SparseModelType::ValueType>> objectives;
+                
+            };
+            
+        }
+    }
+}

src/storm/modelchecker/multiobjective/multiObjectiveModelChecking.cpp

@@ -0,0 +1,122 @@
+#include "storm/modelchecker/multiobjective/multiObjectiveModelChecking.h"
+
+#include "storm/utility/macros.h"
+
+#include "storm/models/sparse/Mdp.h"
+#include "storm/models/sparse/MarkovAutomaton.h"
+#include "storm/models/sparse/StandardRewardModel.h"
+#include "storm/modelchecker/multiobjective/SparseMultiObjectivePreprocessor.h"
+#include "storm/modelchecker/multiobjective/pcaa/SparsePcaaAchievabilityQuery.h"
+#include "storm/modelchecker/multiobjective/pcaa/SparsePcaaQuantitativeQuery.h"
+#include "storm/modelchecker/multiobjective/pcaa/SparsePcaaParetoQuery.h"
+#include "storm/modelchecker/multiobjective/constraintbased/SparseCbAchievabilityQuery.h"
+#include "storm/settings/SettingsManager.h"
+#include "storm/settings/modules/MultiObjectiveSettings.h"
+#include "storm/settings/modules/CoreSettings.h"
+#include "storm/utility/Stopwatch.h"
+
+#include "storm/exceptions/InvalidArgumentException.h"
+
+
+namespace storm {
+    namespace modelchecker {
+        namespace multiobjective {
+            
+            template<typename SparseModelType>
+            std::unique_ptr<CheckResult> performMultiObjectiveModelChecking(SparseModelType const& model, storm::logic::MultiObjectiveFormula const& formula,  MultiObjectiveMethodSelection methodSelection) {
+                storm::utility::Stopwatch swTotal(true);
+                storm::utility::Stopwatch swPreprocessing(true);
+                STORM_LOG_ASSERT(model.getInitialStates().getNumberOfSetBits() == 1, "Multi-objective Model checking on model with multiple initial states is not supported.");
+                
+                // If we consider an MA, ensure that it is closed
+                if(model.isOfType(storm::models::ModelType::MarkovAutomaton)) {
+                    STORM_LOG_THROW(dynamic_cast<storm::models::sparse::MarkovAutomaton<typename SparseModelType::ValueType> const *>(&model)->isClosed(), storm::exceptions::InvalidArgumentException, "Unable to check multi-objective formula on non-closed Markov automaton.");
+                }
+                
+                // Preprocess the model
+                auto preprocessorResult = SparseMultiObjectivePreprocessor<SparseModelType>::preprocess(model, formula);
+                swPreprocessing.stop();
+                if (storm::settings::getModule<storm::settings::modules::CoreSettings>().isShowStatisticsSet()) {
+                    STORM_PRINT_AND_LOG("Preprocessing done in " << swPreprocessing << " seconds." << std::endl << " Result: " << preprocessorResult << std::endl);
+                } else {
+                    STORM_LOG_INFO("Preprocessing done in " << swPreprocessing << " seconds." << std::endl << " Result: " << preprocessorResult << std::endl);
+                }
+                
+                // Get the solution method
+                MultiObjectiveMethod method;
+                if (methodSelection == MultiObjectiveMethodSelection::FROMSETTINGS) {
+                     method =  storm::settings::getModule<storm::settings::modules::MultiObjectiveSettings>().getMultiObjectiveMethod();
+                } else {
+                    method = convert(methodSelection);
+                }
+                
+                // Invoke the analysis
+                storm::utility::Stopwatch swAnalysis(true);
+                std::unique_ptr<CheckResult> result;
+                switch (method) {
+                    case MultiObjectiveMethod::Pcaa:
+                    {
+                        std::unique_ptr<SparsePcaaQuery<SparseModelType, storm::RationalNumber>> query;
+                        switch (preprocessorResult.queryType) {
+                            case SparseMultiObjectivePreprocessorReturnType<SparseModelType>::QueryType::Achievability:
+                                query = std::unique_ptr<SparsePcaaQuery<SparseModelType, storm::RationalNumber>> (new SparsePcaaAchievabilityQuery<SparseModelType, storm::RationalNumber>(preprocessorResult));
+                                break;
+                            case SparseMultiObjectivePreprocessorReturnType<SparseModelType>::QueryType::Quantitative:
+                                query = std::unique_ptr<SparsePcaaQuery<SparseModelType, storm::RationalNumber>> (new SparsePcaaQuantitativeQuery<SparseModelType, storm::RationalNumber>(preprocessorResult));
+                                break;
+                            case SparseMultiObjectivePreprocessorReturnType<SparseModelType>::QueryType::Pareto:
+                                query = std::unique_ptr<SparsePcaaQuery<SparseModelType, storm::RationalNumber>> (new SparsePcaaParetoQuery<SparseModelType, storm::RationalNumber>(preprocessorResult));
+                                break;
+                            default:
+                                STORM_LOG_THROW(false, storm::exceptions::InvalidArgumentException, "The multi-objective query type is not supported for the selected solution method '" << toString(method) << "'.");
+                                break;
+                        }
+        
+                        result = query->check();
+                                        
+                        if(storm::settings::getModule<storm::settings::modules::MultiObjectiveSettings>().isExportPlotSet()) {
+                            query->exportPlotOfCurrentApproximation(storm::settings::getModule<storm::settings::modules::MultiObjectiveSettings>().getExportPlotDirectory());
+                        }
+                        break;
+                    }
+                    case MultiObjectiveMethod::ConstraintBased:
+                    {
+                        std::unique_ptr<SparseCbQuery<SparseModelType>> query;
+                        switch (preprocessorResult.queryType) {
+                            case SparseMultiObjectivePreprocessorReturnType<SparseModelType>::QueryType::Achievability:
+                                query = std::unique_ptr<SparseCbQuery<SparseModelType>> (new SparseCbAchievabilityQuery<SparseModelType>(preprocessorResult));
+                                break;
+                            default:
+                                STORM_LOG_THROW(false, storm::exceptions::InvalidArgumentException, "The multi-objective query type is not supported for the selected solution method '" << toString(method) << "'.");
+                                break;
+                        }
+                        
+                        result = query->check();
+                     
+                        if(storm::settings::getModule<storm::settings::modules::MultiObjectiveSettings>().isExportPlotSet()) {
+                            STORM_LOG_ERROR("Can not export plot for the constrained based solver.");
+                        }
+                        break;
+                    }
+                    default:
+                        STORM_LOG_THROW(false, storm::exceptions::InvalidArgumentException, "The multi-objective solution method '" << toString(method) << "' is not supported.");
+                }
+                swAnalysis.stop();
+                
+                swTotal.stop();
+                if (storm::settings::getModule<storm::settings::modules::CoreSettings>().isShowStatisticsSet()) {
+                    STORM_PRINT_AND_LOG("Solving multi-objective query took " << swTotal << " seconds (consisting of " << swPreprocessing << " seconds for preprocessing and " << swAnalysis << " seconds for analyzing the preprocessed model)." << std::endl);
+                }
+
+                return result;
+            }
+     
+            
+            template std::unique_ptr<CheckResult> performMultiObjectiveModelChecking<storm::models::sparse::Mdp<double>>(storm::models::sparse::Mdp<double> const& model, storm::logic::MultiObjectiveFormula const& formula, MultiObjectiveMethodSelection methodSelection);
+            template std::unique_ptr<CheckResult> performMultiObjectiveModelChecking<storm::models::sparse::MarkovAutomaton<double>>(storm::models::sparse::MarkovAutomaton<double> const& model, storm::logic::MultiObjectiveFormula const& formula, MultiObjectiveMethodSelection methodSelection);
+            template std::unique_ptr<CheckResult> performMultiObjectiveModelChecking<storm::models::sparse::Mdp<storm::RationalNumber>>(storm::models::sparse::Mdp<storm::RationalNumber> const& model, storm::logic::MultiObjectiveFormula const& formula, MultiObjectiveMethodSelection methodSelection);
+           // template std::unique_ptr<CheckResult> performMultiObjectiveModelChecking<storm::models::sparse::MarkovAutomaton<storm::RationalNumber>>(storm::models::sparse::MarkovAutomaton<storm::RationalNumber> const& model, storm::logic::MultiObjectiveFormula const& formula, MultiObjectiveMethodSelection methodSelection);
+
+        }
+    }
+}

src/storm/modelchecker/multiobjective/multiObjectiveModelChecking.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <memory>
+
+#include "storm/modelchecker/results/CheckResult.h"
+#include "storm/modelchecker/multiobjective/MultiObjectiveModelCheckingMethod.h"
+#include "storm/logic/Formulas.h"
+
+namespace storm {
+    namespace modelchecker {
+        namespace multiobjective {
+            
+            
+            template<typename SparseModelType>
+            std::unique_ptr<CheckResult> performMultiObjectiveModelChecking(SparseModelType const& model, storm::logic::MultiObjectiveFormula const& formula, MultiObjectiveMethodSelection methodSelection = MultiObjectiveMethodSelection::FROMSETTINGS);
+            
+        }
+    }
+}

src/storm/modelchecker/multiobjective/pcaa.cpp

@@ -1,88 +0,0 @@
-#include "storm/modelchecker/multiobjective/pcaa.h"
-
-#include "storm/utility/macros.h"
-
-#include "storm/models/sparse/Mdp.h"
-#include "storm/models/sparse/MarkovAutomaton.h"
-#include "storm/models/sparse/StandardRewardModel.h"
-#include "storm/modelchecker/multiobjective/SparseMultiObjectivePreprocessor.h"
-#include "storm/modelchecker/multiobjective/pcaa/SparsePcaaAchievabilityQuery.h"
-#include "storm/modelchecker/multiobjective/pcaa/SparsePcaaQuantitativeQuery.h"
-#include "storm/modelchecker/multiobjective/pcaa/SparsePcaaParetoQuery.h"
-#include "storm/settings/SettingsManager.h"
-#include "storm/settings/modules/MultiObjectiveSettings.h"
-#include "storm/settings/modules/CoreSettings.h"
-#include "storm/utility/Stopwatch.h"
-
-#include "storm/exceptions/InvalidArgumentException.h"
-
-
-namespace storm {
-    namespace modelchecker {
-        namespace multiobjective {
-            
-            template<typename SparseModelType>
-            std::unique_ptr<CheckResult> performPcaa(SparseModelType const& model, storm::logic::MultiObjectiveFormula const& formula) {
-                storm::utility::Stopwatch swTotal(true);
-                storm::utility::Stopwatch swPreprocessing(true);
-                STORM_LOG_ASSERT(model.getInitialStates().getNumberOfSetBits() == 1, "Multi-objective Model checking on model with multiple initial states is not supported.");
-                
-#ifdef STORM_HAVE_CARL
-                
-                // If we consider an MA, ensure that it is closed
-                if(model.isOfType(storm::models::ModelType::MarkovAutomaton)) {
-                    STORM_LOG_THROW(dynamic_cast<storm::models::sparse::MarkovAutomaton<typename SparseModelType::ValueType> const *>(&model)->isClosed(), storm::exceptions::InvalidArgumentException, "Unable to check multi-objective formula on non-closed Markov automaton.");
-                }
-                
-                auto preprocessorResult = SparseMultiObjectivePreprocessor<SparseModelType>::preprocess(model, formula);
-                swPreprocessing.stop();
-                if (storm::settings::getModule<storm::settings::modules::CoreSettings>().isShowStatisticsSet()) {
-                    STORM_PRINT_AND_LOG("Preprocessing done in " << swPreprocessing << " seconds." << std::endl << " Result: " << preprocessorResult << std::endl);
-                } else {
-                    STORM_LOG_INFO("Preprocessing done in " << swPreprocessing << " seconds." << std::endl << " Result: " << preprocessorResult << std::endl);
-                }
-                storm::utility::Stopwatch swValueIterations(true);
-                std::unique_ptr<SparsePcaaQuery<SparseModelType, storm::RationalNumber>> query;
-                switch (preprocessorResult.queryType) {
-                    case SparseMultiObjectivePreprocessorReturnType<SparseModelType>::QueryType::Achievability:
-                        query = std::unique_ptr<SparsePcaaQuery<SparseModelType, storm::RationalNumber>> (new SparsePcaaAchievabilityQuery<SparseModelType, storm::RationalNumber>(preprocessorResult));
-                        break;
-                    case SparseMultiObjectivePreprocessorReturnType<SparseModelType>::QueryType::Quantitative:
-                        query = std::unique_ptr<SparsePcaaQuery<SparseModelType, storm::RationalNumber>> (new SparsePcaaQuantitativeQuery<SparseModelType, storm::RationalNumber>(preprocessorResult));
-                        break;
-                    case SparseMultiObjectivePreprocessorReturnType<SparseModelType>::QueryType::Pareto:
-                        query = std::unique_ptr<SparsePcaaQuery<SparseModelType, storm::RationalNumber>> (new SparsePcaaParetoQuery<SparseModelType, storm::RationalNumber>(preprocessorResult));
-                        break;
-                    default:
-                        STORM_LOG_THROW(false, storm::exceptions::InvalidArgumentException, "Unsupported multi-objective Query Type.");
-                        break;
-                }
-
-                auto result = query->check();
-                swValueIterations.stop();
-                swTotal.stop();
-                if (storm::settings::getModule<storm::settings::modules::CoreSettings>().isShowStatisticsSet()) {
-                    STORM_PRINT_AND_LOG("Solving multi-objective query took " << swTotal << " seconds (consisting of " << swPreprocessing << " seconds for preprocessing and " << swValueIterations << " seconds for value iteration-based exploration of achievable points)." << std::endl);
-                }
-
-                
-                if(storm::settings::getModule<storm::settings::modules::MultiObjectiveSettings>().isExportPlotSet()) {
-                    query->exportPlotOfCurrentApproximation(storm::settings::getModule<storm::settings::modules::MultiObjectiveSettings>().getExportPlotDirectory());
-                }
-                return result;
-#else
-                STORM_LOG_THROW(false, storm::exceptions::UnexpectedException, "Multi-objective model checking requires carl.");
-                return nullptr;
-#endif
-            }
-            
-            template std::unique_ptr<CheckResult> performPcaa<storm::models::sparse::Mdp<double>>(storm::models::sparse::Mdp<double> const& model, storm::logic::MultiObjectiveFormula const& formula);
-            template std::unique_ptr<CheckResult> performPcaa<storm::models::sparse::MarkovAutomaton<double>>(storm::models::sparse::MarkovAutomaton<double> const& model, storm::logic::MultiObjectiveFormula const& formula);
-#ifdef STORM_HAVE_CARL
-            template std::unique_ptr<CheckResult> performPcaa<storm::models::sparse::Mdp<storm::RationalNumber>>(storm::models::sparse::Mdp<storm::RationalNumber> const& model, storm::logic::MultiObjectiveFormula const& formula);
-           // template std::unique_ptr<CheckResult> performPcaa<storm::models::sparse::MarkovAutomaton<storm::RationalNumber>>(storm::models::sparse::MarkovAutomaton<storm::RationalNumber> const& model, storm::logic::MultiObjectiveFormula const& formula);
-#endif
-
-        }
-    }
-}

src/storm/modelchecker/multiobjective/pcaa.h

@@ -1,20 +0,0 @@
-#ifndef STORM_MODELCHECKER_MULTIOBJECTIVE_PCAA_H_
-#define STORM_MODELCHECKER_MULTIOBJECTIVE_PCAA_H_
-
-#include <memory>
-
-#include "storm/modelchecker/results/CheckResult.h"
-#include "storm/logic/Formulas.h"
-
-namespace storm {
-    namespace modelchecker {
-        namespace multiobjective {
-            
-            template<typename SparseModelType>
-            std::unique_ptr<CheckResult> performPcaa(SparseModelType const& model, storm::logic::MultiObjectiveFormula const& formula);
-            
-        }
-    }
-}
-
-#endif /* STORM_MODELCHECKER_MULTIOBJECTIVE_PCAA_H_ */

src/storm/modelchecker/multiobjective/pcaa/SparsePcaaQuery.h

@@ -95,7 +95,7 @@ namespace storm {
                 bool maxStepsPerformed() const;
                 
                 /*
-                 * Transforms the given point (or polytope) to values w.r.t. the original model (e.g. negates negative rewards for minimizing objectives).
+                 * Transforms the given point (or polytope) to values w.r.t. the original model/formula (e.g. negates values for minimizing objectives).
                  */
                 Point transformPointToOriginalModel(Point const& polytope) const;
                 std::shared_ptr<storm::storage::geometry::Polytope<GeometryValueType>> transformPolytopeToOriginalModel(std::shared_ptr<storm::storage::geometry::Polytope<GeometryValueType>> const& polytope) const;

src/storm/modelchecker/prctl/HybridMdpPrctlModelChecker.cpp

@@ -16,7 +16,7 @@
 
 #include "storm/logic/FragmentSpecification.h"
 
-#include "storm/modelchecker/multiobjective/pcaa.h"
+#include "storm/modelchecker/multiobjective/multiObjectiveModelChecking.h"
 
 #include "storm/solver/MinMaxLinearEquationSolver.h"
 
@@ -126,7 +126,7 @@ namespace storm {
         template<typename ModelType>
         std::unique_ptr<CheckResult> HybridMdpPrctlModelChecker<ModelType>::checkMultiObjectiveFormula(CheckTask<storm::logic::MultiObjectiveFormula, ValueType> const& checkTask) {
             auto sparseModel = storm::transformer::SymbolicMdpToSparseMdpTransformer<DdType, ValueType>::translate(this->getModel());
-            std::unique_ptr<CheckResult> explicitResult = multiobjective::performPcaa(*sparseModel, checkTask.getFormula());
+            std::unique_ptr<CheckResult> explicitResult = multiobjective::performMultiObjectiveModelChecking(*sparseModel, checkTask.getFormula());
 
             // Convert the explicit result
             if(explicitResult->isExplicitQualitativeCheckResult()) {

src/storm/modelchecker/prctl/SparseMdpPrctlModelChecker.cpp

@@ -14,7 +14,7 @@
 
 #include "storm/modelchecker/prctl/helper/SparseMdpPrctlHelper.h"
 
-#include "storm/modelchecker/multiobjective/pcaa.h"
+#include "storm/modelchecker/multiobjective/multiObjectiveModelChecking.h"
 
 #include "storm/solver/LpSolver.h"
 
@@ -164,7 +164,7 @@ namespace storm {
         
         template<typename SparseMdpModelType>
         std::unique_ptr<CheckResult> SparseMdpPrctlModelChecker<SparseMdpModelType>::checkMultiObjectiveFormula(CheckTask<storm::logic::MultiObjectiveFormula, ValueType> const& checkTask) {
-            return multiobjective::performPcaa(this->getModel(), checkTask.getFormula());
+            return multiobjective::performMultiObjectiveModelChecking(this->getModel(), checkTask.getFormula());
         }
         
         template class SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<double>>;

src/storm/settings/modules/MultiObjectiveSettings.cpp

@@ -12,11 +12,14 @@ namespace storm {
         namespace modules {
             
             const std::string MultiObjectiveSettings::moduleName = "multiobjective";
+            const std::string MultiObjectiveSettings::methodOptionName = "method";
             const std::string MultiObjectiveSettings::exportPlotOptionName = "exportplot";
             const std::string MultiObjectiveSettings::precisionOptionName = "precision";
             const std::string MultiObjectiveSettings::maxStepsOptionName = "maxsteps";
             
             MultiObjectiveSettings::MultiObjectiveSettings() : ModuleSettings(moduleName) {
+                std::vector<std::string> methods = {"pcaa", "constraintbased"};
+                this->addOption(storm::settings::OptionBuilder(moduleName, methodOptionName, true, "The method to be used for multi objective model checking.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the method to use.").addValidatorString(ArgumentValidatorFactory::createMultipleChoiceValidator(methods)).setDefaultValueString("pcaa").build()).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, exportPlotOptionName, true, "Saves data for plotting of pareto curves and achievable values.")
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("directory", "A path to a directory in which the results will be saved.").build()).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, precisionOptionName, true, "The precision used for the approximation of numerical- and pareto queries.")
@@ -25,12 +28,26 @@ namespace storm {
                                 .addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("value", "the threshold for the number of refinement steps to be performed.").build()).build());
             }
             
+            storm::modelchecker::multiobjective::MultiObjectiveMethod MultiObjectiveSettings::getMultiObjectiveMethod() const {
+                std::string methodAsString = this->getOption(methodOptionName).getArgumentByName("name").getValueAsString();
+                if (methodAsString == "pcaa") {
+                    return storm::modelchecker::multiobjective::MultiObjectiveMethod::Pcaa;
+                } else  {
+                    STORM_LOG_ASSERT(methodAsString == "constraintbased", "Unexpected method name for multi objective model checking method.");
+                    return storm::modelchecker::multiobjective::MultiObjectiveMethod::ConstraintBased;
+                }
+            }
+            
             bool MultiObjectiveSettings::isExportPlotSet() const {
                 return this->getOption(exportPlotOptionName).getHasOptionBeenSet();
             }
             
             std::string MultiObjectiveSettings::getExportPlotDirectory() const {
-                return this->getOption(exportPlotOptionName).getArgumentByName("directory").getValueAsString();
+                std::string result = this->getOption(exportPlotOptionName).getArgumentByName("directory").getValueAsString();
+                if (result.back() != '/') {
+                    result.push_back('/');
+                }
+                return result;
             }
             
             double MultiObjectiveSettings::getPrecision() const {

src/storm/settings/modules/MultiObjectiveSettings.h

@@ -2,6 +2,7 @@
 #define STORM_SETTINGS_MODULES_MULTIOBJECTIVESETTINGS_H_
 
 #include "storm/settings/modules/ModuleSettings.h"
+#include "storm/modelchecker/multiobjective/MultiObjectiveModelCheckingMethod.h"
 
 namespace storm {
     namespace settings {
@@ -18,6 +19,11 @@ namespace storm {
                  */
                 MultiObjectiveSettings();
 				
+				/*!
+				 * Returns the preferred method for multi objective model checking
+				 */
+				storm::modelchecker::multiobjective::MultiObjectiveMethod getMultiObjectiveMethod() const;
+				
 				/*!
 				 * Retrieves whether the data for plotting should be exported.
                  * @return  True iff the data for plotting should be exported.
@@ -63,6 +69,7 @@ namespace storm {
                 const static std::string moduleName;
                 
             private:
+				const static std::string methodOptionName;
 				const static std::string exportPlotOptionName;
 				const static std::string precisionOptionName;
 				const static std::string maxStepsOptionName;

src/test/modelchecker/SparseMaPcaaModelCheckerTest.cpp → src/test/modelchecker/SparseMaPcaaMultiObjectiveModelCheckerTest.cpp

@@ -3,7 +3,7 @@
 
 #if defined STORM_HAVE_HYPRO || defined STORM_HAVE_Z3_OPTIMIZE
 
-#include "storm/modelchecker/multiobjective/pcaa.h"
+#include "storm/modelchecker/multiobjective/multiObjectiveModelChecking.h"
 #include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h"
 #include "storm/modelchecker/results/ExplicitQualitativeCheckResult.h"
 #include "storm/modelchecker/results/ExplicitParetoCurveCheckResult.h"
@@ -17,7 +17,7 @@
 
 
 /* Rationals for MAs not supported at this point
-TEST(SparseMaPcaaModelCheckerTest, serverRationalNumbers) {
+TEST(SparseMaPcaaMultiObjectiveModelCheckerTest, serverRationalNumbers) {
     
     std::string programFile = STORM_TEST_RESOURCES_DIR "/ma/server.ma";
     std::string formulasAsString = "multi(Tmax=? [ F \"error\" ], Pmax=? [ F \"processB\" ]) "; // pareto
@@ -48,7 +48,7 @@ TEST(SparseMaPcaaModelCheckerTest, serverRationalNumbers) {
 }*/
 
 
-TEST(SparseMaPcaaModelCheckerTest, server) {
+TEST(SparseMaPcaaMultiObjectiveModelCheckerTest, server) {
     
     std::string programFile = STORM_TEST_RESOURCES_DIR "/ma/server.ma";
     std::string formulasAsString = "multi(Tmax=? [ F \"error\" ], Pmax=? [ F \"processB\" ]) "; // pareto
@@ -58,7 +58,7 @@ TEST(SparseMaPcaaModelCheckerTest, server) {
     std::vector<std::shared_ptr<storm::logic::Formula const>> formulas = storm::extractFormulasFromProperties(storm::parsePropertiesForPrismProgram(formulasAsString, program));
     std::shared_ptr<storm::models::sparse::MarkovAutomaton<double>> ma = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::MarkovAutomaton<double>>();
 
-    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performPcaa(*ma, formulas[0]->asMultiObjectiveFormula());
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*ma, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result->isExplicitParetoCurveCheckResult());
     
     // we do our checks with rationals to avoid numerical issues when doing polytope computations...
@@ -77,7 +77,7 @@ TEST(SparseMaPcaaModelCheckerTest, server) {
 
 }
 
-TEST(SparseMaPcaaModelCheckerTest, jobscheduler_pareto_3Obj) {
+TEST(SparseMaPcaaMultiObjectiveModelCheckerTest, jobscheduler_pareto_3Obj) {
 
     std::string programFile = STORM_TEST_RESOURCES_DIR "/ma/jobscheduler.ma";
     std::string formulasAsString = "multi(Tmin=? [ F  \"all_jobs_finished\" ], Pmax=? [ F<=0.2 \"half_of_jobs_finished\" ], Pmin=? [ F \"slowest_before_fastest\"  ]) ";
@@ -87,7 +87,7 @@ TEST(SparseMaPcaaModelCheckerTest, jobscheduler_pareto_3Obj) {
     std::vector<std::shared_ptr<storm::logic::Formula const>> formulas = storm::extractFormulasFromProperties(storm::parsePropertiesForPrismProgram(formulasAsString, program));
     std::shared_ptr<storm::models::sparse::MarkovAutomaton<double>> ma = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::MarkovAutomaton<double>>();
 
-    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performPcaa(*ma, formulas[0]->asMultiObjectiveFormula());
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*ma, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result->isExplicitParetoCurveCheckResult());
 
     std::vector<double> j12 = {1.266666667,0.1617571721,0.5};
@@ -107,7 +107,7 @@ TEST(SparseMaPcaaModelCheckerTest, jobscheduler_pareto_3Obj) {
     EXPECT_TRUE(result->asExplicitParetoCurveCheckResult<double>().getOverApproximation()->convertNumberRepresentation<storm::RationalNumber>()->minkowskiSum(bloatingBox)->contains(expectedAchievableValues));
 }
 
-TEST(SparseMaPcaaModelCheckerTest, jobscheduler_achievability_3Obj) {
+TEST(SparseMaPcaaMultiObjectiveModelCheckerTest, jobscheduler_achievability_3Obj) {
 
     std::string programFile = STORM_TEST_RESOURCES_DIR "/ma/jobscheduler.ma";
     std::string formulasAsString = "multi(T<=1.31 [ F  \"all_jobs_finished\" ], P>=0.17 [ F<=0.2 \"half_of_jobs_finished\" ], P<=0.31 [ F \"slowest_before_fastest\"  ]) "; //true
@@ -119,16 +119,16 @@ TEST(SparseMaPcaaModelCheckerTest, jobscheduler_achievability_3Obj) {
     std::shared_ptr<storm::models::sparse::MarkovAutomaton<double>> ma = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::MarkovAutomaton<double>>();
     uint_fast64_t const initState = *ma->getInitialStates().begin();
 
-    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performPcaa(*ma, formulas[0]->asMultiObjectiveFormula());
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*ma, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result->isExplicitQualitativeCheckResult());
     EXPECT_TRUE(result->asExplicitQualitativeCheckResult()[initState]);
 
-    std::unique_ptr<storm::modelchecker::CheckResult> result2 = storm::modelchecker::multiobjective::performPcaa(*ma, formulas[1]->asMultiObjectiveFormula());
+    std::unique_ptr<storm::modelchecker::CheckResult> result2 = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*ma, formulas[1]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result2->isExplicitQualitativeCheckResult());
     EXPECT_FALSE(result2->asExplicitQualitativeCheckResult()[initState]);
 }
 
-TEST(SparseMaPcaaModelCheckerTest, jobscheduler_quantitative_3Obj) {
+TEST(SparseMaPcaaMultiObjectiveModelCheckerTest, jobscheduler_quantitative_3Obj) {
 
     std::string programFile = STORM_TEST_RESOURCES_DIR "/ma/jobscheduler.ma";
     std::string formulasAsString = "multi(Tmin=? [ F  \"all_jobs_finished\" ], P>=0.1797900683 [ F<=0.2 \"half_of_jobs_finished\" ], P<=0.3 [ F \"slowest_before_fastest\"  ]) "; //quantitative
@@ -141,16 +141,16 @@ TEST(SparseMaPcaaModelCheckerTest, jobscheduler_quantitative_3Obj) {
     uint_fast64_t const initState = *ma->getInitialStates().begin();
 
 
-    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performPcaa(*ma, formulas[0]->asMultiObjectiveFormula());
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*ma, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result->isExplicitQuantitativeCheckResult());
     EXPECT_NEAR(1.3, result->asExplicitQuantitativeCheckResult<double>()[initState], storm::settings::getModule<storm::settings::modules::MultiObjectiveSettings>().getPrecision());
 
-    std::unique_ptr<storm::modelchecker::CheckResult> result2 = storm::modelchecker::multiobjective::performPcaa(*ma, formulas[1]->asMultiObjectiveFormula());
+    std::unique_ptr<storm::modelchecker::CheckResult> result2 = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*ma, formulas[1]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result2->isExplicitQualitativeCheckResult());
     EXPECT_FALSE(result2->asExplicitQualitativeCheckResult()[initState]);
 }
 
-TEST(SparseMaPcaaModelCheckerTest, jobscheduler_pareto_2Obj) {
+TEST(SparseMaPcaaMultiObjectiveModelCheckerTest, jobscheduler_pareto_2Obj) {
 
     std::string programFile = STORM_TEST_RESOURCES_DIR "/ma/jobscheduler.ma";
     std::string formulasAsString = "multi( Pmax=? [ F<=0.1 \"one_job_finished\"], Pmin=? [F<=0.2 \"all_jobs_finished\"]) ";
@@ -160,7 +160,7 @@ TEST(SparseMaPcaaModelCheckerTest, jobscheduler_pareto_2Obj) {
     std::vector<std::shared_ptr<storm::logic::Formula const>> formulas = storm::extractFormulasFromProperties(storm::parsePropertiesForPrismProgram(formulasAsString, program));
     std::shared_ptr<storm::models::sparse::MarkovAutomaton<double>> ma = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::MarkovAutomaton<double>>();
 
-    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performPcaa(*ma, formulas[0]->asMultiObjectiveFormula());
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*ma, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result->isExplicitParetoCurveCheckResult());
 
     std::vector<double> j12 = {0.2591835573, 0.01990529674};

src/test/modelchecker/SparseMdpCbMultiObjectiveModelCheckerTest

@@ -0,0 +1,113 @@
+#include "gtest/gtest.h"
+#include "storm-config.h"
+
+#if defined STORM_HAVE_HYPRO || defined STORM_HAVE_Z3_OPTIMIZE
+
+#include "storm/modelchecker/multiobjective/multiObjectiveModelChecking.h"
+#include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h"
+#include "storm/modelchecker/results/ExplicitQualitativeCheckResult.h"
+#include "storm/models/sparse/Mdp.h"
+#include "storm/settings/modules/GeneralSettings.h"
+#include "storm/settings/SettingsManager.h"
+#include "storm/utility/storm.h"
+
+
+TEST(SparseMdpCbMultiObjectiveModelCheckerTest, consensus) {
+    
+    std::string programFile = STORM_TEST_RESOURCES_DIR "/mdp/multiobj_consensus2_3_2.nm";
+    std::string formulasAsString = "multi(Pmax=? [ F \"one_proc_err\" ], P>=0.8916673903 [ G \"one_coin_ok\" ]) "; // numerical
+    formulasAsString += "; \n multi(P>=0.1 [ F \"one_proc_err\" ], P>=0.8916673903 [ G \"one_coin_ok\" ])"; // achievability (true)
+    formulasAsString += "; \n multi(P>=0.11 [ F \"one_proc_err\" ], P>=0.8916673903 [ G \"one_coin_ok\" ])"; // achievability (false)
+    
+    // programm, model,  formula
+    storm::prism::Program program = storm::parseProgram(programFile);
+    program = storm::utility::prism::preprocess(program, "");
+    std::vector<std::shared_ptr<storm::logic::Formula const>> formulas = storm::extractFormulasFromProperties(storm::parsePropertiesForPrismProgram(formulasAsString, program));
+    std::shared_ptr<storm::models::sparse::Mdp<double>> mdp = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::Mdp<double>>();
+    uint_fast64_t const initState = *mdp->getInitialStates().begin();;
+    
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::ConstraintBased);
+    ASSERT_TRUE(result->isExplicitQuantitativeCheckResult());
+    EXPECT_NEAR(0.10833260970000025, result->asExplicitQuantitativeCheckResult<double>()[initState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    
+    result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[1]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::ConstraintBased);
+    ASSERT_TRUE(result->isExplicitQualitativeCheckResult());
+    EXPECT_TRUE(result->asExplicitQualitativeCheckResult()[initState]);
+    
+    result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[2]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::ConstraintBased);
+    ASSERT_TRUE(result->isExplicitQualitativeCheckResult());
+    EXPECT_FALSE(result->asExplicitQualitativeCheckResult()[initState]);
+    
+}
+
+TEST(SparseMdpCbMultiObjectiveModelCheckerTest, zeroconf) {
+    
+    std::string programFile = STORM_TEST_RESOURCES_DIR "/mdp/multiobj_zeroconf4.nm";
+    std::string formulasAsString = "multi(Pmax=? [ F l=4 & ip=1 ] , P>=0.993141[ G (error=0) ]) "; // numerical
+    
+    // programm, model,  formula
+    storm::prism::Program program = storm::parseProgram(programFile);
+    program = storm::utility::prism::preprocess(program, "");
+    std::vector<std::shared_ptr<storm::logic::Formula const>> formulas = storm::extractFormulasFromProperties(storm::parsePropertiesForPrismProgram(formulasAsString, program));
+    std::shared_ptr<storm::models::sparse::Mdp<double>> mdp = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::Mdp<double>>();
+    uint_fast64_t const initState = *mdp->getInitialStates().begin();
+    
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::ConstraintBased);
+    ASSERT_TRUE(result->isExplicitQuantitativeCheckResult());
+    EXPECT_NEAR(0.0003075787401574803, result->asExplicitQuantitativeCheckResult<double>()[initState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+}
+
+TEST(SparseMdpCbMultiObjectiveModelCheckerTest, team3with3objectives) {
+    
+    std::string programFile = STORM_TEST_RESOURCES_DIR "/mdp/multiobj_team3.nm";
+    std::string formulasAsString = "multi(Pmax=? [ F \"task1_compl\" ], R{\"w_1_total\"}>=2.210204082 [ C ],  P>=0.5 [ F \"task2_compl\" ])"; // numerical
+    
+    // programm, model,  formula
+    storm::prism::Program program = storm::parseProgram(programFile);
+    program = storm::utility::prism::preprocess(program, "");
+    std::vector<std::shared_ptr<storm::logic::Formula const>> formulas = storm::extractFormulasFromProperties(storm::parsePropertiesForPrismProgram(formulasAsString, program));
+    std::shared_ptr<storm::models::sparse::Mdp<double>> mdp = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::Mdp<double>>();
+    uint_fast64_t const initState = *mdp->getInitialStates().begin();
+    
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::ConstraintBased);
+    ASSERT_TRUE(result->isExplicitQuantitativeCheckResult());
+    EXPECT_NEAR(0.7448979591841851, result->asExplicitQuantitativeCheckResult<double>()[initState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+}
+
+TEST(SparseMdpCbMultiObjectiveModelCheckerTest, scheduler) {
+    
+    std::string programFile = STORM_TEST_RESOURCES_DIR "/mdp/multiobj_scheduler05.nm";
+    std::string formulasAsString = "multi(R{\"time\"}<= 11.778[ F \"tasks_complete\" ], R{\"energy\"}<=1.45 [  F \"tasks_complete\" ]) ";
+    
+    // programm, model,  formula
+    storm::prism::Program program = storm::parseProgram(programFile);
+    program = storm::utility::prism::preprocess(program, "");
+    std::vector<std::shared_ptr<storm::logic::Formula const>> formulas = storm::extractFormulasFromProperties(storm::parsePropertiesForPrismProgram(formulasAsString, program));
+    std::shared_ptr<storm::models::sparse::Mdp<double>> mdp = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::Mdp<double>>();
+    uint_fast64_t const initState = *mdp->getInitialStates().begin();
+    
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::ConstraintBased);
+    EXPECT_TRUE(result->asExplicitQualitativeCheckResult()[initState]);
+}
+
+TEST(SparseMdpCbMultiObjectiveModelCheckerTest, dpm) {
+    
+    std::string programFile = STORM_TEST_RESOURCES_DIR "/mdp/multiobj_dpm100.nm";
+    std::string formulasAsString = "multi(R{\"power\"}min=? [ C<=100 ], R{\"queue\"}<=70 [ C<=100 ])"; // numerical
+    
+    // programm, model,  formula
+    storm::prism::Program program = storm::parseProgram(programFile);
+    program = storm::utility::prism::preprocess(program, "");
+    std::vector<std::shared_ptr<storm::logic::Formula const>> formulas = storm::extractFormulasFromProperties(storm::parsePropertiesForPrismProgram(formulasAsString, program));
+    std::shared_ptr<storm::models::sparse::Mdp<double>> mdp = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::Mdp<double>>();
+    uint_fast64_t const initState = *mdp->getInitialStates().begin();
+    
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::ConstraintBased);
+    ASSERT_TRUE(result->isExplicitQuantitativeCheckResult());
+    EXPECT_NEAR(121.6128842, result->asExplicitQuantitativeCheckResult<double>()[initState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+}
+
+
+
+
+#endif /* STORM_HAVE_HYPRO || defined STORM_HAVE_Z3_OPTIMIZE */

src/test/modelchecker/SparseMdpPcaaModelCheckerTest.cpp → src/test/modelchecker/SparseMdpPcaaMultiObjectiveModelCheckerTest.cpp

@@ -3,7 +3,7 @@
 
 #if defined STORM_HAVE_HYPRO || defined STORM_HAVE_Z3_OPTIMIZE
 
-#include "storm/modelchecker/multiobjective/pcaa.h"
+#include "storm/modelchecker/multiobjective/multiObjectiveModelChecking.h"
 #include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h"
 #include "storm/modelchecker/results/ExplicitQualitativeCheckResult.h"
 #include "storm/models/sparse/Mdp.h"
@@ -12,7 +12,7 @@
 #include "storm/utility/storm.h"
 
 
-TEST(SparseMdpPcaaModelCheckerTest, consensus) {
+TEST(SparseMdpPcaaMultiObjectiveModelCheckerTest, consensus) {
     
     std::string programFile = STORM_TEST_RESOURCES_DIR "/mdp/multiobj_consensus2_3_2.nm";
     std::string formulasAsString = "multi(Pmax=? [ F \"one_proc_err\" ], P>=0.8916673903 [ G \"one_coin_ok\" ]) "; // numerical
@@ -26,21 +26,21 @@ TEST(SparseMdpPcaaModelCheckerTest, consensus) {
     std::shared_ptr<storm::models::sparse::Mdp<double>> mdp = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::Mdp<double>>();
     uint_fast64_t const initState = *mdp->getInitialStates().begin();;
     
-    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performPcaa(*mdp, formulas[0]->asMultiObjectiveFormula());
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result->isExplicitQuantitativeCheckResult());
     EXPECT_NEAR(0.10833260970000025, result->asExplicitQuantitativeCheckResult<double>()[initState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
-    result = storm::modelchecker::multiobjective::performPcaa(*mdp, formulas[1]->asMultiObjectiveFormula());
+    result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[1]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result->isExplicitQualitativeCheckResult());
     EXPECT_TRUE(result->asExplicitQualitativeCheckResult()[initState]);
     
-    result = storm::modelchecker::multiobjective::performPcaa(*mdp, formulas[2]->asMultiObjectiveFormula());
+    result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[2]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result->isExplicitQualitativeCheckResult());
     EXPECT_FALSE(result->asExplicitQualitativeCheckResult()[initState]);
     
 }
 
-TEST(SparseMdpPcaaModelCheckerTest, zeroconf) {
+TEST(SparseMdpPcaaMultiObjectiveModelCheckerTest, zeroconf) {
     
     std::string programFile = STORM_TEST_RESOURCES_DIR "/mdp/multiobj_zeroconf4.nm";
     std::string formulasAsString = "multi(Pmax=? [ F l=4 & ip=1 ] , P>=0.993141[ G (error=0) ]) "; // numerical
@@ -52,12 +52,12 @@ TEST(SparseMdpPcaaModelCheckerTest, zeroconf) {
     std::shared_ptr<storm::models::sparse::Mdp<double>> mdp = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::Mdp<double>>();
     uint_fast64_t const initState = *mdp->getInitialStates().begin();
     
-    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performPcaa(*mdp, formulas[0]->asMultiObjectiveFormula());
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result->isExplicitQuantitativeCheckResult());
     EXPECT_NEAR(0.0003075787401574803, result->asExplicitQuantitativeCheckResult<double>()[initState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
-TEST(SparseMdpPcaaModelCheckerTest, team3with3objectives) {
+TEST(SparseMdpPcaaMultiObjectiveModelCheckerTest, team3with3objectives) {
     
     std::string programFile = STORM_TEST_RESOURCES_DIR "/mdp/multiobj_team3.nm";
     std::string formulasAsString = "multi(Pmax=? [ F \"task1_compl\" ], R{\"w_1_total\"}>=2.210204082 [ C ],  P>=0.5 [ F \"task2_compl\" ])"; // numerical
@@ -69,12 +69,12 @@ TEST(SparseMdpPcaaModelCheckerTest, team3with3objectives) {
     std::shared_ptr<storm::models::sparse::Mdp<double>> mdp = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::Mdp<double>>();
     uint_fast64_t const initState = *mdp->getInitialStates().begin();
     
-    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performPcaa(*mdp, formulas[0]->asMultiObjectiveFormula());
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result->isExplicitQuantitativeCheckResult());
     EXPECT_NEAR(0.7448979591841851, result->asExplicitQuantitativeCheckResult<double>()[initState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
-TEST(SparseMdpPcaaModelCheckerTest, scheduler) {
+TEST(SparseMdpPcaaMultiObjectiveModelCheckerTest, scheduler) {
     
     std::string programFile = STORM_TEST_RESOURCES_DIR "/mdp/multiobj_scheduler05.nm";
     std::string formulasAsString = "multi(R{\"time\"}<= 11.778[ F \"tasks_complete\" ], R{\"energy\"}<=1.45 [  F \"tasks_complete\" ]) ";
@@ -86,11 +86,11 @@ TEST(SparseMdpPcaaModelCheckerTest, scheduler) {
     std::shared_ptr<storm::models::sparse::Mdp<double>> mdp = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::Mdp<double>>();
     uint_fast64_t const initState = *mdp->getInitialStates().begin();
     
-    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performPcaa(*mdp, formulas[0]->asMultiObjectiveFormula());
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     EXPECT_TRUE(result->asExplicitQualitativeCheckResult()[initState]);
 }
 
-TEST(SparseMdpPcaaModelCheckerTest, dpm) {
+TEST(SparseMdpPcaaMultiObjectiveModelCheckerTest, dpm) {
     
     std::string programFile = STORM_TEST_RESOURCES_DIR "/mdp/multiobj_dpm100.nm";
     std::string formulasAsString = "multi(R{\"power\"}min=? [ C<=100 ], R{\"queue\"}<=70 [ C<=100 ])"; // numerical
@@ -102,7 +102,7 @@ TEST(SparseMdpPcaaModelCheckerTest, dpm) {
     std::shared_ptr<storm::models::sparse::Mdp<double>> mdp = storm::buildSparseModel<double>(program, formulas)->as<storm::models::sparse::Mdp<double>>();
     uint_fast64_t const initState = *mdp->getInitialStates().begin();
     
-    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performPcaa(*mdp, formulas[0]->asMultiObjectiveFormula());
+    std::unique_ptr<storm::modelchecker::CheckResult> result = storm::modelchecker::multiobjective::performMultiObjectiveModelChecking(*mdp, formulas[0]->asMultiObjectiveFormula(), storm::modelchecker::multiobjective::MultiObjectiveMethodSelection::Pcaa);
     ASSERT_TRUE(result->isExplicitQuantitativeCheckResult());
     EXPECT_NEAR(121.6128842, result->asExplicitQuantitativeCheckResult<double>()[initState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }