Different function for exact and approximate DFT analysis

src/storm-dft-cli/storm-dft.cpp

@@ -95,12 +95,6 @@ void processOptions() {
             }
         }
 
-        // Set possible approximation error
-        double approximationError = 0.0;
-        if (faultTreeSettings.isApproximationErrorSet()) {
-            approximationError = faultTreeSettings.getApproximationError();
-        }
-
         // Build properties
         STORM_LOG_THROW(!properties.empty(), storm::exceptions::InvalidSettingsException, "No property given.");
         std::string propString = properties[0];
@@ -111,7 +105,12 @@ void processOptions() {
         STORM_LOG_ASSERT(props.size() > 0, "No properties found.");
 
         // Carry out the actual analysis
-        storm::api::analyzeDFT<ValueType>(*dft, props, faultTreeSettings.useSymmetryReduction(), faultTreeSettings.useModularisation(), !faultTreeSettings.isDisableDC(), approximationError);
+        if (faultTreeSettings.isApproximationErrorSet()) {
+            // Approximate analysis
+            storm::api::analyzeDFTApprox<ValueType>(*dft, props, faultTreeSettings.useSymmetryReduction(), faultTreeSettings.useModularisation(), !faultTreeSettings.isDisableDC(), faultTreeSettings.getApproximationError());
+        } else {
+            storm::api::analyzeDFT<ValueType>(*dft, props, faultTreeSettings.useSymmetryReduction(), faultTreeSettings.useModularisation(), !faultTreeSettings.isDisableDC());
+        }
 }
 
 /*!

src/storm-dft/api/storm-dft.h

@@ -50,14 +50,38 @@ namespace storm {
          * @param symred Flag whether symmetry reduction should be used.
          * @param allowModularisation Flag whether modularisation should be applied if possible.
          * @param enableDC Flag whether Don't Care propagation should be used.
-         * @param approximationError Allowed approximation error, 0 indicates no approximation.
+         *
+         * @return Result.
+         */
+        template <typename ValueType>
+        typename storm::modelchecker::DFTModelChecker<ValueType>::dft_results analyzeDFT(storm::storage::DFT<ValueType> const& dft, std::vector<std::shared_ptr<storm::logic::Formula const>> const& properties, bool symred, bool allowModularisation, bool enableDC) {
+            storm::modelchecker::DFTModelChecker<ValueType> modelChecker;
+            typename storm::modelchecker::DFTModelChecker<ValueType>::dft_results results = modelChecker.check(dft, properties, symred, allowModularisation, enableDC, 0.0);
+            modelChecker.printTimings();
+            modelChecker.printResults();
+            return results;
+        }
+
+        /*!
+         * Approximate the analysis result of the given DFT according to the given properties.
+         * First the Markov model is built from the DFT and then this model is checked against the given properties.
+         *
+         * @param dft DFT.
+         * @param properties PCTL formulas capturing the properties to check.
+         * @param symred Flag whether symmetry reduction should be used.
+         * @param allowModularisation Flag whether modularisation should be applied if possible.
+         * @param enableDC Flag whether Don't Care propagation should be used.
+         * @param approximationError Allowed approximation error.
+         *
+         * @return Result.
          */
         template <typename ValueType>
-        void analyzeDFT(storm::storage::DFT<ValueType> const& dft, std::vector<std::shared_ptr<storm::logic::Formula const>> const& properties, bool symred, bool allowModularisation, bool enableDC, double approximationError) {
+        typename storm::modelchecker::DFTModelChecker<ValueType>::dft_results analyzeDFTApprox(storm::storage::DFT<ValueType> const& dft, std::vector<std::shared_ptr<storm::logic::Formula const>> const& properties, bool symred, bool allowModularisation, bool enableDC, double approximationError) {
             storm::modelchecker::DFTModelChecker<ValueType> modelChecker;
-            modelChecker.check(dft, properties, symred, allowModularisation, enableDC, approximationError);
+            typename storm::modelchecker::DFTModelChecker<ValueType>::dft_results results = modelChecker.check(dft, properties, symred, allowModularisation, enableDC, approximationError);
             modelChecker.printTimings();
             modelChecker.printResults();
+            return results;
         }
 
 

src/storm-dft/modelchecker/dft/DFTModelChecker.cpp

@@ -14,7 +14,7 @@ namespace storm {
     namespace modelchecker {
 
         template<typename ValueType>
-        void DFTModelChecker<ValueType>::check(storm::storage::DFT<ValueType> const& origDft, std::vector<std::shared_ptr<const storm::logic::Formula>> const& properties, bool symred, bool allowModularisation, bool enableDC, double approximationError) {
+        typename DFTModelChecker<ValueType>::dft_results DFTModelChecker<ValueType>::check(storm::storage::DFT<ValueType> const& origDft, std::vector<std::shared_ptr<const storm::logic::Formula>> const& properties, bool symred, bool allowModularisation, bool enableDC, double approximationError) {
             // Initialize
             this->approximationError = approximationError;
             totalTimer.start();
@@ -33,11 +33,11 @@ namespace storm {
                 for (ValueType result : resultsValue) {
                     checkResults.push_back(result);
                 }
-
             } else {
                 checkResults = checkHelper(dft, properties, symred, allowModularisation, enableDC, approximationError);
             }
             totalTimer.stop();
+            return checkResults;
         }
 
         template<typename ValueType>

src/storm-dft/modelchecker/dft/DFTModelChecker.h

@@ -17,12 +17,11 @@ namespace storm {
         template<typename ValueType>
         class DFTModelChecker {
 
+        public:
             typedef std::pair<ValueType, ValueType> approximation_result;
             typedef std::vector<boost::variant<ValueType, approximation_result>> dft_results;
             typedef std::vector<std::shared_ptr<storm::logic::Formula const>> property_vector;
 
-        public:
-
             /*!
              * Constructor.
              */
@@ -38,8 +37,10 @@ namespace storm {
              * @param allowModularisation Flag indication if modularisation is allowed
              * @param enableDC            Flag indicating if dont care propagation should be used
              * @param approximationError  Error allowed for approximation. Value 0 indicates no approximation
+             *
+             * @return Model checking results for the given properties.
              */
-            void check(storm::storage::DFT<ValueType> const& origDft, property_vector const& properties, bool symred = true, bool allowModularisation = true, bool enableDC = true, double approximationError = 0.0);
+            dft_results check(storm::storage::DFT<ValueType> const& origDft, property_vector const& properties, bool symred = true, bool allowModularisation = true, bool enableDC = true, double approximationError = 0.0);
 
             /*!
              * Print timings of all operations to stream.