From fd3ffafcd9e0efa27591567fc5efc9d3efae965a Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 8 Jul 2015 15:47:51 +0200
Subject: [PATCH 001/246] First version of the monolithic state space
 generation

Former-commit-id: fab8f6e356ce0187373c5941da1640ac70e642d5
---
 src/builder/ExplicitDFTModelBuilder.h         |  93 +++
 src/parser/DFTGalileoParser.cpp               | 102 +++
 src/parser/DFTGalileoParser.h                 |  29 +
 src/storage/BitVector.cpp                     |  25 +
 src/storage/BitVector.h                       |   7 +
 src/storage/dft/DFT.cpp                       | 121 ++++
 src/storage/dft/DFT.h                         | 184 +++++
 src/storage/dft/DFTBuilder.cpp                | 132 ++++
 src/storage/dft/DFTBuilder.h                  | 116 ++++
 src/storage/dft/DFTElementState.h             |  26 +
 src/storage/dft/DFTElements.cpp               |  38 ++
 src/storage/dft/DFTElements.h                 | 635 ++++++++++++++++++
 src/storage/dft/DFTState.cpp                  | 125 ++++
 src/storage/dft/DFTState.h                    | 138 ++++
 .../dft/DFTStateSpaceGenerationQueues.h       |  78 +++
 src/storage/dft/OrderDFTElementsById.cpp      |  18 +
 src/storage/dft/OrderDFTElementsById.h        |  24 +
 src/storm-dyftee.cpp                          |  22 +
 src/utility/cli.h                             |  48 --
 src/utility/initialize.h                      |  68 ++
 src/utility/math.h                            |   8 +
 21 files changed, 1989 insertions(+), 48 deletions(-)
 create mode 100644 src/builder/ExplicitDFTModelBuilder.h
 create mode 100644 src/parser/DFTGalileoParser.cpp
 create mode 100644 src/parser/DFTGalileoParser.h
 create mode 100644 src/storage/dft/DFT.cpp
 create mode 100644 src/storage/dft/DFT.h
 create mode 100644 src/storage/dft/DFTBuilder.cpp
 create mode 100644 src/storage/dft/DFTBuilder.h
 create mode 100644 src/storage/dft/DFTElementState.h
 create mode 100644 src/storage/dft/DFTElements.cpp
 create mode 100644 src/storage/dft/DFTElements.h
 create mode 100644 src/storage/dft/DFTState.cpp
 create mode 100644 src/storage/dft/DFTState.h
 create mode 100644 src/storage/dft/DFTStateSpaceGenerationQueues.h
 create mode 100644 src/storage/dft/OrderDFTElementsById.cpp
 create mode 100644 src/storage/dft/OrderDFTElementsById.h
 create mode 100644 src/storm-dyftee.cpp
 create mode 100644 src/utility/initialize.h

diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
new file mode 100644
index 000000000..e8c169976
--- /dev/null
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -0,0 +1,93 @@
+#ifndef EXPLICITDFTMODELBUILDER_H
+#define	EXPLICITDFTMODELBUILDER_H
+
+#include "../storage/dft/DFT.h"
+
+namespace storm {
+    namespace builder {
+        class ExplicitDFTModelBuilder {
+            storm::storage::DFT const& mDft;
+            std::unordered_map<storm::storage::DFTState, size_t> mStateIndices;
+            size_t newIndex = 0;
+            //std::stack<std::shared_ptr<storm::storage::DFTState>> mStack;
+            
+        public:
+            ExplicitDFTModelBuilder(storm::storage::DFT const& dft) : mDft(dft)
+            {
+                
+            }
+            
+            
+            void exploreStateSuccessors(storm::storage::DFTState const& state) {
+                size_t smallest = 0; 
+                
+                while(smallest < state.nrFailableBEs()) {
+                    //std::cout << "exploring from :" << std::endl;
+                    //mDft.printElementsWithState(state);
+                    //std::cout << "***************" << std::endl;
+                    storm::storage::DFTState newState(state);
+                    std::pair<std::shared_ptr<storm::storage::DFTBE<double>>, bool> nextBE = newState.letNextBEFail(smallest++);
+                    if(nextBE.first == nullptr) {
+                        //std::cout << "break" << std::endl;
+                        break;
+                        
+                    }
+                    //std::cout << "with the failure of: " << nextBE.first->name() << std::endl;
+                        
+                    storm::storage::DFTStateSpaceGenerationQueues queues;
+                    for(std::shared_ptr<storm::storage::DFTGate> parent : nextBE.first->parents()) {
+                       if(newState.isOperational(parent->id())) {
+                            queues.propagateFailure(parent);
+                        }
+                    }
+
+
+
+                    while(!queues.failurePropagationDone()) {
+                        std::shared_ptr<storm::storage::DFTGate> next = queues.nextFailurePropagation();
+                        next->checkFails(newState, queues);
+                    }
+                    
+                    while(!queues.failsafePropagationDone()) {
+                        std::shared_ptr<storm::storage::DFTGate> next = queues.nextFailsafePropagation();
+                        next->checkFailsafe(newState, queues);
+                    }
+                    
+                    while(!queues.dontCarePropagationDone()) {
+                        std::shared_ptr<storm::storage::DFTElement> next = queues.nextDontCarePropagation();
+                        next->checkDontCareAnymore(newState, queues);
+                    }
+                    
+                    
+                    
+                    if(!mDft.hasFailed(newState) && !mDft.isFailsafe(newState)) {
+                        auto it = mStateIndices.find(newState);
+                        if(it == mStateIndices.end()) {
+                            exploreStateSuccessors(newState);
+                            mStateIndices.insert(std::make_pair(newState, newIndex++));
+                            if(newIndex % 16384 == 0) std::cout << newIndex << std::endl;
+                        } 
+                        
+                    }
+                    else {
+                        //std::cout << "done." << std::endl;
+                    }
+
+                    
+                
+                }
+            }
+            
+            void buildCtmc() {
+                storm::storage::DFTState state(mDft);
+                exploreStateSuccessors(state);
+                std::cout << mStateIndices.size() << std::endl;
+            }
+            
+        };
+    }
+}
+
+
+#endif	/* EXPLICITDFTMODELBUILDER_H */
+
diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
new file mode 100644
index 000000000..79e969260
--- /dev/null
+++ b/src/parser/DFTGalileoParser.cpp
@@ -0,0 +1,102 @@
+#include "DFTGalileoParser.h"
+
+#include <iostream>
+#include <fstream>
+#include <boost/algorithm/string.hpp>
+#include <boost/lexical_cast.hpp>
+#include "../exceptions/FileIoException.h"
+#include "../exceptions/NotSupportedException.h"
+#include "src/utility/macros.h"
+
+namespace storm {
+    namespace parser {
+        storm::storage::DFT DFTGalileoParser::parseDFT(const std::string& filename) {
+            if(readFile(filename)) {
+                return mBuilder.build();
+            } else {
+                throw storm::exceptions::FileIoException();
+            }
+        }
+        
+        std::string stripQuotsFromName(std::string const& name) {
+            size_t firstQuots = name.find("\"");
+            size_t secondQuots = name.find("\"", firstQuots+1);
+            
+            if(firstQuots == std::string::npos) {
+                return name;
+            } else {
+                return name.substr(firstQuots+1,secondQuots-1);
+            }
+        }
+        
+        bool DFTGalileoParser::readFile(const std::string& filename) {
+            // constants
+            std::string topleveltoken = "toplevel";
+            
+            
+            std::string toplevelId;
+           
+            
+            std::ifstream file;
+            file.exceptions ( std::ifstream::failbit );
+            try {
+                file.open(filename);
+            }
+            catch (std::ifstream::failure e) {
+                std::cerr << "Exception during file opening on " << filename << "." << std::endl;
+                return false;
+            }
+            file.exceptions( 0 );
+
+
+            std::string line;
+            while(std::getline(file, line))
+            {
+                std::cout << line << std::endl;
+                size_t commentstarts = line.find("//");
+                line = line.substr(0, commentstarts);
+                size_t firstsemicolon = line.find(";");
+                line = line.substr(0, firstsemicolon);
+
+                // Top level indicator.
+                if(boost::starts_with(line, topleveltoken)) {
+                    toplevelId = stripQuotsFromName(line.substr(topleveltoken.size()+1));
+                }
+                else
+                {
+                    std::vector<std::string> tokens;
+                    boost::split(tokens, line, boost::is_any_of(" "));
+                    std::string name(stripQuotsFromName(tokens[0]));
+
+                    std::vector<std::string> childNames;
+                    for(unsigned i = 2; i < tokens.size(); ++i) {
+                        childNames.push_back(stripQuotsFromName(tokens[i]));
+                    }
+                    if(tokens[1] == "and") {
+                        mBuilder.addAndElement(name, childNames);
+                    } else if(tokens[1] == "or") {
+                        mBuilder.addOrElement(name, childNames);
+                    } else if(boost::starts_with(tokens[1], "vot")) {
+                        mBuilder.addVotElement(name, boost::lexical_cast<unsigned>(tokens[1].substr(3)), childNames);
+                    } else if(tokens[1] == "pand") {
+                        mBuilder.addPandElement(name, childNames);
+                    } else if(tokens[1] == "wsp" || tokens[1] == "csp") {
+                        mBuilder.addSpareElement(name, childNames);
+                    } else if(boost::starts_with(tokens[1], "lambda=")) {
+                        mBuilder.addBasicElement(name, boost::lexical_cast<double>(tokens[1].substr(7)), boost::lexical_cast<double>(tokens[2].substr(5)));
+                    } else {
+                        STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Type name: " + tokens[1] + "  not recognized.");
+                    }
+                }
+
+            }
+            if(!mBuilder.setTopLevel(toplevelId)) {
+                STORM_LOG_THROW(false, storm::exceptions::FileIoException, "Top level id unknown.");
+            }
+            file.close();
+            return true;                        
+        }
+        
+        
+    }
+}
\ No newline at end of file
diff --git a/src/parser/DFTGalileoParser.h b/src/parser/DFTGalileoParser.h
new file mode 100644
index 000000000..3dc6f11eb
--- /dev/null
+++ b/src/parser/DFTGalileoParser.h
@@ -0,0 +1,29 @@
+#ifndef DFTGALILEOPARSER_H
+#define	DFTGALILEOPARSER_H
+
+#include "../storage/dft/DFT.h"
+#include "../storage/dft/DFTBuilder.h"
+
+#include <map>
+
+
+
+namespace storm {
+    namespace parser {
+        class DFTGalileoParser {
+            storm::storage::DFTBuilder mBuilder;
+        public:
+            storm::storage::DFT parseDFT(std::string const& filename);
+            
+        private:
+            bool readFile(std::string const& filename);
+            
+    
+    };
+}
+}
+
+
+
+#endif	/* DFTGALILEOPARSER_H */
+
diff --git a/src/storage/BitVector.cpp b/src/storage/BitVector.cpp
index 923916793..f74ac0312 100644
--- a/src/storage/BitVector.cpp
+++ b/src/storage/BitVector.cpp
@@ -9,6 +9,7 @@
 #include "src/utility/OsDetection.h"
 #include "src/utility/Hash.h"
 #include "src/utility/macros.h"
+#include "resources/3rdparty/glpk-4.53/src/zlib/zconf.h"
 
 namespace storm {
     namespace storage {
@@ -71,6 +72,7 @@ namespace storm {
             } else {
                 bucketVector = std::vector<uint64_t>(bucketCount, 0);
             }
+            
         }
         
         template<typename InputIterator>
@@ -440,6 +442,29 @@ namespace storm {
             }
         }
         
+        uint_fast64_t BitVector::getTwoBitsAligned(uint_fast64_t bitIndex) const {
+            // Check whether it is aligned.
+            assert(bitIndex % 64 != 63);
+            uint64_t bucket = bitIndex >> 6;
+            uint64_t bitIndexInBucket = bitIndex & mod64mask;
+            
+            uint64_t mask;
+            if (bitIndexInBucket == 0) {
+                mask = -1ull;
+            } else {
+                mask = (1ull << (64 - bitIndexInBucket)) - 1ull;
+            }
+            
+            if (bitIndexInBucket  < 62) { // bitIndexInBucket + 2 < 64
+                // If the value stops before the end of the bucket, we need to erase some lower bits.
+                mask &= ~((1ull << (62 - (bitIndexInBucket))) - 1ull);
+                return (bucketVector[bucket] & mask) >> (62 - bitIndexInBucket);
+            } else {
+                // In this case, it suffices to take the current mask.
+                return bucketVector[bucket] & mask;
+            }
+        }
+        
         void BitVector::setFromInt(uint_fast64_t bitIndex, uint_fast64_t numberOfBits, uint64_t value) {
             STORM_LOG_ASSERT((value >> numberOfBits) == 0, "Integer value too large to fit in the given number of bits.");
             
diff --git a/src/storage/BitVector.h b/src/storage/BitVector.h
index ec4cce693..4759d358c 100644
--- a/src/storage/BitVector.h
+++ b/src/storage/BitVector.h
@@ -358,6 +358,13 @@ namespace storm {
              */
             uint_fast64_t getAsInt(uint_fast64_t bitIndex, uint_fast64_t numberOfBits) const;
             
+            /*!
+             * 
+             * @param bitIndex The index of the first of the two bits to get
+             * @return A value between 0 and 3, encoded as a byte.
+             */
+            uint_fast64_t getTwoBitsAligned(uint_fast64_t bitIndex) const;
+            
             /*!
              * Sets the selected number of lowermost bits of the provided value at the given bit index.
              *
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
new file mode 100644
index 000000000..e06661988
--- /dev/null
+++ b/src/storage/dft/DFT.cpp
@@ -0,0 +1,121 @@
+#include "DFT.h"
+
+namespace storm {
+    namespace storage {
+        
+        DFT::DFT(std::vector<std::shared_ptr<DFTElement>> const& elements, std::shared_ptr<DFTElement> const& tle) : mElements(elements), mNrOfBEs(0), mNrOfSpares(0)
+        {
+            assert(elementIndicesCorrect());
+
+            size_t stateIndex = 0;
+            mUsageInfoBits = storm::utility::math::uint64_log2(mElements.size()-1)+1;
+
+            for(auto& elem : mElements) {
+                mIdToFailureIndex.push_back(stateIndex);
+                stateIndex += 2;
+                if(elem->isBasicElement()) {
+                    ++mNrOfBEs;
+                }
+                else if(elem->isSpareGate()) {
+                    ++mNrOfSpares;
+                    for(auto const& spareReprs : std::static_pointer_cast<DFTSpare>(elem)->children()) {
+                        if(mActivationIndex.count(spareReprs->id()) == 0) {
+                            mActivationIndex[spareReprs->id()] =  stateIndex++;
+                        }
+                        std::set<size_t> module = {spareReprs->id()};
+                        spareReprs->extendSpareModule(module);
+                        std::vector<size_t> sparesAndBes;
+                        for(auto const& modelem : module) {
+                            if(mElements[modelem]->isSpareGate() || mElements[modelem]->isBasicElement()) {
+                                sparesAndBes.push_back(modelem);
+                            }
+                        }
+                        mSpareModules.insert(std::make_pair(spareReprs->id(), sparesAndBes));
+
+                    }
+                    std::static_pointer_cast<DFTSpare>(elem)->setUseIndex(stateIndex);
+                    mUsageIndex.insert(std::make_pair(elem->id(), stateIndex));
+                    stateIndex += mUsageInfoBits;
+
+
+                }
+            }
+
+            // For the top module, we assume, contrary to [Jun15], that we have all spare gates and basic elements which are not in another module.
+            std::set<size_t> topModuleSet;
+            // Initialize with all ids.
+            for(auto const& elem : mElements) {
+                if (elem->isBasicElement() || elem->isSpareGate()) {
+                    topModuleSet.insert(elem->id());
+                }
+            }
+
+            for(auto const& module : mSpareModules) {
+                for(auto const& index : module.second) {
+                    topModuleSet.erase(index);
+                }
+            }
+            mTopModule = std::vector<size_t>(topModuleSet.begin(), topModuleSet.end());
+
+            mStateSize = stateIndex;
+            mTopLevelIndex = tle->id();
+
+        }
+        
+        void DFT::printElements(std::ostream& os) const {
+            for (auto const& elem : mElements) {
+                elem->print(os);
+                os << std::endl;
+            }
+        }
+
+        void DFT::printInfo(std::ostream& os) const {
+            os << "Top level index: " << mTopLevelIndex << std::endl << "Nr BEs" << mNrOfBEs << std::endl;
+        }
+
+        void DFT::printSpareModules(std::ostream& os) const {
+            std::cout << "[" << mElements[mTopLevelIndex] << "] {";
+            std::vector<size_t>::const_iterator it = mTopModule.begin();
+            assert(it != mTopModule.end());
+            os << mElements[(*it)]->name();
+            ++it;
+            while(it != mTopModule.end()) {
+                os <<  ", " << mElements[(*it)]->name();
+                ++it;
+            }
+            os << "}" << std::endl;
+
+            for(auto const& spareModule : mSpareModules) {
+                std::cout << "[" << mElements[spareModule.first]->name() << "] = {";
+                os.flush();
+                std::vector<size_t>::const_iterator it = spareModule.second.begin();
+                assert(it != spareModule.second.end());
+                os << mElements[(*it)]->name();
+                ++it;
+                while(it != spareModule.second.end()) {
+                    os <<  ", " << mElements[(*it)]->name();
+                    os.flush();
+                    ++it;
+                }
+                os << "}" << std::endl;
+            }
+        }
+
+        void DFT::printElementsWithState(DFTState const& state, std::ostream& os) const{
+            for (auto const& elem : mElements) {
+                os << "[" << elem->id() << "]";
+                elem->print(os);
+                os << "\t** " << state.getElementState(elem->id());
+                if(elem->isSpareGate()) {
+                    if(state.isActiveSpare(elem->id())) {
+                        os << " actively";
+                    }
+                    os << " using " << state.uses(elem->id());
+                } 
+                std::cout << std::endl;
+
+
+            }
+        }
+    }
+}
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
new file mode 100644
index 000000000..1f8939fd7
--- /dev/null
+++ b/src/storage/dft/DFT.h
@@ -0,0 +1,184 @@
+
+#ifndef DFT_H
+#define	DFT_H
+
+
+#include "DFTElements.h"
+#include "../BitVector.h"
+#include <memory>
+#include <unordered_map>
+#include <list>
+#include <map>
+
+#include "../../utility/math.h"
+#include <boost/iterator/counting_iterator.hpp>
+
+namespace storm {
+    namespace storage {
+
+                
+        struct DFTElementSort {
+            bool operator()(std::shared_ptr<DFTElement> const& a, std::shared_ptr<DFTElement> const& b)  const {
+                if (a->rank() == 0 && b->rank() == 0) {
+                    return a->isConstant();
+                } else {
+                    return a->rank() < b->rank();
+                }
+            }
+        };
+        
+        class DFT {
+
+            
+
+        private:
+            std::vector<std::shared_ptr<DFTElement>> mElements;
+            size_t mNrOfBEs;
+            size_t mNrOfSpares;
+            size_t mTopLevelIndex;
+            size_t mUsageInfoBits;
+            size_t mStateSize;
+            std::map<size_t, size_t> mActivationIndex;
+            std::map<size_t, std::vector<size_t>> mSpareModules;
+            std::vector<size_t> mTopModule;
+            std::vector<size_t> mIdToFailureIndex;
+            std::map<size_t, size_t> mUsageIndex;
+            
+            
+        public:
+            DFT(std::vector<std::shared_ptr<DFTElement>> const& elements, std::shared_ptr<DFTElement> const& tle);
+            
+            
+            size_t stateSize() const {
+                return mStateSize;
+            }
+            
+            size_t nrElements() const {
+                return mElements.size();
+            }
+            
+            size_t nrBasicElements() const {
+                return mNrOfBEs;
+            }
+            
+            size_t usageInfoBits() const {
+                return mUsageInfoBits;
+            }
+            
+            size_t usageIndex(size_t id) const {
+                assert(mUsageIndex.find(id) != mUsageIndex.end());
+                return mUsageIndex.find(id)->second;
+            }
+            
+            size_t failureIndex(size_t id) const {
+                return mIdToFailureIndex[id];
+            }
+            
+            void initializeUses(DFTState& state) const {
+                for(auto const& elem : mElements) {
+                    if(elem->isSpareGate()) {
+                        std::static_pointer_cast<DFTSpare>(elem)->initializeUses(state);
+                    }
+                }
+            }
+            
+            void initializeActivation(DFTState& state) const {
+                state.activate(mTopLevelIndex);
+                for(auto const& elem : mTopModule) {
+                    if(mElements[elem]->isSpareGate()) {
+                        propagateActivation(state, state.uses(elem));
+                    }
+                }
+            }
+            
+            std::vector<size_t> getSpareIndices() const {
+                std::vector<size_t> indices;
+                for(auto const& elem : mElements) {
+                    if(elem->isSpareGate()) {
+                        indices.push_back(elem->id());
+                    }
+                }
+                return indices;
+            }
+            
+            std::vector<size_t> const& module(size_t representativeId) const {
+                if(representativeId == mTopLevelIndex) {
+                    return mTopModule;
+                } else {
+                    assert(mSpareModules.count(representativeId)>0);
+                    return mSpareModules.find(representativeId)->second;
+                }
+            }
+            
+            
+            void propagateActivation(DFTState& state, size_t representativeId) const {
+                state.activate(representativeId);
+                for(size_t id : module(representativeId)) {
+                    if(mElements[id]->isSpareGate()) {
+                        propagateActivation(state, state.uses(id));
+                    }
+                }
+            }
+            
+            std::vector<size_t> nonColdBEs() const {
+                std::vector<size_t> result;
+                for(std::shared_ptr<DFTElement> elem : mElements) {
+                    if(elem->isBasicElement() && !elem->isColdBasicElement()) {
+                        result.push_back(elem->id());
+                    }
+                }
+                return result;
+            }
+            
+            std::shared_ptr<DFTElement> const& getElement(size_t index) const {
+                assert(index < nrElements());
+                return mElements[index];
+            }
+            
+            std::shared_ptr<DFTBE<double>> getBasicElement(size_t index) const {
+                assert(mElements[index]->isBasicElement());
+                return std::static_pointer_cast<DFTBE<double>>(mElements[index]);
+            }
+            
+            bool hasFailed(DFTState const& state) const {
+                return state.hasFailed(mTopLevelIndex);
+            }
+            
+            bool isFailsafe(DFTState const& state) const {
+                return state.isFailsafe(mTopLevelIndex);
+            }
+                    
+            
+            void printElements(std::ostream& os = std::cout) const;
+            
+            void printInfo(std::ostream& os = std::cout) const;
+            
+            void printSpareModules(std::ostream& os = std::cout) const;
+            
+            void printElementsWithState(DFTState const& state, std::ostream& os = std::cout) const; 
+            
+        private:
+            bool elementIndicesCorrect() const {
+                for(size_t i = 0; i < mElements.size(); ++i) {
+                    if(mElements[i]->id() != i) return false;
+                }
+                return true;
+            }
+
+
+
+
+        };
+        
+        
+        
+       
+
+        
+        
+        
+       
+    }
+}
+#endif	/* DFT_H */
+
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
new file mode 100644
index 000000000..f6364a523
--- /dev/null
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -0,0 +1,132 @@
+
+
+#include "DFTBuilder.h"
+
+#include "DFT.h"
+#include <algorithm>
+#include "OrderDFTElementsById.h"
+#include "../../exceptions/WrongFormatException.h"
+
+
+namespace storm {
+    namespace storage {
+        
+         
+        DFT DFTBuilder::build() {
+            for(auto& elem : mChildNames) {
+                for(auto const& child : elem.second) {
+                    std::shared_ptr<DFTGate> gate = std::static_pointer_cast<DFTGate>(elem.first);
+                    gate->pushBackChild(mElements[child]);
+                    mElements[child]->addParent(gate);
+                }
+            }
+
+            // Sort elements topologically
+
+
+
+            // compute rank
+            for (auto& elem : mElements) {
+                computeRank(elem.second);
+            }
+
+            std::vector<std::shared_ptr<DFTElement>> elems = topoSort();
+            size_t id = 0;
+            for(std::shared_ptr<DFTElement> e : elems) {
+                e->setId(id++);
+            }
+            for(auto& e : elems) {
+                std::cout << "[" << e->id() << "] ";
+                e->print();
+                std::cout << std::endl;
+            }
+            return DFT(elems, mElements[topLevelIdentifier]);
+
+        }
+        
+        unsigned DFTBuilder::computeRank(std::shared_ptr<DFTElement> const& elem) {
+            if(elem->rank() == -1) {
+                if(elem->nrChildren() == 0) {
+                    elem->setRank(0);
+                    return 0;
+                }
+                std::shared_ptr<DFTGate> gate = std::static_pointer_cast<DFTGate>(elem);
+                unsigned maxrnk = 0;
+                unsigned newrnk = 0;
+
+                for(std::shared_ptr<DFTElement> const& child : gate->children()) {
+                    newrnk = computeRank(child);
+                    if(newrnk > maxrnk) {
+                        maxrnk = newrnk;
+                    }
+                }
+                elem->setRank(maxrnk+1);
+                return maxrnk + 1;
+            } else {
+                return elem->rank();
+            }
+        }
+        
+        bool DFTBuilder::addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementTypes tp) {
+            assert(children.size() > 0);
+            if(mElements.count(name) != 0) {
+                // Element with that name already exists.
+                return false;
+            }
+            std::shared_ptr<DFTElement> element;
+            switch(tp) {
+                case DFTElementTypes::AND:
+                    element = std::make_shared<DFTAnd>(mNextId++, name);
+                    break;
+                case DFTElementTypes::OR:
+                    element = std::make_shared<DFTOr>(mNextId++, name);
+                    break;
+                case DFTElementTypes::PAND:
+                    element = std::make_shared<DFTPand>(mNextId++, name);
+                    break;
+                case DFTElementTypes::POR:
+                    element = std::make_shared<DFTPor>(mNextId++, name);
+                    break;
+                case DFTElementTypes::SPARE:
+                   element = std::make_shared<DFTSpare>(mNextId++, name);
+                   break;
+            }
+            mElements[name] = element;
+            mChildNames[element] = children;
+            return true;
+        }
+        
+        
+        void DFTBuilder::topoVisit(std::shared_ptr<DFTElement> const& n, std::map<std::shared_ptr<DFTElement>, topoSortColour>& visited, std::vector<std::shared_ptr<DFTElement>>& L) {
+            if(visited[n] == topoSortColour::GREY) {
+                throw storm::exceptions::WrongFormatException("DFT is cyclic");
+            } else if(visited[n] == topoSortColour::WHITE) {
+                if(n->isGate()) {
+                    visited[n] = topoSortColour::GREY;
+                    for(std::shared_ptr<DFTElement> const& c : std::static_pointer_cast<DFTGate>(n)->children()) {
+                        topoVisit(c, visited, L);
+                    }
+                }
+                visited[n] = topoSortColour::BLACK;
+                L.push_back(n);
+               
+            }
+        }
+
+        std::vector<std::shared_ptr<DFTElement>> DFTBuilder::topoSort() {
+            std::map<std::shared_ptr<DFTElement>, topoSortColour> visited;
+            for(auto const& e : mElements) {
+                visited.insert(std::make_pair(e.second, topoSortColour::WHITE)); 
+            }
+
+            std::vector<std::shared_ptr<DFTElement>> L;
+            for(auto const& e : visited) {
+                topoVisit(e.first, visited, L);
+            }
+            //std::reverse(L.begin(), L.end()); 
+            return L;
+       }
+
+    }
+}
+            
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
new file mode 100644
index 000000000..e29a8aa02
--- /dev/null
+++ b/src/storage/dft/DFTBuilder.h
@@ -0,0 +1,116 @@
+
+#ifndef DFTBUILDER_H
+#define	DFTBUILDER_H
+
+#include "DFTElements.h"
+#include <iostream>
+#include <unordered_map>
+#include <map>
+
+namespace storm {
+    namespace storage {
+        class DFT;
+        
+        class DFTBuilder {
+            
+            std::size_t mNextId = 0;
+            std::string topLevelIdentifier;
+            std::unordered_map<std::string, std::shared_ptr<DFTElement>> mElements;
+            std::unordered_map<std::shared_ptr<DFTElement>, std::vector<std::string>> mChildNames;
+            
+        public:
+            DFTBuilder() {
+                
+            }
+            
+            bool addAndElement(std::string const& name, std::vector<std::string> const& children) {
+                return addStandardGate(name, children, DFTElementTypes::AND);
+            }
+            
+            bool addOrElement(std::string const& name, std::vector<std::string> const& children) {
+                return addStandardGate(name, children, DFTElementTypes::OR);
+            }
+            
+            bool addPandElement(std::string const& name, std::vector<std::string> const& children) {
+                return addStandardGate(name, children, DFTElementTypes::PAND);
+            }
+            
+            bool addPorElement(std::string const& name, std::vector<std::string> const& children) {
+                return addStandardGate(name, children, DFTElementTypes::POR);
+            }
+            
+            bool addSpareElement(std::string const& name, std::vector<std::string> const& children) {
+                return addStandardGate(name, children, DFTElementTypes::SPARE);
+            }
+            
+            
+            
+            bool addVotElement(std::string const& name, unsigned threshold, std::vector<std::string> const& children) {
+                assert(children.size() > 0);
+                if(mElements.count(name) != 0) {
+                    std::cerr << "Element with name: " << name << " already exists." << std::endl;
+                    return false;
+                }
+                // It is an and-gate
+                if(children.size() == threshold) {
+                    return addAndElement(name, children);
+                }
+                // It is an or-gate
+                if(threshold == 1) {
+                    return addOrElement(name, children);
+                }
+                
+                if(threshold > children.size()) {
+                    std::cerr << "Voting gates with threshold higher than the number of children is not supported." << std::endl;
+                    return false;
+                }
+                std::shared_ptr<DFTElement> element = std::make_shared<DFTVot>(mNextId++, name, threshold);
+                
+                mElements[name] = element;
+                mChildNames[element] = children;
+                return true;
+            }
+            
+            bool addBasicElement(std::string const& name, double failureRate, double dormancyFactor) {
+                if(failureRate <= 0.0) {
+                    std::cerr << "Failure rate must be positive." << std::endl;
+                    return false;
+                }
+                
+                if(dormancyFactor < 0.0 || dormancyFactor > 1.0) {
+                    std::cerr << "Dormancy factor must be between 0 and 1." << std::endl;
+                    return false;
+                }
+                
+                mElements[name] = std::make_shared<DFTBE<double>>(mNextId++, name, failureRate, dormancyFactor);
+                return true;
+            }
+            
+            bool setTopLevel(std::string const& tle) {
+                topLevelIdentifier = tle;
+                return mElements.count(tle) > 0;
+            }
+            
+            DFT build();
+
+         
+        private:
+            
+            unsigned computeRank(std::shared_ptr<DFTElement> const& elem);
+            
+            bool addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementTypes tp);
+            
+            enum class topoSortColour {WHITE, BLACK, GREY}; 
+            
+            void topoVisit(std::shared_ptr<DFTElement> const& n, std::map<std::shared_ptr<DFTElement>, topoSortColour>& visited, std::vector<std::shared_ptr<DFTElement>>& L);
+            std::vector<std::shared_ptr<DFTElement>> topoSort();
+
+            
+        };
+    }
+}
+
+
+
+#endif	/* DFTBUILDER_H */
+
diff --git a/src/storage/dft/DFTElementState.h b/src/storage/dft/DFTElementState.h
new file mode 100644
index 000000000..1926745bf
--- /dev/null
+++ b/src/storage/dft/DFTElementState.h
@@ -0,0 +1,26 @@
+
+#ifndef DFTELEMENTSTATE_H
+#define	DFTELEMENTSTATE_H
+
+namespace storm {
+    namespace storage {
+        enum class DFTElementState  {Operational = 0, Failed = 2, Failsafe = 1, DontCare = 3};
+        
+        inline std::ostream& operator<<(std::ostream& os, DFTElementState st) {
+            switch(st) {
+                case DFTElementState::Operational:
+                    return os << "Operational";
+                case DFTElementState::Failed:
+                    return os << "Failed";
+                case DFTElementState::Failsafe:
+                    return os << "Failsafe";
+                case DFTElementState::DontCare:
+                    return os << "Don't Care";
+            }
+        }
+    }
+}
+
+
+#endif	/* DFTELEMENTSTATE_H */
+
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
new file mode 100644
index 000000000..b96ceafb4
--- /dev/null
+++ b/src/storage/dft/DFTElements.cpp
@@ -0,0 +1,38 @@
+#include "DFTElements.h"
+
+namespace storm {
+    namespace storage {
+        bool DFTElement::checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+            if(!state.dontCare(mId))
+            {
+                for(std::shared_ptr<DFTGate> const& parent : mParents) {
+                    if(state.isOperational(parent->id())) {
+                        return false;
+                    }
+                }
+                state.setDontCare(mId);
+                return true;
+
+            }
+            return false;
+        }
+        
+        void DFTElement::extendSpareModule(std::set<size_t>& elementsInModule) const {
+            for(auto const& parent : mParents) {
+                if(elementsInModule.count(parent->id()) == 0 && !parent->isSpareGate()) {
+                    elementsInModule.insert(parent->id());
+                    parent->extendSpareModule(elementsInModule);
+                }
+            }
+        }
+        
+        template<>
+        bool DFTBE<double>::checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+            if(DFTElement::checkDontCareAnymore(state, queues)) {
+                state.beNoLongerFailable(mId);
+                return true;
+            }
+            return false;
+        }
+    }
+}
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
new file mode 100644
index 000000000..9d3338022
--- /dev/null
+++ b/src/storage/dft/DFTElements.h
@@ -0,0 +1,635 @@
+#ifndef DFTELEMENTS_H
+#define	DFTELEMENTS_H
+
+#include <set>
+#include <vector>
+#include <memory>
+#include <string>
+#include <cassert>
+#include <cstdlib>
+#include <iostream>
+
+#include "DFTState.h"
+#include "DFTStateSpaceGenerationQueues.h"
+
+using std::size_t;
+
+namespace storm {
+    namespace storage {
+        class DFTGate;
+        
+        class DFTElement {
+        protected:
+            size_t mId;
+            std::string mName;
+            size_t mRank = -1;
+            std::vector<std::shared_ptr<DFTGate>> mParents;
+            
+
+            
+
+        public:
+            DFTElement(size_t id, std::string const& name) : mId(id), mName(name)
+            {}
+            virtual ~DFTElement() {}
+
+            
+            virtual size_t id() const {
+                return mId;
+            }
+            
+            virtual void setRank(size_t rank) {
+                mRank = rank;
+            }
+            
+            virtual size_t rank() const {
+                return mRank;
+            }
+            
+            virtual bool isConstant() const {
+                return false;
+            }
+            
+            virtual bool isGate() const {
+                return false;
+            }
+            
+            virtual bool isBasicElement() const {
+                return false;
+            }
+            
+            virtual bool isColdBasicElement() const {
+                return false;
+            }
+            
+            virtual bool isSpareGate() const {
+                return false;
+            }
+            
+            virtual void setId(size_t newId) {
+                mId = newId;
+            }
+            
+            virtual std::string const& name() const {
+                return mName;
+            }
+            
+            bool addParent(std::shared_ptr<DFTGate> const& e) {
+                if(std::find(mParents.begin(), mParents.end(), e) != mParents.end()) {
+                    return false;
+                }
+                else 
+                {
+                    mParents.push_back(e);
+                    return true;
+                }
+            }
+
+            bool hasParents() const {
+                return !mParents.empty();
+            }
+            
+            std::vector<std::shared_ptr<DFTGate>> const& parents() const {
+                return mParents;
+            }
+            
+            virtual void extendSpareModule(std::set<size_t>& elementsInModule) const;
+            
+            virtual size_t nrChildren() const = 0;
+            virtual void print(std::ostream& = std::cout) const = 0;
+            
+            virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const;
+        };
+
+
+        enum class DFTElementTypes {AND, COUNTING, OR, VOT, BE, CONSTF, CONSTS, PAND, SPARE, POR, FDEP, SEQAND};
+
+        inline bool isGateType(DFTElementTypes const& tp) {
+            switch(tp) {
+                case DFTElementTypes::AND:
+                case DFTElementTypes::COUNTING:
+                case DFTElementTypes::OR:
+                case DFTElementTypes::VOT:
+                case DFTElementTypes::PAND:
+                case DFTElementTypes::SPARE:
+                case DFTElementTypes::POR:
+                case DFTElementTypes::SEQAND:
+                    return true;
+                case DFTElementTypes::BE:
+                case DFTElementTypes::CONSTF:
+                case DFTElementTypes::CONSTS:
+                case DFTElementTypes::FDEP:
+                    return false;
+                default:
+                    assert(false);
+            }
+        }
+        
+        class DFTGate : public DFTElement {
+        protected:
+            std::vector<std::shared_ptr<DFTElement>> mChildren;
+        public:
+            DFTGate(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children) :
+            DFTElement(id, name), mChildren(children)
+            {}
+            
+            virtual ~DFTGate() {}
+            
+            void pushBackChild(std::shared_ptr<DFTElement> elem) {
+                return mChildren.push_back(elem);
+            }
+
+            size_t nrChildren() const {
+                return mChildren.size();
+            }
+            
+            std::vector<std::shared_ptr<DFTElement>> const& children() const {
+                return mChildren;
+            }
+            
+            virtual bool isGate() const {
+                return true;
+            }
+            
+            
+            virtual std::string typestring() const = 0;
+            virtual void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const = 0;
+            virtual void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const = 0;
+            
+            virtual void extendSpareModule(std::set<size_t>& elementsInSpareModule) const override {
+                DFTElement::extendSpareModule(elementsInSpareModule);
+                for(auto const& child : mChildren) {
+                    if(elementsInSpareModule.count(child->id()) == 0) {
+                        elementsInSpareModule.insert(child->id());
+                        child->extendSpareModule(elementsInSpareModule);
+                    }
+                }
+            }
+            
+            virtual void print(std::ostream& os = std::cout) const {
+                os << "{" << name() << "} " << typestring() << "( ";
+                std::vector<std::shared_ptr<DFTElement>>::const_iterator it = mChildren.begin();
+                os << (*it)->name();
+                ++it;
+                while(it != mChildren.end()) {
+                    os <<  ", " << (*it)->name();
+                    ++it;
+                }
+                os << ")";
+            }    
+            
+            virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+                if(DFTElement::checkDontCareAnymore(state, queues)) {
+                    childrenDontCare(state, queues);
+                    return true;
+                }
+                return false;
+            }
+        protected:
+            void fail(DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+                for(std::shared_ptr<DFTGate> parent : mParents) {
+                    if(state.isOperational(parent->id())) {
+                        queues.propagateFailure(parent);
+                    }
+                }
+                state.setFailed(mId);        
+            }
+            
+            void failsafe(DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+                for(std::shared_ptr<DFTGate> parent : mParents) {
+                    if(state.isOperational(parent->id())) {
+                        queues.propagateFailsafe(parent);
+                    }
+                }
+                state.setFailsafe(mId);
+            }
+            
+            void childrenDontCare(DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+                queues.propagateDontCare(mChildren);
+            }
+            
+            bool hasFailsafeChild(DFTState& state) const {
+                for(auto const& child : mChildren) {
+                    if(state.isFailsafe(child->id()))
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            
+            
+            bool hasFailedChild(DFTState& state) const {
+                for(auto const& child : mChildren) {
+                    if(state.hasFailed(child->id())) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+        };
+        
+       
+
+        template<typename FailureRateType>
+        class DFTBE : public DFTElement {
+
+            
+            FailureRateType mActiveFailureRate;
+            FailureRateType mPassiveFailureRate;
+        public:
+            DFTBE(size_t id, std::string const& name, FailureRateType failureRate, FailureRateType dormancyFactor) :
+            DFTElement(id, name), mActiveFailureRate(failureRate), mPassiveFailureRate(dormancyFactor * failureRate)
+            {
+                
+            }
+                        
+            virtual size_t nrChildren() const {
+                return 0;
+            }
+            
+            FailureRateType const& activeFailureRate() const {
+                return mActiveFailureRate;
+            }
+            
+            FailureRateType const& passiveFailureRate() const {
+                return mPassiveFailureRate;
+            }
+        
+            void print(std::ostream& os = std::cout) const {
+                os << *this;
+            }
+            
+            bool isBasicElement() const {
+                return true;
+            }
+            
+            bool isColdBasicElement() const {
+                return mPassiveFailureRate == 0;
+            }
+            
+
+            virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const;
+        };
+        
+        inline std::ostream& operator<<(std::ostream& os, DFTBE<double> const& be) {
+            return os << "{" << be.name() << "} BE(" << be.activeFailureRate() << ", " << be.passiveFailureRate() << ")";
+        }
+
+        
+        
+
+        class DFTConst : public DFTElement {
+            bool mFailed;
+        public:
+            DFTConst(size_t id, std::string const& name, bool failed) : DFTElement(id, name), mFailed(failed) 
+            {
+                
+            }
+            
+            bool failed() const {
+                return mFailed;
+            }
+            
+            virtual bool isConstant() const {
+                return true;
+            }
+            
+            virtual size_t nrChildren() const {
+                return 0;
+            }
+            
+        };
+
+        class DFTAnd : public DFTGate {
+            
+        public:
+            DFTAnd(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
+            DFTGate(id, name, children) 
+            {}
+            
+            void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+                
+                if(state.isOperational(mId)) {
+                    for(auto const& child : mChildren)
+                    {
+                        if(!state.hasFailed(child->id())) {
+                            return;// false;
+                        }
+                    }
+                    fail(state, queues);
+                    //return true;
+                } 
+                //return false;
+            }
+            
+            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const{
+                assert(hasFailsafeChild(state));
+                if(state.isOperational(mId)) {
+                    failsafe(state, queues);
+                    childrenDontCare(state, queues);
+                    //return true;
+                }
+                //return false;
+            }
+            
+            std::string typestring() const {
+                return "AND";
+            }
+        };
+        
+        inline std::ostream& operator<<(std::ostream& os, DFTAnd const& gate) {
+            gate.print(os);
+            return os;
+        }
+       
+        
+
+        class DFTOr : public DFTGate {
+        public:
+            DFTOr(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
+            DFTGate(id, name, children) 
+            {}
+            
+             void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+                 assert(hasFailedChild(state));
+                if(state.isOperational(mId)) {
+                    fail(state, queues);
+                    //return true;
+                } 
+                // return false;
+            }
+             
+            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const{
+                 for(auto const& child : mChildren) {
+                     if(!state.isFailsafe(child->id())) {
+                         return;// false;
+                     }
+                 }
+                 failsafe(state, queues);
+                 //return true;
+            }
+            
+            std::string typestring() const {
+                return "OR";
+            }
+        private:
+            //static const std::string typestring = "or";
+        };
+        
+         inline std::ostream& operator<<(std::ostream& os, DFTOr const& gate) {
+            gate.print(os);
+            return os;
+        }
+
+        class DFTSeqAnd : public DFTGate {
+        public:
+            DFTSeqAnd(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
+            DFTGate(id, name, children) 
+            {}
+            
+            void checkFails(storm::storage::DFTState& state,  DFTStateSpaceGenerationQueues& queues) const {
+                
+                if(!state.hasFailed(mId)) {
+                    bool childOperationalBefore = false;
+                    for(auto const& child : mChildren)
+                    {
+                        if(!state.hasFailed(child->id())) {
+                            childOperationalBefore = true;
+                        }
+                        else {
+                            if(childOperationalBefore) {
+                                state.markAsInvalid();
+                                return; //false;
+                            }
+                        }
+                    }
+                    if(!childOperationalBefore) {
+                       fail(state, queues);
+                       //return true;
+                    }
+                  
+                } 
+                //return false;
+            }
+            
+            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const{
+                assert(hasFailsafeChild(state));
+                if(state.isOperational(mId)) {
+                    failsafe(state, queues);
+                    //return true;
+                }
+                //return false;
+            }
+            
+            std::string  typestring() const {
+                return "SEQAND";
+            }
+        private:
+            //static const std::string typestring = "seqand"; 
+        };
+        
+         inline std::ostream& operator<<(std::ostream& os, DFTSeqAnd const& gate) {
+            gate.print(os);
+            return os;
+        }
+        
+        class DFTPand : public DFTGate {
+        public:
+            DFTPand(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
+            DFTGate(id, name, children) 
+            {}
+            
+            void checkFails(storm::storage::DFTState& state,  DFTStateSpaceGenerationQueues& queues) const {
+                if(state.isOperational(mId)) {
+                    bool childOperationalBefore = false;
+                    for(auto const& child : mChildren)
+                    {
+                        if(!state.hasFailed(child->id())) {
+                            childOperationalBefore = true;
+                        } else if(childOperationalBefore && state.hasFailed(child->id())){
+                            failsafe(state, queues);
+                            childrenDontCare(state, queues);
+                            return; //false;
+                        }
+                    }
+                    if(!childOperationalBefore) {
+                        fail(state, queues);
+                        //return true;
+                    }
+                }
+                // return false;
+            }
+             
+            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const{
+                assert(hasFailsafeChild(state));
+                if(state.isOperational(mId)) {
+                    failsafe(state, queues);
+                    childrenDontCare(state, queues);
+                    //return true;
+                }
+                //return false;
+            } 
+            
+            std::string typestring() const {
+                return "PAND";
+            }
+        };
+        
+         inline std::ostream& operator<<(std::ostream& os, DFTPand const& gate) {
+            gate.print(os);
+            return os;
+        }
+        
+        class DFTPor : public DFTGate {
+        public:
+            DFTPor(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
+            DFTGate(id, name, children) 
+            {}
+            
+            void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+                 assert(false);
+            }
+             
+            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const{
+                assert(false);
+            }
+            
+            std::string  typestring() const {
+                return "POR";
+            }
+        };
+        
+         inline std::ostream& operator<<(std::ostream& os, DFTPor const& gate) {
+            gate.print(os);
+            return os;
+        }
+
+        class DFTVot : public DFTGate {
+        private:
+            unsigned mThreshold;
+        public:
+            DFTVot(size_t id, std::string const& name, unsigned threshold, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
+            DFTGate(id, name, children), mThreshold(threshold)
+            {}
+            
+            void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+                
+                if(state.isOperational(mId)) {
+                    unsigned nrFailedChildren = 0;
+                    for(auto const& child : mChildren)
+                    {
+                        if(state.hasFailed(child->id())) {
+                            ++nrFailedChildren;
+                            if(nrFailedChildren >= mThreshold) 
+                            {
+                                fail(state, queues);
+                                return;// true;
+                            }
+                        }
+                    }
+                  
+                } 
+                //    return false;
+               
+            }
+            
+            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const{
+                assert(hasFailsafeChild(state));
+                if(state.isOperational(mId)) {
+                    unsigned nrFailsafeChildren = 0;
+                    for(auto const& child : mChildren)
+                    {
+                        if(state.isFailsafe(child->id())) {
+                            ++nrFailsafeChildren;
+                            if(nrFailsafeChildren > nrChildren() - mThreshold) 
+                            {
+                                failsafe(state, queues);
+                                childrenDontCare(state, queues);
+                                return;// true;
+                            }
+                        }
+                    }
+                }
+                //return false;
+            }
+            
+            std::string typestring() const {
+                return "VOT (" + std::to_string(mThreshold) + ")";
+            }
+
+        };
+
+        inline std::ostream& operator<<(std::ostream& os, DFTVot const& gate) {
+            gate.print(os);
+            return os;
+        }        
+        
+        class DFTSpare : public DFTGate {
+            size_t mUseIndex;
+            size_t mActiveIndex;
+            
+        public:
+            DFTSpare(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
+            DFTGate(id, name, children)
+            {
+                
+            }
+            
+            
+            std::string typestring() const {
+                return "SPARE";
+            }
+            
+            bool isSpareGate() const {
+                return true;
+            }
+            
+            void setUseIndex(size_t useIndex) {
+                mUseIndex = useIndex; 
+            }
+            
+            void setActiveIndex(size_t activeIndex) {
+                mActiveIndex = activeIndex;
+            }
+            
+            void initializeUses(storm::storage::DFTState& state) {
+                assert(mChildren.size() > 0);
+                state.setUsesAtPosition(mUseIndex, mChildren[0]->id());
+            }
+            
+            void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+                if(state.isOperational(mId)) {
+                    size_t uses = state.extractUses(mUseIndex);
+                    if(!state.isOperational(uses)) {
+                        // TODO compute children ids before.
+                        std::vector<size_t> childrenIds;
+                        for(auto const& child : mChildren) {
+                            childrenIds.push_back(child->id());
+                        }
+                        
+                        bool claimingSuccessful = state.claimNew(mId, mUseIndex, uses, childrenIds);
+                        if(!claimingSuccessful) {
+                            fail(state, queues);
+                        }
+                    }                  
+                } 
+            }
+            
+            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+                if(state.isOperational(mId)) {
+                    if(state.isFailsafe(state.extractUses((mUseIndex)))) {
+                        failsafe(state, queues);
+                        childrenDontCare(state, queues);
+                    }
+                }
+            }
+        };
+    }
+}
+
+
+
+#endif	/* DFTELEMENTS_H */
+
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
new file mode 100644
index 000000000..5536b05a6
--- /dev/null
+++ b/src/storage/dft/DFTState.cpp
@@ -0,0 +1,125 @@
+#include "DFTState.h"
+#include "DFTElements.h"
+#include "DFT.h"
+
+namespace storm {
+    namespace storage {
+        
+        DFTState::DFTState(DFT const& dft) : mStatus(dft.stateSize()), mDft(dft)  {
+            mInactiveSpares = dft.getSpareIndices();
+            dft.initializeUses(*this);
+            dft.initializeActivation(*this);
+            std::vector<size_t> alwaysActiveBEs = dft.nonColdBEs();
+            mIsCurrentlyFailableBE.insert(mIsCurrentlyFailableBE.end(), alwaysActiveBEs.begin(), alwaysActiveBEs.end());
+            
+        }
+        
+        DFTElementState DFTState::getElementState(size_t id) const {
+            return static_cast<DFTElementState>(mStatus.getAsInt(mDft.failureIndex(id), 2));
+        }
+
+        bool DFTState::isOperational(size_t id) const {
+            return getElementState(id) == DFTElementState::Operational;
+        }
+
+        bool DFTState::hasFailed(size_t id) const {
+            return mStatus[mDft.failureIndex(id)];
+        }
+
+        bool DFTState::isFailsafe(size_t id) const {
+            return mStatus[mDft.failureIndex(id)+1];
+        }
+
+        bool DFTState::dontCare(size_t id) const {
+            return getElementState(id) == DFTElementState::DontCare;
+        }
+
+        void DFTState::setFailed(size_t id) {
+            mStatus.set(mDft.failureIndex(id));
+        }
+
+        void DFTState::setFailsafe(size_t id) {
+            mStatus.set(mDft.failureIndex(id)+1);
+        }
+
+        void DFTState::setDontCare(size_t id) {
+            mStatus.setFromInt(mDft.failureIndex(id), 2, static_cast<uint_fast64_t>(DFTElementState::DontCare) );
+        }
+        
+        void DFTState::beNoLongerFailable(size_t id) {
+            auto it = std::find(mIsCurrentlyFailableBE.begin(), mIsCurrentlyFailableBE.end(), id);
+            if(it != mIsCurrentlyFailableBE.end()) {
+                mIsCurrentlyFailableBE.erase(it);
+            }
+        }
+
+        
+        std::pair<std::shared_ptr<DFTBE<double>>, bool> DFTState::letNextBEFail(size_t index) 
+        {
+            assert(index < mIsCurrentlyFailableBE.size());
+            //std::cout << "currently failable: ";
+            //printCurrentlyFailable(std::cout);
+            std::pair<std::shared_ptr<DFTBE<double>>,bool> res(mDft.getBasicElement(mIsCurrentlyFailableBE[index]), false);
+            mIsCurrentlyFailableBE.erase(mIsCurrentlyFailableBE.begin() + index);
+            setFailed(res.first->id());
+            return res;
+        }
+        
+        void DFTState::activate(size_t repr) {
+            std::vector<size_t>  const& module = mDft.module(repr);
+            for(size_t elem : module) {
+                if(mDft.getElement(elem)->isColdBasicElement() && isOperational(elem)) {
+                    mIsCurrentlyFailableBE.push_back(elem);
+                }
+                else if(mDft.getElement(elem)->isSpareGate()) {
+                    assert(std::find(mInactiveSpares.begin(), mInactiveSpares.end(), elem) != mInactiveSpares.end());
+                    mInactiveSpares.erase(std::find(mInactiveSpares.begin(), mInactiveSpares.end(), elem));
+                }
+            }
+        }
+        
+        
+        bool DFTState::isActiveSpare(size_t id) const {
+            assert(mDft.getElement(id)->isSpareGate());
+            return (std::find(mInactiveSpares.begin(), mInactiveSpares.end(), id) == mInactiveSpares.end());
+        }
+        
+        uint_fast64_t DFTState::uses(size_t id) const {
+            return extractUses(mDft.usageIndex(id));
+        }
+        
+        uint_fast64_t DFTState::extractUses(size_t from) const {
+            assert(mDft.usageInfoBits() < 64);
+            return mStatus.getAsInt(from, mDft.usageInfoBits());
+        }
+        
+        bool DFTState::isUsed(size_t child) {
+            return (std::find(mUsedRepresentants.begin(), mUsedRepresentants.end(), child) != mUsedRepresentants.end());
+            
+        }
+        
+        
+        
+        void DFTState::setUsesAtPosition(size_t usageIndex, size_t child) {
+            mStatus.setFromInt(usageIndex, mDft.usageInfoBits(), child);
+            mUsedRepresentants.push_back(child);
+        }
+        
+        bool DFTState::claimNew(size_t spareId, size_t usageIndex, size_t currentlyUses, std::vector<size_t> const& childIds) {
+            auto it = find(childIds.begin(), childIds.end(), currentlyUses);
+            assert(it != childIds.end());
+            ++it;
+            while(it != childIds.end()) {
+                if(!hasFailed(*it) && !isUsed(*it)) {
+                    setUsesAtPosition(usageIndex, *it);
+                    if(isActiveSpare(spareId)) {
+                        mDft.propagateActivation(*this,*it);
+                    }
+                    return true;
+                }
+                ++it;
+            }
+            return false;
+        }
+    }
+}
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
new file mode 100644
index 000000000..719d49e37
--- /dev/null
+++ b/src/storage/dft/DFTState.h
@@ -0,0 +1,138 @@
+#ifndef DFTSTATE_H
+#define	DFTSTATE_H
+
+#include "../BitVector.h"
+#include "DFTElementState.h"
+
+
+namespace storm {
+    namespace storage {
+       
+        class DFT; 
+        template<typename T>
+        class DFTBE;
+        
+        
+        
+        class DFTState {
+            friend struct std::hash<DFTState>;
+        private:
+            storm::storage::BitVector mStatus;
+            std::vector<size_t> mInactiveSpares;
+            std::vector<size_t> mIsCurrentlyFailableBE;
+            std::vector<size_t> mUsedRepresentants;
+            bool mValid = true;
+            const DFT& mDft;
+            
+        public:
+            DFTState(DFT const& dft);
+            
+            DFTElementState getElementState(size_t id) const;
+            
+            bool isOperational(size_t id) const;
+            
+            bool hasFailed(size_t id) const;
+            
+            bool isFailsafe(size_t id) const ;
+            
+            bool dontCare(size_t id) const;
+            
+            void setFailed(size_t id);
+            
+            void setFailsafe(size_t id);
+            
+            void setDontCare(size_t id);
+            
+            void beNoLongerFailable(size_t id);
+            
+            void activate(size_t repr);
+            
+            bool isActiveSpare(size_t id) const;
+            
+            void markAsInvalid() {
+                mValid = false;
+            }
+           
+            bool isInvalid() {
+                return !mValid;
+            }
+            
+            storm::storage::BitVector const& status() const {
+                return mStatus;
+            }
+           
+            /**
+             * This method gets the usage information for a spare
+             * @param id Id of the spare
+             * @return The child that currently is used.
+             */
+            uint_fast64_t uses(size_t id) const;
+            
+            /**
+             * This method is commonly used to get the usage information for spares. 
+             * @param from Starting index where the usage info is.
+             * @return The child that currently is used.
+             */
+            uint_fast64_t extractUses(size_t from) const;
+            
+            /**
+             * Checks whether an element is currently used.
+             * @param child The id of the child for which we want to know whether it is currently used.
+             * @return true iff it is currently used by any of the spares.
+             */
+            bool isUsed(size_t child);
+            
+            /**
+             * Sets to to the usageIndex which child is now used.
+             * @param usageIndex 
+             * @param child
+             */
+            void setUsesAtPosition(size_t usageIndex, size_t child);
+            
+            
+            
+            bool claimNew(size_t spareId, size_t usageIndex, size_t currentlyUses, std::vector<size_t> const& childIds);
+            
+            bool hasOutgoingEdges() const {
+                return !mIsCurrentlyFailableBE.empty();
+            }
+            
+            size_t nrFailableBEs() const {
+                return mIsCurrentlyFailableBE.size();
+            }
+            
+            std::pair<std::shared_ptr<DFTBE<double>>, bool> letNextBEFail(size_t smallestIndex = 0);
+            
+            void printCurrentlyFailable(std::ostream& os) {
+                auto it = mIsCurrentlyFailableBE.begin();
+                os << "{";
+                if(it != mIsCurrentlyFailableBE.end()) {
+                    os << *it;
+                }
+                ++it;
+                while(it != mIsCurrentlyFailableBE.end()) {
+                    os << ", " << *it;
+                    ++it;
+                }
+                os << "}" << std::endl;
+            }
+            
+            friend bool operator==(DFTState const& a, DFTState const& b) {
+                return a.mStatus == b.mStatus;
+            }
+        };
+
+    }
+}
+
+namespace std {
+    template<>
+    struct hash<storm::storage::DFTState> {
+        size_t operator()(storm::storage::DFTState const& s) const {
+            return hash<storm::storage::BitVector>()(s.mStatus);
+        }
+    };
+}
+
+#endif	/* DFTSTATE_H */
+
diff --git a/src/storage/dft/DFTStateSpaceGenerationQueues.h b/src/storage/dft/DFTStateSpaceGenerationQueues.h
new file mode 100644
index 000000000..f748e8232
--- /dev/null
+++ b/src/storage/dft/DFTStateSpaceGenerationQueues.h
@@ -0,0 +1,78 @@
+#ifndef DFTSTATESPACEGENERATIONQUEUES_H
+#define	DFTSTATESPACEGENERATIONQUEUES_H
+
+#include <list>
+#include <queue>
+#include <vector>
+#include <deque>
+
+#include "OrderDFTElementsById.h"
+
+namespace storm {
+    namespace storage {
+        class DFTGate;
+        class DFTElement;
+        
+    
+        
+        class DFTStateSpaceGenerationQueues {
+            std::priority_queue<std::shared_ptr<DFTGate>, std::vector<std::shared_ptr<DFTGate>>, OrderElementsByRank> failurePropagation;
+            std::vector<std::shared_ptr<DFTGate>> failsafePropagation;
+            std::vector<std::shared_ptr<DFTElement>> dontcarePropagation;
+            std::vector<std::shared_ptr<DFTElement>> activatePropagation;
+
+        public:
+            void propagateFailure(std::shared_ptr<DFTGate> const& elem) {
+                failurePropagation.push(elem);
+            }
+
+            bool failurePropagationDone() const {
+                return failurePropagation.empty();
+            }
+
+            std::shared_ptr<DFTGate> nextFailurePropagation() {
+                std::shared_ptr<DFTGate> next= failurePropagation.top();
+                failurePropagation.pop();
+                return next;
+            }
+            
+            bool failsafePropagationDone() const {
+                return failsafePropagation.empty();
+            }
+            
+            void propagateFailsafe(std::shared_ptr<DFTGate> const& gate) {
+                failsafePropagation.push_back(gate);
+            }
+            
+            std::shared_ptr<DFTGate> nextFailsafePropagation() {
+                std::shared_ptr<DFTGate> next = failsafePropagation.back();
+                failsafePropagation.pop_back();
+                return next;
+            }
+            
+            bool dontCarePropagationDone() const {
+                return dontcarePropagation.empty();
+            }
+            
+            void propagateDontCare(std::shared_ptr<DFTElement> const& elem) {
+                dontcarePropagation.push_back(elem);
+            }
+            
+            void propagateDontCare(std::vector<std::shared_ptr<DFTElement>> const& elems) {
+                dontcarePropagation.insert(dontcarePropagation.end(), elems.begin(), elems.end());
+            }
+            
+            std::shared_ptr<DFTElement> nextDontCarePropagation() {
+                std::shared_ptr<DFTElement> next = dontcarePropagation.back();
+                dontcarePropagation.pop_back();
+                return next;
+            }
+        };
+    }
+    
+}
+
+
+
+#endif	/* DFTSTATESPACEGENERATIONQUEUES_H */
+
diff --git a/src/storage/dft/OrderDFTElementsById.cpp b/src/storage/dft/OrderDFTElementsById.cpp
new file mode 100644
index 000000000..017969848
--- /dev/null
+++ b/src/storage/dft/OrderDFTElementsById.cpp
@@ -0,0 +1,18 @@
+#include "OrderDFTElementsById.h"
+#include "DFTElements.h"
+
+namespace storm {
+    namespace storage {
+        bool OrderElementsById::operator()(std::shared_ptr<DFTGate> const& a , std::shared_ptr<DFTGate> const& b) const {
+            return a->id() < b->id();
+        }
+        bool OrderElementsById::operator ()(const std::shared_ptr<DFTElement>& a, const std::shared_ptr<DFTElement>& b) const {
+            return a->id() < b->id();
+        }
+        
+        
+        bool OrderElementsByRank::operator ()(const std::shared_ptr<DFTGate>& a, const std::shared_ptr<DFTGate>& b) const {
+            return a->rank() < b->rank();
+        }
+    }
+}
diff --git a/src/storage/dft/OrderDFTElementsById.h b/src/storage/dft/OrderDFTElementsById.h
new file mode 100644
index 000000000..8dfc22da0
--- /dev/null
+++ b/src/storage/dft/OrderDFTElementsById.h
@@ -0,0 +1,24 @@
+#ifndef ORDERDFTELEMENTS_H
+#define	ORDERDFTELEMENTS_H
+
+#include <memory>
+
+namespace storm {
+    namespace storage {
+        class DFTGate;
+        class DFTElement;
+        
+        struct OrderElementsById {
+            bool operator()(std::shared_ptr<DFTGate> const& a , std::shared_ptr<DFTGate> const& b) const;
+            bool operator()(std::shared_ptr<DFTElement> const& a, std::shared_ptr<DFTElement> const& b) const;
+        };
+        
+        struct OrderElementsByRank {
+            bool operator()(std::shared_ptr<DFTGate> const& a, std::shared_ptr<DFTGate> const& b) const;
+        };
+
+    }
+}
+
+#endif	/* ORDERDFTELEMENTSBYID_H */
+
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
new file mode 100644
index 000000000..39b614f8c
--- /dev/null
+++ b/src/storm-dyftee.cpp
@@ -0,0 +1,22 @@
+#include "parser/DFTGalileoParser.h"
+#include "utility/initialize.h"
+#include "builder/ExplicitDFTModelBuilder.h"
+
+
+/*
+ * Entry point for the DyFTeE backend.
+ */
+int main(int argc, char** argv) {
+    if(argc != 2) {
+        std::cout <<  "Storm-DyFTeE should be called with a filename as argument." << std::endl;
+    }
+    storm::utility::initialize::setUp();
+    
+    storm::parser::DFTGalileoParser parser;
+    storm::storage::DFT dft = parser.parseDFT(argv[1]);
+    dft.printElements();
+    dft.printSpareModules();
+    storm::builder::ExplicitDFTModelBuilder builder(dft);
+    builder.buildCtmc();
+}
+
diff --git a/src/utility/cli.h b/src/utility/cli.h
index 40f50acfa..1a44610f4 100644
--- a/src/utility/cli.h
+++ b/src/utility/cli.h
@@ -35,17 +35,7 @@
 #include "lib/smtrat.h"
 #endif
 
-#include "log4cplus/logger.h"
-#include "log4cplus/loggingmacros.h"
-#include "log4cplus/consoleappender.h"
-#include "log4cplus/fileappender.h"
-log4cplus::Logger logger;
-log4cplus::Logger printer;
 
-// Headers that provide auxiliary functionality.
-#include "src/utility/storm-version.h"
-#include "src/utility/OsDetection.h"
-#include "src/settings/SettingsManager.h"
 
 // Headers related to parsing.
 #include "src/parser/AutoParser.h"
@@ -93,44 +83,6 @@ namespace storm {
     namespace utility {
         namespace cli {
             
-            /*!
-             * Initializes the logging framework and sets up logging to console.
-             */
-            void initializeLogger() {
-                logger = log4cplus::Logger::getInstance(LOG4CPLUS_TEXT("main"));
-                log4cplus::SharedAppenderPtr consoleLogAppender(new log4cplus::ConsoleAppender());
-                consoleLogAppender->setName("mainConsoleAppender");
-                consoleLogAppender->setLayout(std::auto_ptr<log4cplus::Layout>(new log4cplus::PatternLayout("%-5p - %D{%H:%M:%S} (%r ms) - %b:%L: %m%n")));
-                logger.addAppender(consoleLogAppender);
-                auto loglevel = storm::settings::debugSettings().isTraceSet() ? log4cplus::TRACE_LOG_LEVEL : storm::settings::debugSettings().isDebugSet() ? log4cplus::DEBUG_LOG_LEVEL : log4cplus::WARN_LOG_LEVEL;
-                logger.setLogLevel(loglevel);
-                consoleLogAppender->setThreshold(loglevel);
-            }
-            
-            /*!
-             * Performs some necessary initializations.
-             */
-            void setUp() {
-                initializeLogger();
-                std::cout.precision(10);
-            }
-            
-            /*!
-             * Performs some necessary clean-up.
-             */
-            void cleanUp() {
-                // Intentionally left empty.
-            }
-            
-            /*!
-             * Sets up the logging to file.
-             */
-            void initializeFileLogging() {
-                log4cplus::SharedAppenderPtr fileLogAppender(new log4cplus::FileAppender(storm::settings::debugSettings().getLogfilename()));
-                fileLogAppender->setName("mainFileAppender");
-                fileLogAppender->setLayout(std::auto_ptr<log4cplus::Layout>(new log4cplus::PatternLayout("%-5p - %D{%H:%M:%S} (%r ms) - %F:%L: %m%n")));
-                logger.addAppender(fileLogAppender);
-            }
             
             /*!
              * Gives the current working directory
diff --git a/src/utility/initialize.h b/src/utility/initialize.h
new file mode 100644
index 000000000..a58e6d3c9
--- /dev/null
+++ b/src/utility/initialize.h
@@ -0,0 +1,68 @@
+
+
+#ifndef INITIALIZE_H
+#define	INITIALIZE_H
+
+
+#include "log4cplus/logger.h"
+#include "log4cplus/loggingmacros.h"
+#include "log4cplus/consoleappender.h"
+#include "log4cplus/fileappender.h"
+log4cplus::Logger logger;
+log4cplus::Logger printer;
+
+
+// Headers that provide auxiliary functionality.
+#include "src/utility/storm-version.h"
+#include "src/utility/OsDetection.h"
+#include "src/settings/SettingsManager.h"
+
+namespace storm {
+    namespace utility {
+        namespace initialize {
+            
+            /*!
+             * Initializes the logging framework and sets up logging to console.
+             */
+            void initializeLogger() {
+                logger = log4cplus::Logger::getInstance(LOG4CPLUS_TEXT("main"));
+                log4cplus::SharedAppenderPtr consoleLogAppender(new log4cplus::ConsoleAppender());
+                consoleLogAppender->setName("mainConsoleAppender");
+                consoleLogAppender->setLayout(std::auto_ptr<log4cplus::Layout>(new log4cplus::PatternLayout("%-5p - %D{%H:%M:%S} (%r ms) - %b:%L: %m%n")));
+                logger.addAppender(consoleLogAppender);
+                auto loglevel = storm::settings::debugSettings().isTraceSet() ? log4cplus::TRACE_LOG_LEVEL : storm::settings::debugSettings().isDebugSet() ? log4cplus::DEBUG_LOG_LEVEL : log4cplus::WARN_LOG_LEVEL;
+                logger.setLogLevel(loglevel);
+                consoleLogAppender->setThreshold(loglevel);
+            }
+            
+            /*!
+             * Performs some necessary initializations.
+             */
+            void setUp() {
+                initializeLogger();
+                std::cout.precision(10);
+            }
+            
+            /*!
+             * Performs some necessary clean-up.
+             */
+            void cleanUp() {
+                // Intentionally left empty.
+            }
+            
+            /*!
+             * Sets up the logging to file.
+             */
+            void initializeFileLogging() {
+                log4cplus::SharedAppenderPtr fileLogAppender(new log4cplus::FileAppender(storm::settings::debugSettings().getLogfilename()));
+                fileLogAppender->setName("mainFileAppender");
+                fileLogAppender->setLayout(std::auto_ptr<log4cplus::Layout>(new log4cplus::PatternLayout("%-5p - %D{%H:%M:%S} (%r ms) - %F:%L: %m%n")));
+                logger.addAppender(fileLogAppender);
+            }
+            
+        }
+    }
+}
+
+#endif	/* INITIALIZE_H */
+
diff --git a/src/utility/math.h b/src/utility/math.h
index ba21bcfa1..b2c41adc2 100644
--- a/src/utility/math.h
+++ b/src/utility/math.h
@@ -17,6 +17,14 @@ namespace storm {
                 return std::log(number) / std::log(2);
 #		endif
             }
+            
+            inline uint64_t uint64_log2(uint64_t n)
+            {
+                assert(n != 0);
+                #define S(k) if (n >= (UINT64_C(1) << k)) { i += k; n >>= k; }
+                uint64_t i = 0; S(32); S(16); S(8); S(4); S(2); S(1); return i;
+                #undef S
+            }
         }
     }
 }

From 59fe9ace09ab2c7a607b6aceac7a11dc64aa2bab Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 17 Jul 2015 14:06:15 +0200
Subject: [PATCH 002/246] Further work on state space generation

Former-commit-id: bb373138e5982beaa6188ddd21d76751c7a71f19
---
 src/storage/dft/DFT.cpp          |  3 ++-
 src/storage/dft/DFTElements.cpp  | 14 ++++++++++++++
 src/storage/dft/DFTElements.h    | 32 +++++++++++++++++++++++++++++++-
 src/storage/dft/DFTUnit.h        | 22 ++++++++++++++++++++++
 src/storage/dft/SymmetricUnits.h |  7 +++++++
 5 files changed, 76 insertions(+), 2 deletions(-)
 create mode 100644 src/storage/dft/DFTUnit.h
 create mode 100644 src/storage/dft/SymmetricUnits.h

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index e06661988..551c7ad2a 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -37,7 +37,6 @@ namespace storm {
                     mUsageIndex.insert(std::make_pair(elem->id(), stateIndex));
                     stateIndex += mUsageInfoBits;
 
-
                 }
             }
 
@@ -68,6 +67,8 @@ namespace storm {
                 os << std::endl;
             }
         }
+        
+        
 
         void DFT::printInfo(std::ostream& os) const {
             os << "Top level index: " << mTopLevelIndex << std::endl << "Nr BEs" << mNrOfBEs << std::endl;
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index b96ceafb4..699fe47e5 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -26,6 +26,19 @@ namespace storm {
             }
         }
         
+        void DFTElement::extendUnit(std::set<size_t>& unit) const {
+            unit.insert(mId);
+            for(auto const& parent : mParents) {
+                if(unit.count(parent->id()) != 0) {
+                    parent->extendUnit(unit);
+                }
+            }
+        }
+        
+        void DFTElement::checkForSymmetricChildren() const {
+            
+        }
+        
         template<>
         bool DFTBE<double>::checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
             if(DFTElement::checkDontCareAnymore(state, queues)) {
@@ -34,5 +47,6 @@ namespace storm {
             }
             return false;
         }
+        
     }
 }
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 9d3338022..12da6a4bf 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -99,6 +99,10 @@ namespace storm {
             virtual void print(std::ostream& = std::cout) const = 0;
             
             virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const;
+            
+            virtual std::vector<size_t> independentUnit() const = 0;
+        
+            virtual void  extendUnit(std::set<size_t>& unit) const;
         };
 
 
@@ -166,6 +170,21 @@ namespace storm {
                 }
             }
             
+            virtual std::vector<size_t> independentUnit() const {
+                std::set<size_t> unit = {mId};
+                for(auto const& child : mChildren) {
+                    child->extendUnit(unit);
+                }
+                for(auto const& parent : mParents) {
+                    if(unit.count(parent->id()) != 0) {
+                        return {};
+                    } 
+                }
+                return std::vector<size_t>(unit.begin(), unit.end()); 
+           }
+
+            
+            
             virtual void print(std::ostream& os = std::cout) const {
                 os << "{" << name() << "} " << typestring() << "( ";
                 std::vector<std::shared_ptr<DFTElement>>::const_iterator it = mChildren.begin();
@@ -185,7 +204,16 @@ namespace storm {
                 }
                 return false;
             }
+            
+            virtual void extendUnit(std::set<size_t>& unit) const {
+                DFTElement::extendUnit(unit);
+                for(auto const& child : mChildren) {
+                    child->extendUnit(unit);
+                }
+            }
+            
         protected:
+            
             void fail(DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
                 for(std::shared_ptr<DFTGate> parent : mParents) {
                     if(state.isOperational(parent->id())) {
@@ -269,7 +297,9 @@ namespace storm {
                 return mPassiveFailureRate == 0;
             }
             
-
+            virtual std::vector<size_t> independentUnit() const {
+                return {mId};
+            }
             virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const;
         };
         
diff --git a/src/storage/dft/DFTUnit.h b/src/storage/dft/DFTUnit.h
new file mode 100644
index 000000000..18319b70c
--- /dev/null
+++ b/src/storage/dft/DFTUnit.h
@@ -0,0 +1,22 @@
+#ifndef DFTUNIT_H
+#define	DFTUNIT_H
+
+namespace storm {
+    namespace storage {
+        class DFT;
+        
+        class DFTUnit {
+        private:
+            DFT const& mDft;
+            BitVector mMembers;
+            
+            
+        public:
+            DFTUnit(DFT const& dft, BitVector const& members);
+        };
+    }
+}
+
+
+#endif	/* DFTUNIT_H */
+
diff --git a/src/storage/dft/SymmetricUnits.h b/src/storage/dft/SymmetricUnits.h
new file mode 100644
index 000000000..3959593a1
--- /dev/null
+++ b/src/storage/dft/SymmetricUnits.h
@@ -0,0 +1,7 @@
+#ifndef SYMMETRICUNITS_H
+#define	SYMMETRICUNITS_H
+
+
+
+#endif	/* SYMMETRICUNITS_H */
+

From 37eacf574b2a42d2661ff5019f2dbac1bac881e6 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Mon, 20 Jul 2015 17:57:42 +0200
Subject: [PATCH 003/246] Further work on state space generation

Former-commit-id: 3c0c4c016d0f3b0167070b27994a50bad5aa7d22
---
 CMakeLists.txt | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6ae07a267..3e85ecbc7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -390,6 +390,7 @@ endif()
 file(GLOB_RECURSE STORM_HEADERS ${PROJECT_SOURCE_DIR}/src/*.h)
 file(GLOB_RECURSE STORM_SOURCES_WITHOUT_MAIN ${PROJECT_SOURCE_DIR}/src/*/*.cpp)
 file(GLOB_RECURSE STORM_MAIN_FILE ${PROJECT_SOURCE_DIR}/src/storm.cpp)
+file(GLOB_RECURSE STORM_MAIN_FILE ${PROJECT_SOURCE_DIR}/src/storm-dyftee.cpp)
 set(STORM_SOURCES "${STORM_SOURCES_WITHOUT_MAIN};${STORM_MAIN_FILE};")
 file(GLOB_RECURSE STORM_ADAPTERS_FILES ${PROJECT_SOURCE_DIR}/src/adapters/*.h ${PROJECT_SOURCE_DIR}/src/adapters/*.cpp)
 file(GLOB_RECURSE STORM_BUILDER_FILES ${PROJECT_SOURCE_DIR}/src/builder/*.h ${PROJECT_SOURCE_DIR}/src/builder/*.cpp)
@@ -415,6 +416,7 @@ file(GLOB_RECURSE STORM_STORAGE_DD_FILES ${PROJECT_SOURCE_DIR}/src/storage/dd/*.
 file(GLOB_RECURSE STORM_STORAGE_EXPRESSIONS_FILES ${PROJECT_SOURCE_DIR}/src/storage/expressions/*.h ${PROJECT_SOURCE_DIR}/src/storage/expressions/*.cpp)
 file(GLOB_RECURSE STORM_STORAGE_PRISM_FILES ${PROJECT_SOURCE_DIR}/src/storage/prism/*.h ${PROJECT_SOURCE_DIR}/src/storage/prism/*.cpp)
 file(GLOB_RECURSE STORM_STORAGE_SPARSE_FILES ${PROJECT_SOURCE_DIR}/src/storage/sparse/*.h ${PROJECT_SOURCE_DIR}/src/storage/sparse/*.cpp)
+file(GLOB_RECURSE STORM_STORAGE_DFT_FILES ${PROJECT_SOURCE_DIR}/src/storage/dft/*.h ${PROJECT_SOURCE_DIR}/src/storage/sparse/*.cpp)
 file(GLOB_RECURSE STORM_UTILITY_FILES ${PROJECT_SOURCE_DIR}/src/utility/*.h ${PROJECT_SOURCE_DIR}/src/utility/*.cpp)
 # Test Sources
 # Note that the tests also need the source files, except for the main file
@@ -428,6 +430,7 @@ file(GLOB_RECURSE STORM_BUILD_HEADERS ${PROJECT_BINARY_DIR}/include/*.h)
 
 # Group the headers and sources
 source_group(main FILES ${STORM_MAIN_FILE})
+source_group(dft FILES ${STORM_DYFTTEE_FILE})
 source_group(adapters FILES ${STORM_ADAPTERS_FILES})
 source_group(builder FILES ${STORM_BUILDER_FILES})
 source_group(exceptions FILES ${STORM_EXCEPTIONS_FILES})
@@ -453,6 +456,7 @@ source_group(storage\\dd FILES ${STORM_STORAGE_DD_FILES})
 source_group(storage\\expressions FILES ${STORM_STORAGE_EXPRESSIONS_FILES})
 source_group(storage\\prism FILES ${STORM_STORAGE_PRISM_FILES})
 source_group(storage\\sparse FILES ${STORM_STORAGE_SPARSE_FILES})
+source_group(storage\\dft FILES ${STORM_STORAGE_DFT_FILES})
 source_group(utility FILES ${STORM_UTILITY_FILES})
 source_group(functional-test FILES ${STORM_FUNCTIONAL_TEST_FILES})
 source_group(performance-test FILES ${STORM_PERFORMANCE_TEST_FILES} ${})
@@ -518,6 +522,9 @@ target_link_libraries(storm-functional-tests storm)
 add_executable(storm-performance-tests ${STORM_PERFORMANCE_TEST_MAIN_FILE} ${STORM_PERFORMANCE_TEST_FILES})
 target_link_libraries(storm-performance-tests storm)
 
+add_executable(storm-dyftee ${STORM_MAIN_FILE})
+target_link_libraries(storm-dyftee storm)
+
 #############################################################
 ##
 ##	Boost

From 7643ebc70db9c468503f364a26051af929b39396 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 11 Dec 2015 19:10:55 +0100
Subject: [PATCH 004/246] Compile fixes

Former-commit-id: d304a6a8e06346f729acc7f690ee8ae6154c4a4b
---
 src/storage/dft/DFTElements.h | 2 ++
 src/storm-dyftee.cpp          | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 12da6a4bf..d6245a606 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -103,6 +103,8 @@ namespace storm {
             virtual std::vector<size_t> independentUnit() const = 0;
         
             virtual void  extendUnit(std::set<size_t>& unit) const;
+
+            void checkForSymmetricChildren() const;
         };
 
 
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 39b614f8c..07e2624ee 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -10,7 +10,7 @@ int main(int argc, char** argv) {
     if(argc != 2) {
         std::cout <<  "Storm-DyFTeE should be called with a filename as argument." << std::endl;
     }
-    storm::utility::initialize::setUp();
+    storm::utility::setUp();
     
     storm::parser::DFTGalileoParser parser;
     storm::storage::DFT dft = parser.parseDFT(argv[1]);

From 4bd59b86491eb6cc69df90fb950a25b0b6726661 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 14 Dec 2015 16:44:53 +0100
Subject: [PATCH 005/246] Small formatting changes

Former-commit-id: 08eb57a9b0df7ff4f84ca2a4ead102a7ac71eef5
---
 src/parser/DFTGalileoParser.cpp | 38 ++++++++++++++++++++-------------
 src/parser/DFTGalileoParser.h   |  4 ----
 src/storage/dft/DFT.cpp         |  2 +-
 src/storage/dft/DFT.h           |  4 ----
 src/storage/dft/DFTBuilder.cpp  | 29 +++++++++++--------------
 src/storage/dft/DFTBuilder.h    |  4 +---
 src/storage/dft/DFTUnit.h       |  2 ++
 src/storm-dyftee.cpp            | 12 ++++++++++-
 8 files changed, 50 insertions(+), 45 deletions(-)

diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index 79e969260..a93e84e92 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -24,6 +24,9 @@ namespace storm {
             
             if(firstQuots == std::string::npos) {
                 return name;
+            } else if (secondQuots ==std::string::npos) {
+                std::cerr << "No ending quotation mark found in " << name <<std::endl;
+                throw storm::exceptions::FileIoException();
             } else {
                 return name.substr(firstQuots+1,secondQuots-1);
             }
@@ -32,11 +35,8 @@ namespace storm {
         bool DFTGalileoParser::readFile(const std::string& filename) {
             // constants
             std::string topleveltoken = "toplevel";
-            
-            
             std::string toplevelId;
-           
-            
+
             std::ifstream file;
             file.exceptions ( std::ifstream::failbit );
             try {
@@ -48,19 +48,25 @@ namespace storm {
             }
             file.exceptions( 0 );
 
-
             std::string line;
+            bool generalSuccess = true;
             while(std::getline(file, line))
             {
+                bool success = true;
                 std::cout << line << std::endl;
                 size_t commentstarts = line.find("//");
                 line = line.substr(0, commentstarts);
                 size_t firstsemicolon = line.find(";");
                 line = line.substr(0, firstsemicolon);
+                if (line.find_first_not_of(' ') == std::string::npos)
+                {
+                    // Only whitespace
+                    continue;
+                }
 
                 // Top level indicator.
                 if(boost::starts_with(line, topleveltoken)) {
-                    toplevelId = stripQuotsFromName(line.substr(topleveltoken.size()+1));
+                    toplevelId = stripQuotsFromName(line.substr(topleveltoken.size() + 1));
                 }
                 else
                 {
@@ -73,30 +79,32 @@ namespace storm {
                         childNames.push_back(stripQuotsFromName(tokens[i]));
                     }
                     if(tokens[1] == "and") {
-                        mBuilder.addAndElement(name, childNames);
+                        success = mBuilder.addAndElement(name, childNames);
                     } else if(tokens[1] == "or") {
-                        mBuilder.addOrElement(name, childNames);
+                        success = mBuilder.addOrElement(name, childNames);
                     } else if(boost::starts_with(tokens[1], "vot")) {
-                        mBuilder.addVotElement(name, boost::lexical_cast<unsigned>(tokens[1].substr(3)), childNames);
+                        success = mBuilder.addVotElement(name, boost::lexical_cast<unsigned>(tokens[1].substr(3)), childNames);
                     } else if(tokens[1] == "pand") {
-                        mBuilder.addPandElement(name, childNames);
+                        success = mBuilder.addPandElement(name, childNames);
                     } else if(tokens[1] == "wsp" || tokens[1] == "csp") {
-                        mBuilder.addSpareElement(name, childNames);
+                        success = mBuilder.addSpareElement(name, childNames);
                     } else if(boost::starts_with(tokens[1], "lambda=")) {
-                        mBuilder.addBasicElement(name, boost::lexical_cast<double>(tokens[1].substr(7)), boost::lexical_cast<double>(tokens[2].substr(5)));
+                        success = mBuilder.addBasicElement(name, boost::lexical_cast<double>(tokens[1].substr(7)), boost::lexical_cast<double>(tokens[2].substr(5)));
                     } else {
                         STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Type name: " + tokens[1] + "  not recognized.");
+                        success = false;
                     }
                 }
-
+                if (generalSuccess) {
+                    generalSuccess = success;
+                }
             }
             if(!mBuilder.setTopLevel(toplevelId)) {
                 STORM_LOG_THROW(false, storm::exceptions::FileIoException, "Top level id unknown.");
             }
             file.close();
-            return true;                        
+            return generalSuccess;
         }
         
-        
     }
 }
\ No newline at end of file
diff --git a/src/parser/DFTGalileoParser.h b/src/parser/DFTGalileoParser.h
index 3dc6f11eb..9d0cc0096 100644
--- a/src/parser/DFTGalileoParser.h
+++ b/src/parser/DFTGalileoParser.h
@@ -6,8 +6,6 @@
 
 #include <map>
 
-
-
 namespace storm {
     namespace parser {
         class DFTGalileoParser {
@@ -23,7 +21,5 @@ namespace storm {
 }
 }
 
-
-
 #endif	/* DFTGALILEOPARSER_H */
 
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 551c7ad2a..8dee2a0b6 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -75,7 +75,7 @@ namespace storm {
         }
 
         void DFT::printSpareModules(std::ostream& os) const {
-            std::cout << "[" << mElements[mTopLevelIndex] << "] {";
+            std::cout << "[" << mElements[mTopLevelIndex]->id() << "] {";
             std::vector<size_t>::const_iterator it = mTopModule.begin();
             assert(it != mTopModule.end());
             os << mElements[(*it)]->name();
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 1f8939fd7..fbf035f44 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -16,7 +16,6 @@
 namespace storm {
     namespace storage {
 
-                
         struct DFTElementSort {
             bool operator()(std::shared_ptr<DFTElement> const& a, std::shared_ptr<DFTElement> const& b)  const {
                 if (a->rank() == 0 && b->rank() == 0) {
@@ -29,8 +28,6 @@ namespace storm {
         
         class DFT {
 
-            
-
         private:
             std::vector<std::shared_ptr<DFTElement>> mElements;
             size_t mNrOfBEs;
@@ -44,7 +41,6 @@ namespace storm {
             std::vector<size_t> mIdToFailureIndex;
             std::map<size_t, size_t> mUsageIndex;
             
-            
         public:
             DFT(std::vector<std::shared_ptr<DFTElement>> const& elements, std::shared_ptr<DFTElement> const& tle);
             
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index f6364a523..b8e2c54a2 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -10,7 +10,6 @@
 
 namespace storm {
     namespace storage {
-        
          
         DFT DFTBuilder::build() {
             for(auto& elem : mChildNames) {
@@ -23,8 +22,6 @@ namespace storm {
 
             // Sort elements topologically
 
-
-
             // compute rank
             for (auto& elem : mElements) {
                 computeRank(elem.second);
@@ -48,23 +45,22 @@ namespace storm {
             if(elem->rank() == -1) {
                 if(elem->nrChildren() == 0) {
                     elem->setRank(0);
-                    return 0;
-                }
-                std::shared_ptr<DFTGate> gate = std::static_pointer_cast<DFTGate>(elem);
-                unsigned maxrnk = 0;
-                unsigned newrnk = 0;
+                } else {
+                    std::shared_ptr<DFTGate> gate = std::static_pointer_cast<DFTGate>(elem);
+                    unsigned maxrnk = 0;
+                    unsigned newrnk = 0;
 
-                for(std::shared_ptr<DFTElement> const& child : gate->children()) {
-                    newrnk = computeRank(child);
-                    if(newrnk > maxrnk) {
-                        maxrnk = newrnk;
+                    for (std::shared_ptr<DFTElement> const &child : gate->children()) {
+                        newrnk = computeRank(child);
+                        if (newrnk > maxrnk) {
+                            maxrnk = newrnk;
+                        }
                     }
+                    elem->setRank(maxrnk + 1);
                 }
-                elem->setRank(maxrnk+1);
-                return maxrnk + 1;
-            } else {
-                return elem->rank();
             }
+
+            return elem->rank();
         }
         
         bool DFTBuilder::addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementTypes tp) {
@@ -109,7 +105,6 @@ namespace storm {
                 }
                 visited[n] = topoSortColour::BLACK;
                 L.push_back(n);
-               
             }
         }
 
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index e29a8aa02..68e64b1dc 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -43,8 +43,6 @@ namespace storm {
                 return addStandardGate(name, children, DFTElementTypes::SPARE);
             }
             
-            
-            
             bool addVotElement(std::string const& name, unsigned threshold, std::vector<std::string> const& children) {
                 assert(children.size() > 0);
                 if(mElements.count(name) != 0) {
@@ -103,8 +101,8 @@ namespace storm {
             enum class topoSortColour {WHITE, BLACK, GREY}; 
             
             void topoVisit(std::shared_ptr<DFTElement> const& n, std::map<std::shared_ptr<DFTElement>, topoSortColour>& visited, std::vector<std::shared_ptr<DFTElement>>& L);
-            std::vector<std::shared_ptr<DFTElement>> topoSort();
 
+            std::vector<std::shared_ptr<DFTElement>> topoSort();
             
         };
     }
diff --git a/src/storage/dft/DFTUnit.h b/src/storage/dft/DFTUnit.h
index 18319b70c..5e179f091 100644
--- a/src/storage/dft/DFTUnit.h
+++ b/src/storage/dft/DFTUnit.h
@@ -1,6 +1,8 @@
 #ifndef DFTUNIT_H
 #define	DFTUNIT_H
 
+#include "../BitVector.h"
+
 namespace storm {
     namespace storage {
         class DFT;
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 07e2624ee..e491cbe2b 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -11,12 +11,22 @@ int main(int argc, char** argv) {
         std::cout <<  "Storm-DyFTeE should be called with a filename as argument." << std::endl;
     }
     storm::utility::setUp();
-    
+
+    std::cout << "Parsing DFT file..." << std::endl;
     storm::parser::DFTGalileoParser parser;
     storm::storage::DFT dft = parser.parseDFT(argv[1]);
+
+    std::cout << "Built data structure" << std::endl;
     dft.printElements();
     dft.printSpareModules();
+
+    std::cout << "Building CTMC..." << std::endl;
     storm::builder::ExplicitDFTModelBuilder builder(dft);
     builder.buildCtmc();
+    std::cout << "Built CTMC" << std::endl;
+
+    //std::cout << "Model checking..." << std::endl;
+    //TODO check CTMC
+    //std::cout << "Checked model" << std::endl;
 }
 

From 7b37023f791145b2ad2e9978d2c958c714834831 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 15 Dec 2015 11:48:11 +0100
Subject: [PATCH 006/246] Some refactoring

Former-commit-id: c5954a71a2b035a195f3cb2b1161a803a00dd744
---
 src/builder/ExplicitDFTModelBuilder.cpp | 72 +++++++++++++++++++
 src/builder/ExplicitDFTModelBuilder.h   | 91 +++++--------------------
 src/storage/dft/DFT.cpp                 | 15 +++-
 src/storage/dft/DFT.h                   |  4 +-
 src/storage/dft/DFTState.cpp            | 21 ++++--
 src/storage/dft/DFTState.h              | 14 +++-
 src/storm-dyftee.cpp                    |  2 +-
 7 files changed, 134 insertions(+), 85 deletions(-)
 create mode 100644 src/builder/ExplicitDFTModelBuilder.cpp

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
new file mode 100644
index 000000000..8683dd57e
--- /dev/null
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -0,0 +1,72 @@
+#include "src/builder/ExplicitDFTModelBuilder.h"
+
+namespace storm {
+    namespace builder {
+
+        void ExplicitDFTModelBuilder::exploreStateSuccessors(storm::storage::DFTState const &state) {
+            size_t smallest = 0;
+
+            while(smallest < state.nrFailableBEs()) {
+                //std::cout << "exploring from: " << mDft.getStateString(state) << std::endl;
+
+                storm::storage::DFTState newState(state);
+                std::pair<std::shared_ptr<storm::storage::DFTBE<double>>, bool> nextBE = newState.letNextBEFail(smallest++);
+                if(nextBE.first == nullptr) {
+                    //std::cout << "break" << std::endl;
+                    break;
+
+                }
+                //std::cout << "with the failure of: " << nextBE.first->name() << " [" << nextBE.first->id() << "]" << std::endl;
+
+                storm::storage::DFTStateSpaceGenerationQueues queues;
+
+                for(std::shared_ptr<storm::storage::DFTGate> parent : nextBE.first->parents()) {
+                    if(newState.isOperational(parent->id())) {
+                        queues.propagateFailure(parent);
+                    }
+                }
+
+                while(!queues.failurePropagationDone()) {
+                    std::shared_ptr<storm::storage::DFTGate> next = queues.nextFailurePropagation();
+                    next->checkFails(newState, queues);
+                }
+
+                while(!queues.failsafePropagationDone()) {
+                    std::shared_ptr<storm::storage::DFTGate> next = queues.nextFailsafePropagation();
+                    next->checkFailsafe(newState, queues);
+                }
+
+                while(!queues.dontCarePropagationDone()) {
+                    std::shared_ptr<storm::storage::DFTElement> next = queues.nextDontCarePropagation();
+                    next->checkDontCareAnymore(newState, queues);
+                }
+
+                auto it = mStates.find(newState);
+                if (it == mStates.end()) {
+                    // New state
+                    newState.setId(newIndex++);
+                    mStates.insert(newState);
+                    //std::cout << "New state " << mDft.getStateString(newState) << std::endl;
+
+                    // Recursive call
+                    if(!mDft.hasFailed(newState) && !mDft.isFailsafe(newState)) {
+                        exploreStateSuccessors(newState);
+                    } else {
+                        if (mDft.hasFailed(newState)) {
+                            //std::cout << "Failed " << mDft.getStateString(newState) << std::endl;
+                        } else {
+                            assert(mDft.isFailsafe(newState));
+                            //std::cout << "Failsafe" << mDft.getStateString(newState) << std::endl;
+                        }
+                    }
+                } else {
+                    // State already exists
+                    //std::cout << "State " << mDft.getStateString(*it) << " already exists" << std::endl;
+                }
+            }
+        }
+
+    } // namespace builder
+} // namespace storm
+
+
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index e8c169976..7009c4896 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -3,91 +3,34 @@
 
 #include "../storage/dft/DFT.h"
 
+#include <unordered_set>
+
 namespace storm {
     namespace builder {
         class ExplicitDFTModelBuilder {
-            storm::storage::DFT const& mDft;
-            std::unordered_map<storm::storage::DFTState, size_t> mStateIndices;
+            storm::storage::DFT const &mDft;
+            std::unordered_set<storm::storage::DFTState> mStates;
             size_t newIndex = 0;
             //std::stack<std::shared_ptr<storm::storage::DFTState>> mStack;
-            
-        public:
-            ExplicitDFTModelBuilder(storm::storage::DFT const& dft) : mDft(dft)
-            {
-                
-            }
-            
-            
-            void exploreStateSuccessors(storm::storage::DFTState const& state) {
-                size_t smallest = 0; 
-                
-                while(smallest < state.nrFailableBEs()) {
-                    //std::cout << "exploring from :" << std::endl;
-                    //mDft.printElementsWithState(state);
-                    //std::cout << "***************" << std::endl;
-                    storm::storage::DFTState newState(state);
-                    std::pair<std::shared_ptr<storm::storage::DFTBE<double>>, bool> nextBE = newState.letNextBEFail(smallest++);
-                    if(nextBE.first == nullptr) {
-                        //std::cout << "break" << std::endl;
-                        break;
-                        
-                    }
-                    //std::cout << "with the failure of: " << nextBE.first->name() << std::endl;
-                        
-                    storm::storage::DFTStateSpaceGenerationQueues queues;
-                    for(std::shared_ptr<storm::storage::DFTGate> parent : nextBE.first->parents()) {
-                       if(newState.isOperational(parent->id())) {
-                            queues.propagateFailure(parent);
-                        }
-                    }
-
-
 
-                    while(!queues.failurePropagationDone()) {
-                        std::shared_ptr<storm::storage::DFTGate> next = queues.nextFailurePropagation();
-                        next->checkFails(newState, queues);
-                    }
-                    
-                    while(!queues.failsafePropagationDone()) {
-                        std::shared_ptr<storm::storage::DFTGate> next = queues.nextFailsafePropagation();
-                        next->checkFailsafe(newState, queues);
-                    }
-                    
-                    while(!queues.dontCarePropagationDone()) {
-                        std::shared_ptr<storm::storage::DFTElement> next = queues.nextDontCarePropagation();
-                        next->checkDontCareAnymore(newState, queues);
-                    }
-                    
-                    
-                    
-                    if(!mDft.hasFailed(newState) && !mDft.isFailsafe(newState)) {
-                        auto it = mStateIndices.find(newState);
-                        if(it == mStateIndices.end()) {
-                            exploreStateSuccessors(newState);
-                            mStateIndices.insert(std::make_pair(newState, newIndex++));
-                            if(newIndex % 16384 == 0) std::cout << newIndex << std::endl;
-                        } 
-                        
-                    }
-                    else {
-                        //std::cout << "done." << std::endl;
-                    }
+        public:
+            ExplicitDFTModelBuilder(storm::storage::DFT const &dft) : mDft(dft) {
 
-                    
-                
-                }
             }
-            
-            void buildCtmc() {
-                storm::storage::DFTState state(mDft);
+
+            void buildCTMC() {
+                // Construct starting start
+                storm::storage::DFTState state(mDft, newIndex++);
+                mStates.insert(state);
+                // Begin model generation
                 exploreStateSuccessors(state);
-                std::cout << mStateIndices.size() << std::endl;
+                std::cout << "Generated " << mStates.size() << " states" << std::endl;
             }
-            
+
+        private:
+            void exploreStateSuccessors(storm::storage::DFTState const &state);
         };
     }
 }
 
-
-#endif	/* EXPLICITDFTMODELBUILDER_H */
-
+#endif	/* EXPLICITDFTMODELBUILDER_H */
\ No newline at end of file
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 8dee2a0b6..faed81efd 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -114,9 +114,22 @@ namespace storm {
                     os << " using " << state.uses(elem->id());
                 } 
                 std::cout << std::endl;
+            }
+        }
 
-
+        std::string DFT::getStateString(DFTState const& state) const{
+            std::stringstream stream;
+            stream << "(" << state.getId() << ") ";
+            for (auto const& elem : mElements) {
+                stream << state.getElementStateInt(elem->id());
+                /*if(elem->isSpareGate()) {
+                    if(state.isActiveSpare(elem->id())) {
+                        os << " actively";
+                    }
+                    os << " using " << state.uses(elem->id());
+                }*/
             }
+            return stream.str();
         }
     }
 }
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index fbf035f44..64a9ccdc4 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -151,7 +151,9 @@ namespace storm {
             
             void printSpareModules(std::ostream& os = std::cout) const;
             
-            void printElementsWithState(DFTState const& state, std::ostream& os = std::cout) const; 
+            void printElementsWithState(DFTState const& state, std::ostream& os = std::cout) const;
+
+            std::string getStateString(DFTState const& state) const;
             
         private:
             bool elementIndicesCorrect() const {
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 5536b05a6..01534342b 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -5,7 +5,7 @@
 namespace storm {
     namespace storage {
         
-        DFTState::DFTState(DFT const& dft) : mStatus(dft.stateSize()), mDft(dft)  {
+        DFTState::DFTState(DFT const& dft, size_t id) : mStatus(dft.stateSize()), mDft(dft), mId(id)  {
             mInactiveSpares = dft.getSpareIndices();
             dft.initializeUses(*this);
             dft.initializeActivation(*this);
@@ -15,7 +15,19 @@ namespace storm {
         }
         
         DFTElementState DFTState::getElementState(size_t id) const {
-            return static_cast<DFTElementState>(mStatus.getAsInt(mDft.failureIndex(id), 2));
+            return static_cast<DFTElementState>(getElementStateInt(id));
+        }
+
+        int DFTState::getElementStateInt(size_t id) const {
+            return mStatus.getAsInt(mDft.failureIndex(id), 2);
+        }
+
+        size_t DFTState::getId() const {
+            return mId;
+        }
+
+        void DFTState::setId(size_t id) {
+            mId = id;
         }
 
         bool DFTState::isOperational(size_t id) const {
@@ -58,7 +70,7 @@ namespace storm {
         {
             assert(index < mIsCurrentlyFailableBE.size());
             //std::cout << "currently failable: ";
-            //printCurrentlyFailable(std::cout);
+            //printCurrentlyFailable();
             std::pair<std::shared_ptr<DFTBE<double>>,bool> res(mDft.getBasicElement(mIsCurrentlyFailableBE[index]), false);
             mIsCurrentlyFailableBE.erase(mIsCurrentlyFailableBE.begin() + index);
             setFailed(res.first->id());
@@ -98,8 +110,6 @@ namespace storm {
             
         }
         
-        
-        
         void DFTState::setUsesAtPosition(size_t usageIndex, size_t child) {
             mStatus.setFromInt(usageIndex, mDft.usageInfoBits(), child);
             mUsedRepresentants.push_back(child);
@@ -121,5 +131,6 @@ namespace storm {
             }
             return false;
         }
+
     }
 }
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 719d49e37..67eec6598 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -4,6 +4,7 @@
 #include "../BitVector.h"
 #include "DFTElementState.h"
 
+#include <iostream>
 
 namespace storm {
     namespace storage {
@@ -18,6 +19,7 @@ namespace storm {
             friend struct std::hash<DFTState>;
         private:
             storm::storage::BitVector mStatus;
+            size_t mId;
             std::vector<size_t> mInactiveSpares;
             std::vector<size_t> mIsCurrentlyFailableBE;
             std::vector<size_t> mUsedRepresentants;
@@ -25,9 +27,15 @@ namespace storm {
             const DFT& mDft;
             
         public:
-            DFTState(DFT const& dft);
+            DFTState(DFT const& dft, size_t id);
             
             DFTElementState getElementState(size_t id) const;
+
+            int getElementStateInt(size_t id) const;
+
+            size_t getId() const;
+
+            void setId(size_t id);
             
             bool isOperational(size_t id) const;
             
@@ -103,7 +111,7 @@ namespace storm {
             
             std::pair<std::shared_ptr<DFTBE<double>>, bool> letNextBEFail(size_t smallestIndex = 0);
             
-            void printCurrentlyFailable(std::ostream& os) {
+            void printCurrentlyFailable(std::ostream& os = std::cout) {
                 auto it = mIsCurrentlyFailableBE.begin();
                 os << "{";
                 if(it != mIsCurrentlyFailableBE.end()) {
@@ -116,7 +124,7 @@ namespace storm {
                 }
                 os << "}" << std::endl;
             }
-            
+
             friend bool operator==(DFTState const& a, DFTState const& b) {
                 return a.mStatus == b.mStatus;
             }
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index e491cbe2b..b86781460 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -22,7 +22,7 @@ int main(int argc, char** argv) {
 
     std::cout << "Building CTMC..." << std::endl;
     storm::builder::ExplicitDFTModelBuilder builder(dft);
-    builder.buildCtmc();
+    builder.buildCTMC();
     std::cout << "Built CTMC" << std::endl;
 
     //std::cout << "Model checking..." << std::endl;

From 4c1d71fc9164a9a1ed6e1ea897b061b776d3ea02 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 15 Dec 2015 12:14:12 +0100
Subject: [PATCH 007/246] Fixed compile warnings

Former-commit-id: 62ef59c239f558a0adb5db43b3f4fd59b5aa5551
---
 src/storage/dft/DFTBuilder.cpp | 12 ++++++++++++
 src/storage/dft/DFTElements.h  | 12 ++++++------
 src/storage/dft/DFTState.cpp   |  2 +-
 3 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index b8e2c54a2..d1d6f320f 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -5,6 +5,8 @@
 #include "DFT.h"
 #include <algorithm>
 #include "OrderDFTElementsById.h"
+#include <src/utility/macros.h>
+#include <src/exceptions/NotSupportedException.h>
 #include "../../exceptions/WrongFormatException.h"
 
 
@@ -86,6 +88,16 @@ namespace storm {
                 case DFTElementTypes::SPARE:
                    element = std::make_shared<DFTSpare>(mNextId++, name);
                    break;
+                case DFTElementTypes::BE:
+                case DFTElementTypes::VOT:
+                    // Handled separately
+                    STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type handled separately.");
+                case DFTElementTypes::CONSTF:
+                case DFTElementTypes::CONSTS:
+                case DFTElementTypes::FDEP:
+                    STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type not supported.");
+                default:
+                    STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type not known.");
             }
             mElements[name] = element;
             mChildNames[element] = children;
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index d6245a606..d223387e8 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -145,7 +145,7 @@ namespace storm {
                 return mChildren.push_back(elem);
             }
 
-            size_t nrChildren() const {
+            size_t nrChildren() const override {
                 return mChildren.size();
             }
             
@@ -153,7 +153,7 @@ namespace storm {
                 return mChildren;
             }
             
-            virtual bool isGate() const {
+            virtual bool isGate() const override {
                 return true;
             }
             
@@ -172,7 +172,7 @@ namespace storm {
                 }
             }
             
-            virtual std::vector<size_t> independentUnit() const {
+            virtual std::vector<size_t> independentUnit() const override {
                 std::set<size_t> unit = {mId};
                 for(auto const& child : mChildren) {
                     child->extendUnit(unit);
@@ -187,7 +187,7 @@ namespace storm {
 
             
             
-            virtual void print(std::ostream& os = std::cout) const {
+            virtual void print(std::ostream& os = std::cout) const override {
                 os << "{" << name() << "} " << typestring() << "( ";
                 std::vector<std::shared_ptr<DFTElement>>::const_iterator it = mChildren.begin();
                 os << (*it)->name();
@@ -199,7 +199,7 @@ namespace storm {
                 os << ")";
             }    
             
-            virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+            virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const override {
                 if(DFTElement::checkDontCareAnymore(state, queues)) {
                     childrenDontCare(state, queues);
                     return true;
@@ -207,7 +207,7 @@ namespace storm {
                 return false;
             }
             
-            virtual void extendUnit(std::set<size_t>& unit) const {
+            virtual void extendUnit(std::set<size_t>& unit) const override {
                 DFTElement::extendUnit(unit);
                 for(auto const& child : mChildren) {
                     child->extendUnit(unit);
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 01534342b..e7756cbbd 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -5,7 +5,7 @@
 namespace storm {
     namespace storage {
         
-        DFTState::DFTState(DFT const& dft, size_t id) : mStatus(dft.stateSize()), mDft(dft), mId(id)  {
+        DFTState::DFTState(DFT const& dft, size_t id) : mStatus(dft.stateSize()), mId(id), mDft(dft)  {
             mInactiveSpares = dft.getSpareIndices();
             dft.initializeUses(*this);
             dft.initializeActivation(*this);

From 0c37f078fb45243b1585b757f17b58bf43756f0d Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 16 Dec 2015 14:16:26 +0100
Subject: [PATCH 008/246] Build transition matrix for FT

Former-commit-id: 2ffb55295ade2c9337e463e94b865f69d18d63f1
---
 src/builder/ExplicitDFTModelBuilder.cpp | 155 +++++++++++++++++-------
 src/builder/ExplicitDFTModelBuilder.h   |  30 +++--
 src/storage/dft/DFTElements.h           |  18 +--
 src/storm-dyftee.cpp                    |   3 +-
 4 files changed, 139 insertions(+), 67 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 8683dd57e..788c5a0fa 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -3,69 +3,132 @@
 namespace storm {
     namespace builder {
 
-        void ExplicitDFTModelBuilder::exploreStateSuccessors(storm::storage::DFTState const &state) {
-            size_t smallest = 0;
+        template<typename ValueType, typename RewardModelType, typename IndexType>
+        void ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::buildCTMC() {
+            // Initialize
+            storm::storage::DFTState state(mDft, newIndex++);
+            mStates.insert(state);
 
-            while(smallest < state.nrFailableBEs()) {
-                //std::cout << "exploring from: " << mDft.getStateString(state) << std::endl;
+            std::queue<storm::storage::DFTState> stateQueue;
+            stateQueue.push(state);
 
-                storm::storage::DFTState newState(state);
-                std::pair<std::shared_ptr<storm::storage::DFTBE<double>>, bool> nextBE = newState.letNextBEFail(smallest++);
-                if(nextBE.first == nullptr) {
-                    //std::cout << "break" << std::endl;
-                    break;
+            bool deterministicModel = true;
+            storm::storage::SparseMatrixBuilder<ValueType> transitionMatrixBuilder(0, 0, 0, false, !deterministicModel, 0);
 
-                }
-                //std::cout << "with the failure of: " << nextBE.first->name() << " [" << nextBE.first->id() << "]" << std::endl;
+            // Begin model generation
+            exploreStates(stateQueue, transitionMatrixBuilder);
+            //std::cout << "Generated " << mStates.size() << " states" << std::endl;
+
+            // Build CTMC
+            transitionMatrix = transitionMatrixBuilder.build();
+            //std::cout << "TransitionMatrix: " << std::endl;
+            //std::cout << transitionMatrix << std::endl;
+            // TODO Matthias: build CTMC
+        }
+
+        template<typename ValueType, typename RewardModelType, typename IndexType>
+        void ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::exploreStates(std::queue<storm::storage::DFTState>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder) {
+
+            std::vector<std::pair<size_t, ValueType>> outgoingTransitions;
+
+            while (!stateQueue.empty()) {
+                // Initialization
+                outgoingTransitions.clear();
+                ValueType sum = 0;
+
+                // Consider next state
+                storm::storage::DFTState state = stateQueue.front();
+                stateQueue.pop();
 
-                storm::storage::DFTStateSpaceGenerationQueues queues;
+                size_t smallest = 0;
+
+                // Let BE fail
+                while (smallest < state.nrFailableBEs()) {
+                    //std::cout << "exploring from: " << mDft.getStateString(state) << std::endl;
+
+                    storm::storage::DFTState newState(state);
+                    std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType>>, bool> nextBE = newState.letNextBEFail(smallest++);
+                    if (nextBE.first == nullptr) {
+                        std::cout << "break" << std::endl;
+                        break;
 
-                for(std::shared_ptr<storm::storage::DFTGate> parent : nextBE.first->parents()) {
-                    if(newState.isOperational(parent->id())) {
-                        queues.propagateFailure(parent);
                     }
-                }
+                    //std::cout << "with the failure of: " << nextBE.first->name() << " [" << nextBE.first->id() << "]" << std::endl;
 
-                while(!queues.failurePropagationDone()) {
-                    std::shared_ptr<storm::storage::DFTGate> next = queues.nextFailurePropagation();
-                    next->checkFails(newState, queues);
-                }
+                    storm::storage::DFTStateSpaceGenerationQueues queues;
 
-                while(!queues.failsafePropagationDone()) {
-                    std::shared_ptr<storm::storage::DFTGate> next = queues.nextFailsafePropagation();
-                    next->checkFailsafe(newState, queues);
-                }
+                    for (std::shared_ptr<storm::storage::DFTGate> parent : nextBE.first->parents()) {
+                        if (newState.isOperational(parent->id())) {
+                            queues.propagateFailure(parent);
+                        }
+                    }
 
-                while(!queues.dontCarePropagationDone()) {
-                    std::shared_ptr<storm::storage::DFTElement> next = queues.nextDontCarePropagation();
-                    next->checkDontCareAnymore(newState, queues);
-                }
+                    while (!queues.failurePropagationDone()) {
+                        std::shared_ptr<storm::storage::DFTGate> next = queues.nextFailurePropagation();
+                        next->checkFails(newState, queues);
+                    }
 
-                auto it = mStates.find(newState);
-                if (it == mStates.end()) {
-                    // New state
-                    newState.setId(newIndex++);
-                    mStates.insert(newState);
-                    //std::cout << "New state " << mDft.getStateString(newState) << std::endl;
+                    while (!queues.failsafePropagationDone()) {
+                        std::shared_ptr<storm::storage::DFTGate> next = queues.nextFailsafePropagation();
+                        next->checkFailsafe(newState, queues);
+                    }
 
-                    // Recursive call
-                    if(!mDft.hasFailed(newState) && !mDft.isFailsafe(newState)) {
-                        exploreStateSuccessors(newState);
-                    } else {
-                        if (mDft.hasFailed(newState)) {
-                            //std::cout << "Failed " << mDft.getStateString(newState) << std::endl;
+                    while (!queues.dontCarePropagationDone()) {
+                        std::shared_ptr<storm::storage::DFTElement> next = queues.nextDontCarePropagation();
+                        next->checkDontCareAnymore(newState, queues);
+                    }
+
+                    auto it = mStates.find(newState);
+                    if (it == mStates.end()) {
+                        // New state
+                        newState.setId(newIndex++);
+                        auto itInsert = mStates.insert(newState);
+                        assert(itInsert.second);
+                        it = itInsert.first;
+                        //std::cout << "New state " << mDft.getStateString(newState) << std::endl;
+
+                        // Recursive call
+                        if (!mDft.hasFailed(newState) && !mDft.isFailsafe(newState)) {
+                            stateQueue.push(newState);
                         } else {
-                            assert(mDft.isFailsafe(newState));
-                            //std::cout << "Failsafe" << mDft.getStateString(newState) << std::endl;
+                            if (mDft.hasFailed(newState)) {
+                                //std::cout << "Failed " << mDft.getStateString(newState) << std::endl;
+                            } else {
+                                assert(mDft.isFailsafe(newState));
+                                //std::cout << "Failsafe" << mDft.getStateString(newState) << std::endl;
+                            }
                         }
+                    } else {
+                        // State already exists
+                        //std::cout << "State " << mDft.getStateString(*it) << " already exists" << std::endl;
                     }
-                } else {
-                    // State already exists
-                    //std::cout << "State " << mDft.getStateString(*it) << " already exists" << std::endl;
+
+                    // Set transition
+                    ValueType prob = nextBE.first->activeFailureRate();
+                    outgoingTransitions.push_back(std::make_pair(it->getId(), prob));
+                    sum += prob;
+                } // end while failing BE
+
+                // Add all transitions
+                for (auto it = outgoingTransitions.begin(); it != outgoingTransitions.end(); ++it)
+                {
+                    ValueType rate = it->second / sum;
+                    transitionMatrixBuilder.addNextValue(state.getId(), it->first, rate);
+                    //std::cout << "Added transition from " << state.getId() << " to " << it->first << " with " << rate << std::endl;
                 }
-            }
+
+            } // end while queue
         }
 
+        // Explicitly instantiate the class.
+        template
+        class ExplicitDFTModelBuilder<double, storm::models::sparse::StandardRewardModel<double>, uint32_t>;
+
+#ifdef STORM_HAVE_CARL
+        template class ExplicitDFTModelBuilder<double, storm::models::sparse::StandardRewardModel<storm::Interval>, uint32_t>;
+        template class ExplicitDFTModelBuilder<RationalFunction, storm::models::sparse::StandardRewardModel<RationalFunction>, uint32_t>;
+#endif
+
     } // namespace builder
 } // namespace storm
 
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 7009c4896..8938e690f 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -3,32 +3,42 @@
 
 #include "../storage/dft/DFT.h"
 
+#include <src/models/sparse/StateLabeling.h>
+#include <src/models/sparse/StandardRewardModel.h>
+#include <src/storage/SparseMatrix.h>
+#include <boost/container/flat_set.hpp>
+#include <boost/optional/optional.hpp>
+#include <stack>
 #include <unordered_set>
 
 namespace storm {
     namespace builder {
+
+        template<typename ValueType, typename RewardModelType = storm::models::sparse::StandardRewardModel<ValueType>, typename IndexType = uint32_t>
         class ExplicitDFTModelBuilder {
             storm::storage::DFT const &mDft;
             std::unordered_set<storm::storage::DFTState> mStates;
             size_t newIndex = 0;
-            //std::stack<std::shared_ptr<storm::storage::DFTState>> mStack;
+
+            // The transition matrix.
+            storm::storage::SparseMatrix<ValueType> transitionMatrix;
+
+            // The state labeling.
+            storm::models::sparse::StateLabeling stateLabeling;
+
+            // A vector that stores a labeling for each choice.
+            boost::optional<std::vector<boost::container::flat_set<uint_fast64_t>>> choiceLabeling;
 
         public:
             ExplicitDFTModelBuilder(storm::storage::DFT const &dft) : mDft(dft) {
 
             }
 
-            void buildCTMC() {
-                // Construct starting start
-                storm::storage::DFTState state(mDft, newIndex++);
-                mStates.insert(state);
-                // Begin model generation
-                exploreStateSuccessors(state);
-                std::cout << "Generated " << mStates.size() << " states" << std::endl;
-            }
+            void buildCTMC();
 
         private:
-            void exploreStateSuccessors(storm::storage::DFTState const &state);
+            void exploreStates(std::queue<storm::storage::DFTState>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder);
+
         };
     }
 }
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index d223387e8..9479293d2 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -262,14 +262,14 @@ namespace storm {
         
        
 
-        template<typename FailureRateType>
+        template<typename ValueType>
         class DFTBE : public DFTElement {
 
-            
-            FailureRateType mActiveFailureRate;
-            FailureRateType mPassiveFailureRate;
+
+            ValueType mActiveFailureRate;
+            ValueType mPassiveFailureRate;
         public:
-            DFTBE(size_t id, std::string const& name, FailureRateType failureRate, FailureRateType dormancyFactor) :
+            DFTBE(size_t id, std::string const& name, ValueType failureRate, ValueType dormancyFactor) :
             DFTElement(id, name), mActiveFailureRate(failureRate), mPassiveFailureRate(dormancyFactor * failureRate)
             {
                 
@@ -278,12 +278,12 @@ namespace storm {
             virtual size_t nrChildren() const {
                 return 0;
             }
-            
-            FailureRateType const& activeFailureRate() const {
+
+            ValueType const& activeFailureRate() const {
                 return mActiveFailureRate;
             }
-            
-            FailureRateType const& passiveFailureRate() const {
+
+            ValueType const& passiveFailureRate() const {
                 return mPassiveFailureRate;
             }
         
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index b86781460..75f329ccb 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -21,7 +21,7 @@ int main(int argc, char** argv) {
     dft.printSpareModules();
 
     std::cout << "Building CTMC..." << std::endl;
-    storm::builder::ExplicitDFTModelBuilder builder(dft);
+    storm::builder::ExplicitDFTModelBuilder<double> builder(dft);
     builder.buildCTMC();
     std::cout << "Built CTMC" << std::endl;
 
@@ -29,4 +29,3 @@ int main(int argc, char** argv) {
     //TODO check CTMC
     //std::cout << "Checked model" << std::endl;
 }
-

From 4ae86c76f91a1b526076944a6c14f15cf3127629 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 16 Dec 2015 16:53:33 +0100
Subject: [PATCH 009/246] Output uses logger now

Former-commit-id: bb5061ccd41a7c5a7e83f67fa5323e4f138df50c
---
 src/builder/ExplicitDFTModelBuilder.cpp       | 19 ++++---
 src/parser/DFTGalileoParser.cpp               | 15 +++---
 src/storage/dft/DFT.cpp                       | 53 ++++++++++---------
 src/storage/dft/DFT.h                         | 27 +++-------
 src/storage/dft/DFTBuilder.cpp                |  6 ---
 src/storage/dft/DFTElements.h                 | 40 +++++++-------
 src/storage/dft/DFTState.cpp                  |  3 +-
 src/storage/dft/DFTState.h                    | 14 ++---
 .../dft/DFTStateSpaceGenerationQueues.h       |  2 +-
 src/storm-dyftee.cpp                          | 12 +++--
 10 files changed, 90 insertions(+), 101 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 788c5a0fa..bf23c5d4f 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -17,12 +17,11 @@ namespace storm {
 
             // Begin model generation
             exploreStates(stateQueue, transitionMatrixBuilder);
-            //std::cout << "Generated " << mStates.size() << " states" << std::endl;
+            STORM_LOG_DEBUG("Generated " << mStates.size() << " states");
 
             // Build CTMC
             transitionMatrix = transitionMatrixBuilder.build();
-            //std::cout << "TransitionMatrix: " << std::endl;
-            //std::cout << transitionMatrix << std::endl;
+            STORM_LOG_DEBUG("TransitionMatrix: " << std::endl << transitionMatrix);
             // TODO Matthias: build CTMC
         }
 
@@ -44,7 +43,7 @@ namespace storm {
 
                 // Let BE fail
                 while (smallest < state.nrFailableBEs()) {
-                    //std::cout << "exploring from: " << mDft.getStateString(state) << std::endl;
+                    STORM_LOG_TRACE("exploring from: " << mDft.getStateString(state));
 
                     storm::storage::DFTState newState(state);
                     std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType>>, bool> nextBE = newState.letNextBEFail(smallest++);
@@ -53,7 +52,7 @@ namespace storm {
                         break;
 
                     }
-                    //std::cout << "with the failure of: " << nextBE.first->name() << " [" << nextBE.first->id() << "]" << std::endl;
+                    STORM_LOG_TRACE("with the failure of: " << nextBE.first->name() << " [" << nextBE.first->id() << "]");
 
                     storm::storage::DFTStateSpaceGenerationQueues queues;
 
@@ -85,22 +84,22 @@ namespace storm {
                         auto itInsert = mStates.insert(newState);
                         assert(itInsert.second);
                         it = itInsert.first;
-                        //std::cout << "New state " << mDft.getStateString(newState) << std::endl;
+                        STORM_LOG_TRACE("New state " << mDft.getStateString(newState));
 
                         // Recursive call
                         if (!mDft.hasFailed(newState) && !mDft.isFailsafe(newState)) {
                             stateQueue.push(newState);
                         } else {
                             if (mDft.hasFailed(newState)) {
-                                //std::cout << "Failed " << mDft.getStateString(newState) << std::endl;
+                                STORM_LOG_TRACE("Failed " << mDft.getStateString(newState));
                             } else {
                                 assert(mDft.isFailsafe(newState));
-                                //std::cout << "Failsafe" << mDft.getStateString(newState) << std::endl;
+                                STORM_LOG_TRACE("Failsafe" << mDft.getStateString(newState));
                             }
                         }
                     } else {
                         // State already exists
-                        //std::cout << "State " << mDft.getStateString(*it) << " already exists" << std::endl;
+                        STORM_LOG_TRACE("State " << mDft.getStateString(*it) << " already exists");
                     }
 
                     // Set transition
@@ -114,7 +113,7 @@ namespace storm {
                 {
                     ValueType rate = it->second / sum;
                     transitionMatrixBuilder.addNextValue(state.getId(), it->first, rate);
-                    //std::cout << "Added transition from " << state.getId() << " to " << it->first << " with " << rate << std::endl;
+                    STORM_LOG_TRACE("Added transition from " << state.getId() << " to " << it->first << " with " << rate);
                 }
 
             } // end while queue
diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index a93e84e92..a710e81d3 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -12,7 +12,10 @@ namespace storm {
     namespace parser {
         storm::storage::DFT DFTGalileoParser::parseDFT(const std::string& filename) {
             if(readFile(filename)) {
-                return mBuilder.build();
+                storm::storage::DFT dft = mBuilder.build();
+                STORM_LOG_DEBUG("Elements:" << std::endl << dft.getElementsString());
+                STORM_LOG_DEBUG("Spare Modules:" << std::endl << dft.getSpareModulesString());
+                return dft;
             } else {
                 throw storm::exceptions::FileIoException();
             }
@@ -24,9 +27,8 @@ namespace storm {
             
             if(firstQuots == std::string::npos) {
                 return name;
-            } else if (secondQuots ==std::string::npos) {
-                std::cerr << "No ending quotation mark found in " << name <<std::endl;
-                throw storm::exceptions::FileIoException();
+            } else if (secondQuots == std::string::npos) {
+                STORM_LOG_THROW(false, storm::exceptions::FileIoException, "No ending quotation mark found in " << name);
             } else {
                 return name.substr(firstQuots+1,secondQuots-1);
             }
@@ -43,7 +45,7 @@ namespace storm {
                 file.open(filename);
             }
             catch (std::ifstream::failure e) {
-                std::cerr << "Exception during file opening on " << filename << "." << std::endl;
+                STORM_LOG_THROW(false, storm::exceptions::FileIoException, "Exception during file opening on " << filename << ".");
                 return false;
             }
             file.exceptions( 0 );
@@ -53,7 +55,7 @@ namespace storm {
             while(std::getline(file, line))
             {
                 bool success = true;
-                std::cout << line << std::endl;
+                STORM_LOG_TRACE("Parsing: " << line);
                 size_t commentstarts = line.find("//");
                 line = line.substr(0, commentstarts);
                 size_t firstsemicolon = line.find(";");
@@ -89,6 +91,7 @@ namespace storm {
                     } else if(tokens[1] == "wsp" || tokens[1] == "csp") {
                         success = mBuilder.addSpareElement(name, childNames);
                     } else if(boost::starts_with(tokens[1], "lambda=")) {
+                        //TODO Matthias: Use ValueType instead of fixed double
                         success = mBuilder.addBasicElement(name, boost::lexical_cast<double>(tokens[1].substr(7)), boost::lexical_cast<double>(tokens[2].substr(5)));
                     } else {
                         STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Type name: " + tokens[1] + "  not recognized.");
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index faed81efd..c7801681b 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -61,60 +61,63 @@ namespace storm {
 
         }
         
-        void DFT::printElements(std::ostream& os) const {
+        std::string DFT::getElementsString() const {
+            std::stringstream stream;
             for (auto const& elem : mElements) {
-                elem->print(os);
-                os << std::endl;
+                stream << "[" << elem->id() << "]" << elem->toString() << std::endl;
             }
+            return stream.str();
         }
-        
-        
 
-        void DFT::printInfo(std::ostream& os) const {
-            os << "Top level index: " << mTopLevelIndex << std::endl << "Nr BEs" << mNrOfBEs << std::endl;
+        std::string DFT::getInfoString() const {
+            std::stringstream stream;
+            stream << "Top level index: " << mTopLevelIndex << ", Nr BEs" << mNrOfBEs;
+            return stream.str();
         }
 
-        void DFT::printSpareModules(std::ostream& os) const {
-            std::cout << "[" << mElements[mTopLevelIndex]->id() << "] {";
+        std::string DFT::getSpareModulesString() const {
+            std::stringstream stream;
+            stream << "[" << mElements[mTopLevelIndex]->id() << "] {";
             std::vector<size_t>::const_iterator it = mTopModule.begin();
             assert(it != mTopModule.end());
-            os << mElements[(*it)]->name();
+            stream << mElements[(*it)]->name();
             ++it;
             while(it != mTopModule.end()) {
-                os <<  ", " << mElements[(*it)]->name();
+                stream <<  ", " << mElements[(*it)]->name();
                 ++it;
             }
-            os << "}" << std::endl;
+            stream << "}" << std::endl;
 
             for(auto const& spareModule : mSpareModules) {
-                std::cout << "[" << mElements[spareModule.first]->name() << "] = {";
-                os.flush();
+                stream << "[" << mElements[spareModule.first]->name() << "] = {";
                 std::vector<size_t>::const_iterator it = spareModule.second.begin();
                 assert(it != spareModule.second.end());
-                os << mElements[(*it)]->name();
+                stream << mElements[(*it)]->name();
                 ++it;
                 while(it != spareModule.second.end()) {
-                    os <<  ", " << mElements[(*it)]->name();
-                    os.flush();
+                    stream <<  ", " << mElements[(*it)]->name();
                     ++it;
                 }
-                os << "}" << std::endl;
+                stream << "}" << std::endl;
             }
+            return stream.str();
         }
 
-        void DFT::printElementsWithState(DFTState const& state, std::ostream& os) const{
+        std::string DFT::getElementsWithStateString(DFTState const& state) const{
+            std::stringstream stream;
             for (auto const& elem : mElements) {
-                os << "[" << elem->id() << "]";
-                elem->print(os);
-                os << "\t** " << state.getElementState(elem->id());
+                stream << "[" << elem->id() << "]";
+                stream << elem->toString();
+                stream << "\t** " << state.getElementState(elem->id());
                 if(elem->isSpareGate()) {
                     if(state.isActiveSpare(elem->id())) {
-                        os << " actively";
+                        stream << " actively";
                     }
-                    os << " using " << state.uses(elem->id());
+                    stream << " using " << state.uses(elem->id());
                 } 
-                std::cout << std::endl;
+                stream << std::endl;
             }
+            return stream.str();
         }
 
         std::string DFT::getStateString(DFTState const& state) const{
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 64a9ccdc4..df97df476 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -11,6 +11,7 @@
 #include <map>
 
 #include "../../utility/math.h"
+#include "src/utility/macros.h"
 #include <boost/iterator/counting_iterator.hpp>
 
 namespace storm {
@@ -143,15 +144,14 @@ namespace storm {
             bool isFailsafe(DFTState const& state) const {
                 return state.isFailsafe(mTopLevelIndex);
             }
-                    
             
-            void printElements(std::ostream& os = std::cout) const;
-            
-            void printInfo(std::ostream& os = std::cout) const;
-            
-            void printSpareModules(std::ostream& os = std::cout) const;
-            
-            void printElementsWithState(DFTState const& state, std::ostream& os = std::cout) const;
+            std::string getElementsString() const;
+
+            std::string getInfoString() const;
+
+            std::string getSpareModulesString() const;
+
+            std::string getElementsWithStateString(DFTState const& state) const;
 
             std::string getStateString(DFTState const& state) const;
             
@@ -163,18 +163,7 @@ namespace storm {
                 return true;
             }
 
-
-
-
         };
-        
-        
-        
-       
-
-        
-        
-        
        
     }
 }
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index d1d6f320f..10d96b6d0 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -34,13 +34,7 @@ namespace storm {
             for(std::shared_ptr<DFTElement> e : elems) {
                 e->setId(id++);
             }
-            for(auto& e : elems) {
-                std::cout << "[" << e->id() << "] ";
-                e->print();
-                std::cout << std::endl;
-            }
             return DFT(elems, mElements[topLevelIdentifier]);
-
         }
         
         unsigned DFTBuilder::computeRank(std::shared_ptr<DFTElement> const& elem) {
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 9479293d2..e7a97e66c 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -96,8 +96,8 @@ namespace storm {
             virtual void extendSpareModule(std::set<size_t>& elementsInModule) const;
             
             virtual size_t nrChildren() const = 0;
-            virtual void print(std::ostream& = std::cout) const = 0;
-            
+            virtual std::string toString() const = 0;
+
             virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const;
             
             virtual std::vector<size_t> independentUnit() const = 0;
@@ -187,16 +187,18 @@ namespace storm {
 
             
             
-            virtual void print(std::ostream& os = std::cout) const override {
-                os << "{" << name() << "} " << typestring() << "( ";
+            virtual std::string toString() const override {
+                std::stringstream stream;
+                stream << "{" << name() << "} " << typestring() << "( ";
                 std::vector<std::shared_ptr<DFTElement>>::const_iterator it = mChildren.begin();
-                os << (*it)->name();
+                stream << (*it)->name();
                 ++it;
                 while(it != mChildren.end()) {
-                    os <<  ", " << (*it)->name();
+                    stream <<  ", " << (*it)->name();
                     ++it;
                 }
-                os << ")";
+                stream << ")";
+                return stream.str();
             }    
             
             virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const override {
@@ -287,8 +289,10 @@ namespace storm {
                 return mPassiveFailureRate;
             }
         
-            void print(std::ostream& os = std::cout) const {
-                os << *this;
+            std::string toString() const {
+                std::stringstream stream;
+                stream << *this;
+                return stream.str();
             }
             
             bool isBasicElement() const {
@@ -372,8 +376,7 @@ namespace storm {
         };
         
         inline std::ostream& operator<<(std::ostream& os, DFTAnd const& gate) {
-            gate.print(os);
-            return os;
+            return os << gate.toString();
         }
        
         
@@ -411,8 +414,7 @@ namespace storm {
         };
         
          inline std::ostream& operator<<(std::ostream& os, DFTOr const& gate) {
-            gate.print(os);
-            return os;
+            return os << gate.toString();
         }
 
         class DFTSeqAnd : public DFTGate {
@@ -463,8 +465,7 @@ namespace storm {
         };
         
          inline std::ostream& operator<<(std::ostream& os, DFTSeqAnd const& gate) {
-            gate.print(os);
-            return os;
+             return os << gate.toString();
         }
         
         class DFTPand : public DFTGate {
@@ -510,8 +511,7 @@ namespace storm {
         };
         
          inline std::ostream& operator<<(std::ostream& os, DFTPand const& gate) {
-            gate.print(os);
-            return os;
+             return os << gate.toString();
         }
         
         class DFTPor : public DFTGate {
@@ -534,8 +534,7 @@ namespace storm {
         };
         
          inline std::ostream& operator<<(std::ostream& os, DFTPor const& gate) {
-            gate.print(os);
-            return os;
+             return os << gate.toString();
         }
 
         class DFTVot : public DFTGate {
@@ -594,8 +593,7 @@ namespace storm {
         };
 
         inline std::ostream& operator<<(std::ostream& os, DFTVot const& gate) {
-            gate.print(os);
-            return os;
+            return os << gate.toString();
         }        
         
         class DFTSpare : public DFTGate {
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index e7756cbbd..599de5525 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -69,8 +69,7 @@ namespace storm {
         std::pair<std::shared_ptr<DFTBE<double>>, bool> DFTState::letNextBEFail(size_t index) 
         {
             assert(index < mIsCurrentlyFailableBE.size());
-            //std::cout << "currently failable: ";
-            //printCurrentlyFailable();
+            STORM_LOG_TRACE("currently failable: " << getCurrentlyFailableString());
             std::pair<std::shared_ptr<DFTBE<double>>,bool> res(mDft.getBasicElement(mIsCurrentlyFailableBE[index]), false);
             mIsCurrentlyFailableBE.erase(mIsCurrentlyFailableBE.begin() + index);
             setFailed(res.first->id());
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 67eec6598..2085ba010 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -4,7 +4,7 @@
 #include "../BitVector.h"
 #include "DFTElementState.h"
 
-#include <iostream>
+#include <sstream>
 
 namespace storm {
     namespace storage {
@@ -111,18 +111,20 @@ namespace storm {
             
             std::pair<std::shared_ptr<DFTBE<double>>, bool> letNextBEFail(size_t smallestIndex = 0);
             
-            void printCurrentlyFailable(std::ostream& os = std::cout) {
+            std::string getCurrentlyFailableString() {
+                std::stringstream stream;
                 auto it = mIsCurrentlyFailableBE.begin();
-                os << "{";
+                stream << "{";
                 if(it != mIsCurrentlyFailableBE.end()) {
-                    os << *it;
+                    stream << *it;
                 }
                 ++it;
                 while(it != mIsCurrentlyFailableBE.end()) {
-                    os << ", " << *it;
+                    stream << ", " << *it;
                     ++it;
                 }
-                os << "}" << std::endl;
+                stream << "}";
+                return stream.str();
             }
 
             friend bool operator==(DFTState const& a, DFTState const& b) {
diff --git a/src/storage/dft/DFTStateSpaceGenerationQueues.h b/src/storage/dft/DFTStateSpaceGenerationQueues.h
index f748e8232..ec0879d52 100644
--- a/src/storage/dft/DFTStateSpaceGenerationQueues.h
+++ b/src/storage/dft/DFTStateSpaceGenerationQueues.h
@@ -31,7 +31,7 @@ namespace storm {
             }
 
             std::shared_ptr<DFTGate> nextFailurePropagation() {
-                std::shared_ptr<DFTGate> next= failurePropagation.top();
+                std::shared_ptr<DFTGate> next = failurePropagation.top();
                 failurePropagation.pop();
                 return next;
             }
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 75f329ccb..bd34cdeea 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -10,22 +10,24 @@ int main(int argc, char** argv) {
     if(argc != 2) {
         std::cout <<  "Storm-DyFTeE should be called with a filename as argument." << std::endl;
     }
+
     storm::utility::setUp();
+    log4cplus::LogLevel level = log4cplus::TRACE_LOG_LEVEL;
+    logger.setLogLevel(level);
+    logger.getAppender("mainConsoleAppender")->setThreshold(level);
 
     std::cout << "Parsing DFT file..." << std::endl;
     storm::parser::DFTGalileoParser parser;
     storm::storage::DFT dft = parser.parseDFT(argv[1]);
 
     std::cout << "Built data structure" << std::endl;
-    dft.printElements();
-    dft.printSpareModules();
 
     std::cout << "Building CTMC..." << std::endl;
     storm::builder::ExplicitDFTModelBuilder<double> builder(dft);
     builder.buildCTMC();
     std::cout << "Built CTMC" << std::endl;
 
-    //std::cout << "Model checking..." << std::endl;
-    //TODO check CTMC
-    //std::cout << "Checked model" << std::endl;
+    std::cout << "Model checking..." << std::endl;
+    //TODO Matthias: check CTMC
+    std::cout << "Checked model" << std::endl;
 }

From 91fe16c699ae3a58f752f99a8bf05ef3b5b5f637 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 16 Dec 2015 17:59:55 +0100
Subject: [PATCH 010/246] 1st try on CTMC model checking

Former-commit-id: 5520801c2d2f0fc7c1ccfae7e33ef3382350eb7b
---
 src/builder/ExplicitDFTModelBuilder.cpp | 34 ++++++++++++++++++++++---
 src/builder/ExplicitDFTModelBuilder.h   | 30 ++++++++++++++--------
 src/storm-dyftee.cpp                    | 17 ++++++++++---
 3 files changed, 64 insertions(+), 17 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index bf23c5d4f..6e938f289 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -1,10 +1,16 @@
 #include "src/builder/ExplicitDFTModelBuilder.h"
+#include <src/models/sparse/Ctmc.h>
 
 namespace storm {
     namespace builder {
 
+        template <typename ValueType, typename RewardModelType, typename IndexType>
+        ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::ModelComponents::ModelComponents() : transitionMatrix(), stateLabeling(), rewardModels(), choiceLabeling() {
+            // Intentionally left empty.
+        }
+
         template<typename ValueType, typename RewardModelType, typename IndexType>
-        void ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::buildCTMC() {
+        std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>> ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::buildCTMC() {
             // Initialize
             storm::storage::DFTState state(mDft, newIndex++);
             mStates.insert(state);
@@ -20,9 +26,29 @@ namespace storm {
             STORM_LOG_DEBUG("Generated " << mStates.size() << " states");
 
             // Build CTMC
-            transitionMatrix = transitionMatrixBuilder.build();
-            STORM_LOG_DEBUG("TransitionMatrix: " << std::endl << transitionMatrix);
-            // TODO Matthias: build CTMC
+            ModelComponents modelComponents;
+            // Build transition matrix
+            modelComponents.transitionMatrix = transitionMatrixBuilder.build();
+            STORM_LOG_DEBUG("TransitionMatrix: " << std::endl << modelComponents.transitionMatrix);
+
+            // Build state labeling
+            modelComponents.stateLabeling = storm::models::sparse::StateLabeling(mStates.size());
+            // Also label the initial state with the special label "init".
+            modelComponents.stateLabeling.addLabel("init");
+            modelComponents.stateLabeling.addLabelToState("init", 0);
+            // TODO Matthias: not fixed
+            modelComponents.stateLabeling.addLabel("failed");
+            modelComponents.stateLabeling.addLabelToState("failed", 7);
+
+            // TODO Matthias: initialize
+            modelComponents.rewardModels;
+            modelComponents.choiceLabeling;
+
+
+            std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>> model;
+            model = std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>>(new storm::models::sparse::Ctmc<ValueType, RewardModelType>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.rewardModels), std::move(modelComponents.choiceLabeling)));
+            model->printModelInformationToStream(std::cout);
+            return model;
         }
 
         template<typename ValueType, typename RewardModelType, typename IndexType>
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 8938e690f..f5920bb52 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -5,6 +5,7 @@
 
 #include <src/models/sparse/StateLabeling.h>
 #include <src/models/sparse/StandardRewardModel.h>
+#include <src/models/sparse/Model.h>
 #include <src/storage/SparseMatrix.h>
 #include <boost/container/flat_set.hpp>
 #include <boost/optional/optional.hpp>
@@ -16,25 +17,34 @@ namespace storm {
 
         template<typename ValueType, typename RewardModelType = storm::models::sparse::StandardRewardModel<ValueType>, typename IndexType = uint32_t>
         class ExplicitDFTModelBuilder {
-            storm::storage::DFT const &mDft;
-            std::unordered_set<storm::storage::DFTState> mStates;
-            size_t newIndex = 0;
 
-            // The transition matrix.
-            storm::storage::SparseMatrix<ValueType> transitionMatrix;
+            // A structure holding the individual components of a model.
+            struct ModelComponents {
+                ModelComponents();
+
+                // The transition matrix.
+                storm::storage::SparseMatrix<ValueType> transitionMatrix;
+
+                // The state labeling.
+                storm::models::sparse::StateLabeling stateLabeling;
 
-            // The state labeling.
-            storm::models::sparse::StateLabeling stateLabeling;
+                // The reward models associated with the model.
+                std::unordered_map<std::string, storm::models::sparse::StandardRewardModel<typename RewardModelType::ValueType>> rewardModels;
 
-            // A vector that stores a labeling for each choice.
-            boost::optional<std::vector<boost::container::flat_set<uint_fast64_t>>> choiceLabeling;
+                // A vector that stores a labeling for each choice.
+                boost::optional<std::vector<boost::container::flat_set<uint_fast64_t>>> choiceLabeling;
+            };
+
+            storm::storage::DFT const &mDft;
+            std::unordered_set<storm::storage::DFTState> mStates;
+            size_t newIndex = 0;
 
         public:
             ExplicitDFTModelBuilder(storm::storage::DFT const &dft) : mDft(dft) {
 
             }
 
-            void buildCTMC();
+            std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>> buildCTMC();
 
         private:
             void exploreStates(std::queue<storm::storage::DFTState>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder);
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index bd34cdeea..a5a4feb98 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -1,7 +1,9 @@
+#include "logic/Formula.h"
 #include "parser/DFTGalileoParser.h"
 #include "utility/initialize.h"
 #include "builder/ExplicitDFTModelBuilder.h"
-
+#include "modelchecker/results/CheckResult.h"
+#include "utility/storm.h"
 
 /*
  * Entry point for the DyFTeE backend.
@@ -24,10 +26,19 @@ int main(int argc, char** argv) {
 
     std::cout << "Building CTMC..." << std::endl;
     storm::builder::ExplicitDFTModelBuilder<double> builder(dft);
-    builder.buildCTMC();
+    std::shared_ptr<storm::models::sparse::Model<double>> model = builder.buildCTMC();
     std::cout << "Built CTMC" << std::endl;
 
     std::cout << "Model checking..." << std::endl;
-    //TODO Matthias: check CTMC
+    //TODO Matthias: Construct formula, do not fix
+    std::vector<std::shared_ptr<storm::logic::Formula>> formulas = storm::parseFormulasForExplicit("Pmax=?[true U \"failed\"]");
+    assert(formulas.size() == 1);
+    // Verify the model, if a formula was given.
+    std::unique_ptr<storm::modelchecker::CheckResult> result(storm::verifySparseModel(model, formulas[0]));
+    assert(result);
+    std::cout << "Result (initial states): ";
+    result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
+    std::cout << *result << std::endl;
+
     std::cout << "Checked model" << std::endl;
 }

From d5474722c0ed470dad3b5121c5339eb553d0dcad Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 17 Dec 2015 11:35:28 +0100
Subject: [PATCH 011/246] Label generation from FT

Former-commit-id: 111a02a1437345bffd42806fdf6be4d3e252b949
---
 src/builder/ExplicitDFTModelBuilder.cpp | 27 +++++++++++++++++++++----
 src/storage/dft/DFT.h                   | 13 +++++++++++-
 src/storage/dft/DFTState.h              | 11 ++++------
 src/storm-dyftee.cpp                    | 17 ++++++++++++----
 4 files changed, 52 insertions(+), 16 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 6e938f289..bb4204918 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -33,18 +33,37 @@ namespace storm {
 
             // Build state labeling
             modelComponents.stateLabeling = storm::models::sparse::StateLabeling(mStates.size());
-            // Also label the initial state with the special label "init".
+            // Initial state is always first state without any failure
             modelComponents.stateLabeling.addLabel("init");
             modelComponents.stateLabeling.addLabelToState("init", 0);
-            // TODO Matthias: not fixed
+            // Label all states corresponding to their status (failed, failsafe, failed BE)
             modelComponents.stateLabeling.addLabel("failed");
-            modelComponents.stateLabeling.addLabelToState("failed", 7);
+            modelComponents.stateLabeling.addLabel("failsafe");
+            // Collect labels for all BE
+            std::vector<std::shared_ptr<storage::DFTBE<ValueType>>> basicElements = mDft.getBasicElements();
+            for (std::shared_ptr<storage::DFTBE<ValueType>> elem : basicElements) {
+                modelComponents.stateLabeling.addLabel(elem->name() + "_fail");
+            }
+
+            for (storm::storage::DFTState state : mStates) {
+                if (mDft.hasFailed(state)) {
+                    modelComponents.stateLabeling.addLabelToState("failed", state.getId());
+                }
+                if (mDft.isFailsafe(state)) {
+                    modelComponents.stateLabeling.addLabelToState("failsafe", state.getId());
+                };
+                // Set fail status for each BE
+                for (std::shared_ptr<storage::DFTBE<ValueType>> elem : basicElements) {
+                    if (state.hasFailed(elem->id())) {
+                        modelComponents.stateLabeling.addLabelToState(elem->name() + "_fail", state.getId());
+                    }
+                }
+            }
 
             // TODO Matthias: initialize
             modelComponents.rewardModels;
             modelComponents.choiceLabeling;
 
-
             std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>> model;
             model = std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>>(new storm::models::sparse::Ctmc<ValueType, RewardModelType>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.rewardModels), std::move(modelComponents.choiceLabeling)));
             model->printModelInformationToStream(std::cout);
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index df97df476..69a407461 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -136,7 +136,18 @@ namespace storm {
                 assert(mElements[index]->isBasicElement());
                 return std::static_pointer_cast<DFTBE<double>>(mElements[index]);
             }
-            
+
+            std::vector<std::shared_ptr<DFTBE<double>>> getBasicElements() const {
+                std::vector<std::shared_ptr<DFTBE<double>>> elements;
+                for (std::shared_ptr<storm::storage::DFTElement> elem : mElements) {
+                    if (elem->isBasicElement()) {
+                        elements.push_back(std::static_pointer_cast<DFTBE<double>>(elem));
+                    }
+                }
+                return elements;
+            }
+
+
             bool hasFailed(DFTState const& state) const {
                 return state.hasFailed(mTopLevelIndex);
             }
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 2085ba010..788162ce3 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -9,12 +9,11 @@
 namespace storm {
     namespace storage {
        
-        class DFT; 
-        template<typename T>
+        class DFT;
+        template<typename ValueType>
         class DFTBE;
-        
-        
-        
+
+
         class DFTState {
             friend struct std::hash<DFTState>;
         private:
@@ -97,8 +96,6 @@ namespace storm {
              */
             void setUsesAtPosition(size_t usageIndex, size_t child);
             
-            
-            
             bool claimNew(size_t spareId, size_t usageIndex, size_t currentlyUses, std::vector<size_t> const& childIds);
             
             bool hasOutgoingEdges() const {
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index a5a4feb98..d24d2ad08 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -9,7 +9,7 @@
  * Entry point for the DyFTeE backend.
  */
 int main(int argc, char** argv) {
-    if(argc != 2) {
+    if(argc < 2) {
         std::cout <<  "Storm-DyFTeE should be called with a filename as argument." << std::endl;
     }
 
@@ -30,10 +30,19 @@ int main(int argc, char** argv) {
     std::cout << "Built CTMC" << std::endl;
 
     std::cout << "Model checking..." << std::endl;
-    //TODO Matthias: Construct formula, do not fix
-    std::vector<std::shared_ptr<storm::logic::Formula>> formulas = storm::parseFormulasForExplicit("Pmax=?[true U \"failed\"]");
+    // Construct PCTL forumla
+    std::string inputFormula;
+    if (argc < 3) {
+        // Set explicit reachability formula
+        inputFormula = "Pmax=?[true U \"failed\"]";
+    } else {
+        // Read formula from input
+        inputFormula = argv[2];
+    }
+    std::vector<std::shared_ptr<storm::logic::Formula>> formulas = storm::parseFormulasForExplicit(inputFormula);
     assert(formulas.size() == 1);
-    // Verify the model, if a formula was given.
+
+    // Verify the model
     std::unique_ptr<storm::modelchecker::CheckResult> result(storm::verifySparseModel(model, formulas[0]));
     assert(result);
     std::cout << "Result (initial states): ";

From 4343b5b98001bfb8c5d88903db4d0c8aed33e8d2 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 17 Dec 2015 11:55:29 +0100
Subject: [PATCH 012/246] Refactored some classes into templates

Former-commit-id: b495cf93d44619444463b18c189f988a80bf3a55
---
 src/builder/ExplicitDFTModelBuilder.cpp |  3 +--
 src/parser/DFTGalileoParser.cpp         | 21 ++++++++++++----
 src/parser/DFTGalileoParser.h           | 10 +++++---
 src/storage/dft/DFT.h                   |  4 ++-
 src/storage/dft/DFTBuilder.cpp          | 33 ++++++++++++++++---------
 src/storage/dft/DFTBuilder.h            |  7 +++---
 src/storage/dft/DFTState.cpp            |  4 +--
 src/storage/dft/DFTState.h              |  3 ++-
 src/storm-dyftee.cpp                    |  2 +-
 9 files changed, 57 insertions(+), 30 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index bb4204918..6dff245c5 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -165,8 +165,7 @@ namespace storm {
         }
 
         // Explicitly instantiate the class.
-        template
-        class ExplicitDFTModelBuilder<double, storm::models::sparse::StandardRewardModel<double>, uint32_t>;
+        template class ExplicitDFTModelBuilder<double, storm::models::sparse::StandardRewardModel<double>, uint32_t>;
 
 #ifdef STORM_HAVE_CARL
         template class ExplicitDFTModelBuilder<double, storm::models::sparse::StandardRewardModel<storm::Interval>, uint32_t>;
diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index a710e81d3..0bce51685 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -10,7 +10,9 @@
 
 namespace storm {
     namespace parser {
-        storm::storage::DFT DFTGalileoParser::parseDFT(const std::string& filename) {
+
+        template<typename ValueType>
+        storm::storage::DFT DFTGalileoParser<ValueType>::parseDFT(const std::string& filename) {
             if(readFile(filename)) {
                 storm::storage::DFT dft = mBuilder.build();
                 STORM_LOG_DEBUG("Elements:" << std::endl << dft.getElementsString());
@@ -20,8 +22,9 @@ namespace storm {
                 throw storm::exceptions::FileIoException();
             }
         }
-        
-        std::string stripQuotsFromName(std::string const& name) {
+
+        template<typename ValueType>
+        std::string DFTGalileoParser<ValueType>::stripQuotsFromName(std::string const& name) {
             size_t firstQuots = name.find("\"");
             size_t secondQuots = name.find("\"", firstQuots+1);
             
@@ -33,8 +36,9 @@ namespace storm {
                 return name.substr(firstQuots+1,secondQuots-1);
             }
         }
-        
-        bool DFTGalileoParser::readFile(const std::string& filename) {
+
+        template<typename ValueType>
+        bool DFTGalileoParser<ValueType>::readFile(const std::string& filename) {
             // constants
             std::string topleveltoken = "toplevel";
             std::string toplevelId;
@@ -108,6 +112,13 @@ namespace storm {
             file.close();
             return generalSuccess;
         }
+
+        // Explicitly instantiate the class.
+        template class DFTGalileoParser<double>;
+
+#ifdef STORM_HAVE_CARL
+        template class DFTGalileoParser<RationalFunction>;
+#endif
         
     }
 }
\ No newline at end of file
diff --git a/src/parser/DFTGalileoParser.h b/src/parser/DFTGalileoParser.h
index 9d0cc0096..d0f95383e 100644
--- a/src/parser/DFTGalileoParser.h
+++ b/src/parser/DFTGalileoParser.h
@@ -8,16 +8,18 @@
 
 namespace storm {
     namespace parser {
+
+        template<typename ValueType>
         class DFTGalileoParser {
-            storm::storage::DFTBuilder mBuilder;
+            storm::storage::DFTBuilder<ValueType> mBuilder;
         public:
             storm::storage::DFT parseDFT(std::string const& filename);
             
         private:
             bool readFile(std::string const& filename);
-            
-    
-    };
+
+            std::string stripQuotsFromName(std::string const& name);
+        };
 }
 }
 
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 69a407461..3878198bd 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -131,12 +131,14 @@ namespace storm {
                 assert(index < nrElements());
                 return mElements[index];
             }
-            
+
+            // TODO Matthias: template
             std::shared_ptr<DFTBE<double>> getBasicElement(size_t index) const {
                 assert(mElements[index]->isBasicElement());
                 return std::static_pointer_cast<DFTBE<double>>(mElements[index]);
             }
 
+            // TODO Matthias: template
             std::vector<std::shared_ptr<DFTBE<double>>> getBasicElements() const {
                 std::vector<std::shared_ptr<DFTBE<double>>> elements;
                 for (std::shared_ptr<storm::storage::DFTElement> elem : mElements) {
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index 10d96b6d0..bb51852ee 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -12,8 +12,9 @@
 
 namespace storm {
     namespace storage {
-         
-        DFT DFTBuilder::build() {
+
+        template<typename ValueType>
+        DFT DFTBuilder<ValueType>::build() {
             for(auto& elem : mChildNames) {
                 for(auto const& child : elem.second) {
                     std::shared_ptr<DFTGate> gate = std::static_pointer_cast<DFTGate>(elem.first);
@@ -36,8 +37,9 @@ namespace storm {
             }
             return DFT(elems, mElements[topLevelIdentifier]);
         }
-        
-        unsigned DFTBuilder::computeRank(std::shared_ptr<DFTElement> const& elem) {
+
+        template<typename ValueType>
+        unsigned DFTBuilder<ValueType>::computeRank(std::shared_ptr<DFTElement> const& elem) {
             if(elem->rank() == -1) {
                 if(elem->nrChildren() == 0) {
                     elem->setRank(0);
@@ -58,8 +60,9 @@ namespace storm {
 
             return elem->rank();
         }
-        
-        bool DFTBuilder::addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementTypes tp) {
+
+        template<typename ValueType>
+        bool DFTBuilder<ValueType>::addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementTypes tp) {
             assert(children.size() > 0);
             if(mElements.count(name) != 0) {
                 // Element with that name already exists.
@@ -97,9 +100,9 @@ namespace storm {
             mChildNames[element] = children;
             return true;
         }
-        
-        
-        void DFTBuilder::topoVisit(std::shared_ptr<DFTElement> const& n, std::map<std::shared_ptr<DFTElement>, topoSortColour>& visited, std::vector<std::shared_ptr<DFTElement>>& L) {
+
+        template<typename ValueType>
+        void DFTBuilder<ValueType>::topoVisit(std::shared_ptr<DFTElement> const& n, std::map<std::shared_ptr<DFTElement>, topoSortColour>& visited, std::vector<std::shared_ptr<DFTElement>>& L) {
             if(visited[n] == topoSortColour::GREY) {
                 throw storm::exceptions::WrongFormatException("DFT is cyclic");
             } else if(visited[n] == topoSortColour::WHITE) {
@@ -114,7 +117,8 @@ namespace storm {
             }
         }
 
-        std::vector<std::shared_ptr<DFTElement>> DFTBuilder::topoSort() {
+        template<typename ValueType>
+        std::vector<std::shared_ptr<DFTElement>> DFTBuilder<ValueType>::topoSort() {
             std::map<std::shared_ptr<DFTElement>, topoSortColour> visited;
             for(auto const& e : mElements) {
                 visited.insert(std::make_pair(e.second, topoSortColour::WHITE)); 
@@ -126,7 +130,14 @@ namespace storm {
             }
             //std::reverse(L.begin(), L.end()); 
             return L;
-       }
+        }
+
+        // Explicitly instantiate the class.
+        template class DFTBuilder<double>;
+
+#ifdef STORM_HAVE_CARL
+        template class DFTBuilder<RationalFunction>;
+#endif
 
     }
 }
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index 68e64b1dc..a78d62224 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -10,7 +10,8 @@
 namespace storm {
     namespace storage {
         class DFT;
-        
+
+        template<typename ValueType>
         class DFTBuilder {
             
             std::size_t mNextId = 0;
@@ -69,7 +70,7 @@ namespace storm {
                 return true;
             }
             
-            bool addBasicElement(std::string const& name, double failureRate, double dormancyFactor) {
+            bool addBasicElement(std::string const& name, ValueType failureRate, ValueType dormancyFactor) {
                 if(failureRate <= 0.0) {
                     std::cerr << "Failure rate must be positive." << std::endl;
                     return false;
@@ -80,7 +81,7 @@ namespace storm {
                     return false;
                 }
                 
-                mElements[name] = std::make_shared<DFTBE<double>>(mNextId++, name, failureRate, dormancyFactor);
+                mElements[name] = std::make_shared<DFTBE<ValueType>>(mNextId++, name, failureRate, dormancyFactor);
                 return true;
             }
             
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 599de5525..201f32810 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -65,8 +65,8 @@ namespace storm {
             }
         }
 
-        
-        std::pair<std::shared_ptr<DFTBE<double>>, bool> DFTState::letNextBEFail(size_t index) 
+        // TODO Matthias: template
+        std::pair<std::shared_ptr<DFTBE<double>>, bool> DFTState::letNextBEFail(size_t index)
         {
             assert(index < mIsCurrentlyFailableBE.size());
             STORM_LOG_TRACE("currently failable: " << getCurrentlyFailableString());
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 788162ce3..d2964e152 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -105,7 +105,8 @@ namespace storm {
             size_t nrFailableBEs() const {
                 return mIsCurrentlyFailableBE.size();
             }
-            
+
+            // TODO Matthias: template
             std::pair<std::shared_ptr<DFTBE<double>>, bool> letNextBEFail(size_t smallestIndex = 0);
             
             std::string getCurrentlyFailableString() {
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index d24d2ad08..2c85edcf6 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -19,7 +19,7 @@ int main(int argc, char** argv) {
     logger.getAppender("mainConsoleAppender")->setThreshold(level);
 
     std::cout << "Parsing DFT file..." << std::endl;
-    storm::parser::DFTGalileoParser parser;
+    storm::parser::DFTGalileoParser<double> parser;
     storm::storage::DFT dft = parser.parseDFT(argv[1]);
 
     std::cout << "Built data structure" << std::endl;

From 7737205149708a764bfe4194078b83376b79713b Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 17 Dec 2015 12:16:34 +0100
Subject: [PATCH 013/246] More refactoring with templates

Former-commit-id: 6b614ed7f306010c1a3d63ecc5a3d527693fee30
---
 src/builder/ExplicitDFTModelBuilder.h |  4 ++--
 src/parser/DFTGalileoParser.cpp       | 19 +++++++++++++----
 src/parser/DFTGalileoParser.h         |  2 +-
 src/storage/dft/DFT.cpp               | 30 ++++++++++++++++++++-------
 src/storage/dft/DFT.h                 | 15 +++++++-------
 src/storage/dft/DFTBuilder.cpp        |  4 ++--
 src/storage/dft/DFTBuilder.h          |  3 ++-
 src/storage/dft/DFTState.cpp          |  5 +++--
 src/storage/dft/DFTState.h            |  9 +++++---
 src/storm-dyftee.cpp                  | 10 +++++----
 10 files changed, 66 insertions(+), 35 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index f5920bb52..de3a94293 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -35,12 +35,12 @@ namespace storm {
                 boost::optional<std::vector<boost::container::flat_set<uint_fast64_t>>> choiceLabeling;
             };
 
-            storm::storage::DFT const &mDft;
+            storm::storage::DFT<ValueType> const &mDft;
             std::unordered_set<storm::storage::DFTState> mStates;
             size_t newIndex = 0;
 
         public:
-            ExplicitDFTModelBuilder(storm::storage::DFT const &dft) : mDft(dft) {
+            ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const &dft) : mDft(dft) {
 
             }
 
diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index 0bce51685..e3368bbe3 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -4,6 +4,7 @@
 #include <fstream>
 #include <boost/algorithm/string.hpp>
 #include <boost/lexical_cast.hpp>
+#include <src/exceptions/NotImplementedException.h>
 #include "../exceptions/FileIoException.h"
 #include "../exceptions/NotSupportedException.h"
 #include "src/utility/macros.h"
@@ -12,9 +13,9 @@ namespace storm {
     namespace parser {
 
         template<typename ValueType>
-        storm::storage::DFT DFTGalileoParser<ValueType>::parseDFT(const std::string& filename) {
+        storm::storage::DFT<ValueType> DFTGalileoParser<ValueType>::parseDFT(const std::string& filename) {
             if(readFile(filename)) {
-                storm::storage::DFT dft = mBuilder.build();
+                storm::storage::DFT<ValueType> dft = mBuilder.build();
                 STORM_LOG_DEBUG("Elements:" << std::endl << dft.getElementsString());
                 STORM_LOG_DEBUG("Spare Modules:" << std::endl << dft.getSpareModulesString());
                 return dft;
@@ -95,8 +96,18 @@ namespace storm {
                     } else if(tokens[1] == "wsp" || tokens[1] == "csp") {
                         success = mBuilder.addSpareElement(name, childNames);
                     } else if(boost::starts_with(tokens[1], "lambda=")) {
-                        //TODO Matthias: Use ValueType instead of fixed double
-                        success = mBuilder.addBasicElement(name, boost::lexical_cast<double>(tokens[1].substr(7)), boost::lexical_cast<double>(tokens[2].substr(5)));
+                        ValueType failureRate = 0;
+                        ValueType dormancyFactor = 0;
+                        if (std::is_same<ValueType, double>::value) {
+                            failureRate = boost::lexical_cast<double>(tokens[1].substr(7));
+                            dormancyFactor = boost::lexical_cast<double>(tokens[2].substr(5));
+                        } else {
+                            // TODO Matthias: Parse RationalFunction
+                            failureRate;
+                            dormancyFactor;
+                            STORM_LOG_THROW(false, storm::exceptions::NotImplementedException, "Parsing into rational function not supported.");
+                        }
+                        success = mBuilder.addBasicElement(name, failureRate, dormancyFactor);
                     } else {
                         STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Type name: " + tokens[1] + "  not recognized.");
                         success = false;
diff --git a/src/parser/DFTGalileoParser.h b/src/parser/DFTGalileoParser.h
index d0f95383e..4f7da1566 100644
--- a/src/parser/DFTGalileoParser.h
+++ b/src/parser/DFTGalileoParser.h
@@ -13,7 +13,7 @@ namespace storm {
         class DFTGalileoParser {
             storm::storage::DFTBuilder<ValueType> mBuilder;
         public:
-            storm::storage::DFT parseDFT(std::string const& filename);
+            storm::storage::DFT<ValueType> parseDFT(std::string const& filename);
             
         private:
             bool readFile(std::string const& filename);
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index c7801681b..719c59e26 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -2,8 +2,9 @@
 
 namespace storm {
     namespace storage {
-        
-        DFT::DFT(std::vector<std::shared_ptr<DFTElement>> const& elements, std::shared_ptr<DFTElement> const& tle) : mElements(elements), mNrOfBEs(0), mNrOfSpares(0)
+
+        template<typename ValueType>
+        DFT<ValueType>::DFT(std::vector<std::shared_ptr<DFTElement>> const& elements, std::shared_ptr<DFTElement> const& tle) : mElements(elements), mNrOfBEs(0), mNrOfSpares(0)
         {
             assert(elementIndicesCorrect());
 
@@ -60,8 +61,9 @@ namespace storm {
             mTopLevelIndex = tle->id();
 
         }
-        
-        std::string DFT::getElementsString() const {
+
+        template<typename ValueType>
+        std::string DFT<ValueType>::getElementsString() const {
             std::stringstream stream;
             for (auto const& elem : mElements) {
                 stream << "[" << elem->id() << "]" << elem->toString() << std::endl;
@@ -69,13 +71,15 @@ namespace storm {
             return stream.str();
         }
 
-        std::string DFT::getInfoString() const {
+        template<typename ValueType>
+        std::string DFT<ValueType>::getInfoString() const {
             std::stringstream stream;
             stream << "Top level index: " << mTopLevelIndex << ", Nr BEs" << mNrOfBEs;
             return stream.str();
         }
 
-        std::string DFT::getSpareModulesString() const {
+        template<typename ValueType>
+        std::string DFT<ValueType>::getSpareModulesString() const {
             std::stringstream stream;
             stream << "[" << mElements[mTopLevelIndex]->id() << "] {";
             std::vector<size_t>::const_iterator it = mTopModule.begin();
@@ -103,7 +107,8 @@ namespace storm {
             return stream.str();
         }
 
-        std::string DFT::getElementsWithStateString(DFTState const& state) const{
+        template<typename ValueType>
+        std::string DFT<ValueType>::getElementsWithStateString(DFTState const& state) const{
             std::stringstream stream;
             for (auto const& elem : mElements) {
                 stream << "[" << elem->id() << "]";
@@ -120,7 +125,8 @@ namespace storm {
             return stream.str();
         }
 
-        std::string DFT::getStateString(DFTState const& state) const{
+        template<typename ValueType>
+        std::string DFT<ValueType>::getStateString(DFTState const& state) const{
             std::stringstream stream;
             stream << "(" << state.getId() << ") ";
             for (auto const& elem : mElements) {
@@ -134,5 +140,13 @@ namespace storm {
             }
             return stream.str();
         }
+
+        // Explicitly instantiate the class.
+        template class DFT<double>;
+
+#ifdef STORM_HAVE_CARL
+        template class DFT<RationalFunction>;
+#endif
+
     }
 }
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 3878198bd..068ea4ef1 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -26,7 +26,8 @@ namespace storm {
                 }
             }
         };
-        
+
+        template<typename ValueType>
         class DFT {
 
         private:
@@ -132,18 +133,16 @@ namespace storm {
                 return mElements[index];
             }
 
-            // TODO Matthias: template
-            std::shared_ptr<DFTBE<double>> getBasicElement(size_t index) const {
+            std::shared_ptr<DFTBE<ValueType>> getBasicElement(size_t index) const {
                 assert(mElements[index]->isBasicElement());
-                return std::static_pointer_cast<DFTBE<double>>(mElements[index]);
+                return std::static_pointer_cast<DFTBE<ValueType>>(mElements[index]);
             }
 
-            // TODO Matthias: template
-            std::vector<std::shared_ptr<DFTBE<double>>> getBasicElements() const {
-                std::vector<std::shared_ptr<DFTBE<double>>> elements;
+            std::vector<std::shared_ptr<DFTBE<ValueType>>> getBasicElements() const {
+                std::vector<std::shared_ptr<DFTBE<ValueType>>> elements;
                 for (std::shared_ptr<storm::storage::DFTElement> elem : mElements) {
                     if (elem->isBasicElement()) {
-                        elements.push_back(std::static_pointer_cast<DFTBE<double>>(elem));
+                        elements.push_back(std::static_pointer_cast<DFTBE<ValueType>>(elem));
                     }
                 }
                 return elements;
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index bb51852ee..ee7676449 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -14,7 +14,7 @@ namespace storm {
     namespace storage {
 
         template<typename ValueType>
-        DFT DFTBuilder<ValueType>::build() {
+        DFT<ValueType> DFTBuilder<ValueType>::build() {
             for(auto& elem : mChildNames) {
                 for(auto const& child : elem.second) {
                     std::shared_ptr<DFTGate> gate = std::static_pointer_cast<DFTGate>(elem.first);
@@ -35,7 +35,7 @@ namespace storm {
             for(std::shared_ptr<DFTElement> e : elems) {
                 e->setId(id++);
             }
-            return DFT(elems, mElements[topLevelIdentifier]);
+            return DFT<ValueType>(elems, mElements[topLevelIdentifier]);
         }
 
         template<typename ValueType>
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index a78d62224..f129afc0b 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -9,6 +9,7 @@
 
 namespace storm {
     namespace storage {
+        template<typename ValueType>
         class DFT;
 
         template<typename ValueType>
@@ -90,7 +91,7 @@ namespace storm {
                 return mElements.count(tle) > 0;
             }
             
-            DFT build();
+            DFT<ValueType> build();
 
          
         private:
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 201f32810..87838b9a2 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -4,8 +4,9 @@
 
 namespace storm {
     namespace storage {
-        
-        DFTState::DFTState(DFT const& dft, size_t id) : mStatus(dft.stateSize()), mId(id), mDft(dft)  {
+
+        // TODO Matthias: template
+        DFTState::DFTState(DFT<double> const& dft, size_t id) : mStatus(dft.stateSize()), mId(id), mDft(dft)  {
             mInactiveSpares = dft.getSpareIndices();
             dft.initializeUses(*this);
             dft.initializeActivation(*this);
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index d2964e152..1e8f8cb01 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -8,7 +8,8 @@
 
 namespace storm {
     namespace storage {
-       
+
+        template<typename ValueType>
         class DFT;
         template<typename ValueType>
         class DFTBE;
@@ -23,10 +24,12 @@ namespace storm {
             std::vector<size_t> mIsCurrentlyFailableBE;
             std::vector<size_t> mUsedRepresentants;
             bool mValid = true;
-            const DFT& mDft;
+            // TODO Matthias: template
+            const DFT<double>& mDft;
             
         public:
-            DFTState(DFT const& dft, size_t id);
+            // TODO Matthias: template
+            DFTState(DFT<double> const& dft, size_t id);
             
             DFTElementState getElementState(size_t id) const;
 
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 2c85edcf6..7040db9ad 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -5,6 +5,8 @@
 #include "modelchecker/results/CheckResult.h"
 #include "utility/storm.h"
 
+#define VALUE_TYPE double
+
 /*
  * Entry point for the DyFTeE backend.
  */
@@ -19,14 +21,14 @@ int main(int argc, char** argv) {
     logger.getAppender("mainConsoleAppender")->setThreshold(level);
 
     std::cout << "Parsing DFT file..." << std::endl;
-    storm::parser::DFTGalileoParser<double> parser;
-    storm::storage::DFT dft = parser.parseDFT(argv[1]);
+    storm::parser::DFTGalileoParser<VALUE_TYPE> parser;
+    storm::storage::DFT<VALUE_TYPE> dft = parser.parseDFT(argv[1]);
 
     std::cout << "Built data structure" << std::endl;
 
     std::cout << "Building CTMC..." << std::endl;
-    storm::builder::ExplicitDFTModelBuilder<double> builder(dft);
-    std::shared_ptr<storm::models::sparse::Model<double>> model = builder.buildCTMC();
+    storm::builder::ExplicitDFTModelBuilder<VALUE_TYPE> builder(dft);
+    std::shared_ptr<storm::models::sparse::Model<VALUE_TYPE>> model = builder.buildCTMC();
     std::cout << "Built CTMC" << std::endl;
 
     std::cout << "Model checking..." << std::endl;

From 69168e92364f3dda6786629db782c1dc5f4a186f Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 17 Dec 2015 13:52:34 +0100
Subject: [PATCH 014/246] Use rate instead of prob

Former-commit-id: 50bf0a9ba8052385b5dec3002476ae317dc9a593
---
 src/builder/ExplicitDFTModelBuilder.cpp | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 6dff245c5..fb1c5cd33 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -1,5 +1,6 @@
 #include "src/builder/ExplicitDFTModelBuilder.h"
 #include <src/models/sparse/Ctmc.h>
+#include <src/utility/constants.h>
 
 namespace storm {
     namespace builder {
@@ -86,6 +87,14 @@ namespace storm {
 
                 size_t smallest = 0;
 
+                // Add self loop for target states
+                if (mDft.hasFailed(state) || mDft.isFailsafe(state)) {
+                    transitionMatrixBuilder.addNextValue(state.getId(), state.getId(), storm::utility::one<ValueType>());
+                    STORM_LOG_TRACE("Added self loop for " << state.getId());
+                    // No further exploration required
+                    continue;
+                }
+
                 // Let BE fail
                 while (smallest < state.nrFailableBEs()) {
                     STORM_LOG_TRACE("exploring from: " << mDft.getStateString(state));
@@ -131,17 +140,8 @@ namespace storm {
                         it = itInsert.first;
                         STORM_LOG_TRACE("New state " << mDft.getStateString(newState));
 
-                        // Recursive call
-                        if (!mDft.hasFailed(newState) && !mDft.isFailsafe(newState)) {
-                            stateQueue.push(newState);
-                        } else {
-                            if (mDft.hasFailed(newState)) {
-                                STORM_LOG_TRACE("Failed " << mDft.getStateString(newState));
-                            } else {
-                                assert(mDft.isFailsafe(newState));
-                                STORM_LOG_TRACE("Failsafe" << mDft.getStateString(newState));
-                            }
-                        }
+                        // Add state to search
+                        stateQueue.push(newState);
                     } else {
                         // State already exists
                         STORM_LOG_TRACE("State " << mDft.getStateString(*it) << " already exists");
@@ -156,7 +156,8 @@ namespace storm {
                 // Add all transitions
                 for (auto it = outgoingTransitions.begin(); it != outgoingTransitions.end(); ++it)
                 {
-                    ValueType rate = it->second / sum;
+                    // TODO Matthias: correct?
+                    ValueType rate = it->second;// / sum;
                     transitionMatrixBuilder.addNextValue(state.getId(), it->first, rate);
                     STORM_LOG_TRACE("Added transition from " << state.getId() << " to " << it->first << " with " << rate);
                 }

From 7a0207637a68a0a50f2e29c6bc3de230c832047a Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 18 Dec 2015 10:35:15 +0100
Subject: [PATCH 015/246] Small templating

Former-commit-id: 4cc3c301ee2c9260f4125742b078e8fee40321e2
---
 src/storage/dft/DFTElements.cpp | 13 ++++++++++---
 src/storage/dft/DFTElements.h   |  5 +++--
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index 699fe47e5..a9040eab0 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -38,15 +38,22 @@ namespace storm {
         void DFTElement::checkForSymmetricChildren() const {
             
         }
-        
-        template<>
-        bool DFTBE<double>::checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+
+        template<typename ValueType>
+        bool DFTBE<ValueType>::checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
             if(DFTElement::checkDontCareAnymore(state, queues)) {
                 state.beNoLongerFailable(mId);
                 return true;
             }
             return false;
         }
+
+        // Explicitly instantiate the class.
+        template class DFTBE<double>;
+
+#ifdef STORM_HAVE_CARL
+        template class DFTBE<RationalFunction>;
+#endif
         
     }
 }
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index e7a97e66c..7d3c6110c 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -308,8 +308,9 @@ namespace storm {
             }
             virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const;
         };
-        
-        inline std::ostream& operator<<(std::ostream& os, DFTBE<double> const& be) {
+
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTBE<ValueType> const& be) {
             return os << "{" << be.name() << "} BE(" << be.activeFailureRate() << ", " << be.passiveFailureRate() << ")";
         }
 

From 6e2f5602e1406bc81d0a731a87c27eec320f0561 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 18 Dec 2015 14:00:02 +0100
Subject: [PATCH 016/246] Finished templating

Former-commit-id: 7225717fdbc78fcdad9dbc3b7d4ff1fc14a6b318
---
 src/builder/ExplicitDFTModelBuilder.cpp       |  22 +-
 src/builder/ExplicitDFTModelBuilder.h         |   7 +-
 src/storage/dft/DFT.cpp                       |  10 +-
 src/storage/dft/DFT.h                         |  42 +-
 src/storage/dft/DFTBuilder.cpp                |  35 +-
 src/storage/dft/DFTBuilder.h                  |  20 +-
 src/storage/dft/DFTElements.cpp               |  33 +-
 src/storage/dft/DFTElements.h                 | 438 +++++++++---------
 src/storage/dft/DFTState.cpp                  |  96 ++--
 src/storage/dft/DFTState.h                    |  17 +-
 .../dft/DFTStateSpaceGenerationQueues.h       |  49 +-
 src/storage/dft/OrderDFTElementsById.cpp      |  25 +-
 src/storage/dft/OrderDFTElementsById.h        |  16 +-
 13 files changed, 453 insertions(+), 357 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index fb1c5cd33..e039b389f 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -13,10 +13,10 @@ namespace storm {
         template<typename ValueType, typename RewardModelType, typename IndexType>
         std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>> ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::buildCTMC() {
             // Initialize
-            storm::storage::DFTState state(mDft, newIndex++);
+            storm::storage::DFTState<ValueType> state(mDft, newIndex++);
             mStates.insert(state);
 
-            std::queue<storm::storage::DFTState> stateQueue;
+            std::queue<storm::storage::DFTState<ValueType>> stateQueue;
             stateQueue.push(state);
 
             bool deterministicModel = true;
@@ -46,7 +46,7 @@ namespace storm {
                 modelComponents.stateLabeling.addLabel(elem->name() + "_fail");
             }
 
-            for (storm::storage::DFTState state : mStates) {
+            for (storm::storage::DFTState<ValueType> state : mStates) {
                 if (mDft.hasFailed(state)) {
                     modelComponents.stateLabeling.addLabelToState("failed", state.getId());
                 }
@@ -72,7 +72,7 @@ namespace storm {
         }
 
         template<typename ValueType, typename RewardModelType, typename IndexType>
-        void ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::exploreStates(std::queue<storm::storage::DFTState>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder) {
+        void ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::exploreStates(std::queue<storm::storage::DFTState<ValueType>>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder) {
 
             std::vector<std::pair<size_t, ValueType>> outgoingTransitions;
 
@@ -82,7 +82,7 @@ namespace storm {
                 ValueType sum = 0;
 
                 // Consider next state
-                storm::storage::DFTState state = stateQueue.front();
+                storm::storage::DFTState<ValueType> state = stateQueue.front();
                 stateQueue.pop();
 
                 size_t smallest = 0;
@@ -99,7 +99,7 @@ namespace storm {
                 while (smallest < state.nrFailableBEs()) {
                     STORM_LOG_TRACE("exploring from: " << mDft.getStateString(state));
 
-                    storm::storage::DFTState newState(state);
+                    storm::storage::DFTState<ValueType> newState(state);
                     std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType>>, bool> nextBE = newState.letNextBEFail(smallest++);
                     if (nextBE.first == nullptr) {
                         std::cout << "break" << std::endl;
@@ -108,26 +108,26 @@ namespace storm {
                     }
                     STORM_LOG_TRACE("with the failure of: " << nextBE.first->name() << " [" << nextBE.first->id() << "]");
 
-                    storm::storage::DFTStateSpaceGenerationQueues queues;
+                    storm::storage::DFTStateSpaceGenerationQueues<ValueType> queues;
 
-                    for (std::shared_ptr<storm::storage::DFTGate> parent : nextBE.first->parents()) {
+                    for (DFTGatePointer parent : nextBE.first->parents()) {
                         if (newState.isOperational(parent->id())) {
                             queues.propagateFailure(parent);
                         }
                     }
 
                     while (!queues.failurePropagationDone()) {
-                        std::shared_ptr<storm::storage::DFTGate> next = queues.nextFailurePropagation();
+                        DFTGatePointer next = queues.nextFailurePropagation();
                         next->checkFails(newState, queues);
                     }
 
                     while (!queues.failsafePropagationDone()) {
-                        std::shared_ptr<storm::storage::DFTGate> next = queues.nextFailsafePropagation();
+                        DFTGatePointer next = queues.nextFailsafePropagation();
                         next->checkFailsafe(newState, queues);
                     }
 
                     while (!queues.dontCarePropagationDone()) {
-                        std::shared_ptr<storm::storage::DFTElement> next = queues.nextDontCarePropagation();
+                        DFTElementPointer next = queues.nextDontCarePropagation();
                         next->checkDontCareAnymore(newState, queues);
                     }
 
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index de3a94293..8148559c3 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -18,6 +18,9 @@ namespace storm {
         template<typename ValueType, typename RewardModelType = storm::models::sparse::StandardRewardModel<ValueType>, typename IndexType = uint32_t>
         class ExplicitDFTModelBuilder {
 
+            using DFTElementPointer = std::shared_ptr<storm::storage::DFTElement<ValueType>>;
+            using DFTGatePointer = std::shared_ptr<storm::storage::DFTGate<ValueType>>;
+
             // A structure holding the individual components of a model.
             struct ModelComponents {
                 ModelComponents();
@@ -36,7 +39,7 @@ namespace storm {
             };
 
             storm::storage::DFT<ValueType> const &mDft;
-            std::unordered_set<storm::storage::DFTState> mStates;
+            std::unordered_set<storm::storage::DFTState<ValueType>> mStates;
             size_t newIndex = 0;
 
         public:
@@ -47,7 +50,7 @@ namespace storm {
             std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>> buildCTMC();
 
         private:
-            void exploreStates(std::queue<storm::storage::DFTState>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder);
+            void exploreStates(std::queue<storm::storage::DFTState<ValueType>>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder);
 
         };
     }
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 719c59e26..0b8c99685 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -4,7 +4,7 @@ namespace storm {
     namespace storage {
 
         template<typename ValueType>
-        DFT<ValueType>::DFT(std::vector<std::shared_ptr<DFTElement>> const& elements, std::shared_ptr<DFTElement> const& tle) : mElements(elements), mNrOfBEs(0), mNrOfSpares(0)
+        DFT<ValueType>::DFT(DFTElementVector const& elements, DFTElementPointer const& tle) : mElements(elements), mNrOfBEs(0), mNrOfSpares(0)
         {
             assert(elementIndicesCorrect());
 
@@ -19,7 +19,7 @@ namespace storm {
                 }
                 else if(elem->isSpareGate()) {
                     ++mNrOfSpares;
-                    for(auto const& spareReprs : std::static_pointer_cast<DFTSpare>(elem)->children()) {
+                    for(auto const& spareReprs : std::static_pointer_cast<DFTSpare<ValueType>>(elem)->children()) {
                         if(mActivationIndex.count(spareReprs->id()) == 0) {
                             mActivationIndex[spareReprs->id()] =  stateIndex++;
                         }
@@ -34,7 +34,7 @@ namespace storm {
                         mSpareModules.insert(std::make_pair(spareReprs->id(), sparesAndBes));
 
                     }
-                    std::static_pointer_cast<DFTSpare>(elem)->setUseIndex(stateIndex);
+                    std::static_pointer_cast<DFTSpare<ValueType>>(elem)->setUseIndex(stateIndex);
                     mUsageIndex.insert(std::make_pair(elem->id(), stateIndex));
                     stateIndex += mUsageInfoBits;
 
@@ -108,7 +108,7 @@ namespace storm {
         }
 
         template<typename ValueType>
-        std::string DFT<ValueType>::getElementsWithStateString(DFTState const& state) const{
+        std::string DFT<ValueType>::getElementsWithStateString(DFTState<ValueType> const& state) const{
             std::stringstream stream;
             for (auto const& elem : mElements) {
                 stream << "[" << elem->id() << "]";
@@ -126,7 +126,7 @@ namespace storm {
         }
 
         template<typename ValueType>
-        std::string DFT<ValueType>::getStateString(DFTState const& state) const{
+        std::string DFT<ValueType>::getStateString(DFTState<ValueType> const& state) const{
             std::stringstream stream;
             stream << "(" << state.getId() << ") ";
             for (auto const& elem : mElements) {
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 068ea4ef1..0f39e3ddc 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -17,8 +17,9 @@
 namespace storm {
     namespace storage {
 
+        template<typename ValueType>
         struct DFTElementSort {
-            bool operator()(std::shared_ptr<DFTElement> const& a, std::shared_ptr<DFTElement> const& b)  const {
+            bool operator()(std::shared_ptr<DFTElement<ValueType>> const& a, std::shared_ptr<DFTElement<ValueType>> const& b)  const {
                 if (a->rank() == 0 && b->rank() == 0) {
                     return a->isConstant();
                 } else {
@@ -27,11 +28,18 @@ namespace storm {
             }
         };
 
+
+
         template<typename ValueType>
         class DFT {
 
+            using DFTElementPointer = std::shared_ptr<DFTElement<ValueType>>;
+            using DFTElementVector = std::vector<DFTElementPointer>;
+            using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
+            using DFTGateVector = std::vector<DFTGatePointer>;
+
         private:
-            std::vector<std::shared_ptr<DFTElement>> mElements;
+            DFTElementVector mElements;
             size_t mNrOfBEs;
             size_t mNrOfSpares;
             size_t mTopLevelIndex;
@@ -44,9 +52,8 @@ namespace storm {
             std::map<size_t, size_t> mUsageIndex;
             
         public:
-            DFT(std::vector<std::shared_ptr<DFTElement>> const& elements, std::shared_ptr<DFTElement> const& tle);
-            
-            
+            DFT(DFTElementVector const& elements, DFTElementPointer const& tle);
+
             size_t stateSize() const {
                 return mStateSize;
             }
@@ -72,15 +79,15 @@ namespace storm {
                 return mIdToFailureIndex[id];
             }
             
-            void initializeUses(DFTState& state) const {
+            void initializeUses(DFTState<ValueType>& state) const {
                 for(auto const& elem : mElements) {
                     if(elem->isSpareGate()) {
-                        std::static_pointer_cast<DFTSpare>(elem)->initializeUses(state);
+                        std::static_pointer_cast<DFTSpare<ValueType>>(elem)->initializeUses(state);
                     }
                 }
             }
             
-            void initializeActivation(DFTState& state) const {
+            void initializeActivation(DFTState<ValueType>& state) const {
                 state.activate(mTopLevelIndex);
                 for(auto const& elem : mTopModule) {
                     if(mElements[elem]->isSpareGate()) {
@@ -108,8 +115,7 @@ namespace storm {
                 }
             }
             
-            
-            void propagateActivation(DFTState& state, size_t representativeId) const {
+            void propagateActivation(DFTState<ValueType>& state, size_t representativeId) const {
                 state.activate(representativeId);
                 for(size_t id : module(representativeId)) {
                     if(mElements[id]->isSpareGate()) {
@@ -120,15 +126,15 @@ namespace storm {
             
             std::vector<size_t> nonColdBEs() const {
                 std::vector<size_t> result;
-                for(std::shared_ptr<DFTElement> elem : mElements) {
+                for(DFTElementPointer elem : mElements) {
                     if(elem->isBasicElement() && !elem->isColdBasicElement()) {
                         result.push_back(elem->id());
                     }
                 }
                 return result;
             }
-            
-            std::shared_ptr<DFTElement> const& getElement(size_t index) const {
+
+            DFTElementPointer const& getElement(size_t index) const {
                 assert(index < nrElements());
                 return mElements[index];
             }
@@ -140,7 +146,7 @@ namespace storm {
 
             std::vector<std::shared_ptr<DFTBE<ValueType>>> getBasicElements() const {
                 std::vector<std::shared_ptr<DFTBE<ValueType>>> elements;
-                for (std::shared_ptr<storm::storage::DFTElement> elem : mElements) {
+                for (DFTElementPointer elem : mElements) {
                     if (elem->isBasicElement()) {
                         elements.push_back(std::static_pointer_cast<DFTBE<ValueType>>(elem));
                     }
@@ -149,11 +155,11 @@ namespace storm {
             }
 
 
-            bool hasFailed(DFTState const& state) const {
+            bool hasFailed(DFTState<ValueType> const& state) const {
                 return state.hasFailed(mTopLevelIndex);
             }
             
-            bool isFailsafe(DFTState const& state) const {
+            bool isFailsafe(DFTState<ValueType> const& state) const {
                 return state.isFailsafe(mTopLevelIndex);
             }
             
@@ -163,9 +169,9 @@ namespace storm {
 
             std::string getSpareModulesString() const;
 
-            std::string getElementsWithStateString(DFTState const& state) const;
+            std::string getElementsWithStateString(DFTState<ValueType> const& state) const;
 
-            std::string getStateString(DFTState const& state) const;
+            std::string getStateString(DFTState<ValueType> const& state) const;
             
         private:
             bool elementIndicesCorrect() const {
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index ee7676449..870b7f8bf 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -17,7 +17,7 @@ namespace storm {
         DFT<ValueType> DFTBuilder<ValueType>::build() {
             for(auto& elem : mChildNames) {
                 for(auto const& child : elem.second) {
-                    std::shared_ptr<DFTGate> gate = std::static_pointer_cast<DFTGate>(elem.first);
+                    DFTGatePointer gate = std::static_pointer_cast<DFTGate<ValueType>>(elem.first);
                     gate->pushBackChild(mElements[child]);
                     mElements[child]->addParent(gate);
                 }
@@ -30,25 +30,25 @@ namespace storm {
                 computeRank(elem.second);
             }
 
-            std::vector<std::shared_ptr<DFTElement>> elems = topoSort();
+            DFTElementVector elems = topoSort();
             size_t id = 0;
-            for(std::shared_ptr<DFTElement> e : elems) {
+            for(DFTElementPointer e : elems) {
                 e->setId(id++);
             }
             return DFT<ValueType>(elems, mElements[topLevelIdentifier]);
         }
 
         template<typename ValueType>
-        unsigned DFTBuilder<ValueType>::computeRank(std::shared_ptr<DFTElement> const& elem) {
+        unsigned DFTBuilder<ValueType>::computeRank(DFTElementPointer const& elem) {
             if(elem->rank() == -1) {
                 if(elem->nrChildren() == 0) {
                     elem->setRank(0);
                 } else {
-                    std::shared_ptr<DFTGate> gate = std::static_pointer_cast<DFTGate>(elem);
+                    DFTGatePointer gate = std::static_pointer_cast<DFTGate<ValueType>>(elem);
                     unsigned maxrnk = 0;
                     unsigned newrnk = 0;
 
-                    for (std::shared_ptr<DFTElement> const &child : gate->children()) {
+                    for (DFTElementPointer const &child : gate->children()) {
                         newrnk = computeRank(child);
                         if (newrnk > maxrnk) {
                             maxrnk = newrnk;
@@ -68,22 +68,22 @@ namespace storm {
                 // Element with that name already exists.
                 return false;
             }
-            std::shared_ptr<DFTElement> element;
+            DFTElementPointer element;
             switch(tp) {
                 case DFTElementTypes::AND:
-                    element = std::make_shared<DFTAnd>(mNextId++, name);
+                    element = std::make_shared<DFTAnd<ValueType>>(mNextId++, name);
                     break;
                 case DFTElementTypes::OR:
-                    element = std::make_shared<DFTOr>(mNextId++, name);
+                    element = std::make_shared<DFTOr<ValueType>>(mNextId++, name);
                     break;
                 case DFTElementTypes::PAND:
-                    element = std::make_shared<DFTPand>(mNextId++, name);
+                    element = std::make_shared<DFTPand<ValueType>>(mNextId++, name);
                     break;
                 case DFTElementTypes::POR:
-                    element = std::make_shared<DFTPor>(mNextId++, name);
+                    element = std::make_shared<DFTPor<ValueType>>(mNextId++, name);
                     break;
                 case DFTElementTypes::SPARE:
-                   element = std::make_shared<DFTSpare>(mNextId++, name);
+                   element = std::make_shared<DFTSpare<ValueType>>(mNextId++, name);
                    break;
                 case DFTElementTypes::BE:
                 case DFTElementTypes::VOT:
@@ -102,13 +102,13 @@ namespace storm {
         }
 
         template<typename ValueType>
-        void DFTBuilder<ValueType>::topoVisit(std::shared_ptr<DFTElement> const& n, std::map<std::shared_ptr<DFTElement>, topoSortColour>& visited, std::vector<std::shared_ptr<DFTElement>>& L) {
+        void DFTBuilder<ValueType>::topoVisit(DFTElementPointer const& n, std::map<DFTElementPointer, topoSortColour>& visited, DFTElementVector& L) {
             if(visited[n] == topoSortColour::GREY) {
                 throw storm::exceptions::WrongFormatException("DFT is cyclic");
             } else if(visited[n] == topoSortColour::WHITE) {
                 if(n->isGate()) {
                     visited[n] = topoSortColour::GREY;
-                    for(std::shared_ptr<DFTElement> const& c : std::static_pointer_cast<DFTGate>(n)->children()) {
+                    for(DFTElementPointer const& c : std::static_pointer_cast<DFTGate<ValueType>>(n)->children()) {
                         topoVisit(c, visited, L);
                     }
                 }
@@ -117,14 +117,15 @@ namespace storm {
             }
         }
 
+        // TODO Matthias: use typedefs
         template<typename ValueType>
-        std::vector<std::shared_ptr<DFTElement>> DFTBuilder<ValueType>::topoSort() {
-            std::map<std::shared_ptr<DFTElement>, topoSortColour> visited;
+        std::vector<std::shared_ptr<DFTElement<ValueType>>> DFTBuilder<ValueType>::topoSort() {
+            std::map<std::shared_ptr<DFTElement<ValueType>>, topoSortColour> visited;
             for(auto const& e : mElements) {
                 visited.insert(std::make_pair(e.second, topoSortColour::WHITE)); 
             }
 
-            std::vector<std::shared_ptr<DFTElement>> L;
+            std::vector<std::shared_ptr<DFTElement<ValueType>>> L;
             for(auto const& e : visited) {
                 topoVisit(e.first, visited, L);
             }
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index f129afc0b..88fdc6ef0 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -14,11 +14,17 @@ namespace storm {
 
         template<typename ValueType>
         class DFTBuilder {
-            
+
+            using DFTElementPointer = std::shared_ptr<DFTElement<ValueType>>;
+            using DFTElementVector = std::vector<DFTElementPointer>;
+            using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
+            using DFTGateVector = std::vector<DFTGatePointer>;
+
+        private:
             std::size_t mNextId = 0;
             std::string topLevelIdentifier;
-            std::unordered_map<std::string, std::shared_ptr<DFTElement>> mElements;
-            std::unordered_map<std::shared_ptr<DFTElement>, std::vector<std::string>> mChildNames;
+            std::unordered_map<std::string, DFTElementPointer> mElements;
+            std::unordered_map<DFTElementPointer, std::vector<std::string>> mChildNames;
             
         public:
             DFTBuilder() {
@@ -64,7 +70,7 @@ namespace storm {
                     std::cerr << "Voting gates with threshold higher than the number of children is not supported." << std::endl;
                     return false;
                 }
-                std::shared_ptr<DFTElement> element = std::make_shared<DFTVot>(mNextId++, name, threshold);
+                DFTElementPointer element = std::make_shared<DFTVot<ValueType>>(mNextId++, name, threshold);
                 
                 mElements[name] = element;
                 mChildNames[element] = children;
@@ -96,15 +102,15 @@ namespace storm {
          
         private:
             
-            unsigned computeRank(std::shared_ptr<DFTElement> const& elem);
+            unsigned computeRank(DFTElementPointer const& elem);
             
             bool addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementTypes tp);
             
             enum class topoSortColour {WHITE, BLACK, GREY}; 
             
-            void topoVisit(std::shared_ptr<DFTElement> const& n, std::map<std::shared_ptr<DFTElement>, topoSortColour>& visited, std::vector<std::shared_ptr<DFTElement>>& L);
+            void topoVisit(DFTElementPointer const& n, std::map<DFTElementPointer, topoSortColour>& visited, DFTElementVector& L);
 
-            std::vector<std::shared_ptr<DFTElement>> topoSort();
+            DFTElementVector topoSort();
             
         };
     }
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index a9040eab0..0c18e3be6 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -1,11 +1,15 @@
+#include <src/exceptions/NotImplementedException.h>
+#include <src/utility/macros.h>
 #include "DFTElements.h"
 
 namespace storm {
     namespace storage {
-        bool DFTElement::checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+
+        template<typename ValueType>
+        bool DFTElement<ValueType>::checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
             if(!state.dontCare(mId))
             {
-                for(std::shared_ptr<DFTGate> const& parent : mParents) {
+                for(DFTGatePointer const& parent : mParents) {
                     if(state.isOperational(parent->id())) {
                         return false;
                     }
@@ -16,8 +20,9 @@ namespace storm {
             }
             return false;
         }
-        
-        void DFTElement::extendSpareModule(std::set<size_t>& elementsInModule) const {
+
+        template<typename ValueType>
+        void DFTElement<ValueType>::extendSpareModule(std::set<size_t>& elementsInModule) const {
             for(auto const& parent : mParents) {
                 if(elementsInModule.count(parent->id()) == 0 && !parent->isSpareGate()) {
                     elementsInModule.insert(parent->id());
@@ -25,8 +30,9 @@ namespace storm {
                 }
             }
         }
-        
-        void DFTElement::extendUnit(std::set<size_t>& unit) const {
+
+        template<typename ValueType>
+        void DFTElement<ValueType>::extendUnit(std::set<size_t>& unit) const {
             unit.insert(mId);
             for(auto const& parent : mParents) {
                 if(unit.count(parent->id()) != 0) {
@@ -34,20 +40,23 @@ namespace storm {
                 }
             }
         }
-        
-        void DFTElement::checkForSymmetricChildren() const {
-            
+
+        template<typename ValueType>
+        void DFTElement<ValueType>::checkForSymmetricChildren() const {
+            STORM_LOG_THROW(false, storm::exceptions::NotImplementedException, "Not implemented.");
+            assert(false);
         }
 
         template<typename ValueType>
-        bool DFTBE<ValueType>::checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
-            if(DFTElement::checkDontCareAnymore(state, queues)) {
-                state.beNoLongerFailable(mId);
+        bool DFTBE<ValueType>::checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+            if(DFTElement<ValueType>::checkDontCareAnymore(state, queues)) {
+                state.beNoLongerFailable(this->mId);
                 return true;
             }
             return false;
         }
 
+
         // Explicitly instantiate the class.
         template class DFTBE<double>;
 
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 7d3c6110c..6296a176f 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -16,21 +16,28 @@ using std::size_t;
 
 namespace storm {
     namespace storage {
+
+        template<typename ValueType>
         class DFTGate;
-        
+
+        template<typename ValueType>
         class DFTElement {
+
+            using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
+            using DFTGateVector = std::vector<DFTGatePointer>;
+
+
         protected:
             size_t mId;
             std::string mName;
             size_t mRank = -1;
-            std::vector<std::shared_ptr<DFTGate>> mParents;
-            
-
-            
+            DFTGateVector mParents;
 
         public:
-            DFTElement(size_t id, std::string const& name) : mId(id), mName(name)
+            DFTElement(size_t id, std::string const& name) :
+                    mId(id), mName(name)
             {}
+
             virtual ~DFTElement() {}
 
             
@@ -74,7 +81,7 @@ namespace storm {
                 return mName;
             }
             
-            bool addParent(std::shared_ptr<DFTGate> const& e) {
+            bool addParent(DFTGatePointer const& e) {
                 if(std::find(mParents.begin(), mParents.end(), e) != mParents.end()) {
                     return false;
                 }
@@ -89,20 +96,21 @@ namespace storm {
                 return !mParents.empty();
             }
             
-            std::vector<std::shared_ptr<DFTGate>> const& parents() const {
+            DFTGateVector const& parents() const {
                 return mParents;
             }
             
             virtual void extendSpareModule(std::set<size_t>& elementsInModule) const;
             
             virtual size_t nrChildren() const = 0;
+
             virtual std::string toString() const = 0;
 
-            virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const;
+            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const;
             
             virtual std::vector<size_t> independentUnit() const = 0;
         
-            virtual void  extendUnit(std::set<size_t>& unit) const;
+            virtual void extendUnit(std::set<size_t>& unit) const;
 
             void checkForSymmetricChildren() const;
         };
@@ -130,26 +138,34 @@ namespace storm {
                     assert(false);
             }
         }
-        
-        class DFTGate : public DFTElement {
+
+
+
+        template<typename ValueType>
+        class DFTGate : public DFTElement<ValueType> {
+
+            using DFTElementPointer = std::shared_ptr<DFTElement<ValueType>>;
+            using DFTElementVector = std::vector<DFTElementPointer>;
+
         protected:
-            std::vector<std::shared_ptr<DFTElement>> mChildren;
+            DFTElementVector mChildren;
+
         public:
-            DFTGate(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children) :
-            DFTElement(id, name), mChildren(children)
+            DFTGate(size_t id, std::string const& name, DFTElementVector const& children) :
+                    DFTElement<ValueType>(id, name), mChildren(children)
             {}
             
             virtual ~DFTGate() {}
             
-            void pushBackChild(std::shared_ptr<DFTElement> elem) {
+            void pushBackChild(DFTElementPointer elem) {
                 return mChildren.push_back(elem);
             }
 
             size_t nrChildren() const override {
                 return mChildren.size();
             }
-            
-            std::vector<std::shared_ptr<DFTElement>> const& children() const {
+
+            DFTElementVector const& children() const {
                 return mChildren;
             }
             
@@ -159,11 +175,13 @@ namespace storm {
             
             
             virtual std::string typestring() const = 0;
-            virtual void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const = 0;
-            virtual void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const = 0;
+
+            virtual void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const = 0;
+
+            virtual void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const = 0;
             
             virtual void extendSpareModule(std::set<size_t>& elementsInSpareModule) const override {
-                DFTElement::extendSpareModule(elementsInSpareModule);
+                DFTElement<ValueType>::extendSpareModule(elementsInSpareModule);
                 for(auto const& child : mChildren) {
                     if(elementsInSpareModule.count(child->id()) == 0) {
                         elementsInSpareModule.insert(child->id());
@@ -173,24 +191,22 @@ namespace storm {
             }
             
             virtual std::vector<size_t> independentUnit() const override {
-                std::set<size_t> unit = {mId};
+                std::set<size_t> unit = {this->mId};
                 for(auto const& child : mChildren) {
                     child->extendUnit(unit);
                 }
-                for(auto const& parent : mParents) {
+                for(auto const& parent : this->mParents) {
                     if(unit.count(parent->id()) != 0) {
                         return {};
                     } 
                 }
-                return std::vector<size_t>(unit.begin(), unit.end()); 
-           }
-
-            
+                return std::vector<size_t>(unit.begin(), unit.end());
+            }
             
             virtual std::string toString() const override {
                 std::stringstream stream;
-                stream << "{" << name() << "} " << typestring() << "( ";
-                std::vector<std::shared_ptr<DFTElement>>::const_iterator it = mChildren.begin();
+                stream << "{" << this->name() << "} " << typestring() << "( ";
+                typename DFTElementVector::const_iterator it = mChildren.begin();
                 stream << (*it)->name();
                 ++it;
                 while(it != mChildren.end()) {
@@ -199,10 +215,10 @@ namespace storm {
                 }
                 stream << ")";
                 return stream.str();
-            }    
-            
-            virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const override {
-                if(DFTElement::checkDontCareAnymore(state, queues)) {
+            }
+
+            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                if(DFTElement<ValueType>::checkDontCareAnymore(state, queues)) {
                     childrenDontCare(state, queues);
                     return true;
                 }
@@ -210,37 +226,37 @@ namespace storm {
             }
             
             virtual void extendUnit(std::set<size_t>& unit) const override {
-                DFTElement::extendUnit(unit);
+                DFTElement<ValueType>::extendUnit(unit);
                 for(auto const& child : mChildren) {
                     child->extendUnit(unit);
                 }
             }
             
         protected:
-            
-            void fail(DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
-                for(std::shared_ptr<DFTGate> parent : mParents) {
+
+            void fail(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                for(std::shared_ptr<DFTGate> parent : this->mParents) {
                     if(state.isOperational(parent->id())) {
                         queues.propagateFailure(parent);
                     }
                 }
-                state.setFailed(mId);        
+                state.setFailed(this->mId);
             }
-            
-            void failsafe(DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
-                for(std::shared_ptr<DFTGate> parent : mParents) {
+
+            void failsafe(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                for(std::shared_ptr<DFTGate> parent : this->mParents) {
                     if(state.isOperational(parent->id())) {
                         queues.propagateFailsafe(parent);
                     }
                 }
-                state.setFailsafe(mId);
+                state.setFailsafe(this->mId);
             }
-            
-            void childrenDontCare(DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+
+            void childrenDontCare(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
                 queues.propagateDontCare(mChildren);
             }
-            
-            bool hasFailsafeChild(DFTState& state) const {
+
+            bool hasFailsafeChild(DFTState<ValueType>& state) const {
                 for(auto const& child : mChildren) {
                     if(state.isFailsafe(child->id()))
                     {
@@ -249,9 +265,8 @@ namespace storm {
                 }
                 return false;
             }
-            
-            
-            bool hasFailedChild(DFTState& state) const {
+
+            bool hasFailedChild(DFTState<ValueType>& state) const {
                 for(auto const& child : mChildren) {
                     if(state.hasFailed(child->id())) {
                         return true;
@@ -265,17 +280,15 @@ namespace storm {
        
 
         template<typename ValueType>
-        class DFTBE : public DFTElement {
-
+        class DFTBE : public DFTElement<ValueType> {
 
             ValueType mActiveFailureRate;
             ValueType mPassiveFailureRate;
+
         public:
             DFTBE(size_t id, std::string const& name, ValueType failureRate, ValueType dormancyFactor) :
-            DFTElement(id, name), mActiveFailureRate(failureRate), mPassiveFailureRate(dormancyFactor * failureRate)
-            {
-                
-            }
+                    DFTElement<ValueType>(id, name), mActiveFailureRate(failureRate), mPassiveFailureRate(dormancyFactor * failureRate)
+            {}
                         
             virtual size_t nrChildren() const {
                 return 0;
@@ -304,9 +317,10 @@ namespace storm {
             }
             
             virtual std::vector<size_t> independentUnit() const {
-                return {mId};
+                return {this->mId};
             }
-            virtual bool checkDontCareAnymore(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const;
+
+            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const;
         };
 
         template<typename ValueType>
@@ -314,16 +328,17 @@ namespace storm {
             return os << "{" << be.name() << "} BE(" << be.activeFailureRate() << ", " << be.passiveFailureRate() << ")";
         }
 
-        
-        
 
-        class DFTConst : public DFTElement {
+
+        template<typename ValueType>
+        class DFTConst : public DFTElement<ValueType> {
+
             bool mFailed;
+
         public:
-            DFTConst(size_t id, std::string const& name, bool failed) : DFTElement(id, name), mFailed(failed) 
-            {
-                
-            }
+            DFTConst(size_t id, std::string const& name, bool failed) :
+                    DFTElement<ValueType>(id, name), mFailed(failed)
+            {}
             
             bool failed() const {
                 return mFailed;
@@ -339,96 +354,96 @@ namespace storm {
             
         };
 
-        class DFTAnd : public DFTGate {
+
+
+        template<typename ValueType>
+        class DFTAnd : public DFTGate<ValueType> {
             
         public:
-            DFTAnd(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
-            DFTGate(id, name, children) 
+            DFTAnd(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children)
             {}
-            
-            void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
-                
-                if(state.isOperational(mId)) {
-                    for(auto const& child : mChildren)
+
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                if(state.isOperational(this->mId)) {
+                    for(auto const& child : this->mChildren)
                     {
                         if(!state.hasFailed(child->id())) {
-                            return;// false;
+                            return;
                         }
                     }
-                    fail(state, queues);
-                    //return true;
-                } 
-                //return false;
+                    this->fail(state, queues);
+                }
             }
-            
-            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const{
-                assert(hasFailsafeChild(state));
-                if(state.isOperational(mId)) {
-                    failsafe(state, queues);
-                    childrenDontCare(state, queues);
-                    //return true;
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
+                assert(this->hasFailsafeChild(state));
+                if(state.isOperational(this->mId)) {
+                    this->failsafe(state, queues);
+                    this->childrenDontCare(state, queues);
                 }
-                //return false;
             }
             
             std::string typestring() const {
                 return "AND";
             }
         };
-        
-        inline std::ostream& operator<<(std::ostream& os, DFTAnd const& gate) {
+
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTAnd<ValueType> const& gate) {
             return os << gate.toString();
         }
-       
+
         
 
-        class DFTOr : public DFTGate {
+        template<typename ValueType>
+        class DFTOr : public DFTGate<ValueType> {
+
         public:
-            DFTOr(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
-            DFTGate(id, name, children) 
+            DFTOr(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children)
             {}
-            
-             void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
-                 assert(hasFailedChild(state));
-                if(state.isOperational(mId)) {
-                    fail(state, queues);
-                    //return true;
-                } 
-                // return false;
+
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                assert(this->hasFailedChild(state));
+                if(state.isOperational(this->mId)) {
+                    this->fail(state, queues);
+                }
             }
-             
-            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const{
-                 for(auto const& child : mChildren) {
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
+                 for(auto const& child : this->mChildren) {
                      if(!state.isFailsafe(child->id())) {
-                         return;// false;
+                         return;
                      }
                  }
-                 failsafe(state, queues);
-                 //return true;
+                 this->failsafe(state, queues);
             }
             
             std::string typestring() const {
                 return "OR";
             }
-        private:
-            //static const std::string typestring = "or";
         };
-        
-         inline std::ostream& operator<<(std::ostream& os, DFTOr const& gate) {
+
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTOr<ValueType> const& gate) {
             return os << gate.toString();
         }
 
-        class DFTSeqAnd : public DFTGate {
+
+
+        template<typename ValueType>
+        class DFTSeqAnd : public DFTGate<ValueType> {
+
         public:
-            DFTSeqAnd(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
-            DFTGate(id, name, children) 
+            DFTSeqAnd(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children)
             {}
-            
-            void checkFails(storm::storage::DFTState& state,  DFTStateSpaceGenerationQueues& queues) const {
-                
-                if(!state.hasFailed(mId)) {
+
+            void checkFails(storm::storage::DFTState<ValueType>& state,  DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                if(!state.hasFailed(this->mId)) {
                     bool childOperationalBefore = false;
-                    for(auto const& child : mChildren)
+                    for(auto const& child : this->mChildren)
                     {
                         if(!state.hasFailed(child->id())) {
                             childOperationalBefore = true;
@@ -436,22 +451,20 @@ namespace storm {
                         else {
                             if(childOperationalBefore) {
                                 state.markAsInvalid();
-                                return; //false;
+                                return;
                             }
                         }
                     }
                     if(!childOperationalBefore) {
                        fail(state, queues);
-                       //return true;
                     }
                   
                 } 
-                //return false;
             }
-            
-            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const{
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
                 assert(hasFailsafeChild(state));
-                if(state.isOperational(mId)) {
+                if(state.isOperational(this->mId)) {
                     failsafe(state, queues);
                     //return true;
                 }
@@ -461,71 +474,74 @@ namespace storm {
             std::string  typestring() const {
                 return "SEQAND";
             }
-        private:
-            //static const std::string typestring = "seqand"; 
         };
-        
-         inline std::ostream& operator<<(std::ostream& os, DFTSeqAnd const& gate) {
+
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTSeqAnd<ValueType> const& gate) {
              return os << gate.toString();
         }
-        
-        class DFTPand : public DFTGate {
+
+
+
+        template<typename ValueType>
+        class DFTPand : public DFTGate<ValueType> {
+
         public:
-            DFTPand(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
-            DFTGate(id, name, children) 
+            DFTPand(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children)
             {}
-            
-            void checkFails(storm::storage::DFTState& state,  DFTStateSpaceGenerationQueues& queues) const {
-                if(state.isOperational(mId)) {
+
+            void checkFails(storm::storage::DFTState<ValueType>& state,  DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                if(state.isOperational(this->mId)) {
                     bool childOperationalBefore = false;
-                    for(auto const& child : mChildren)
+                    for(auto const& child : this->mChildren)
                     {
                         if(!state.hasFailed(child->id())) {
                             childOperationalBefore = true;
                         } else if(childOperationalBefore && state.hasFailed(child->id())){
-                            failsafe(state, queues);
-                            childrenDontCare(state, queues);
-                            return; //false;
+                            this->failsafe(state, queues);
+                            this->childrenDontCare(state, queues);
+                            return;
                         }
                     }
                     if(!childOperationalBefore) {
-                        fail(state, queues);
-                        //return true;
+                        this->fail(state, queues);
                     }
                 }
-                // return false;
             }
-             
-            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const{
-                assert(hasFailsafeChild(state));
-                if(state.isOperational(mId)) {
-                    failsafe(state, queues);
-                    childrenDontCare(state, queues);
-                    //return true;
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
+                assert(this->hasFailsafeChild(state));
+                if(state.isOperational(this->mId)) {
+                    this->failsafe(state, queues);
+                    this->childrenDontCare(state, queues);
                 }
-                //return false;
-            } 
+            }
             
             std::string typestring() const {
                 return "PAND";
             }
         };
         
-         inline std::ostream& operator<<(std::ostream& os, DFTPand const& gate) {
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTPand<ValueType> const& gate) {
              return os << gate.toString();
         }
-        
-        class DFTPor : public DFTGate {
+
+
+
+        template<typename ValueType>
+        class DFTPor : public DFTGate<ValueType> {
         public:
-            DFTPor(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
-            DFTGate(id, name, children) 
+            DFTPor(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children)
             {}
-            
-            void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
+
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
                  assert(false);
             }
-             
-            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const{
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
                 assert(false);
             }
             
@@ -533,58 +549,60 @@ namespace storm {
                 return "POR";
             }
         };
-        
-         inline std::ostream& operator<<(std::ostream& os, DFTPor const& gate) {
+
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTPor<ValueType> const& gate) {
              return os << gate.toString();
         }
 
-        class DFTVot : public DFTGate {
+
+
+        template<typename ValueType>
+        class DFTVot : public DFTGate<ValueType> {
+
         private:
             unsigned mThreshold;
+
         public:
-            DFTVot(size_t id, std::string const& name, unsigned threshold, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
-            DFTGate(id, name, children), mThreshold(threshold)
+            DFTVot(size_t id, std::string const& name, unsigned threshold, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children), mThreshold(threshold)
             {}
-            
-            void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
-                
-                if(state.isOperational(mId)) {
+
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                if(state.isOperational(this->mId)) {
                     unsigned nrFailedChildren = 0;
-                    for(auto const& child : mChildren)
+                    for(auto const& child : this->mChildren)
                     {
                         if(state.hasFailed(child->id())) {
                             ++nrFailedChildren;
                             if(nrFailedChildren >= mThreshold) 
                             {
-                                fail(state, queues);
-                                return;// true;
+                                this->fail(state, queues);
+                                return;
                             }
                         }
                     }
                   
                 } 
-                //    return false;
-               
             }
-            
-            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const{
-                assert(hasFailsafeChild(state));
-                if(state.isOperational(mId)) {
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
+                assert(this->hasFailsafeChild(state));
+                if(state.isOperational(this->mId)) {
                     unsigned nrFailsafeChildren = 0;
-                    for(auto const& child : mChildren)
+                    for(auto const& child : this->mChildren)
                     {
                         if(state.isFailsafe(child->id())) {
                             ++nrFailsafeChildren;
-                            if(nrFailsafeChildren > nrChildren() - mThreshold) 
+                            if(nrFailsafeChildren > this->nrChildren() - mThreshold)
                             {
-                                failsafe(state, queues);
-                                childrenDontCare(state, queues);
-                                return;// true;
+                                this->failsafe(state, queues);
+                                this->childrenDontCare(state, queues);
+                                return;
                             }
                         }
                     }
                 }
-                //return false;
             }
             
             std::string typestring() const {
@@ -593,21 +611,24 @@ namespace storm {
 
         };
 
-        inline std::ostream& operator<<(std::ostream& os, DFTVot const& gate) {
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTVot<ValueType> const& gate) {
             return os << gate.toString();
-        }        
-        
-        class DFTSpare : public DFTGate {
+        }
+
+
+
+        template<typename ValueType>
+        class DFTSpare : public DFTGate<ValueType> {
+
+        private:
             size_t mUseIndex;
             size_t mActiveIndex;
             
         public:
-            DFTSpare(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement>> const& children = {}) :
-            DFTGate(id, name, children)
-            {
-                
-            }
-            
+            DFTSpare(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children)
+            {}
             
             std::string typestring() const {
                 return "SPARE";
@@ -624,39 +645,40 @@ namespace storm {
             void setActiveIndex(size_t activeIndex) {
                 mActiveIndex = activeIndex;
             }
-            
-            void initializeUses(storm::storage::DFTState& state) {
-                assert(mChildren.size() > 0);
-                state.setUsesAtPosition(mUseIndex, mChildren[0]->id());
+
+            void initializeUses(storm::storage::DFTState<ValueType>& state) {
+                assert(this->mChildren.size() > 0);
+                state.setUsesAtPosition(mUseIndex, this->mChildren[0]->id());
             }
-            
-            void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
-                if(state.isOperational(mId)) {
+
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                if(state.isOperational(this->mId)) {
                     size_t uses = state.extractUses(mUseIndex);
                     if(!state.isOperational(uses)) {
                         // TODO compute children ids before.
                         std::vector<size_t> childrenIds;
-                        for(auto const& child : mChildren) {
+                        for(auto const& child : this->mChildren) {
                             childrenIds.push_back(child->id());
                         }
                         
-                        bool claimingSuccessful = state.claimNew(mId, mUseIndex, uses, childrenIds);
+                        bool claimingSuccessful = state.claimNew(this->mId, mUseIndex, uses, childrenIds);
                         if(!claimingSuccessful) {
-                            fail(state, queues);
+                            this->fail(state, queues);
                         }
                     }                  
                 } 
             }
-            
-            void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const {
-                if(state.isOperational(mId)) {
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                if(state.isOperational(this->mId)) {
                     if(state.isFailsafe(state.extractUses((mUseIndex)))) {
-                        failsafe(state, queues);
-                        childrenDontCare(state, queues);
+                        this->failsafe(state, queues);
+                        this->childrenDontCare(state, queues);
                     }
                 }
             }
         };
+
     }
 }
 
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 87838b9a2..98cada93a 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -5,8 +5,8 @@
 namespace storm {
     namespace storage {
 
-        // TODO Matthias: template
-        DFTState::DFTState(DFT<double> const& dft, size_t id) : mStatus(dft.stateSize()), mId(id), mDft(dft)  {
+        template<typename ValueType>
+        DFTState<ValueType>::DFTState(DFT<ValueType> const& dft, size_t id) : mStatus(dft.stateSize()), mId(id), mDft(dft)  {
             mInactiveSpares = dft.getSpareIndices();
             dft.initializeUses(*this);
             dft.initializeActivation(*this);
@@ -14,70 +14,83 @@ namespace storm {
             mIsCurrentlyFailableBE.insert(mIsCurrentlyFailableBE.end(), alwaysActiveBEs.begin(), alwaysActiveBEs.end());
             
         }
-        
-        DFTElementState DFTState::getElementState(size_t id) const {
+
+        template<typename ValueType>
+        DFTElementState DFTState<ValueType>::getElementState(size_t id) const {
             return static_cast<DFTElementState>(getElementStateInt(id));
         }
 
-        int DFTState::getElementStateInt(size_t id) const {
+        template<typename ValueType>
+        int DFTState<ValueType>::getElementStateInt(size_t id) const {
             return mStatus.getAsInt(mDft.failureIndex(id), 2);
         }
 
-        size_t DFTState::getId() const {
+        template<typename ValueType>
+        size_t DFTState<ValueType>::getId() const {
             return mId;
         }
 
-        void DFTState::setId(size_t id) {
+        template<typename ValueType>
+        void DFTState<ValueType>::setId(size_t id) {
             mId = id;
         }
 
-        bool DFTState::isOperational(size_t id) const {
+        template<typename ValueType>
+        bool DFTState<ValueType>::isOperational(size_t id) const {
             return getElementState(id) == DFTElementState::Operational;
         }
 
-        bool DFTState::hasFailed(size_t id) const {
+        template<typename ValueType>
+        bool DFTState<ValueType>::hasFailed(size_t id) const {
             return mStatus[mDft.failureIndex(id)];
         }
 
-        bool DFTState::isFailsafe(size_t id) const {
+        template<typename ValueType>
+        bool DFTState<ValueType>::isFailsafe(size_t id) const {
             return mStatus[mDft.failureIndex(id)+1];
         }
 
-        bool DFTState::dontCare(size_t id) const {
+        template<typename ValueType>
+        bool DFTState<ValueType>::dontCare(size_t id) const {
             return getElementState(id) == DFTElementState::DontCare;
         }
 
-        void DFTState::setFailed(size_t id) {
+        template<typename ValueType>
+        void DFTState<ValueType>::setFailed(size_t id) {
             mStatus.set(mDft.failureIndex(id));
         }
 
-        void DFTState::setFailsafe(size_t id) {
+        template<typename ValueType>
+        void DFTState<ValueType>::setFailsafe(size_t id) {
             mStatus.set(mDft.failureIndex(id)+1);
         }
 
-        void DFTState::setDontCare(size_t id) {
+        template<typename ValueType>
+        void DFTState<ValueType>::setDontCare(size_t id) {
             mStatus.setFromInt(mDft.failureIndex(id), 2, static_cast<uint_fast64_t>(DFTElementState::DontCare) );
         }
-        
-        void DFTState::beNoLongerFailable(size_t id) {
+
+        template<typename ValueType>
+        void DFTState<ValueType>::beNoLongerFailable(size_t id) {
             auto it = std::find(mIsCurrentlyFailableBE.begin(), mIsCurrentlyFailableBE.end(), id);
             if(it != mIsCurrentlyFailableBE.end()) {
                 mIsCurrentlyFailableBE.erase(it);
             }
         }
 
-        // TODO Matthias: template
-        std::pair<std::shared_ptr<DFTBE<double>>, bool> DFTState::letNextBEFail(size_t index)
+        template<typename ValueType>
+        std::pair<std::shared_ptr<DFTBE<ValueType>>, bool> DFTState<ValueType>::letNextBEFail(size_t index)
         {
             assert(index < mIsCurrentlyFailableBE.size());
             STORM_LOG_TRACE("currently failable: " << getCurrentlyFailableString());
-            std::pair<std::shared_ptr<DFTBE<double>>,bool> res(mDft.getBasicElement(mIsCurrentlyFailableBE[index]), false);
+            std::pair<std::shared_ptr<DFTBE<ValueType>>,bool> res(mDft.getBasicElement(mIsCurrentlyFailableBE[index]), false);
             mIsCurrentlyFailableBE.erase(mIsCurrentlyFailableBE.begin() + index);
             setFailed(res.first->id());
             return res;
         }
-        
-        void DFTState::activate(size_t repr) {
+
+        template<typename ValueType>
+        void DFTState<ValueType>::activate(size_t repr) {
             std::vector<size_t>  const& module = mDft.module(repr);
             for(size_t elem : module) {
                 if(mDft.getElement(elem)->isColdBasicElement() && isOperational(elem)) {
@@ -89,33 +102,37 @@ namespace storm {
                 }
             }
         }
-        
-        
-        bool DFTState::isActiveSpare(size_t id) const {
+
+        template<typename ValueType>
+        bool DFTState<ValueType>::isActiveSpare(size_t id) const {
             assert(mDft.getElement(id)->isSpareGate());
             return (std::find(mInactiveSpares.begin(), mInactiveSpares.end(), id) == mInactiveSpares.end());
         }
-        
-        uint_fast64_t DFTState::uses(size_t id) const {
+
+        template<typename ValueType>
+        uint_fast64_t DFTState<ValueType>::uses(size_t id) const {
             return extractUses(mDft.usageIndex(id));
         }
-        
-        uint_fast64_t DFTState::extractUses(size_t from) const {
+
+        template<typename ValueType>
+        uint_fast64_t DFTState<ValueType>::extractUses(size_t from) const {
             assert(mDft.usageInfoBits() < 64);
             return mStatus.getAsInt(from, mDft.usageInfoBits());
         }
-        
-        bool DFTState::isUsed(size_t child) {
+
+        template<typename ValueType>
+        bool DFTState<ValueType>::isUsed(size_t child) {
             return (std::find(mUsedRepresentants.begin(), mUsedRepresentants.end(), child) != mUsedRepresentants.end());
-            
         }
-        
-        void DFTState::setUsesAtPosition(size_t usageIndex, size_t child) {
+
+        template<typename ValueType>
+        void DFTState<ValueType>::setUsesAtPosition(size_t usageIndex, size_t child) {
             mStatus.setFromInt(usageIndex, mDft.usageInfoBits(), child);
             mUsedRepresentants.push_back(child);
         }
-        
-        bool DFTState::claimNew(size_t spareId, size_t usageIndex, size_t currentlyUses, std::vector<size_t> const& childIds) {
+
+        template<typename ValueType>
+        bool DFTState<ValueType>::claimNew(size_t spareId, size_t usageIndex, size_t currentlyUses, std::vector<size_t> const& childIds) {
             auto it = find(childIds.begin(), childIds.end(), currentlyUses);
             assert(it != childIds.end());
             ++it;
@@ -132,5 +149,12 @@ namespace storm {
             return false;
         }
 
+        // Explicitly instantiate the class.
+        template class DFTState<double>;
+
+#ifdef STORM_HAVE_CARL
+        template class DFTState<RationalFunction>;
+#endif
+
     }
-}
+}
\ No newline at end of file
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 1e8f8cb01..4f25550b0 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -14,7 +14,7 @@ namespace storm {
         template<typename ValueType>
         class DFTBE;
 
-
+        template<typename ValueType>
         class DFTState {
             friend struct std::hash<DFTState>;
         private:
@@ -24,12 +24,10 @@ namespace storm {
             std::vector<size_t> mIsCurrentlyFailableBE;
             std::vector<size_t> mUsedRepresentants;
             bool mValid = true;
-            // TODO Matthias: template
-            const DFT<double>& mDft;
+            const DFT<ValueType>& mDft;
             
         public:
-            // TODO Matthias: template
-            DFTState(DFT<double> const& dft, size_t id);
+            DFTState(DFT<ValueType> const& dft, size_t id);
             
             DFTElementState getElementState(size_t id) const;
 
@@ -109,8 +107,7 @@ namespace storm {
                 return mIsCurrentlyFailableBE.size();
             }
 
-            // TODO Matthias: template
-            std::pair<std::shared_ptr<DFTBE<double>>, bool> letNextBEFail(size_t smallestIndex = 0);
+            std::pair<std::shared_ptr<DFTBE<ValueType>>, bool> letNextBEFail(size_t smallestIndex = 0);
             
             std::string getCurrentlyFailableString() {
                 std::stringstream stream;
@@ -137,9 +134,9 @@ namespace storm {
 }
 
 namespace std {
-    template<>
-    struct hash<storm::storage::DFTState> {
-        size_t operator()(storm::storage::DFTState const& s) const {
+    template<typename ValueType>
+    struct hash<storm::storage::DFTState<ValueType>> {
+        size_t operator()(storm::storage::DFTState<ValueType> const& s) const {
             return hash<storm::storage::BitVector>()(s.mStatus);
         }
     };
diff --git a/src/storage/dft/DFTStateSpaceGenerationQueues.h b/src/storage/dft/DFTStateSpaceGenerationQueues.h
index ec0879d52..b881a220b 100644
--- a/src/storage/dft/DFTStateSpaceGenerationQueues.h
+++ b/src/storage/dft/DFTStateSpaceGenerationQueues.h
@@ -10,19 +10,28 @@
 
 namespace storm {
     namespace storage {
+
+        template<typename ValueType>
         class DFTGate;
+        template<typename ValueType>
         class DFTElement;
-        
-    
-        
+
+
+        template<typename ValueType>
         class DFTStateSpaceGenerationQueues {
-            std::priority_queue<std::shared_ptr<DFTGate>, std::vector<std::shared_ptr<DFTGate>>, OrderElementsByRank> failurePropagation;
-            std::vector<std::shared_ptr<DFTGate>> failsafePropagation;
-            std::vector<std::shared_ptr<DFTElement>> dontcarePropagation;
-            std::vector<std::shared_ptr<DFTElement>> activatePropagation;
+
+            using DFTElementPointer = std::shared_ptr<DFTElement<ValueType>>;
+            using DFTElementVector = std::vector<DFTElementPointer>;
+            using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
+            using DFTGateVector = std::vector<DFTGatePointer>;
+
+            std::priority_queue<DFTGatePointer, DFTGateVector, OrderElementsByRank<ValueType>> failurePropagation;
+            DFTGateVector failsafePropagation;
+            DFTElementVector dontcarePropagation;
+            DFTElementVector activatePropagation;
 
         public:
-            void propagateFailure(std::shared_ptr<DFTGate> const& elem) {
+            void propagateFailure(DFTGatePointer const& elem) {
                 failurePropagation.push(elem);
             }
 
@@ -30,8 +39,8 @@ namespace storm {
                 return failurePropagation.empty();
             }
 
-            std::shared_ptr<DFTGate> nextFailurePropagation() {
-                std::shared_ptr<DFTGate> next = failurePropagation.top();
+            DFTGatePointer nextFailurePropagation() {
+                DFTGatePointer next = failurePropagation.top();
                 failurePropagation.pop();
                 return next;
             }
@@ -40,12 +49,12 @@ namespace storm {
                 return failsafePropagation.empty();
             }
             
-            void propagateFailsafe(std::shared_ptr<DFTGate> const& gate) {
+            void propagateFailsafe(DFTGatePointer const& gate) {
                 failsafePropagation.push_back(gate);
             }
-            
-            std::shared_ptr<DFTGate> nextFailsafePropagation() {
-                std::shared_ptr<DFTGate> next = failsafePropagation.back();
+
+            DFTGatePointer nextFailsafePropagation() {
+                DFTGatePointer next = failsafePropagation.back();
                 failsafePropagation.pop_back();
                 return next;
             }
@@ -54,25 +63,23 @@ namespace storm {
                 return dontcarePropagation.empty();
             }
             
-            void propagateDontCare(std::shared_ptr<DFTElement> const& elem) {
+            void propagateDontCare(DFTElementPointer const& elem) {
                 dontcarePropagation.push_back(elem);
             }
             
-            void propagateDontCare(std::vector<std::shared_ptr<DFTElement>> const& elems) {
+            void propagateDontCare(DFTElementVector const& elems) {
                 dontcarePropagation.insert(dontcarePropagation.end(), elems.begin(), elems.end());
             }
             
-            std::shared_ptr<DFTElement> nextDontCarePropagation() {
-                std::shared_ptr<DFTElement> next = dontcarePropagation.back();
+            DFTElementPointer nextDontCarePropagation() {
+                DFTElementPointer next = dontcarePropagation.back();
                 dontcarePropagation.pop_back();
                 return next;
             }
         };
+
     }
-    
 }
 
-
-
 #endif	/* DFTSTATESPACEGENERATIONQUEUES_H */
 
diff --git a/src/storage/dft/OrderDFTElementsById.cpp b/src/storage/dft/OrderDFTElementsById.cpp
index 017969848..6c9493bee 100644
--- a/src/storage/dft/OrderDFTElementsById.cpp
+++ b/src/storage/dft/OrderDFTElementsById.cpp
@@ -3,16 +3,31 @@
 
 namespace storm {
     namespace storage {
-        bool OrderElementsById::operator()(std::shared_ptr<DFTGate> const& a , std::shared_ptr<DFTGate> const& b) const {
+
+        template<typename ValueType>
+        bool OrderElementsById<ValueType>::operator()(std::shared_ptr<DFTGate<ValueType>> const& a , std::shared_ptr<DFTGate<ValueType>> const& b) const {
             return a->id() < b->id();
         }
-        bool OrderElementsById::operator ()(const std::shared_ptr<DFTElement>& a, const std::shared_ptr<DFTElement>& b) const {
+
+        template<typename ValueType>
+        bool OrderElementsById<ValueType>::operator ()(const std::shared_ptr<DFTElement<ValueType>>& a, const std::shared_ptr<DFTElement<ValueType>>& b) const {
             return a->id() < b->id();
         }
-        
-        
-        bool OrderElementsByRank::operator ()(const std::shared_ptr<DFTGate>& a, const std::shared_ptr<DFTGate>& b) const {
+
+
+        template<typename ValueType>
+        bool OrderElementsByRank<ValueType>::operator ()(const std::shared_ptr<DFTGate<ValueType>>& a, const std::shared_ptr<DFTGate<ValueType>>& b) const {
             return a->rank() < b->rank();
         }
+
+
+        // Explicitly instantiate the class.
+        template class OrderElementsById<double>;
+        template class OrderElementsByRank<double>;
+
+#ifdef STORM_HAVE_CARL
+        template class OrderElementsById<RationalFunction>;
+        template class OrderElementsByRank<RationalFunction>;
+#endif
     }
 }
diff --git a/src/storage/dft/OrderDFTElementsById.h b/src/storage/dft/OrderDFTElementsById.h
index 8dfc22da0..821a2de45 100644
--- a/src/storage/dft/OrderDFTElementsById.h
+++ b/src/storage/dft/OrderDFTElementsById.h
@@ -5,16 +5,22 @@
 
 namespace storm {
     namespace storage {
+
+        template<typename ValueType>
         class DFTGate;
+        template<typename ValueType>
         class DFTElement;
-        
+
+        template<typename ValueType>
         struct OrderElementsById {
-            bool operator()(std::shared_ptr<DFTGate> const& a , std::shared_ptr<DFTGate> const& b) const;
-            bool operator()(std::shared_ptr<DFTElement> const& a, std::shared_ptr<DFTElement> const& b) const;
+            bool operator()(std::shared_ptr<DFTGate<ValueType>> const& a , std::shared_ptr<DFTGate<ValueType>> const& b) const;
+
+            bool operator()(std::shared_ptr<DFTElement<ValueType>> const& a, std::shared_ptr<DFTElement<ValueType>> const& b) const;
         };
-        
+
+        template<typename ValueType>
         struct OrderElementsByRank {
-            bool operator()(std::shared_ptr<DFTGate> const& a, std::shared_ptr<DFTGate> const& b) const;
+            bool operator()(std::shared_ptr<DFTGate<ValueType>> const& a, std::shared_ptr<DFTGate<ValueType>> const& b) const;
         };
 
     }

From 4c09f9ce29c23532ca5a71fe473e0670bf2f19a9 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 4 Jan 2016 11:17:44 +0100
Subject: [PATCH 017/246] Minor improvements

Former-commit-id: 63dfd49048df5ec636ca9dd163249e0ea3de76c3
---
 src/parser/DFTGalileoParser.cpp | 12 +++++-------
 src/solver/Z3SmtSolver.cpp      |  2 +-
 src/storm-dyftee.cpp            |  1 +
 3 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index e3368bbe3..97b095f22 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -41,7 +41,7 @@ namespace storm {
         template<typename ValueType>
         bool DFTGalileoParser<ValueType>::readFile(const std::string& filename) {
             // constants
-            std::string topleveltoken = "toplevel";
+            std::string toplevelToken = "toplevel";
             std::string toplevelId;
 
             std::ifstream file;
@@ -57,23 +57,21 @@ namespace storm {
 
             std::string line;
             bool generalSuccess = true;
-            while(std::getline(file, line))
-            {
+            while(std::getline(file, line)) {
                 bool success = true;
                 STORM_LOG_TRACE("Parsing: " << line);
                 size_t commentstarts = line.find("//");
                 line = line.substr(0, commentstarts);
                 size_t firstsemicolon = line.find(";");
                 line = line.substr(0, firstsemicolon);
-                if (line.find_first_not_of(' ') == std::string::npos)
-                {
+                if (line.find_first_not_of(' ') == std::string::npos) {
                     // Only whitespace
                     continue;
                 }
 
                 // Top level indicator.
-                if(boost::starts_with(line, topleveltoken)) {
-                    toplevelId = stripQuotsFromName(line.substr(topleveltoken.size() + 1));
+                if(boost::starts_with(line, toplevelToken)) {
+                    toplevelId = stripQuotsFromName(line.substr(toplevelToken.size() + 1));
                 }
                 else
                 {
diff --git a/src/solver/Z3SmtSolver.cpp b/src/solver/Z3SmtSolver.cpp
index 1c3495335..eba059635 100644
--- a/src/solver/Z3SmtSolver.cpp
+++ b/src/solver/Z3SmtSolver.cpp
@@ -323,7 +323,7 @@ namespace storm {
 
 		std::vector<storm::expressions::Expression> Z3SmtSolver::getUnsatAssumptions() {
 #ifdef STORM_HAVE_Z3
-            STORM_LOG_THROW(lastResult == SmtSolver::CheckResult::Unsat, storm::exceptions::InvalidStateException, "Unable to generate unsatisfiable core of assumptions, because the last check did not determine the formulas to be unsatisfiable.")
+            STORM_LOG_THROW(lastResult == SmtSolver::CheckResult::Unsat, storm::exceptions::InvalidStateException, "Unable to generate unsatisfiable core of assumptions, because the last check did not determine the formulas to be unsatisfiable.");
             STORM_LOG_THROW(lastCheckAssumptions, storm::exceptions::InvalidStateException, "Unable to generate unsatisfiable core of assumptions, because the last check did not involve assumptions.");
 
 			z3::expr_vector z3UnsatAssumptions = this->solver->unsat_core();
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 7040db9ad..1d2696594 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -13,6 +13,7 @@
 int main(int argc, char** argv) {
     if(argc < 2) {
         std::cout <<  "Storm-DyFTeE should be called with a filename as argument." << std::endl;
+        return 1;
     }
 
     storm::utility::setUp();

From 8271045b27f2cd9e53f80278b8eaae5062f18208 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 8 Jan 2016 18:12:37 +0100
Subject: [PATCH 018/246] ToString is const

Former-commit-id: d512894cf4a5af371607da5b7d7805706783f350
---
 src/storage/expressions/Expression.cpp | 2 +-
 src/storage/expressions/Expression.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/storage/expressions/Expression.cpp b/src/storage/expressions/Expression.cpp
index 96cf57a31..bc539c795 100644
--- a/src/storage/expressions/Expression.cpp
+++ b/src/storage/expressions/Expression.cpp
@@ -162,7 +162,7 @@ namespace storm {
             return this->getBaseExpression().accept(visitor);
         }
         
-        std::string Expression::toString() {
+        std::string Expression::toString() const {
             std::stringstream stream;
             stream << *this;
             return stream.str();
diff --git a/src/storage/expressions/Expression.h b/src/storage/expressions/Expression.h
index e8fe0e60b..0c18f122a 100644
--- a/src/storage/expressions/Expression.h
+++ b/src/storage/expressions/Expression.h
@@ -297,7 +297,7 @@ namespace storm {
              *
              * @return The string representation of the expression.
              */
-            std::string toString();
+            std::string toString() const;
             
             friend std::ostream& operator<<(std::ostream& stream, Expression const& expression);
 

From f38eeff1efe25fd11cee3d6796066c56790320cb Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sat, 9 Jan 2016 11:19:34 +0100
Subject: [PATCH 019/246] First try on parsing of rational functions

Former-commit-id: 63a6ae0d146bc81530ace58c314e5ed88b2ac01a
---
 src/builder/ExplicitDFTModelBuilder.cpp |  2 +-
 src/parser/DFTGalileoParser.cpp         | 69 ++++++++++++++++---------
 src/parser/DFTGalileoParser.h           | 25 +++++++--
 src/parser/ExpressionParser.cpp         | 38 +++++++++++++-
 src/parser/ExpressionParser.h           | 18 ++++++-
 src/storage/dft/DFTElements.h           |  6 ++-
 src/storm-dyftee.cpp                    | 36 ++++++-------
 7 files changed, 139 insertions(+), 55 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index e039b389f..b561bb716 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -79,7 +79,7 @@ namespace storm {
             while (!stateQueue.empty()) {
                 // Initialization
                 outgoingTransitions.clear();
-                ValueType sum = 0;
+                ValueType sum = storm::utility::zero<ValueType>();
 
                 // Consider next state
                 storm::storage::DFTState<ValueType> state = stateQueue.front();
diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index 97b095f22..89ad18ff6 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -4,9 +4,10 @@
 #include <fstream>
 #include <boost/algorithm/string.hpp>
 #include <boost/lexical_cast.hpp>
-#include <src/exceptions/NotImplementedException.h>
-#include "../exceptions/FileIoException.h"
-#include "../exceptions/NotSupportedException.h"
+#include "src/storage/expressions/ExpressionManager.h"
+#include "src/exceptions/NotImplementedException.h"
+#include "src/exceptions/FileIoException.h"
+#include "src/exceptions/NotSupportedException.h"
 #include "src/utility/macros.h"
 
 namespace storm {
@@ -15,7 +16,7 @@ namespace storm {
         template<typename ValueType>
         storm::storage::DFT<ValueType> DFTGalileoParser<ValueType>::parseDFT(const std::string& filename) {
             if(readFile(filename)) {
-                storm::storage::DFT<ValueType> dft = mBuilder.build();
+                storm::storage::DFT<ValueType> dft = builder.build();
                 STORM_LOG_DEBUG("Elements:" << std::endl << dft.getElementsString());
                 STORM_LOG_DEBUG("Spare Modules:" << std::endl << dft.getSpareModulesString());
                 return dft;
@@ -43,6 +44,7 @@ namespace storm {
             // constants
             std::string toplevelToken = "toplevel";
             std::string toplevelId;
+            std::string parametricToken = "param";
 
             std::ifstream file;
             file.exceptions ( std::ifstream::failbit );
@@ -73,8 +75,16 @@ namespace storm {
                 if(boost::starts_with(line, toplevelToken)) {
                     toplevelId = stripQuotsFromName(line.substr(toplevelToken.size() + 1));
                 }
-                else
-                {
+                else if (boost::starts_with(line, parametricToken)) {
+                    if (!std::is_same<ValueType, storm::RationalFunction>::value) {
+                        STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Parameters only allowed when using rational functions.");
+                    }
+                    std::string parameter = stripQuotsFromName(line.substr(parametricToken.size() + 1));
+                    storm::expressions::Variable var = manager->declareRationalVariable(parameter);
+                    identifierMapping.emplace(var.getName(), var);
+                    parser.setIdentifierMapping(identifierMapping);
+                    STORM_LOG_TRACE("Added parameter: " << var.getName());
+                } else {
                     std::vector<std::string> tokens;
                     boost::split(tokens, line, boost::is_any_of(" "));
                     std::string name(stripQuotsFromName(tokens[0]));
@@ -84,28 +94,19 @@ namespace storm {
                         childNames.push_back(stripQuotsFromName(tokens[i]));
                     }
                     if(tokens[1] == "and") {
-                        success = mBuilder.addAndElement(name, childNames);
+                        success = builder.addAndElement(name, childNames);
                     } else if(tokens[1] == "or") {
-                        success = mBuilder.addOrElement(name, childNames);
+                        success = builder.addOrElement(name, childNames);
                     } else if(boost::starts_with(tokens[1], "vot")) {
-                        success = mBuilder.addVotElement(name, boost::lexical_cast<unsigned>(tokens[1].substr(3)), childNames);
+                        success = builder.addVotElement(name, boost::lexical_cast<unsigned>(tokens[1].substr(3)), childNames);
                     } else if(tokens[1] == "pand") {
-                        success = mBuilder.addPandElement(name, childNames);
+                        success = builder.addPandElement(name, childNames);
                     } else if(tokens[1] == "wsp" || tokens[1] == "csp") {
-                        success = mBuilder.addSpareElement(name, childNames);
+                        success = builder.addSpareElement(name, childNames);
                     } else if(boost::starts_with(tokens[1], "lambda=")) {
-                        ValueType failureRate = 0;
-                        ValueType dormancyFactor = 0;
-                        if (std::is_same<ValueType, double>::value) {
-                            failureRate = boost::lexical_cast<double>(tokens[1].substr(7));
-                            dormancyFactor = boost::lexical_cast<double>(tokens[2].substr(5));
-                        } else {
-                            // TODO Matthias: Parse RationalFunction
-                            failureRate;
-                            dormancyFactor;
-                            STORM_LOG_THROW(false, storm::exceptions::NotImplementedException, "Parsing into rational function not supported.");
-                        }
-                        success = mBuilder.addBasicElement(name, failureRate, dormancyFactor);
+                        ValueType failureRate = parseRationalExpression(tokens[1].substr(7));
+                        ValueType dormancyFactor = parseRationalExpression(tokens[2].substr(5));
+                        success = builder.addBasicElement(name, failureRate, dormancyFactor);
                     } else {
                         STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Type name: " + tokens[1] + "  not recognized.");
                         success = false;
@@ -115,17 +116,37 @@ namespace storm {
                     generalSuccess = success;
                 }
             }
-            if(!mBuilder.setTopLevel(toplevelId)) {
+            if(!builder.setTopLevel(toplevelId)) {
                 STORM_LOG_THROW(false, storm::exceptions::FileIoException, "Top level id unknown.");
             }
             file.close();
             return generalSuccess;
         }
 
+        template<typename ValueType>
+        ValueType DFTGalileoParser<ValueType>::parseRationalExpression(std::string const& expr) {
+            assert(false);
+        }
+
+        template<>
+        double DFTGalileoParser<double>::parseRationalExpression(std::string const& expr) {
+            return boost::lexical_cast<double>(expr);
+        }
+
         // Explicitly instantiate the class.
         template class DFTGalileoParser<double>;
 
 #ifdef STORM_HAVE_CARL
+        template<>
+        storm::RationalFunction DFTGalileoParser<storm::RationalFunction>::parseRationalExpression(std::string const& expr) {
+            STORM_LOG_TRACE("Translating expression: " << expr);
+            storm::expressions::Expression expression = parser.parseFromString(expr);
+            STORM_LOG_TRACE("Expression: " << expression);
+            storm::RationalFunction rationalFunction = evaluator.asRational(expression);
+            STORM_LOG_TRACE("Parsed expression: " << rationalFunction);
+            return rationalFunction;
+        }
+
         template class DFTGalileoParser<RationalFunction>;
 #endif
         
diff --git a/src/parser/DFTGalileoParser.h b/src/parser/DFTGalileoParser.h
index 4f7da1566..557803465 100644
--- a/src/parser/DFTGalileoParser.h
+++ b/src/parser/DFTGalileoParser.h
@@ -1,8 +1,11 @@
 #ifndef DFTGALILEOPARSER_H
 #define	DFTGALILEOPARSER_H
 
-#include "../storage/dft/DFT.h"
-#include "../storage/dft/DFTBuilder.h"
+#include "src/storage/dft/DFT.h"
+#include "src/storage/dft/DFTBuilder.h"
+#include "src/storage/expressions/ExpressionManager.h"
+#include "src/parser/ExpressionParser.h"
+#include "src/storage/expressions/ExpressionEvaluator.h"
 
 #include <map>
 
@@ -11,16 +14,30 @@ namespace storm {
 
         template<typename ValueType>
         class DFTGalileoParser {
-            storm::storage::DFTBuilder<ValueType> mBuilder;
+            storm::storage::DFTBuilder<ValueType> builder;
+
+            std::shared_ptr<storm::expressions::ExpressionManager> manager;
+
+            storm::parser::ExpressionParser parser;
+
+            storm::expressions::ExpressionEvaluator<ValueType> evaluator;
+
+            std::unordered_map<std::string, storm::expressions::Expression> identifierMapping;
+
         public:
+            DFTGalileoParser() : manager(new storm::expressions::ExpressionManager()), parser(*manager), evaluator(*manager) {
+            }
+
             storm::storage::DFT<ValueType> parseDFT(std::string const& filename);
             
         private:
             bool readFile(std::string const& filename);
 
             std::string stripQuotsFromName(std::string const& name);
+
+            ValueType parseRationalExpression(std::string const& expr);
         };
-}
+    }
 }
 
 #endif	/* DFTGALILEOPARSER_H */
diff --git a/src/parser/ExpressionParser.cpp b/src/parser/ExpressionParser.cpp
index c67f808e0..0e4d0fbb8 100644
--- a/src/parser/ExpressionParser.cpp
+++ b/src/parser/ExpressionParser.cpp
@@ -5,7 +5,7 @@
 
 namespace storm {
     namespace parser {
-        ExpressionParser::ExpressionParser(storm::expressions::ExpressionManager const& manager, qi::symbols<char, uint_fast64_t> const& invalidIdentifiers_, bool allowBacktracking) : ExpressionParser::base_type(expression), orOperator_(), andOperator_(), equalityOperator_(), relationalOperator_(), plusOperator_(), multiplicationOperator_(), powerOperator_(), unaryOperator_(), floorCeilOperator_(), minMaxOperator_(), trueFalse_(manager), manager(manager.getSharedPointer()), createExpressions(false), acceptDoubleLiterals(true), identifiers_(nullptr), invalidIdentifiers_(invalidIdentifiers_) {
+        ExpressionParser::ExpressionParser(storm::expressions::ExpressionManager const& manager, qi::symbols<char, uint_fast64_t> const& invalidIdentifiers_, bool allowBacktracking) : ExpressionParser::base_type(expression), orOperator_(), andOperator_(), equalityOperator_(), relationalOperator_(), plusOperator_(), multiplicationOperator_(), powerOperator_(), unaryOperator_(), floorCeilOperator_(), minMaxOperator_(), trueFalse_(manager), manager(manager.getSharedPointer()), createExpressions(false), acceptDoubleLiterals(true), deleteIdentifierMapping(false), identifiers_(nullptr), invalidIdentifiers_(invalidIdentifiers_) {
             identifier %= qi::as_string[qi::raw[qi::lexeme[((qi::alpha | qi::char_('_')) >> *(qi::alnum | qi::char_('_')))]]][qi::_pass = phoenix::bind(&ExpressionParser::isValidIdentifier, phoenix::ref(*this), qi::_1)];
             identifier.name("identifier");
             
@@ -126,9 +126,23 @@ namespace storm {
                 this->identifiers_ = nullptr;
             }
         }
-        
+
+        void ExpressionParser::setIdentifierMapping(std::unordered_map<std::string, storm::expressions::Expression> const& identifierMapping) {
+            unsetIdentifierMapping();
+            this->createExpressions = true;
+            this->identifiers_ = new qi::symbols<char, storm::expressions::Expression>();
+            for (auto const& identifierExpressionPair : identifierMapping) {
+                this->identifiers_->add(identifierExpressionPair.first, identifierExpressionPair.second);
+            }
+            deleteIdentifierMapping = true;
+        }
+
         void ExpressionParser::unsetIdentifierMapping() {
             this->createExpressions = false;
+            if (deleteIdentifierMapping) {
+                delete this->identifiers_;
+                deleteIdentifierMapping = false;
+            }
             this->identifiers_ = nullptr;
         }
         
@@ -346,5 +360,25 @@ namespace storm {
             }
             return true;
         }
+
+        storm::expressions::Expression ExpressionParser::parseFromString(std::string const& expressionString) const {
+            PositionIteratorType first(expressionString.begin());
+            PositionIteratorType iter = first;
+            PositionIteratorType last(expressionString.end());
+
+            // Create empty result;
+            storm::expressions::Expression result;
+
+            try {
+                // Start parsing.
+                bool succeeded = qi::phrase_parse(iter, last, *this, boost::spirit::ascii::space | qi::lit("//") >> *(qi::char_ - (qi::eol | qi::eoi)) >> (qi::eol | qi::eoi), result);
+                STORM_LOG_THROW(succeeded, storm::exceptions::WrongFormatException, "Could not parse expression.");
+                STORM_LOG_DEBUG("Parsed expression successfully.");
+            } catch (qi::expectation_failure<PositionIteratorType> const& e) {
+                STORM_LOG_THROW(false, storm::exceptions::WrongFormatException, e.what_);
+            }
+
+            return result;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/parser/ExpressionParser.h b/src/parser/ExpressionParser.h
index 19c129b4a..4d40467a0 100644
--- a/src/parser/ExpressionParser.h
+++ b/src/parser/ExpressionParser.h
@@ -25,7 +25,7 @@ namespace storm {
              * points it would typically allow. This can, for example, be used to prevent errors if the outer grammar
              * also parses boolean conjuncts that are erroneously consumed by the expression parser.
              */
-            ExpressionParser(storm::expressions::ExpressionManager const& manager, qi::symbols<char, uint_fast64_t> const& invalidIdentifiers_, bool allowBacktracking = false);
+            ExpressionParser(storm::expressions::ExpressionManager const& manager, qi::symbols<char, uint_fast64_t> const& invalidIdentifiers_ = qi::symbols<char, uint_fast64_t>(), bool allowBacktracking = false);
             
             ExpressionParser(ExpressionParser const& other) = default;
             ExpressionParser& operator=(ExpressionParser const& other) = default;
@@ -38,6 +38,15 @@ namespace storm {
              * @param identifiers_ A pointer to a mapping from identifiers to expressions.
              */
             void setIdentifierMapping(qi::symbols<char, storm::expressions::Expression> const* identifiers_);
+
+            /*!
+             * Sets an identifier mapping that is used to determine valid variables in the expression. The mapped-to
+             * expressions will be substituted wherever the key value appears in the parsed expression. After setting
+             * this, the parser will generate expressions.
+             *
+             * @param identifierMapping A mapping from identifiers to expressions.
+             */
+            void setIdentifierMapping(std::unordered_map<std::string, storm::expressions::Expression> const& identifierMapping);
             
             /*!
              * Unsets a previously set identifier mapping. This will make the parser not generate expressions any more
@@ -51,7 +60,9 @@ namespace storm {
              * @param flag If set to true, double literals are accepted.
              */
             void setAcceptDoubleLiterals(bool flag);
-            
+
+            storm::expressions::Expression parseFromString(std::string const& expressionString) const;
+
         private:
             struct orOperatorStruct : qi::symbols<char, storm::expressions::OperatorType> {
                 orOperatorStruct() {
@@ -184,6 +195,9 @@ namespace storm {
             // A flag that indicates whether double literals are accepted.
             bool acceptDoubleLiterals;
             
+            // A flag that indicates whether the mapping must be deleted on unsetting.
+            bool deleteIdentifierMapping;
+            
             // The currently used mapping of identifiers to expressions. This is used if the parser is set to create
             // expressions.
             qi::symbols<char, storm::expressions::Expression> const* identifiers_;
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 6296a176f..daa1d3d54 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -11,6 +11,8 @@
 
 #include "DFTState.h"
 #include "DFTStateSpaceGenerationQueues.h"
+#include "src/utility/constants.h"
+#include "src/adapters/CarlAdapter.h"
 
 using std::size_t;
 
@@ -313,9 +315,9 @@ namespace storm {
             }
             
             bool isColdBasicElement() const {
-                return mPassiveFailureRate == 0;
+                return storm::utility::isZero(mPassiveFailureRate);
             }
-            
+
             virtual std::vector<size_t> independentUnit() const {
                 return {this->mId};
             }
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 1d2696594..906e9df21 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -5,7 +5,7 @@
 #include "modelchecker/results/CheckResult.h"
 #include "utility/storm.h"
 
-#define VALUE_TYPE double
+#define VALUE_TYPE storm::RationalFunction
 
 /*
  * Entry point for the DyFTeE backend.
@@ -15,6 +15,15 @@ int main(int argc, char** argv) {
         std::cout <<  "Storm-DyFTeE should be called with a filename as argument." << std::endl;
         return 1;
     }
+    // Construct PCTL forumla
+    std::string inputFormula;
+    if (argc < 3) {
+        // Set explicit reachability formula
+        inputFormula = "Pmax=?[true U \"failed\"]";
+    } else {
+        // Read formula from input
+        inputFormula = argv[2];
+    }
 
     storm::utility::setUp();
     log4cplus::LogLevel level = log4cplus::TRACE_LOG_LEVEL;
@@ -24,33 +33,20 @@ int main(int argc, char** argv) {
     std::cout << "Parsing DFT file..." << std::endl;
     storm::parser::DFTGalileoParser<VALUE_TYPE> parser;
     storm::storage::DFT<VALUE_TYPE> dft = parser.parseDFT(argv[1]);
-
     std::cout << "Built data structure" << std::endl;
 
+    // Verify the model as CTMC
     std::cout << "Building CTMC..." << std::endl;
     storm::builder::ExplicitDFTModelBuilder<VALUE_TYPE> builder(dft);
     std::shared_ptr<storm::models::sparse::Model<VALUE_TYPE>> model = builder.buildCTMC();
     std::cout << "Built CTMC" << std::endl;
-
     std::cout << "Model checking..." << std::endl;
-    // Construct PCTL forumla
-    std::string inputFormula;
-    if (argc < 3) {
-        // Set explicit reachability formula
-        inputFormula = "Pmax=?[true U \"failed\"]";
-    } else {
-        // Read formula from input
-        inputFormula = argv[2];
-    }
     std::vector<std::shared_ptr<storm::logic::Formula>> formulas = storm::parseFormulasForExplicit(inputFormula);
     assert(formulas.size() == 1);
-
-    // Verify the model
-    std::unique_ptr<storm::modelchecker::CheckResult> result(storm::verifySparseModel(model, formulas[0]));
-    assert(result);
+    std::unique_ptr<storm::modelchecker::CheckResult> resultCtmc(storm::verifySparseModel(model, formulas[0]));
+    assert(resultCtmc);
     std::cout << "Result (initial states): ";
-    result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
-    std::cout << *result << std::endl;
-
-    std::cout << "Checked model" << std::endl;
+    resultCtmc->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
+    std::cout << *resultCtmc << std::endl;
+    std::cout << "Checked CTMC" << std::endl;
 }

From 20a5d8e96f025751cb0b31944b6f958a0465f4d8 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sat, 9 Jan 2016 11:20:18 +0100
Subject: [PATCH 020/246] Side conditions for rational functions  cannot be
 checked directly

Former-commit-id: c5e6d79c9d597e11b09c40cbadf1b3af0688ba5f
---
 src/storage/dft/DFTBuilder.h | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index 88fdc6ef0..12d5e88c3 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -78,16 +78,10 @@ namespace storm {
             }
             
             bool addBasicElement(std::string const& name, ValueType failureRate, ValueType dormancyFactor) {
-                if(failureRate <= 0.0) {
-                    std::cerr << "Failure rate must be positive." << std::endl;
-                    return false;
-                }
-                
-                if(dormancyFactor < 0.0 || dormancyFactor > 1.0) {
-                    std::cerr << "Dormancy factor must be between 0 and 1." << std::endl;
-                    return false;
-                }
-                
+                //TODO Matthias: collect constraints for SMT solving
+                //failureRate > 0
+                //0 <= dormancyFactor <= 1
+
                 mElements[name] = std::make_shared<DFTBE<ValueType>>(mNextId++, name, failureRate, dormancyFactor);
                 return true;
             }

From c8d2cf17242d36e81ebe493d264b5ff93cba009b Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sat, 9 Jan 2016 11:23:36 +0100
Subject: [PATCH 021/246] Better distinction between parametric and
 non-parametric DFTs

Former-commit-id: 57ac698a3876d3f6fe1828469d4c7c6d2426aa41
---
 src/storm-dyftee.cpp | 82 +++++++++++++++++++++++++++++---------------
 1 file changed, 54 insertions(+), 28 deletions(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 906e9df21..2e9e88bbf 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -5,24 +5,62 @@
 #include "modelchecker/results/CheckResult.h"
 #include "utility/storm.h"
 
-#define VALUE_TYPE storm::RationalFunction
+/*!
+ * Load DFT from filename, build corresponding CTMC and check against given property.
+ *
+ * @param filename Path to DFT file in Galileo format.
+ * @param property PCTC formula capturing the property to check.
+ */
+template <typename ValueType>
+void analyzeDFT(std::string filename, std::string property) {
+    // Parsing DFT
+    std::cout << "Parsing DFT file..." << std::endl;
+    storm::parser::DFTGalileoParser<ValueType> parser;
+    storm::storage::DFT<ValueType> dft = parser.parseDFT(filename);
+    std::cout << "Built data structure" << std::endl;
+
+    // Building CTMC
+    std::cout << "Building CTMC..." << std::endl;
+    storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft);
+    std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildCTMC();
+    std::cout << "Built CTMC" << std::endl;
+
+    // Model checking
+    std::cout << "Model checking..." << std::endl;
+    std::vector<std::shared_ptr<storm::logic::Formula>> formulas = storm::parseFormulasForExplicit(property);
+    assert(formulas.size() == 1);
+    std::unique_ptr<storm::modelchecker::CheckResult> resultCtmc(storm::verifySparseModel(model, formulas[0]));
+    assert(resultCtmc);
+    std::cout << "Result (initial states): ";
+    resultCtmc->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
+    std::cout << *resultCtmc << std::endl;
+    std::cout << "Checked CTMC" << std::endl;
+}
 
-/*
+/*!
  * Entry point for the DyFTeE backend.
+ *
+ * @param argc The argc argument of main().
+ * @param argv The argv argument of main().
+ * @return Return code, 0 if successfull, not 0 otherwise.
  */
 int main(int argc, char** argv) {
     if(argc < 2) {
         std::cout <<  "Storm-DyFTeE should be called with a filename as argument." << std::endl;
         return 1;
     }
-    // Construct PCTL forumla
-    std::string inputFormula;
-    if (argc < 3) {
-        // Set explicit reachability formula
-        inputFormula = "Pmax=?[true U \"failed\"]";
-    } else {
-        // Read formula from input
-        inputFormula = argv[2];
+
+    // Parse cli arguments
+    bool parametric = false;
+    std::string filename = argv[1];
+    std::string pctlFormula = "Pmax=?[true U \"failed\"]";
+    for (int i = 2; i < argc; ++i) {
+        std::string option = argv[i];
+        if (option == "--parametric") {
+            parametric = true;
+        } else {
+            pctlFormula = option;
+        }
     }
 
     storm::utility::setUp();
@@ -30,23 +68,11 @@ int main(int argc, char** argv) {
     logger.setLogLevel(level);
     logger.getAppender("mainConsoleAppender")->setThreshold(level);
 
-    std::cout << "Parsing DFT file..." << std::endl;
-    storm::parser::DFTGalileoParser<VALUE_TYPE> parser;
-    storm::storage::DFT<VALUE_TYPE> dft = parser.parseDFT(argv[1]);
-    std::cout << "Built data structure" << std::endl;
+    std::cout << "Running " << (parametric ? "parametric " : "") << "DFT analysis on file " << filename << " with property " << pctlFormula << std::endl;
 
-    // Verify the model as CTMC
-    std::cout << "Building CTMC..." << std::endl;
-    storm::builder::ExplicitDFTModelBuilder<VALUE_TYPE> builder(dft);
-    std::shared_ptr<storm::models::sparse::Model<VALUE_TYPE>> model = builder.buildCTMC();
-    std::cout << "Built CTMC" << std::endl;
-    std::cout << "Model checking..." << std::endl;
-    std::vector<std::shared_ptr<storm::logic::Formula>> formulas = storm::parseFormulasForExplicit(inputFormula);
-    assert(formulas.size() == 1);
-    std::unique_ptr<storm::modelchecker::CheckResult> resultCtmc(storm::verifySparseModel(model, formulas[0]));
-    assert(resultCtmc);
-    std::cout << "Result (initial states): ";
-    resultCtmc->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
-    std::cout << *resultCtmc << std::endl;
-    std::cout << "Checked CTMC" << std::endl;
+    if (parametric) {
+        analyzeDFT<storm::RationalFunction>(filename, pctlFormula);
+    } else {
+        analyzeDFT<double>(filename, pctlFormula);
+    }
 }

From 3b9a48136c8192376839fd08c3e09ce77b77fdc3 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sat, 9 Jan 2016 11:53:46 +0100
Subject: [PATCH 022/246] Sort transitions before building them

Former-commit-id: eba930f0b65ac3a44b3acf527f1836d21e576dce
---
 src/builder/ExplicitDFTModelBuilder.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index b561bb716..c0c596b02 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -1,6 +1,7 @@
 #include "src/builder/ExplicitDFTModelBuilder.h"
 #include <src/models/sparse/Ctmc.h>
 #include <src/utility/constants.h>
+#include <map>
 
 namespace storm {
     namespace builder {
@@ -74,7 +75,7 @@ namespace storm {
         template<typename ValueType, typename RewardModelType, typename IndexType>
         void ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::exploreStates(std::queue<storm::storage::DFTState<ValueType>>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder) {
 
-            std::vector<std::pair<size_t, ValueType>> outgoingTransitions;
+            std::map<size_t, ValueType> outgoingTransitions;
 
             while (!stateQueue.empty()) {
                 // Initialization
@@ -149,7 +150,8 @@ namespace storm {
 
                     // Set transition
                     ValueType prob = nextBE.first->activeFailureRate();
-                    outgoingTransitions.push_back(std::make_pair(it->getId(), prob));
+                    auto resultInsert = outgoingTransitions.insert(std::make_pair(it->getId(), prob));
+                    assert(resultInsert.second);
                     sum += prob;
                 } // end while failing BE
 

From e024f314eb2db11f02de7e2c6386523c1f85bd78 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sat, 9 Jan 2016 11:59:30 +0100
Subject: [PATCH 023/246] Added dft examples

Former-commit-id: 43e43c3846364c1b1c3cb0ef93d3ddc81d2b4ac8
---
 examples/dft/and.dft          |  4 ++++
 examples/dft/and_param.dft    |  5 +++++
 examples/dft/or.dft           |  4 ++++
 examples/dft/pand.dft         |  4 ++++
 examples/dft/spare.dft        |  5 +++++
 examples/dft/spare2.dft       |  8 ++++++++
 examples/dft/spare3.dft       | 10 ++++++++++
 examples/dft/spare4.dft       |  9 +++++++++
 examples/dft/tripple_and1.dft |  8 ++++++++
 examples/dft/tripple_and2.dft |  6 ++++++
 examples/dft/voting.dft       |  5 +++++
 11 files changed, 68 insertions(+)
 create mode 100644 examples/dft/and.dft
 create mode 100644 examples/dft/and_param.dft
 create mode 100644 examples/dft/or.dft
 create mode 100644 examples/dft/pand.dft
 create mode 100644 examples/dft/spare.dft
 create mode 100644 examples/dft/spare2.dft
 create mode 100644 examples/dft/spare3.dft
 create mode 100644 examples/dft/spare4.dft
 create mode 100644 examples/dft/tripple_and1.dft
 create mode 100644 examples/dft/tripple_and2.dft
 create mode 100644 examples/dft/voting.dft

diff --git a/examples/dft/and.dft b/examples/dft/and.dft
new file mode 100644
index 000000000..2b06cbe95
--- /dev/null
+++ b/examples/dft/and.dft
@@ -0,0 +1,4 @@
+toplevel "A";
+"A" and "B" "C";
+"B" lambda=0.5 dorm=0.3;
+"C" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/and_param.dft b/examples/dft/and_param.dft
new file mode 100644
index 000000000..8c95a0f2a
--- /dev/null
+++ b/examples/dft/and_param.dft
@@ -0,0 +1,5 @@
+param x;
+toplevel "A";
+"A" and "B" "C";
+"B" lambda=0.5 dorm=0.3;
+"C" lambda=x dorm=0.3;
diff --git a/examples/dft/or.dft b/examples/dft/or.dft
new file mode 100644
index 000000000..b1003da11
--- /dev/null
+++ b/examples/dft/or.dft
@@ -0,0 +1,4 @@
+toplevel "A";
+"A" or "B" "C";
+"B" lambda=0.5 dorm=0.3;
+"C" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/pand.dft b/examples/dft/pand.dft
new file mode 100644
index 000000000..d752517b4
--- /dev/null
+++ b/examples/dft/pand.dft
@@ -0,0 +1,4 @@
+toplevel "A";
+"A" pand "B" "C";
+"B" lambda=0.4 dorm=0.3;
+"C" lambda=0.2 dorm=0.3;
diff --git a/examples/dft/spare.dft b/examples/dft/spare.dft
new file mode 100644
index 000000000..4c5d44ff4
--- /dev/null
+++ b/examples/dft/spare.dft
@@ -0,0 +1,5 @@
+toplevel "A";
+"A" wsp "I" "M";
+"I" lambda=0.5 dorm=0.3;
+"M" lambda=0.5 dorm=0.3;
+
diff --git a/examples/dft/spare2.dft b/examples/dft/spare2.dft
new file mode 100644
index 000000000..21b40cf73
--- /dev/null
+++ b/examples/dft/spare2.dft
@@ -0,0 +1,8 @@
+toplevel "A";
+"A" or "B" "C";
+"B" wsp "I" "J";
+"C" wsp "M" "J";
+"I" lambda=0.5 dorm=0.3;
+"J" lambda=0.5 dorm=0.3;
+"M" lambda=0.5 dorm=0.3;
+
diff --git a/examples/dft/spare3.dft b/examples/dft/spare3.dft
new file mode 100644
index 000000000..ba0ac01d4
--- /dev/null
+++ b/examples/dft/spare3.dft
@@ -0,0 +1,10 @@
+toplevel "A";
+"A" or "B" "C" "D";
+"B" wsp "I" "M";
+"C" wsp "J" "M";
+"D" wsp "K" "M";
+"I" lambda=0.5 dorm=0.3;
+"J" lambda=0.5 dorm=0.3;
+"K" lambda=0.5 dorm=0.3;
+"M" lambda=0.5 dorm=0.3;
+
diff --git a/examples/dft/spare4.dft b/examples/dft/spare4.dft
new file mode 100644
index 000000000..a217c6e43
--- /dev/null
+++ b/examples/dft/spare4.dft
@@ -0,0 +1,9 @@
+toplevel "A";
+"A" and "B" "C";
+"B" wsp "I" "J" "K";
+"C" wsp "M" "J";
+"I" lambda=0.5 dorm=0.3;
+"J" lambda=0.5 dorm=0.3;
+"K" lambda=0.5 dorm=0.3;
+"M" lambda=0.5 dorm=0.3;
+
diff --git a/examples/dft/tripple_and1.dft b/examples/dft/tripple_and1.dft
new file mode 100644
index 000000000..b6f1c04b2
--- /dev/null
+++ b/examples/dft/tripple_and1.dft
@@ -0,0 +1,8 @@
+toplevel "A";
+"A" and "B" "C";
+"B" and "BE1" "BE2";
+"C" and "BE3" "BE4";
+"BE1" lambda=0.5 dorm=0.3;
+"BE2" lambda=0.5 dorm=0.3;
+"BE3" lambda=0.5 dorm=0.3;
+"BE4" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/tripple_and2.dft b/examples/dft/tripple_and2.dft
new file mode 100644
index 000000000..0f9d0e491
--- /dev/null
+++ b/examples/dft/tripple_and2.dft
@@ -0,0 +1,6 @@
+toplevel "A";
+"A" and "B" "C";
+"B" and "BE1" "BE2";
+"BE1" lambda=0.5 dorm=0.3;
+"BE2" lambda=0.5 dorm=0.3;
+"C" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/voting.dft b/examples/dft/voting.dft
new file mode 100644
index 000000000..18a54a7fa
--- /dev/null
+++ b/examples/dft/voting.dft
@@ -0,0 +1,5 @@
+toplevel "A";
+"A" vot2 "B" "C" "D";
+"B" lambda=0.5 dorm=0.3;
+"C" lambda=0.5 dorm=0.3;
+"D" lambda=0.5 dorm=0.3;

From d13aca1109cbad0c19020a15e31655dd98697d78 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 22 Jan 2016 11:37:19 +0100
Subject: [PATCH 024/246] Fixed problem with const initializer

Former-commit-id: bcd1343169cd095f07e2725a2baa24e8bcde3371
---
 src/parser/ExpressionParser.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/parser/ExpressionParser.h b/src/parser/ExpressionParser.h
index 4d40467a0..262b9499c 100644
--- a/src/parser/ExpressionParser.h
+++ b/src/parser/ExpressionParser.h
@@ -203,7 +203,7 @@ namespace storm {
             qi::symbols<char, storm::expressions::Expression> const* identifiers_;
             
             // The symbol table of invalid identifiers.
-            qi::symbols<char, uint_fast64_t> const& invalidIdentifiers_;
+            qi::symbols<char, uint_fast64_t> invalidIdentifiers_;
             
             // Rules for parsing a composed expression.
             qi::rule<Iterator, storm::expressions::Expression(), Skipper> expression;

From 545dad861bdf941df9c2a60386a84b8308d101f5 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 25 Jan 2016 18:13:02 +0100
Subject: [PATCH 025/246] Mini change

Former-commit-id: a24bd187a37ea077378a24761289df89277a4326
---
 src/storm-dyftee.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 2e9e88bbf..cf9922c47 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -46,7 +46,8 @@ void analyzeDFT(std::string filename, std::string property) {
  */
 int main(int argc, char** argv) {
     if(argc < 2) {
-        std::cout <<  "Storm-DyFTeE should be called with a filename as argument." << std::endl;
+        std::cout << "Storm-DyFTeE should be called with a filename as argument." << std::endl;
+        std::cout << "./storm-dft <filename> <optional pctl-formula> <optional --parametric>" << std::endl;
         return 1;
     }
 

From 65bb496bb9fea63840c3746d753b103153b7f203 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 26 Jan 2016 10:40:49 +0100
Subject: [PATCH 026/246] Activate expected time in FormulaParser

Former-commit-id: 6fff9e826958ed53ae6eb03516b87cd1dfbcfbb3
---
 src/parser/FormulaParser.cpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/parser/FormulaParser.cpp b/src/parser/FormulaParser.cpp
index 082474187..d6de95ace 100644
--- a/src/parser/FormulaParser.cpp
+++ b/src/parser/FormulaParser.cpp
@@ -270,8 +270,8 @@ namespace storm {
             
             booleanLiteralFormula = (qi::lit("true")[qi::_a = true] | qi::lit("false")[qi::_a = false])[qi::_val = phoenix::bind(&FormulaParserGrammar::createBooleanLiteralFormula, phoenix::ref(*this), qi::_a)];
             booleanLiteralFormula.name("boolean literal formula");
-            
-            operatorFormula = probabilityOperator | rewardOperator | steadyStateOperator;
+
+            operatorFormula = probabilityOperator | rewardOperator | steadyStateOperator | expectedTimeOperator;
             operatorFormula.name("operator formulas");
             
             atomicStateFormula = booleanLiteralFormula | labelFormula | expressionFormula | (qi::lit("(") > stateFormula > qi::lit(")")) | operatorFormula;
@@ -334,8 +334,8 @@ namespace storm {
             start = qi::eps > (stateFormula % +(qi::char_("\n;"))) >> qi::skip(boost::spirit::ascii::space | qi::lit("//") >> *(qi::char_ - (qi::eol | qi::eoi)))[qi::eps] >> qi::eoi;
             start.name("start");
             
-            /*!
-             * Enable the following lines to print debug output for most the rules.
+            //Enable the following lines to print debug output for most the rules.
+            /*
             debug(start);
             debug(stateFormula);
             debug(orStateFormula);
@@ -343,6 +343,7 @@ namespace storm {
             debug(probabilityOperator);
             debug(rewardOperator);
             debug(steadyStateOperator);
+            debug(expectedTimeOperator);
             debug(pathFormulaWithoutUntil);
             debug(pathFormula);
             debug(conditionalFormula);
@@ -357,7 +358,7 @@ namespace storm {
             debug(reachabilityRewardFormula);
             debug(cumulativeRewardFormula);
             debug(instantaneousRewardFormula);
-             */
+            */
 
             // Enable error reporting.
             qi::on_error<qi::fail>(start, handler(qi::_1, qi::_2, qi::_3, qi::_4));
@@ -366,6 +367,7 @@ namespace storm {
             qi::on_error<qi::fail>(andStateFormula, handler(qi::_1, qi::_2, qi::_3, qi::_4));
             qi::on_error<qi::fail>(probabilityOperator, handler(qi::_1, qi::_2, qi::_3, qi::_4));
             qi::on_error<qi::fail>(rewardOperator, handler(qi::_1, qi::_2, qi::_3, qi::_4));
+            qi::on_error<qi::fail>(expectedTimeOperator, handler(qi::_1, qi::_2, qi::_3, qi::_4));
             qi::on_error<qi::fail>(steadyStateOperator, handler(qi::_1, qi::_2, qi::_3, qi::_4));
             qi::on_error<qi::fail>(operatorInformation, handler(qi::_1, qi::_2, qi::_3, qi::_4));
             qi::on_error<qi::fail>(pathFormulaWithoutUntil, handler(qi::_1, qi::_2, qi::_3, qi::_4));

From 71070cb2818784cc0b26620f84f487b5f27cb3cd Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 26 Jan 2016 16:19:32 +0100
Subject: [PATCH 027/246] Implemented expected time on CTMC by reduction to
 DTMC with rewards

Former-commit-id: ebd3603069d846c5c4237287417f374816f8e8f0
---
 .../csl/SparseCtmcCslModelChecker.cpp             | 15 ++++++++++++---
 src/modelchecker/csl/SparseCtmcCslModelChecker.h  |  1 +
 .../csl/helper/SparseCtmcCslHelper.cpp            | 12 +++++++++++-
 src/modelchecker/csl/helper/SparseCtmcCslHelper.h |  2 ++
 4 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp b/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
index 14631fba5..37eaaad52 100644
--- a/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
+++ b/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
@@ -31,7 +31,7 @@ namespace storm {
         
         template <typename SparseCtmcModelType>
         bool SparseCtmcCslModelChecker<SparseCtmcModelType>::canHandle(storm::logic::Formula const& formula) const {
-            return formula.isCslStateFormula() || formula.isCslPathFormula() || formula.isRewardPathFormula();
+            return formula.isCslStateFormula() || formula.isCslPathFormula() || formula.isRewardPathFormula() || formula.isExpectedTimeOperatorFormula();
         }
         
         template <typename SparseCtmcModelType>
@@ -101,8 +101,17 @@ namespace storm {
             storm::storage::SparseMatrix<ValueType> probabilityMatrix = storm::modelchecker::helper::SparseCtmcCslHelper<ValueType>::computeProbabilityMatrix(this->getModel().getTransitionMatrix(), this->getModel().getExitRateVector());
             std::vector<ValueType> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<ValueType>::computeLongRunAverage(probabilityMatrix, subResult.getTruthValuesVector(), &this->getModel().getExitRateVector(), qualitative, *linearEquationSolverFactory);
             return std::unique_ptr<CheckResult>(new ExplicitQuantitativeCheckResult<ValueType>(std::move(numericResult)));
-        }        
-        
+        }
+
+        template <typename SparseCtmcModelType>
+        std::unique_ptr<CheckResult> SparseCtmcCslModelChecker<SparseCtmcModelType>::computeExpectedTimes(storm::logic::EventuallyFormula const& eventuallyFormula, bool qualitative, boost::optional<OptimizationDirection> const& optimalityType) {
+            std::unique_ptr<CheckResult> subResultPointer = this->check(eventuallyFormula.getSubformula());
+            ExplicitQualitativeCheckResult& subResult = subResultPointer->asExplicitQualitativeCheckResult();
+
+            std::vector<ValueType> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<ValueType>::computeExpectedTimes(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), this->getModel().getExitRateVector(), subResult.getTruthValuesVector(), qualitative, *linearEquationSolverFactory);
+            return std::unique_ptr<CheckResult>(new ExplicitQuantitativeCheckResult<ValueType>(std::move(numericResult)));
+        }
+
         // Explicitly instantiate the model checker.
         template class SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<double>>;
         
diff --git a/src/modelchecker/csl/SparseCtmcCslModelChecker.h b/src/modelchecker/csl/SparseCtmcCslModelChecker.h
index 8423cac53..7e25376a1 100644
--- a/src/modelchecker/csl/SparseCtmcCslModelChecker.h
+++ b/src/modelchecker/csl/SparseCtmcCslModelChecker.h
@@ -28,6 +28,7 @@ namespace storm {
             virtual std::unique_ptr<CheckResult> computeInstantaneousRewards(storm::logic::InstantaneousRewardFormula const& rewardPathFormula, boost::optional<std::string> const& rewardModelName = boost::optional<std::string>(), bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
             virtual std::unique_ptr<CheckResult> computeReachabilityRewards(storm::logic::ReachabilityRewardFormula const& rewardPathFormula, boost::optional<std::string> const& rewardModelName = boost::optional<std::string>(), bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
             virtual std::unique_ptr<CheckResult> computeLongRunAverage(storm::logic::StateFormula const& stateFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
+            virtual std::unique_ptr<CheckResult> computeExpectedTimes(storm::logic::EventuallyFormula const& eventuallyFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
 
         private:
             // An object that is used for solving linear equations and performing matrix-vector multiplication.
diff --git a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
index 453496ce2..51c58848c 100644
--- a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
+++ b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
@@ -650,11 +650,21 @@ namespace storm {
                 return result;
             }
             
+            template <typename ValueType>
+            std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory) {
+                // Compute expected time on CTMC by reduction to DTMC with rewards
+                storm::storage::SparseMatrix<ValueType> probabilityMatrix = computeProbabilityMatrix(rateMatrix, exitRateVector);
+                std::vector<ValueType> totalRewardVector;
+                for (auto exitRate : exitRateVector) {
+                    totalRewardVector.push_back(1 / exitRate);
+                }
+                return storm::modelchecker::helper::SparseDtmcPrctlHelper<ValueType>::computeReachabilityRewards(probabilityMatrix, backwardTransitions, totalRewardVector, targetStates, qualitative, linearEquationSolverFactory);
+            }
+
             template class SparseCtmcCslHelper<double>;
             template std::vector<double> SparseCtmcCslHelper<double>::computeInstantaneousRewards(storm::storage::SparseMatrix<double> const& rateMatrix, std::vector<double> const& exitRateVector, storm::models::sparse::StandardRewardModel<double> const& rewardModel, double timeBound, storm::utility::solver::LinearEquationSolverFactory<double> const& linearEquationSolverFactory);
             template std::vector<double> SparseCtmcCslHelper<double>::computeCumulativeRewards(storm::storage::SparseMatrix<double> const& rateMatrix, std::vector<double> const& exitRateVector, storm::models::sparse::StandardRewardModel<double> const& rewardModel, double timeBound, storm::utility::solver::LinearEquationSolverFactory<double> const& linearEquationSolverFactory);
             template std::vector<double> SparseCtmcCslHelper<double>::computeReachabilityRewards(storm::storage::SparseMatrix<double> const& rateMatrix, storm::storage::SparseMatrix<double> const& backwardTransitions, std::vector<double> const& exitRateVector, storm::models::sparse::StandardRewardModel<double> const& rewardModel, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<double> const& linearEquationSolverFactory);
-
         }
     }
 }
\ No newline at end of file
diff --git a/src/modelchecker/csl/helper/SparseCtmcCslHelper.h b/src/modelchecker/csl/helper/SparseCtmcCslHelper.h
index fae4d8498..dfa0ef877 100644
--- a/src/modelchecker/csl/helper/SparseCtmcCslHelper.h
+++ b/src/modelchecker/csl/helper/SparseCtmcCslHelper.h
@@ -28,6 +28,8 @@ namespace storm {
                 
                 static std::vector<ValueType> computeLongRunAverage(storm::storage::SparseMatrix<ValueType> const& probabilityMatrix, storm::storage::BitVector const& psiStates, std::vector<ValueType> const* exitRateVector, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory);
                 
+                static std::vector<ValueType> computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory);
+
                 /*!
                  * Computes the matrix representing the transitions of the uniformized CTMC.
                  *

From 8b59a26fe07e47d962a6030ae18ad225a5e2ad94 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 26 Jan 2016 17:15:24 +0100
Subject: [PATCH 028/246] More dft files

Former-commit-id: b1b7906604b0e8dfe5f443ce25175353c3df3fcb
---
 examples/dft/cm2.dft            | 22 ++++++++++++++++++
 examples/dft/cm4.dft            | 41 +++++++++++++++++++++++++++++++++
 examples/dft/cps.dft            | 26 +++++++++++++++++++++
 examples/dft/mdcs.dft           | 26 +++++++++++++++++++++
 examples/dft/mdcs2.dft          | 19 +++++++++++++++
 examples/dft/mp.dft             |  7 ++++++
 examples/dft/tripple_and2.dft   |  8 ++++---
 examples/dft/tripple_and2_c.dft |  6 +++++
 examples/dft/tripple_and_c.dft  |  7 ++++++
 examples/dft/tripple_or.dft     |  9 ++++++++
 examples/dft/tripple_or2.dft    |  8 +++++++
 examples/dft/tripple_or2_c.dft  |  6 +++++
 examples/dft/tripple_or_c.dft   |  7 ++++++
 examples/dft/voting.dft         |  8 +++----
 examples/dft/voting2.dft        |  5 ++++
 15 files changed, 198 insertions(+), 7 deletions(-)
 create mode 100644 examples/dft/cm2.dft
 create mode 100644 examples/dft/cm4.dft
 create mode 100644 examples/dft/cps.dft
 create mode 100644 examples/dft/mdcs.dft
 create mode 100644 examples/dft/mdcs2.dft
 create mode 100644 examples/dft/mp.dft
 create mode 100644 examples/dft/tripple_and2_c.dft
 create mode 100644 examples/dft/tripple_and_c.dft
 create mode 100644 examples/dft/tripple_or.dft
 create mode 100644 examples/dft/tripple_or2.dft
 create mode 100644 examples/dft/tripple_or2_c.dft
 create mode 100644 examples/dft/tripple_or_c.dft
 create mode 100644 examples/dft/voting2.dft

diff --git a/examples/dft/cm2.dft b/examples/dft/cm2.dft
new file mode 100644
index 000000000..89a1a8eba
--- /dev/null
+++ b/examples/dft/cm2.dft
@@ -0,0 +1,22 @@
+toplevel "System";
+"System" or "BUS" "CM";
+"CM" and "CM1" "CM2";
+"CM1" or "DISK1" "POWER1" "MEMORY1";
+"CM2" or "DISK2" "POWER2" "MEMORY2";
+"DISK1" wsp "D11" "D12";
+"DISK2" wsp "D21" "D22";
+"POWER1" or "P1" "PS";
+"POWER2" or "P2" "PS";
+"MEMORY1" wsp "M1" "M3";
+"MEMORY2" wsp "M2" "M3";
+"BUS" lambda=0.0002 dorm=0;
+"P1" lambda=0.05 dorm=0;
+"P2" lambda=0.05 dorm=0;
+"PS" lambda=0.6 dorm=0;
+"D11" lambda=8.0 dorm=0;
+"D12" lambda=8.0 dorm=0.5;
+"D21" lambda=8.0 dorm=0;
+"D22" lambda=8.0 dorm=0.5;
+"M1" lambda=0.003 dorm=0;
+"M2" lambda=0.003 dorm=0;
+"M3" lambda=0.003 dorm=0.5;
diff --git a/examples/dft/cm4.dft b/examples/dft/cm4.dft
new file mode 100644
index 000000000..deb8a7fb7
--- /dev/null
+++ b/examples/dft/cm4.dft
@@ -0,0 +1,41 @@
+toplevel "System";
+"System" or "BUS" "CM";
+"CM" and "CM1" "CM2" "CM3" "CM4";
+"CM1" or "DISK1" "POWER1" "MEMORY1";
+"CM2" or "DISK2" "POWER2" "MEMORY2";
+"CM3" or "DISK3" "POWER3" "MEMORY3";
+"CM4" or "DISK4" "POWER4" "MEMORY4";
+"DISK1" wsp "D11" "D12";
+"DISK2" wsp "D21" "D22";
+"DISK3" wsp "D31" "D32";
+"DISK4" wsp "D41" "D42";
+"POWER1" or "P1" "PS";
+"POWER2" or "P2" "PS";
+"POWER3" or "P3" "PS2";
+"POWER4" or "P4" "PS2";
+"MEMORY1" wsp "M1" "M3" "M4";
+"MEMORY2" wsp "M2" "M3" "M4";
+"MEMORY3" wsp "M31" "M3";
+"MEMORY4" wsp "M41" "M4";
+"BUS" lambda=0.0002 dorm=0;
+"P1" lambda=0.05 dorm=0;
+"P2" lambda=0.05 dorm=0;
+"P3" lambda=0.05 dorm=0;
+"P4" lambda=0.05 dorm=0;
+"PS" lambda=0.6 dorm=0;
+"PS2" lambda=0.6 dorm=0;
+"D11" lambda=8.0 dorm=0;
+"D12" lambda=8.0 dorm=0.5;
+"D21" lambda=8.0 dorm=0;
+"D22" lambda=8.0 dorm=0.5;
+"D31" lambda=8.0 dorm=0;
+"D32" lambda=8.0 dorm=0.5;
+"D41" lambda=8.0 dorm=0;
+"D42" lambda=8.0 dorm=0.5;
+"M1" lambda=0.003 dorm=0;
+"M2" lambda=0.003 dorm=0;
+"M31" lambda=0.003 dorm=0;
+"M41" lambda=0.003 dorm=0;
+"M3" lambda=0.003 dorm=0.5;
+"M4" lambda=0.003 dorm=0.5;
+
diff --git a/examples/dft/cps.dft b/examples/dft/cps.dft
new file mode 100644
index 000000000..9ee386740
--- /dev/null
+++ b/examples/dft/cps.dft
@@ -0,0 +1,26 @@
+toplevel "System";
+
+"System" pand "A" "B";
+
+"A" and "AA" "AB" "AC" "AD";
+
+"B" pand "C" "D";
+
+"C" and "CA" "CB" "CC" "CD";
+
+"D" and "DA" "DB" "DC" "DD";
+
+"AA" lambda=1 dorm=0;
+"AB" lambda=1 dorm=0;
+"AC" lambda=1 dorm=0;
+"AD" lambda=1 dorm=0;
+
+"CA" lambda=1 dorm=0;
+"CB" lambda=1 dorm=0;
+"CC" lambda=1 dorm=0;
+"CD" lambda=1 dorm=0;
+
+"DA" lambda=1 dorm=0;
+"DB" lambda=1 dorm=0;
+"DC" lambda=1 dorm=0;
+"DD" lambda=1 dorm=0;
diff --git a/examples/dft/mdcs.dft b/examples/dft/mdcs.dft
new file mode 100644
index 000000000..450217a4c
--- /dev/null
+++ b/examples/dft/mdcs.dft
@@ -0,0 +1,26 @@
+toplevel "System";
+
+"System" or "S" "N";
+
+"N" lambda=2e-5 dorm=0;
+
+"S" and "CMA" "CMB";
+
+"CMA" or "DiskA" "PA" "MemA";
+"DiskA" wsp "DAA" "DAB";
+"PA" lambda=500e-5 dorm=0;
+"MemA" wsp "MA" "MC";
+"DAA" lambda=80000e-5 dorm=0.5;
+"DAB" lambda=80000e-5 dorm=0.5;
+"MA" lambda=30e-5 dorm=0;
+
+"CMB" or "DiskB" "PB" "MemB";
+"DiskB" wsp "DBA" "DBB";
+"PB" lambda=500e-5 dorm=0;
+"MemB" wsp "MB" "MC";
+"DBA" lambda=80000e-5 dorm=0.5;
+"DBB" lambda=80000e-5 dorm=0.5;
+"MB" lambda=30e-5 dorm=0;
+
+"MC" lambda=30e-5 dorm=0.5;
+
diff --git a/examples/dft/mdcs2.dft b/examples/dft/mdcs2.dft
new file mode 100644
index 000000000..5a376a7b8
--- /dev/null
+++ b/examples/dft/mdcs2.dft
@@ -0,0 +1,19 @@
+toplevel "System";
+"System" or "S" "N";
+"N" lambda=0.0000200000 dorm=0.0000000000;
+"S" and "CMA" "CMB";
+"CMA" or "DiskA" "PA" "MemA";
+"DiskA" wsp "DAA" "DAB";
+"PA" lambda=0.0049999999 dorm=0.0000000000;
+"MemA" wsp "MA" "MC";
+"DAA" lambda=0.8000000119 dorm=0.5000000000;
+"DAB" lambda=0.8000000119 dorm=0.5000000000;
+"MA" lambda=0.0003000000 dorm=0.0000000000;
+"CMB" or "DiskB" "PB" "MemB";
+"DiskB" wsp "DBA" "DBB";
+"PB" lambda=0.0049999999 dorm=0.0000000000;
+"MemB" wsp "MB" "MC";
+"DBA" lambda=0.8000000119 dorm=0.5000000000;
+"DBB" lambda=0.8000000119 dorm=0.5000000000;
+"MB" lambda=0.0003000000 dorm=0.0000000000;
+"MC" lambda=0.0003000000 dorm=0.5000000000;
diff --git a/examples/dft/mp.dft b/examples/dft/mp.dft
new file mode 100644
index 000000000..a2e769420
--- /dev/null
+++ b/examples/dft/mp.dft
@@ -0,0 +1,7 @@
+toplevel "A";
+"A" or "B" "C";
+"B" or "D" "E";
+"C" or "F" "E";
+"D" lambda=0.1 dorm=0;
+"E" lambda=0.2 dorm=0;
+"F" lambda=0.3 dorm=0;
diff --git a/examples/dft/tripple_and2.dft b/examples/dft/tripple_and2.dft
index 0f9d0e491..9e02d88e7 100644
--- a/examples/dft/tripple_and2.dft
+++ b/examples/dft/tripple_and2.dft
@@ -1,6 +1,8 @@
 toplevel "A";
 "A" and "B" "C";
 "B" and "BE1" "BE2";
-"BE1" lambda=0.5 dorm=0.3;
-"BE2" lambda=0.5 dorm=0.3;
-"C" lambda=0.5 dorm=0.3;
+"C" and "BE2" "BE3";
+"BE1" lambda=0.5 dorm=3;
+"BE2" lambda=0.5 dorm=3;
+"BE3" lambda=0.5 dorm=3;
+
diff --git a/examples/dft/tripple_and2_c.dft b/examples/dft/tripple_and2_c.dft
new file mode 100644
index 000000000..edfde4144
--- /dev/null
+++ b/examples/dft/tripple_and2_c.dft
@@ -0,0 +1,6 @@
+toplevel "A";
+"A" and "BE1" "BE2" "BE3";
+"BE1" lambda=0.5 dorm=3;
+"BE2" lambda=0.5 dorm=3;
+"BE3" lambda=0.5 dorm=3;
+
diff --git a/examples/dft/tripple_and_c.dft b/examples/dft/tripple_and_c.dft
new file mode 100644
index 000000000..72b384c98
--- /dev/null
+++ b/examples/dft/tripple_and_c.dft
@@ -0,0 +1,7 @@
+toplevel "A";
+"A" and "BE1" "BE2" "BE3" "BE4";
+"BE1" lambda=0.5 dorm=3;
+"BE2" lambda=0.5 dorm=3;
+"BE3" lambda=0.5 dorm=3;
+"BE4" lambda=0.5 dorm=3;
+
diff --git a/examples/dft/tripple_or.dft b/examples/dft/tripple_or.dft
new file mode 100644
index 000000000..9dbd0e377
--- /dev/null
+++ b/examples/dft/tripple_or.dft
@@ -0,0 +1,9 @@
+toplevel "A";
+"A" or "B" "C";
+"B" or "BE1" "BE2";
+"C" or "BE3" "BE4";
+"BE1" lambda=0.5 dorm=3;
+"BE2" lambda=0.5 dorm=3;
+"BE3" lambda=0.5 dorm=3;
+"BE4" lambda=0.5 dorm=3;
+
diff --git a/examples/dft/tripple_or2.dft b/examples/dft/tripple_or2.dft
new file mode 100644
index 000000000..32bc0ff8f
--- /dev/null
+++ b/examples/dft/tripple_or2.dft
@@ -0,0 +1,8 @@
+toplevel "A";
+"A" or "B" "C";
+"B" or "BE1" "BE2";
+"C" or "BE2" "BE3";
+"BE1" lambda=0.5 dorm=3;
+"BE2" lambda=0.5 dorm=3;
+"BE3" lambda=0.5 dorm=3;
+
diff --git a/examples/dft/tripple_or2_c.dft b/examples/dft/tripple_or2_c.dft
new file mode 100644
index 000000000..40747fbc8
--- /dev/null
+++ b/examples/dft/tripple_or2_c.dft
@@ -0,0 +1,6 @@
+toplevel "A";
+"A" or "BE1" "BE2" "BE3";
+"BE1" lambda=0.5 dorm=3;
+"BE2" lambda=0.5 dorm=3;
+"BE3" lambda=0.5 dorm=3;
+
diff --git a/examples/dft/tripple_or_c.dft b/examples/dft/tripple_or_c.dft
new file mode 100644
index 000000000..378b29630
--- /dev/null
+++ b/examples/dft/tripple_or_c.dft
@@ -0,0 +1,7 @@
+toplevel "A";
+"A" or "BE1" "BE2" "BE3" "BE4";
+"BE1" lambda=0.5 dorm=3;
+"BE2" lambda=0.5 dorm=3;
+"BE3" lambda=0.5 dorm=3;
+"BE4" lambda=0.5 dorm=3;
+
diff --git a/examples/dft/voting.dft b/examples/dft/voting.dft
index 18a54a7fa..6a5e82b3e 100644
--- a/examples/dft/voting.dft
+++ b/examples/dft/voting.dft
@@ -1,5 +1,5 @@
 toplevel "A";
-"A" vot2 "B" "C" "D";
-"B" lambda=0.5 dorm=0.3;
-"C" lambda=0.5 dorm=0.3;
-"D" lambda=0.5 dorm=0.3;
+"A" vot1 "B" "C" "D";
+"B" lambda=0.1 dorm=0;
+"C" lambda=0.2 dorm=0;
+"D" lambda=0.3 dorm=0;
diff --git a/examples/dft/voting2.dft b/examples/dft/voting2.dft
new file mode 100644
index 000000000..9cdf299f3
--- /dev/null
+++ b/examples/dft/voting2.dft
@@ -0,0 +1,5 @@
+toplevel "A";
+"A" 1of3 "B" "C" "D";
+"B" lambda=0.3 dorm=0;
+"C" lambda=0.4 dorm=0;
+"D" lambda=1 dorm=0;

From 9c1edef4a778f03474d033c3e2f3a6aa38e23f21 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 26 Jan 2016 17:17:46 +0100
Subject: [PATCH 029/246] Parse Galileo representation of voting gate as '1of3'

Former-commit-id: 972869e661abe1c18a8552842fba44c4192d26b3
---
 src/parser/DFTGalileoParser.cpp | 25 +++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index 89ad18ff6..05dc5773a 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -32,9 +32,8 @@ namespace storm {
             
             if(firstQuots == std::string::npos) {
                 return name;
-            } else if (secondQuots == std::string::npos) {
-                STORM_LOG_THROW(false, storm::exceptions::FileIoException, "No ending quotation mark found in " << name);
             } else {
+                STORM_LOG_THROW(secondQuots != std::string::npos, storm::exceptions::FileIoException, "No ending quotation mark found in " << name);
                 return name.substr(firstQuots+1,secondQuots-1);
             }
         }
@@ -76,9 +75,7 @@ namespace storm {
                     toplevelId = stripQuotsFromName(line.substr(toplevelToken.size() + 1));
                 }
                 else if (boost::starts_with(line, parametricToken)) {
-                    if (!std::is_same<ValueType, storm::RationalFunction>::value) {
-                        STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Parameters only allowed when using rational functions.");
-                    }
+                    STORM_LOG_THROW((!std::is_same<ValueType, storm::RationalFunction>::value), storm::exceptions::NotSupportedException, "Parameters only allowed when using rational functions.");
                     std::string parameter = stripQuotsFromName(line.substr(parametricToken.size() + 1));
                     storm::expressions::Variable var = manager->declareRationalVariable(parameter);
                     identifierMapping.emplace(var.getName(), var);
@@ -95,15 +92,23 @@ namespace storm {
                     }
                     if(tokens[1] == "and") {
                         success = builder.addAndElement(name, childNames);
-                    } else if(tokens[1] == "or") {
+                    } else if (tokens[1] == "or") {
                         success = builder.addOrElement(name, childNames);
-                    } else if(boost::starts_with(tokens[1], "vot")) {
+                    } else if (boost::starts_with(tokens[1], "vot")) {
                         success = builder.addVotElement(name, boost::lexical_cast<unsigned>(tokens[1].substr(3)), childNames);
-                    } else if(tokens[1] == "pand") {
+                    } else if (tokens[1].find("of") != std::string::npos) {
+                        size_t pos = tokens[1].find("of");
+                        unsigned threshold = boost::lexical_cast<unsigned>(tokens[1].substr(0, pos));
+                        unsigned count = boost::lexical_cast<unsigned>(tokens[1].substr(pos + 2));
+                        STORM_LOG_THROW(count == childNames.size(), storm::exceptions::FileIoException, "Voting gate does not correspond to number of children.");
+                        success = builder.addVotElement(name, threshold, childNames);
+                    } else if (tokens[1] == "pand") {
                         success = builder.addPandElement(name, childNames);
-                    } else if(tokens[1] == "wsp" || tokens[1] == "csp") {
+                    } else if (tokens[1] == "wsp" || tokens[1] == "csp") {
                         success = builder.addSpareElement(name, childNames);
-                    } else if(boost::starts_with(tokens[1], "lambda=")) {
+                    } else if (boost::starts_with(tokens[1], "fdep")) {
+                        STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Functional dependencies currently not supported");
+                    } else if (boost::starts_with(tokens[1], "lambda=")) {
                         ValueType failureRate = parseRationalExpression(tokens[1].substr(7));
                         ValueType dormancyFactor = parseRationalExpression(tokens[2].substr(5));
                         success = builder.addBasicElement(name, failureRate, dormancyFactor);

From c26cdc90122915a00dfa0942b0bd3958efd865a3 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 26 Jan 2016 17:20:01 +0100
Subject: [PATCH 030/246] Wrong assertion

Former-commit-id: e6b64dcb8aeaeaff1348697de4dfcf18c9c5ec10
---
 src/parser/DFTGalileoParser.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index 05dc5773a..57dec65d1 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -75,7 +75,7 @@ namespace storm {
                     toplevelId = stripQuotsFromName(line.substr(toplevelToken.size() + 1));
                 }
                 else if (boost::starts_with(line, parametricToken)) {
-                    STORM_LOG_THROW((!std::is_same<ValueType, storm::RationalFunction>::value), storm::exceptions::NotSupportedException, "Parameters only allowed when using rational functions.");
+                    STORM_LOG_THROW((std::is_same<ValueType, storm::RationalFunction>::value), storm::exceptions::NotSupportedException, "Parameters only allowed when using rational functions.");
                     std::string parameter = stripQuotsFromName(line.substr(parametricToken.size() + 1));
                     storm::expressions::Variable var = manager->declareRationalVariable(parameter);
                     identifierMapping.emplace(var.getName(), var);

From 0a1ebc2f73d0cb1bd5d80a84ba4e9d267465be3d Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 26 Jan 2016 17:50:40 +0100
Subject: [PATCH 031/246] Distinct error message for parametric model checking

Former-commit-id: 7c1eacb9c28fdf459583f840e46d32ccd9498b8e
---
 src/parser/DFTGalileoParser.cpp |  2 +-
 src/utility/storm.h             | 22 ++++++++++++++++------
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index 57dec65d1..163bc1488 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -113,7 +113,7 @@ namespace storm {
                         ValueType dormancyFactor = parseRationalExpression(tokens[2].substr(5));
                         success = builder.addBasicElement(name, failureRate, dormancyFactor);
                     } else {
-                        STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Type name: " + tokens[1] + "  not recognized.");
+                        STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Type name: " << tokens[1] << "  not recognized.");
                         success = false;
                     }
                 }
diff --git a/src/utility/storm.h b/src/utility/storm.h
index d1e32f839..c3d7a891a 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -70,6 +70,7 @@
 #include "src/exceptions/InvalidSettingsException.h"
 #include "src/exceptions/InvalidTypeException.h"
 #include "src/exceptions/NotImplementedException.h"
+#include "src/exceptions/NotSupportedException.h"
 
 namespace storm {
 
@@ -289,13 +290,22 @@ namespace storm {
     template<>
     inline std::unique_ptr<storm::modelchecker::CheckResult> verifySparseModel(std::shared_ptr<storm::models::sparse::Model<storm::RationalFunction>> model, std::shared_ptr<storm::logic::Formula> const& formula) {
         std::unique_ptr<storm::modelchecker::CheckResult> result;
-        std::shared_ptr<storm::models::sparse::Dtmc<storm::RationalFunction>> dtmc = model->template as<storm::models::sparse::Dtmc<storm::RationalFunction>>();
-
-        storm::modelchecker::SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<storm::RationalFunction>> modelchecker(*dtmc);
-        if (modelchecker.canHandle(*formula)) {
-            result = modelchecker.check(*formula);
+        if (model->getType() == storm::models::ModelType::Dtmc) {
+            std::shared_ptr<storm::models::sparse::Dtmc<storm::RationalFunction>> dtmc = model->template as<storm::models::sparse::Dtmc<storm::RationalFunction>>();
+            storm::modelchecker::SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<storm::RationalFunction>> modelchecker(*dtmc);
+            if (modelchecker.canHandle(*formula)) {
+                result = modelchecker.check(*formula);
+            } else {
+                STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The parametric engine currently does not support this property on DTMCs.");
+            }
+        } else if (model->getType() == storm::models::ModelType::Mdp) {
+            std::shared_ptr<storm::models::sparse::Mdp<storm::RationalFunction>> mdp = model->template as<storm::models::sparse::Mdp<storm::RationalFunction>>();
+            STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The parametric engine currently does not support MDPs.");
+        } else if (model->getType() == storm::models::ModelType::Ctmc) {
+            std::shared_ptr<storm::models::sparse::Ctmc<storm::RationalFunction>> ctmc = model->template as<storm::models::sparse::Ctmc<storm::RationalFunction>>();
+            STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The parametric engine currently does not support CTMCs.");
         } else {
-            STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "The parametric engine currently does not support this property.");
+            STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The parametric engine currently does not support " << model->getType());
         }
         return result;
     }

From 3e4ddbea8c285e0b7cfa943e1618b7f53ff4d060 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 28 Jan 2016 14:27:24 +0100
Subject: [PATCH 032/246] Integrated expected time on parametric CTMCs

Former-commit-id: 2f892ad8db092a0db585d13c40aacec1b354e8ee
---
 .../csl/SparseCtmcCslModelChecker.cpp         |  2 +-
 .../csl/helper/SparseCtmcCslHelper.cpp        | 16 +++++-
 .../csl/helper/SparseCtmcCslHelper.h          |  2 +-
 .../SparseDtmcEliminationModelChecker.cpp     | 56 +++++++++++--------
 .../SparseDtmcEliminationModelChecker.h       |  1 +
 src/utility/storm.h                           | 19 ++++++-
 6 files changed, 66 insertions(+), 30 deletions(-)

diff --git a/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp b/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
index 16ab12244..a9b86d8c8 100644
--- a/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
+++ b/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
@@ -108,7 +108,7 @@ namespace storm {
             std::unique_ptr<CheckResult> subResultPointer = this->check(eventuallyFormula.getSubformula());
             ExplicitQualitativeCheckResult& subResult = subResultPointer->asExplicitQualitativeCheckResult();
 
-            std::vector<ValueType> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<ValueType>::computeExpectedTimes(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), this->getModel().getExitRateVector(), subResult.getTruthValuesVector(), qualitative, *linearEquationSolverFactory);
+            std::vector<ValueType> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<ValueType>::computeExpectedTimes(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), this->getModel().getExitRateVector(), this->getModel().getInitialStates(), subResult.getTruthValuesVector(), qualitative/*, *linearEquationSolverFactory*/);
             return std::unique_ptr<CheckResult>(new ExplicitQuantitativeCheckResult<ValueType>(std::move(numericResult)));
         }
 
diff --git a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
index 5cf10fd84..145eed1b1 100644
--- a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
+++ b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
@@ -1,6 +1,7 @@
 #include "src/modelchecker/csl/helper/SparseCtmcCslHelper.h"
 
 #include "src/modelchecker/prctl/helper/SparseDtmcPrctlHelper.h"
+#include "src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h"
 
 #include "src/models/sparse/StandardRewardModel.h"
 
@@ -11,6 +12,8 @@
 
 #include "src/storage/StronglyConnectedComponentDecomposition.h"
 
+#include "src/adapters/CarlAdapter.h"
+
 #include "src/utility/macros.h"
 #include "src/utility/vector.h"
 #include "src/utility/graph.h"
@@ -647,20 +650,27 @@ namespace storm {
             }
             
             template <typename ValueType>
-            std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory) {
+            std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative/*, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory*/) {
                 // Compute expected time on CTMC by reduction to DTMC with rewards
                 storm::storage::SparseMatrix<ValueType> probabilityMatrix = computeProbabilityMatrix(rateMatrix, exitRateVector);
                 std::vector<ValueType> totalRewardVector;
                 for (auto exitRate : exitRateVector) {
-                    totalRewardVector.push_back(1 / exitRate);
+                    totalRewardVector.push_back(storm::utility::one<ValueType>() / exitRate);
                 }
-                return storm::modelchecker::helper::SparseDtmcPrctlHelper<ValueType>::computeReachabilityRewards(probabilityMatrix, backwardTransitions, totalRewardVector, targetStates, qualitative, linearEquationSolverFactory);
+
+                return storm::modelchecker::SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<ValueType>>::computeReachabilityRewards(probabilityMatrix, backwardTransitions, initialStates, targetStates, totalRewardVector, false, qualitative);
+                // Enable again, if RationalFunction finally is supported
+                //return storm::modelchecker::helper::SparseDtmcPrctlHelper<ValueType>::computeReachabilityRewards(probabilityMatrix, backwardTransitions, totalRewardVector, targetStates, qualitative, linearEquationSolverFactory);
             }
 
             template class SparseCtmcCslHelper<double>;
             template std::vector<double> SparseCtmcCslHelper<double>::computeInstantaneousRewards(storm::storage::SparseMatrix<double> const& rateMatrix, std::vector<double> const& exitRateVector, storm::models::sparse::StandardRewardModel<double> const& rewardModel, double timeBound, storm::utility::solver::LinearEquationSolverFactory<double> const& linearEquationSolverFactory);
             template std::vector<double> SparseCtmcCslHelper<double>::computeCumulativeRewards(storm::storage::SparseMatrix<double> const& rateMatrix, std::vector<double> const& exitRateVector, storm::models::sparse::StandardRewardModel<double> const& rewardModel, double timeBound, storm::utility::solver::LinearEquationSolverFactory<double> const& linearEquationSolverFactory);
             template std::vector<double> SparseCtmcCslHelper<double>::computeReachabilityRewards(storm::storage::SparseMatrix<double> const& rateMatrix, storm::storage::SparseMatrix<double> const& backwardTransitions, std::vector<double> const& exitRateVector, storm::models::sparse::StandardRewardModel<double> const& rewardModel, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<double> const& linearEquationSolverFactory);
+
+#ifdef STORM_HAVE_CARL
+            template std::vector<storm::RationalFunction> SparseCtmcCslHelper<storm::RationalFunction>::computeExpectedTimes(storm::storage::SparseMatrix<storm::RationalFunction> const& rateMatrix, storm::storage::SparseMatrix<storm::RationalFunction> const& backwardTransitions, std::vector<storm::RationalFunction> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative/*, storm::utility::solver::LinearEquationSolverFactory<storm::RationalFunction> const& linearEquationSolverFactory*/);
+#endif
         }
     }
 }
\ No newline at end of file
diff --git a/src/modelchecker/csl/helper/SparseCtmcCslHelper.h b/src/modelchecker/csl/helper/SparseCtmcCslHelper.h
index ef744045e..94752a974 100644
--- a/src/modelchecker/csl/helper/SparseCtmcCslHelper.h
+++ b/src/modelchecker/csl/helper/SparseCtmcCslHelper.h
@@ -28,7 +28,7 @@ namespace storm {
                 
                 static std::vector<ValueType> computeLongRunAverageProbabilities(storm::storage::SparseMatrix<ValueType> const& probabilityMatrix, storm::storage::BitVector const& psiStates, std::vector<ValueType> const* exitRateVector, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory);
                 
-                static std::vector<ValueType> computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory);
+                static std::vector<ValueType> computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative/*, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory*/);
 
                 /*!
                  * Computes the matrix representing the transitions of the uniformized CTMC.
diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
index 6ec1e6d86..41324957b 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
@@ -578,27 +578,40 @@ namespace storm {
         std::unique_ptr<CheckResult> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::computeReachabilityRewards(storm::logic::ReachabilityRewardFormula const& rewardPathFormula, boost::optional<std::string> const& rewardModelName, bool qualitative, boost::optional<OptimizationDirection> const& optimalityType) {
             // Retrieve the appropriate bitvectors by model checking the subformulas.
             std::unique_ptr<CheckResult> subResultPointer = this->check(rewardPathFormula.getSubformula());
-            storm::storage::BitVector phiStates(this->getModel().getNumberOfStates(), true);
-            storm::storage::BitVector const& psiStates = subResultPointer->asExplicitQualitativeCheckResult().getTruthValuesVector();
+            storm::storage::BitVector targetStates = subResultPointer->asExplicitQualitativeCheckResult().getTruthValuesVector();
+            storm::storage::BitVector trueStates(this->getModel().getNumberOfStates(), true);
             
             // Do some sanity checks to establish some required properties.
             RewardModelType const& rewardModel = this->getModel().getRewardModel(rewardModelName ? rewardModelName.get() : "");
+            std::vector<ValueType> stateRewardValues = rewardModel.getTotalRewardVector(trueStates.getNumberOfSetBits(), this->getModel().getTransitionMatrix(), trueStates);
+
             STORM_LOG_THROW(!rewardModel.empty(), storm::exceptions::IllegalArgumentException, "Input model does not have a reward model.");
+            std::vector<ValueType> result = computeReachabilityRewards(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), this->getModel().getInitialStates(), targetStates, stateRewardValues, this->computeResultsForInitialStatesOnly, qualitative, optimalityType);
+
+            // Construct check result
+            std::unique_ptr<CheckResult> checkResult(new ExplicitQuantitativeCheckResult<ValueType>(result));
+            return checkResult;
+        }
+
+        template<typename SparseDtmcModelType>
+        std::vector<typename SparseDtmcModelType::ValueType> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::computeReachabilityRewards(storm::storage::SparseMatrix<ValueType> const& probabilityMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, std::vector<ValueType> const& stateRewardValues, bool computeForInitialStatesOnly, bool qualitative, boost::optional<OptimizationDirection> const& optimalityType) {
+
+            uint_fast64_t numberOfStates = probabilityMatrix.getRowCount();
             
-            // Then, compute the subset of states that has a reachability reward less than infinity.
-            storm::storage::BitVector trueStates(this->getModel().getNumberOfStates(), true);
-            storm::storage::BitVector infinityStates = storm::utility::graph::performProb1(this->getModel().getBackwardTransitions(), trueStates, psiStates);
+            // Compute the subset of states that has a reachability reward less than infinity.
+            storm::storage::BitVector trueStates(numberOfStates, true);
+            storm::storage::BitVector infinityStates = storm::utility::graph::performProb1(backwardTransitions, trueStates, targetStates);
             infinityStates.complement();
-            storm::storage::BitVector maybeStates = ~psiStates & ~infinityStates;
+            storm::storage::BitVector maybeStates = ~targetStates & ~infinityStates;
             
             // Determine whether we need to perform some further computation.
             bool furtherComputationNeeded = true;
-            if (computeResultsForInitialStatesOnly) {
-                if (this->getModel().getInitialStates().isSubsetOf(infinityStates)) {
+            if (computeForInitialStatesOnly) {
+                if (initialStates.isSubsetOf(infinityStates)) {
                     STORM_LOG_DEBUG("The reward of all initial states was found in a preprocessing step.");
                     furtherComputationNeeded = false;
                 }
-                if (this->getModel().getInitialStates().isSubsetOf(psiStates)) {
+                if (initialStates.isSubsetOf(targetStates)) {
                     STORM_LOG_DEBUG("The reward of all initial states was found in a preprocessing step.");
                     furtherComputationNeeded = false;
                 }
@@ -608,40 +621,37 @@ namespace storm {
             if (furtherComputationNeeded) {
                 // If we compute the results for the initial states only, we can cut off all maybe state that are not
                 // reachable from them.
-                if (computeResultsForInitialStatesOnly) {
+                if (computeForInitialStatesOnly) {
                     // Determine the set of states that is reachable from the initial state without jumping over a target state.
-                    storm::storage::BitVector reachableStates = storm::utility::graph::getReachableStates(this->getModel().getTransitionMatrix(), this->getModel().getInitialStates(), maybeStates, psiStates);
+                    storm::storage::BitVector reachableStates = storm::utility::graph::getReachableStates(probabilityMatrix, initialStates, maybeStates, targetStates);
                     
                     // Subtract from the maybe states the set of states that is not reachable (on a path from the initial to a target state).
                     maybeStates &= reachableStates;
                 }
                 
                 // Determine the set of initial states of the sub-model.
-                storm::storage::BitVector newInitialStates = this->getModel().getInitialStates() % maybeStates;
+                storm::storage::BitVector newInitialStates = initialStates % maybeStates;
 
                 // We then build the submatrix that only has the transitions of the maybe states.
-                storm::storage::SparseMatrix<ValueType> submatrix = this->getModel().getTransitionMatrix().getSubmatrix(false, maybeStates, maybeStates);
+                storm::storage::SparseMatrix<ValueType> submatrix = probabilityMatrix.getSubmatrix(false, maybeStates, maybeStates);
                 storm::storage::SparseMatrix<ValueType> submatrixTransposed = submatrix.transpose();
                 
                 // Project the state reward vector to all maybe-states.
-                std::vector<ValueType> stateRewardValues = rewardModel.getTotalRewardVector(maybeStates.getNumberOfSetBits(), this->getModel().getTransitionMatrix(), maybeStates);
-
-                std::vector<ValueType> subresult = computeReachabilityValues(submatrix, stateRewardValues, submatrixTransposed, newInitialStates, computeResultsForInitialStatesOnly, phiStates, psiStates, this->getModel().getTransitionMatrix().getConstrainedRowSumVector(maybeStates, psiStates));
+                std::vector<ValueType> rewardValues = storm::utility::vector::filterVector(stateRewardValues, maybeStates);
+                storm::storage::BitVector phiStates(numberOfStates, true);
+                std::vector<ValueType> subresult = computeReachabilityValues(submatrix, rewardValues, submatrixTransposed, newInitialStates, computeForInitialStatesOnly, phiStates, targetStates, probabilityMatrix.getConstrainedRowSumVector(maybeStates, targetStates));
                 storm::utility::vector::setVectorValues<ValueType>(result, maybeStates, subresult);
             }
             
             // Construct full result.
             storm::utility::vector::setVectorValues<ValueType>(result, infinityStates, storm::utility::infinity<ValueType>());
-            storm::utility::vector::setVectorValues<ValueType>(result, psiStates, storm::utility::zero<ValueType>());
-
-            // Construct check result based on whether we have computed values for all states or just the initial states.
-            std::unique_ptr<CheckResult> checkResult(new ExplicitQuantitativeCheckResult<ValueType>(result));
-            if (computeResultsForInitialStatesOnly) {
+            storm::utility::vector::setVectorValues<ValueType>(result, targetStates, storm::utility::zero<ValueType>());
+            if (computeForInitialStatesOnly) {
                 // If we computed the results for the initial (and inf) states only, we need to filter the result to
                 // only communicate these results.
-                checkResult->filter(ExplicitQualitativeCheckResult(~maybeStates | this->getModel().getInitialStates()));
+                result = storm::utility::vector::filterVector(result, ~maybeStates | initialStates);
             }
-            return checkResult;
+            return result;
         }
         
         template<typename SparseDtmcModelType>
diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
index 692a6be57..a840cef88 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
@@ -28,6 +28,7 @@ namespace storm {
             virtual std::unique_ptr<CheckResult> computeBoundedUntilProbabilities(storm::logic::BoundedUntilFormula const& pathFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
             virtual std::unique_ptr<CheckResult> computeUntilProbabilities(storm::logic::UntilFormula const& pathFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
             virtual std::unique_ptr<CheckResult> computeReachabilityRewards(storm::logic::ReachabilityRewardFormula const& rewardPathFormula, boost::optional<std::string> const& rewardModelName = boost::optional<std::string>(), bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
+            static std::vector<ValueType> computeReachabilityRewards(storm::storage::SparseMatrix<ValueType> const& probabilityMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, std::vector<ValueType> const& stateRewardValues, bool computeForInitialStatesOnly, bool qualitative, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>());
             virtual std::unique_ptr<CheckResult> computeLongRunAverageRewards(storm::logic::LongRunAverageRewardFormula const& rewardPathFormula, boost::optional<std::string> const& rewardModelName = boost::optional<std::string>(), bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
             virtual std::unique_ptr<CheckResult> computeConditionalProbabilities(storm::logic::ConditionalPathFormula const& pathFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
             virtual std::unique_ptr<CheckResult> computeLongRunAverageProbabilities(storm::logic::StateFormula const& stateFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
diff --git a/src/utility/storm.h b/src/utility/storm.h
index a3d2e58ca..4bdf22556 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -58,6 +58,7 @@
 #include "src/modelchecker/prctl/SymbolicMdpPrctlModelChecker.h"
 #include "src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h"
 #include "src/modelchecker/csl/SparseCtmcCslModelChecker.h"
+#include "src/modelchecker/csl/helper/SparseCtmcCslHelper.h"
 #include "src/modelchecker/csl/HybridCtmcCslModelChecker.h"
 #include "src/modelchecker/results/ExplicitQualitativeCheckResult.h"
 #include "src/modelchecker/results/SymbolicQualitativeCheckResult.h"
@@ -329,8 +330,22 @@ namespace storm {
             std::shared_ptr<storm::models::sparse::Mdp<storm::RationalFunction>> mdp = model->template as<storm::models::sparse::Mdp<storm::RationalFunction>>();
             STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The parametric engine currently does not support MDPs.");
         } else if (model->getType() == storm::models::ModelType::Ctmc) {
-            std::shared_ptr<storm::models::sparse::Ctmc<storm::RationalFunction>> ctmc = model->template as<storm::models::sparse::Ctmc<storm::RationalFunction>>();
-            STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The parametric engine currently does not support CTMCs.");
+            // Hack to avoid instantiating the CTMC Model Checker which currently does not work for rational functions
+            if (formula->isExpectedTimeOperatorFormula()) {
+                // We can only solve expected time for pCTMCs at the moment
+                std::shared_ptr<storm::models::sparse::Ctmc<storm::RationalFunction>> ctmc = model->template as<storm::models::sparse::Ctmc<storm::RationalFunction>>();
+
+                // Compute goal states
+                storm::logic::EventuallyFormula eventuallyFormula = formula->asExpectedTimeOperatorFormula().getSubformula().asEventuallyFormula();
+                storm::modelchecker::SparsePropositionalModelChecker<storm::models::sparse::Ctmc<storm::RationalFunction>> propositionalModelchecker(*ctmc);
+                std::unique_ptr<storm::modelchecker::CheckResult> subResultPointer = propositionalModelchecker.check(eventuallyFormula.getSubformula());
+                storm::modelchecker::ExplicitQualitativeCheckResult& subResult = subResultPointer->asExplicitQualitativeCheckResult();
+
+                std::vector<storm::RationalFunction> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<storm::RationalFunction>::computeExpectedTimes(ctmc->getTransitionMatrix(), ctmc->getBackwardTransitions(), ctmc->getExitRateVector(), ctmc->getInitialStates(), subResult.getTruthValuesVector(), false);
+                result = std::unique_ptr<storm::modelchecker::CheckResult>(new storm::modelchecker::ExplicitQuantitativeCheckResult<storm::RationalFunction>(std::move(numericResult)));
+            } else {
+                STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The parametric engine currently does not support this property on CTMCs.");
+            }
         } else {
             STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The parametric engine currently does not support " << model->getType());
         }

From 62f7305bea9d30eabe053886c513110357fac5f8 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 28 Jan 2016 18:07:19 +0100
Subject: [PATCH 033/246] No rewards for target states

Former-commit-id: 98e0139840e5034f55f7f4a06dc4e00ee8496341
---
 .../csl/helper/SparseCtmcCslHelper.cpp          | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
index 145eed1b1..78f48a173 100644
--- a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
+++ b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
@@ -651,15 +651,24 @@ namespace storm {
             
             template <typename ValueType>
             std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative/*, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory*/) {
-                // Compute expected time on CTMC by reduction to DTMC with rewards
+                // Compute expected time on CTMC by reduction to DTMC with rewards.
                 storm::storage::SparseMatrix<ValueType> probabilityMatrix = computeProbabilityMatrix(rateMatrix, exitRateVector);
+
+                // Initialize rewards.
                 std::vector<ValueType> totalRewardVector;
-                for (auto exitRate : exitRateVector) {
-                    totalRewardVector.push_back(storm::utility::one<ValueType>() / exitRate);
+                for (size_t i = 0; i < exitRateVector.size(); ++i) {
+                    std::cout << i << std::endl;
+                    if (targetStates[i]) {
+                        // Set reward for target states to 0.
+                        totalRewardVector.push_back(storm::utility::zero<ValueType>());
+                    } else {
+                        // Reward is (1 / exitRate).
+                        totalRewardVector.push_back(storm::utility::one<ValueType>() / exitRateVector[i]);
+                    }
                 }
 
                 return storm::modelchecker::SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<ValueType>>::computeReachabilityRewards(probabilityMatrix, backwardTransitions, initialStates, targetStates, totalRewardVector, false, qualitative);
-                // Enable again, if RationalFunction finally is supported
+                // Enable again, if RationalFunction finally is supported.
                 //return storm::modelchecker::helper::SparseDtmcPrctlHelper<ValueType>::computeReachabilityRewards(probabilityMatrix, backwardTransitions, totalRewardVector, targetStates, qualitative, linearEquationSolverFactory);
             }
 

From d6b7331a5c00b3b28f603e8967551d380f7bfe6e Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 29 Jan 2016 10:28:20 +0100
Subject: [PATCH 034/246] Fixed problem with multiple transitions to one state

Former-commit-id: 2fe612028ea89b1fde6e7b68955a3761eb6fdf45
---
 examples/dft/pand_param.dft             |  6 ++++++
 examples/dft/tripple_pand.dft           |  9 +++++++++
 examples/dft/tripple_pand2.dft          |  8 ++++++++
 examples/dft/tripple_pand2_c.dft        |  6 ++++++
 examples/dft/tripple_pand_c.dft         |  7 +++++++
 src/builder/ExplicitDFTModelBuilder.cpp | 20 +++++++++++---------
 6 files changed, 47 insertions(+), 9 deletions(-)
 create mode 100644 examples/dft/pand_param.dft
 create mode 100644 examples/dft/tripple_pand.dft
 create mode 100644 examples/dft/tripple_pand2.dft
 create mode 100644 examples/dft/tripple_pand2_c.dft
 create mode 100644 examples/dft/tripple_pand_c.dft

diff --git a/examples/dft/pand_param.dft b/examples/dft/pand_param.dft
new file mode 100644
index 000000000..9a0b3d211
--- /dev/null
+++ b/examples/dft/pand_param.dft
@@ -0,0 +1,6 @@
+param x;
+param y;
+toplevel "A";
+"A" pand "B" "C";
+"B" lambda=x dorm=0.3;
+"C" lambda=y dorm=0.3;
diff --git a/examples/dft/tripple_pand.dft b/examples/dft/tripple_pand.dft
new file mode 100644
index 000000000..7b38cf0f1
--- /dev/null
+++ b/examples/dft/tripple_pand.dft
@@ -0,0 +1,9 @@
+toplevel "A";
+"A" pand "B" "BE4";
+"B" pand "C" "BE3";
+"C" pand "BE1" "BE2";
+"BE1" lambda=0.5 dorm=3;
+"BE2" lambda=0.5 dorm=3;
+"BE3" lambda=0.5 dorm=3;
+"BE4" lambda=0.5 dorm=3;
+
diff --git a/examples/dft/tripple_pand2.dft b/examples/dft/tripple_pand2.dft
new file mode 100644
index 000000000..4e6ef460f
--- /dev/null
+++ b/examples/dft/tripple_pand2.dft
@@ -0,0 +1,8 @@
+toplevel "A";
+"A" pand "B" "C";
+"B" pand "BE1" "BE2";
+"C" pand "BE2" "BE3";
+"BE1" lambda=0.5 dorm=3;
+"BE2" lambda=0.5 dorm=3;
+"BE3" lambda=0.5 dorm=3;
+
diff --git a/examples/dft/tripple_pand2_c.dft b/examples/dft/tripple_pand2_c.dft
new file mode 100644
index 000000000..1c6001ea4
--- /dev/null
+++ b/examples/dft/tripple_pand2_c.dft
@@ -0,0 +1,6 @@
+toplevel "A";
+"A" pand "BE1" "BE2" "BE3";
+"BE1" lambda=0.5 dorm=3;
+"BE2" lambda=0.5 dorm=3;
+"BE3" lambda=0.5 dorm=3;
+
diff --git a/examples/dft/tripple_pand_c.dft b/examples/dft/tripple_pand_c.dft
new file mode 100644
index 000000000..bfb8daa1c
--- /dev/null
+++ b/examples/dft/tripple_pand_c.dft
@@ -0,0 +1,7 @@
+toplevel "A";
+"A" pand "BE1" "BE2" "BE3" "BE4";
+"BE1" lambda=0.5 dorm=3;
+"BE2" lambda=0.5 dorm=3;
+"BE3" lambda=0.5 dorm=3;
+"BE4" lambda=0.5 dorm=3;
+
diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index c0c596b02..0d37e795f 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -62,12 +62,8 @@ namespace storm {
                 }
             }
 
-            // TODO Matthias: initialize
-            modelComponents.rewardModels;
-            modelComponents.choiceLabeling;
-
             std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>> model;
-            model = std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>>(new storm::models::sparse::Ctmc<ValueType, RewardModelType>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.rewardModels), std::move(modelComponents.choiceLabeling)));
+            model = std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>>(new storm::models::sparse::Ctmc<ValueType, RewardModelType>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling)));
             model->printModelInformationToStream(std::cout);
             return model;
         }
@@ -149,10 +145,16 @@ namespace storm {
                     }
 
                     // Set transition
-                    ValueType prob = nextBE.first->activeFailureRate();
-                    auto resultInsert = outgoingTransitions.insert(std::make_pair(it->getId(), prob));
-                    assert(resultInsert.second);
-                    sum += prob;
+                    ValueType rate = nextBE.first->activeFailureRate();
+                    auto resultFind = outgoingTransitions.find(it->getId());
+                    if (resultFind != outgoingTransitions.end()) {
+                        // Add to existing transition
+                        resultFind->second += rate;
+                    } else {
+                        // Insert new transition
+                        outgoingTransitions.insert(std::make_pair(it->getId(), rate));
+                    }
+                    sum += rate;
                 } // end while failing BE
 
                 // Add all transitions

From e04cc99931728084194c2850641da1e41b6cc6a5 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 29 Jan 2016 10:28:38 +0100
Subject: [PATCH 035/246] Removed debug output

Former-commit-id: ca149a082fc89dfdecfafe6514acd8f9e4f401da
---
 src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
index 78f48a173..a8471c990 100644
--- a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
+++ b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
@@ -657,7 +657,6 @@ namespace storm {
                 // Initialize rewards.
                 std::vector<ValueType> totalRewardVector;
                 for (size_t i = 0; i < exitRateVector.size(); ++i) {
-                    std::cout << i << std::endl;
                     if (targetStates[i]) {
                         // Set reward for target states to 0.
                         totalRewardVector.push_back(storm::utility::zero<ValueType>());

From 0775bdf549079030aa0b80de3cc4eb7357955e7c Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 29 Jan 2016 12:11:32 +0100
Subject: [PATCH 036/246] Disabled some debug output

Former-commit-id: 31ae65f255efc625441e1f0a98ba08bdd00a3d14
---
 examples/dft/voting.dft                 | 2 +-
 src/builder/ExplicitDFTModelBuilder.cpp | 1 -
 src/storm-dyftee.cpp                    | 5 ++---
 3 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/examples/dft/voting.dft b/examples/dft/voting.dft
index 6a5e82b3e..5c648d424 100644
--- a/examples/dft/voting.dft
+++ b/examples/dft/voting.dft
@@ -1,5 +1,5 @@
 toplevel "A";
-"A" vot1 "B" "C" "D";
+"A" 1of3 "B" "C" "D";
 "B" lambda=0.1 dorm=0;
 "C" lambda=0.2 dorm=0;
 "D" lambda=0.3 dorm=0;
diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 0d37e795f..a203c93e8 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -99,7 +99,6 @@ namespace storm {
                     storm::storage::DFTState<ValueType> newState(state);
                     std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType>>, bool> nextBE = newState.letNextBEFail(smallest++);
                     if (nextBE.first == nullptr) {
-                        std::cout << "break" << std::endl;
                         break;
 
                     }
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index cf9922c47..c187e5057 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -31,10 +31,9 @@ void analyzeDFT(std::string filename, std::string property) {
     assert(formulas.size() == 1);
     std::unique_ptr<storm::modelchecker::CheckResult> resultCtmc(storm::verifySparseModel(model, formulas[0]));
     assert(resultCtmc);
-    std::cout << "Result (initial states): ";
+    std::cout << "Result: ";
     resultCtmc->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
     std::cout << *resultCtmc << std::endl;
-    std::cout << "Checked CTMC" << std::endl;
 }
 
 /*!
@@ -65,7 +64,7 @@ int main(int argc, char** argv) {
     }
 
     storm::utility::setUp();
-    log4cplus::LogLevel level = log4cplus::TRACE_LOG_LEVEL;
+    log4cplus::LogLevel level = log4cplus::WARN_LOG_LEVEL;
     logger.setLogLevel(level);
     logger.getAppender("mainConsoleAppender")->setThreshold(level);
 

From 8211b8091dadc355f7d380b4f88c8ad150b5d500 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 29 Jan 2016 13:31:17 +0100
Subject: [PATCH 037/246] Helpful comment

Former-commit-id: 96bef1efb476b46b55422f99750644af54b269da
---
 src/storage/dft/DFTState.cpp | 4 +++-
 src/storage/dft/DFTState.h   | 5 +++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 98cada93a..e6e410760 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -83,7 +83,9 @@ namespace storm {
         {
             assert(index < mIsCurrentlyFailableBE.size());
             STORM_LOG_TRACE("currently failable: " << getCurrentlyFailableString());
-            std::pair<std::shared_ptr<DFTBE<ValueType>>,bool> res(mDft.getBasicElement(mIsCurrentlyFailableBE[index]), false);
+            // TODO set when implementing functional dependencies
+            bool dueToFdep = false;
+            std::pair<std::shared_ptr<DFTBE<ValueType>>,bool> res(mDft.getBasicElement(mIsCurrentlyFailableBE[index]), dueToFdep);
             mIsCurrentlyFailableBE.erase(mIsCurrentlyFailableBE.begin() + index);
             setFailed(res.first->id());
             return res;
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 4f25550b0..b084e1a82 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -107,6 +107,11 @@ namespace storm {
                 return mIsCurrentlyFailableBE.size();
             }
 
+            /**
+             * Sets the next BE as failed
+             * @param smallestIndex Index in currentlyFailableBE of BE to fail
+             * @return Pair of BE which fails and flag indicating if the failure was due to functional dependencies
+             */
             std::pair<std::shared_ptr<DFTBE<ValueType>>, bool> letNextBEFail(size_t smallestIndex = 0);
             
             std::string getCurrentlyFailableString() {

From 4079a3f9cc2c228ae2730b3c7b80b1479f4506bc Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 29 Jan 2016 13:50:49 +0100
Subject: [PATCH 038/246] Refactoring

Former-commit-id: ef3aa2c516c474f4e9d3444addc16a1887840c64
---
 src/builder/ExplicitDFTModelBuilder.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index a203c93e8..107baa4bb 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -97,16 +97,16 @@ namespace storm {
                     STORM_LOG_TRACE("exploring from: " << mDft.getStateString(state));
 
                     storm::storage::DFTState<ValueType> newState(state);
-                    std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType>>, bool> nextBE = newState.letNextBEFail(smallest++);
-                    if (nextBE.first == nullptr) {
+                    std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType>>, bool> nextBEPair = newState.letNextBEFail(smallest++);
+                    std::shared_ptr<storm::storage::DFTBE<ValueType>> nextBE = nextBEPair.first;
+                    if (nextBE == nullptr) {
                         break;
-
                     }
-                    STORM_LOG_TRACE("with the failure of: " << nextBE.first->name() << " [" << nextBE.first->id() << "]");
+                    STORM_LOG_TRACE("with the failure of: " << nextBE->name() << " [" << nextBE->id() << "]");
 
                     storm::storage::DFTStateSpaceGenerationQueues<ValueType> queues;
 
-                    for (DFTGatePointer parent : nextBE.first->parents()) {
+                    for (DFTGatePointer parent : nextBE->parents()) {
                         if (newState.isOperational(parent->id())) {
                             queues.propagateFailure(parent);
                         }
@@ -144,7 +144,7 @@ namespace storm {
                     }
 
                     // Set transition
-                    ValueType rate = nextBE.first->activeFailureRate();
+                    ValueType rate = nextBE->activeFailureRate();
                     auto resultFind = outgoingTransitions.find(it->getId());
                     if (resultFind != outgoingTransitions.end()) {
                         // Add to existing transition

From a781df35c291e34c52ff443456fb65f7c76b73c2 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sun, 31 Jan 2016 17:21:13 +0100
Subject: [PATCH 039/246] Use passive failure rate if BE is not used

Former-commit-id: fdc4a6687bb658f26585391e6d5ce7f811dabea0
---
 src/builder/ExplicitDFTModelBuilder.cpp | 21 +++++++++++++--------
 src/storage/dft/DFT.cpp                 |  9 +++++----
 src/storage/dft/DFT.h                   |  9 +++++++++
 3 files changed, 27 insertions(+), 12 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 107baa4bb..811d0fdcb 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -127,31 +127,36 @@ namespace storm {
                         next->checkDontCareAnymore(newState, queues);
                     }
 
-                    auto it = mStates.find(newState);
-                    if (it == mStates.end()) {
+                    auto itState = mStates.find(newState);
+                    if (itState == mStates.end()) {
                         // New state
                         newState.setId(newIndex++);
                         auto itInsert = mStates.insert(newState);
                         assert(itInsert.second);
-                        it = itInsert.first;
+                        itState = itInsert.first;
                         STORM_LOG_TRACE("New state " << mDft.getStateString(newState));
 
                         // Add state to search
                         stateQueue.push(newState);
                     } else {
                         // State already exists
-                        STORM_LOG_TRACE("State " << mDft.getStateString(*it) << " already exists");
+                        STORM_LOG_TRACE("State " << mDft.getStateString(*itState) << " already exists");
                     }
 
-                    // Set transition
-                    ValueType rate = nextBE->activeFailureRate();
-                    auto resultFind = outgoingTransitions.find(it->getId());
+                    // Set failure rate according to usage
+                    bool isUsed = true;
+                    if (mDft.hasRepresentant(nextBE->id())) {
+                        isUsed = newState.isUsed(nextBE->id());
+                    }
+                    STORM_LOG_TRACE("BE " << nextBE->name() << " is " << (isUsed ? "used" : "not used"));
+                    ValueType rate = isUsed ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
+                    auto resultFind = outgoingTransitions.find(itState->getId());
                     if (resultFind != outgoingTransitions.end()) {
                         // Add to existing transition
                         resultFind->second += rate;
                     } else {
                         // Insert new transition
-                        outgoingTransitions.insert(std::make_pair(it->getId(), rate));
+                        outgoingTransitions.insert(std::make_pair(itState->getId(), rate));
                     }
                     sum += rate;
                 } // end while failing BE
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 0b8c99685..ae4ec62eb 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -29,6 +29,7 @@ namespace storm {
                         for(auto const& modelem : module) {
                             if(mElements[modelem]->isSpareGate() || mElements[modelem]->isBasicElement()) {
                                 sparesAndBes.push_back(modelem);
+                                mRepresentants.insert(std::make_pair(modelem, spareReprs->id()));
                             }
                         }
                         mSpareModules.insert(std::make_pair(spareReprs->id(), sparesAndBes));
@@ -131,12 +132,12 @@ namespace storm {
             stream << "(" << state.getId() << ") ";
             for (auto const& elem : mElements) {
                 stream << state.getElementStateInt(elem->id());
-                /*if(elem->isSpareGate()) {
+                if(elem->isSpareGate()) {
                     if(state.isActiveSpare(elem->id())) {
-                        os << " actively";
+                        stream << " actively";
                     }
-                    os << " using " << state.uses(elem->id());
-                }*/
+                    stream << " using " << state.uses(elem->id());
+                }
             }
             return stream.str();
         }
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 0f39e3ddc..17d6c7fd5 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -50,6 +50,7 @@ namespace storm {
             std::vector<size_t> mTopModule;
             std::vector<size_t> mIdToFailureIndex;
             std::map<size_t, size_t> mUsageIndex;
+            std::map<size_t, size_t> mRepresentants;
             
         public:
             DFT(DFTElementVector const& elements, DFTElementPointer const& tle);
@@ -154,6 +155,14 @@ namespace storm {
                 return elements;
             }
 
+            bool hasRepresentant(size_t id) const {
+                return mRepresentants.find(id) != mRepresentants.end();
+            }
+
+            DFTElementPointer getRepresentant(size_t id) const {
+                assert(hasRepresentant(id));
+                return getElement(mRepresentants.find(id)->second);
+            }
 
             bool hasFailed(DFTState<ValueType> const& state) const {
                 return state.hasFailed(mTopLevelIndex);

From ed6d299d464d01345fedcf5e2def7b2a6db3b360 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 1 Feb 2016 10:57:40 +0100
Subject: [PATCH 040/246] Benchmark script for DFTs

Former-commit-id: 574c46528ec97bfd5883e51246e6c7a2d93f3c85
---
 benchmark_dft.py              | 107 ++++++++++++++++++++++++++++++++++
 examples/dft/spare5.dft       |   9 +++
 examples/dft/spare6.dft       |   7 +++
 examples/dft/tripple_and2.dft |   6 +-
 4 files changed, 126 insertions(+), 3 deletions(-)
 create mode 100644 benchmark_dft.py
 create mode 100644 examples/dft/spare5.dft
 create mode 100644 examples/dft/spare6.dft

diff --git a/benchmark_dft.py b/benchmark_dft.py
new file mode 100644
index 000000000..54fb06593
--- /dev/null
+++ b/benchmark_dft.py
@@ -0,0 +1,107 @@
+import os
+import os.path
+import subprocess
+import re
+import time
+import math
+
+STORM_PATH= "/Users/mvolk/develop/storm/build/src/storm-dft"
+EXAMPLE_DIR= "/Users/mvolk/develop/storm/examples/dft/"
+
+
+benchmarks = [ 
+    ("and", False, 3),
+    ("and_param", True, "(4*x^2+2*x+1)/((x) * (2*x+1))"),
+    ("cm2", False, 0.256272),
+    #("cm4", False, 0),
+    ("cps", False, "inf"),
+    #("fdep", False, 0),
+    ("mdcs", False, 2.85414),
+    ("mdcs2", False, 2.85414),
+    ("mp", False, 1.66667),
+    ("or", False, 1),
+    ("pand", False, "inf"),
+    ("pand_param", True, "-1"),
+    ("spare", False, 3.53846),
+    ("spare2", False, 1.86957),
+    ("spare3", False, 1.27273),
+    ("spare4", False, 4.8459),
+    ("spare5", False, 2.16667),
+    ("spare6", False, 1.4),
+    ("tripple_and1", False, 4.16667),
+    ("tripple_and2", False, 3.66667),
+    ("tripple_and2_c", False, 3.6667),
+    ("tripple_and_c", False, 4.16667),
+    ("tripple_or", False, 0.5),
+    ("tripple_or2", False, 0.666667),
+    ("tripple_or2_c", False, 0.66667),
+    ("tripple_or_c", False, 0.5),
+    ("tripple_pand", False, "inf"),
+    ("tripple_pand2", False, "inf"),
+    ("tripple_pand2_c", False, "inf"),
+    ("tripple_pand_c", False, "inf"),
+    ("voting", False, 1.66667),
+    ("voting2", False, 0.588235)
+]
+
+def run_storm_dft(filename, parametric, quiet):
+    # Run storm-dft on filename and return result
+    prop = "ET=? [F \"failed\"]"
+    dft_file = os.path.join(EXAMPLE_DIR, filename + ".dft")
+    args = [STORM_PATH,
+            dft_file,
+            '--prop', prop]
+    if parametric:
+        args.append('--parametric')
+
+    output = run_tool(args, quiet)
+    # Get result
+    match = re.search(r'Result: \[(.*)\]', output)
+    if not match:
+        print("No valid result found in: " + output)
+        return
+    
+    result = match.group(1)
+    return result
+
+def run_tool(args, quiet=False):
+    """
+    Executes a process,
+    :returns: the `stdout`
+    """
+    pipe = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    result = "";
+    for line in iter(pipe.stdout.readline, ""):
+        if not line and pipe.poll() is not None:
+            break
+        output = line.decode(encoding='UTF-8').rstrip()
+        if output != "":
+            if  not quiet:
+                print("\t * " + output)
+            result = output
+    return result
+
+if __name__ == "__main__":
+    count = 0
+    correct = 0
+    start = time.time()
+    for (benchmark, parametric, result_original) in benchmarks:
+        # Run benchmark and check result
+        count += 1;
+        print("Running '{}'".format(benchmark))
+        result = run_storm_dft(benchmark, parametric, True)
+        if not parametric:
+            # Float
+            result = float(result)
+            if not math.isclose(result, float(result_original), rel_tol=1e-05):
+                print("!!! File '{}': result: {}, Expected: {}".format(benchmark, result, result_original))
+            else:
+                correct += 1
+        else:
+            # Parametric
+            if result != result_original:
+                print("!!! File {}: result: {}, Expected: {}".format(benchmark, result, result_original))
+            else:
+                correct += 1
+    end = time.time()
+    print("Correct results for {} of {} DFTs in {}s".format(correct, count, end-start))
diff --git a/examples/dft/spare5.dft b/examples/dft/spare5.dft
new file mode 100644
index 000000000..dcb4d80a4
--- /dev/null
+++ b/examples/dft/spare5.dft
@@ -0,0 +1,9 @@
+toplevel "A";
+"A" wsp "I" "B";
+"B" or "K" "J";
+"C" or "K" "L";
+"I" lambda=0.5 dorm=0;
+"J" lambda=0.5 dorm=0;
+"K" lambda=0.5 dorm=0;
+"L" lambda=0.5 dorm=0;
+
diff --git a/examples/dft/spare6.dft b/examples/dft/spare6.dft
new file mode 100644
index 000000000..d5f2b270b
--- /dev/null
+++ b/examples/dft/spare6.dft
@@ -0,0 +1,7 @@
+toplevel "A";
+"A" or "I" "B";
+"B" wsp "J" "M";
+"I" lambda=0.5 dorm=0.5;
+"J" lambda=0.5 dorm=0.5;
+"M" lambda=0.5 dorm=0.5;
+
diff --git a/examples/dft/tripple_and2.dft b/examples/dft/tripple_and2.dft
index 9e02d88e7..382c1657d 100644
--- a/examples/dft/tripple_and2.dft
+++ b/examples/dft/tripple_and2.dft
@@ -2,7 +2,7 @@ toplevel "A";
 "A" and "B" "C";
 "B" and "BE1" "BE2";
 "C" and "BE2" "BE3";
-"BE1" lambda=0.5 dorm=3;
-"BE2" lambda=0.5 dorm=3;
-"BE3" lambda=0.5 dorm=3;
+"BE1" lambda=0.5 dorm=0.3;
+"BE2" lambda=0.5 dorm=0.3;
+"BE3" lambda=0.5 dorm=0.3;
 

From 0a21431c075caff5d51a487673cfaf7a598e7eff Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 1 Feb 2016 11:00:00 +0100
Subject: [PATCH 041/246] Use representant for usage flag in DFTBuilder

Former-commit-id: 9084ce2f2f43492f60527f9ea66b0c60feed35bd
---
 src/builder/ExplicitDFTModelBuilder.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 811d0fdcb..10534d0a5 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -146,7 +146,8 @@ namespace storm {
                     // Set failure rate according to usage
                     bool isUsed = true;
                     if (mDft.hasRepresentant(nextBE->id())) {
-                        isUsed = newState.isUsed(nextBE->id());
+                        DFTElementPointer representant = mDft.getRepresentant(nextBE->id());
+                        isUsed = newState.isUsed(representant->id());
                     }
                     STORM_LOG_TRACE("BE " << nextBE->name() << " is " << (isUsed ? "used" : "not used"));
                     ValueType rate = isUsed ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();

From 2e8f74a70090ac7754de88845bb762a6158abf80 Mon Sep 17 00:00:00 2001
From: dehnert <dehnert@cs.rwth-aachen.de>
Date: Mon, 1 Feb 2016 14:51:34 +0100
Subject: [PATCH 042/246] First steps toward exact linear equation solver

Former-commit-id: 669af13b84574d35c6df40e16ca8a007ed303dc4
---
 src/adapters/CarlAdapter.h                    |  9 +-
 .../EliminationLinearEquationSolver.cpp       | 62 +++++++++++++
 src/solver/EliminationLinearEquationSolver.h  | 34 +++++++
 src/solver/NativeLinearEquationSolver.h       |  2 +-
 src/storage/FlexibleSparseMatrix.cpp          | 88 +++++++++++++++++++
 src/storage/FlexibleSparseMatrix.h            | 65 ++++++++++++++
 .../expressions/ToRationalFunctionVisitor.cpp |  4 +-
 src/utility/vector.h                          |  2 +-
 8 files changed, 260 insertions(+), 6 deletions(-)
 create mode 100644 src/solver/EliminationLinearEquationSolver.cpp
 create mode 100644 src/solver/EliminationLinearEquationSolver.h
 create mode 100644 src/storage/FlexibleSparseMatrix.cpp
 create mode 100644 src/storage/FlexibleSparseMatrix.h

diff --git a/src/adapters/CarlAdapter.h b/src/adapters/CarlAdapter.h
index 2ed172cde..093ea6ae7 100644
--- a/src/adapters/CarlAdapter.h
+++ b/src/adapters/CarlAdapter.h
@@ -4,6 +4,8 @@
 // Include config to know whether CARL is available or not.
 #include "storm-config.h"
 
+#include <boost/multiprecision/gmp.hpp>
+
 #ifdef STORM_HAVE_CARL
 
 #include <carl/numbers/numbers.h>
@@ -42,9 +44,12 @@ namespace carl {
 }
 
 namespace storm {
-    typedef cln::cl_RA RationalNumber;
+//    typedef boost::multiprecision::gmp_rational RationalNumber;
+    typedef mpq_class RationalNumber;
+    
+    typedef cln::cl_RA CarlRationalNumber;
     typedef carl::Variable Variable;
-    typedef carl::MultivariatePolynomial<RationalNumber> RawPolynomial;
+    typedef carl::MultivariatePolynomial<CarlRationalNumber> RawPolynomial;
     typedef carl::FactorizedPolynomial<RawPolynomial> Polynomial;
     typedef carl::Relation CompareRelation;
     
diff --git a/src/solver/EliminationLinearEquationSolver.cpp b/src/solver/EliminationLinearEquationSolver.cpp
new file mode 100644
index 000000000..67a281b70
--- /dev/null
+++ b/src/solver/EliminationLinearEquationSolver.cpp
@@ -0,0 +1,62 @@
+#include "src/solver/EliminationLinearEquationSolver.h"
+
+#include "src/utility/vector.h"
+
+namespace storm {
+    namespace solver {
+        template<typename ValueType>
+        EliminationLinearEquationSolver<ValueType>::EliminationLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A) : A(A) {
+            // Intentionally left empty.
+        }
+        
+        template<typename ValueType>
+        void EliminationLinearEquationSolver<ValueType>::solveEquationSystem(std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult) const {
+            // TODO: implement state-elimination here.
+        }
+        
+        template<typename ValueType>
+        void EliminationLinearEquationSolver<ValueType>::performMatrixVectorMultiplication(std::vector<ValueType>& x, std::vector<ValueType> const* b, uint_fast64_t n, std::vector<ValueType>* multiplyResult) const {
+            // Set up some temporary variables so that we can just swap pointers instead of copying the result after
+            // each iteration.
+            std::vector<ValueType>* currentX = &x;
+            
+            bool multiplyResultProvided = true;
+            std::vector<ValueType>* nextX = multiplyResult;
+            if (nextX == nullptr) {
+                nextX = new std::vector<ValueType>(x.size());
+                multiplyResultProvided = false;
+            }
+            std::vector<ValueType> const* copyX = nextX;
+            
+            // Now perform matrix-vector multiplication as long as we meet the bound.
+            for (uint_fast64_t i = 0; i < n; ++i) {
+                A.multiplyWithVector(*currentX, *nextX);
+                std::swap(nextX, currentX);
+                
+                // If requested, add an offset to the current result vector.
+                if (b != nullptr) {
+                    storm::utility::vector::addVectors(*currentX, *b, *currentX);
+                }
+            }
+            
+            // If we performed an odd number of repetitions, we need to swap the contents of currentVector and x,
+            // because the output is supposed to be stored in the input vector x.
+            if (currentX == copyX) {
+                std::swap(x, *currentX);
+            }
+            
+            // If the vector for the temporary multiplication result was not provided, we need to delete it.
+            if (!multiplyResultProvided) {
+                delete copyX;
+            }
+        }
+
+        template class EliminationLinearEquationSolver<double>;
+        
+        // TODO: make this work with the proper implementation of solveEquationSystem.
+        template class EliminationLinearEquationSolver<storm::RationalNumber>;
+        template class EliminationLinearEquationSolver<storm::RationalFunction>;
+        
+    }
+}
+
diff --git a/src/solver/EliminationLinearEquationSolver.h b/src/solver/EliminationLinearEquationSolver.h
new file mode 100644
index 000000000..25dffa651
--- /dev/null
+++ b/src/solver/EliminationLinearEquationSolver.h
@@ -0,0 +1,34 @@
+#ifndef STORM_SOLVER_ELIMINATIONLINEAREQUATIONSOLVER_H_
+#define STORM_SOLVER_ELIMINATIONLINEAREQUATIONSOLVER_H_
+
+#include "src/solver/LinearEquationSolver.h"
+
+namespace storm {
+    namespace solver {
+        /*!
+         * A class that uses gaussian elimination to implement the LinearEquationSolver interface. In particular
+         */
+        template<typename ValueType>
+        class EliminationLinearEquationSolver : public LinearEquationSolver<ValueType> {
+        public:
+            
+            /*!
+             * Constructs a linear equation solver.
+             *
+             * @param A The matrix defining the coefficients of the linear equation system.
+             */
+            EliminationLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A);
+            
+            virtual void solveEquationSystem(std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult = nullptr) const override;
+            
+            virtual void performMatrixVectorMultiplication(std::vector<ValueType>& x, std::vector<ValueType> const* b, uint_fast64_t n = 1, std::vector<ValueType>* multiplyResult = nullptr) const override;
+
+        private:
+            // A reference to the original matrix used for this equation solver.
+            storm::storage::SparseMatrix<ValueType> const& A;
+            
+        };
+    }
+}
+
+#endif /* STORM_SOLVER_ELIMINATIONLINEAREQUATIONSOLVER_H_ */
\ No newline at end of file
diff --git a/src/solver/NativeLinearEquationSolver.h b/src/solver/NativeLinearEquationSolver.h
index 6fa972f05..42dbbd3d9 100644
--- a/src/solver/NativeLinearEquationSolver.h
+++ b/src/solver/NativeLinearEquationSolver.h
@@ -10,6 +10,7 @@ namespace storm {
         enum class NativeLinearEquationSolverSolutionMethod {
             Jacobi, GaussSeidel, SOR
         };
+        
         /*!
          * A class that uses StoRM's native matrix operations to implement the LinearEquationSolver interface.
          */
@@ -17,7 +18,6 @@ namespace storm {
         class NativeLinearEquationSolver : public LinearEquationSolver<ValueType> {
         public:
             
-            
             /*!
              * Constructs a linear equation solver with parameters being set according to the settings object.
              *
diff --git a/src/storage/FlexibleSparseMatrix.cpp b/src/storage/FlexibleSparseMatrix.cpp
new file mode 100644
index 000000000..b77f59736
--- /dev/null
+++ b/src/storage/FlexibleSparseMatrix.cpp
@@ -0,0 +1,88 @@
+#include "src/storage/FlexibleSparseMatrix.h"
+
+#include "src/storage/SparseMatrix.h"
+#include "src/storage/BitVector.h"
+
+namespace storm {
+    namespace storage {
+        template<typename ValueType>
+        FlexibleSparseMatrix<ValueType>::FlexibleSparseMatrix(index_type rows) : data(rows) {
+            // Intentionally left empty.
+        }
+        
+        template<typename ValueType>
+        void FlexibleSparseMatrix<ValueType>::reserveInRow(index_type row, index_type numberOfElements) {
+            this->data[row].reserve(numberOfElements);
+        }
+        
+        template<typename ValueType>
+        typename FlexibleSparseMatrix<ValueType>::row_type& FlexibleSparseMatrix<ValueType>::getRow(index_type index) {
+            return this->data[index];
+        }
+        
+        template<typename ValueType>
+        typename FlexibleSparseMatrix<ValueType>::row_type const& FlexibleSparseMatrix<ValueType>::getRow(index_type index) const {
+            return this->data[index];
+        }
+        
+        template<typename ValueType>
+        typename FlexibleSparseMatrix<ValueType>::index_type FlexibleSparseMatrix<ValueType>::getNumberOfRows() const {
+            return this->data.size();
+        }
+        
+        template<typename ValueType>
+        bool FlexibleSparseMatrix<ValueType>::hasSelfLoop(storm::storage::sparse::state_type state) {
+            for (auto const& entry : this->getRow(state)) {
+                if (entry.getColumn() < state) {
+                    continue;
+                } else if (entry.getColumn() > state) {
+                    return false;
+                } else if (entry.getColumn() == state) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        
+        template<typename ValueType>
+        void FlexibleSparseMatrix<ValueType>::print() const {
+            for (uint_fast64_t index = 0; index < this->data.size(); ++index) {
+                std::cout << index << " - ";
+                for (auto const& element : this->getRow(index)) {
+                    std::cout << "(" << element.getColumn() << ", " << element.getValue() << ") ";
+                }
+                std::cout << std::endl;
+            }
+        }
+        
+        template<typename ValueType>
+        bool FlexibleSparseMatrix<ValueType>::empty() const {
+            for (auto const& row : this->data) {
+                if (!row.empty()) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        
+        template<typename ValueType>
+        void FlexibleSparseMatrix<ValueType>::filter(storm::storage::BitVector const& rowFilter, storm::storage::BitVector const& columnFilter) {
+            for (uint_fast64_t rowIndex = 0; rowIndex < this->data.size(); ++rowIndex) {
+                auto& row = this->data[rowIndex];
+                if (!rowFilter.get(rowIndex)) {
+                    row.clear();
+                    row.shrink_to_fit();
+                    continue;
+                }
+                row_type newRow;
+                for (auto const& element : row) {
+                    if (columnFilter.get(element.getColumn())) {
+                        newRow.push_back(element);
+                    }
+                }
+                row = std::move(newRow);
+            }
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/src/storage/FlexibleSparseMatrix.h b/src/storage/FlexibleSparseMatrix.h
new file mode 100644
index 000000000..6a30109ac
--- /dev/null
+++ b/src/storage/FlexibleSparseMatrix.h
@@ -0,0 +1,65 @@
+#ifndef STORM_STORAGE_FLEXIBLESPARSEMATRIX_H_
+#define STORM_STORAGE_FLEXIBLESPARSEMATRIX_H_
+
+#include <cstdint>
+#include <vector>
+
+#include "src/storage/sparse/StateType.h"
+
+namespace storm {
+    namespace storage {
+        template <typename IndexType, typename ValueType>
+        class MatrixEntry;
+        
+        class BitVector;
+        
+        template<typename ValueType>
+        class FlexibleSparseMatrix {
+        public:
+            // TODO: make this class a bit more consistent with the big sparse matrix and improve it:
+            // * rename getNumberOfRows -> getRowCount
+            // * store number of columns to also provide getColumnCount
+            // * rename hasSelfLoop -> rowHasDiagonalElement
+            // * add output iterator and improve the way the matrix is printed
+            // * add conversion functionality from/to sparse matrix
+            // * add documentation
+            // * rename filter to something more appropriate (getSubmatrix?)
+            // * add stuff like clearRow, multiplyRowWithScalar
+            
+            typedef uint_fast64_t index_type;
+            typedef ValueType value_type;
+            typedef std::vector<storm::storage::MatrixEntry<index_type, value_type>> row_type;
+            typedef typename row_type::iterator iterator;
+            typedef typename row_type::const_iterator const_iterator;
+            
+            FlexibleSparseMatrix() = default;
+            FlexibleSparseMatrix(index_type rows);
+            
+            void reserveInRow(index_type row, index_type numberOfElements);
+            
+            row_type& getRow(index_type);
+            row_type const& getRow(index_type) const;
+            
+            index_type getNumberOfRows() const;
+            
+            void print() const;
+            
+            bool empty() const;
+            
+            void filter(storm::storage::BitVector const& rowFilter, storm::storage::BitVector const& columnFilter);
+            
+            /*!
+             * Checks whether the given state has a self-loop with an arbitrary probability in the probability matrix.
+             *
+             * @param state The state for which to check whether it possesses a self-loop.
+             * @return True iff the given state has a self-loop with an arbitrary probability in the probability matrix.
+             */
+            bool hasSelfLoop(storm::storage::sparse::state_type state);
+            
+        private:
+            std::vector<row_type> data;
+        };
+    }
+}
+
+#endif /* STORM_STORAGE_FLEXIBLESPARSEMATRIX_H_ */
\ No newline at end of file
diff --git a/src/storage/expressions/ToRationalFunctionVisitor.cpp b/src/storage/expressions/ToRationalFunctionVisitor.cpp
index 97501aa1b..5e0ebcd64 100644
--- a/src/storage/expressions/ToRationalFunctionVisitor.cpp
+++ b/src/storage/expressions/ToRationalFunctionVisitor.cpp
@@ -88,12 +88,12 @@ namespace storm {
         
         template<typename RationalFunctionType>
         boost::any ToRationalFunctionVisitor<RationalFunctionType>::visit(IntegerLiteralExpression const& expression) {
-            return RationalFunctionType(carl::rationalize<storm::RationalNumber>(static_cast<size_t>(expression.getValue())));
+            return RationalFunctionType(carl::rationalize<storm::CarlRationalNumber>(static_cast<size_t>(expression.getValue())));
         }
         
         template<typename RationalFunctionType>
         boost::any ToRationalFunctionVisitor<RationalFunctionType>::visit(DoubleLiteralExpression const& expression) {
-            return RationalFunctionType(carl::rationalize<storm::RationalNumber>(expression.getValue()));
+            return RationalFunctionType(carl::rationalize<storm::CarlRationalNumber>(expression.getValue()));
         }
 
         template class ToRationalFunctionVisitor<storm::RationalFunction>;
diff --git a/src/utility/vector.h b/src/utility/vector.h
index 665569645..a4e551efa 100644
--- a/src/utility/vector.h
+++ b/src/utility/vector.h
@@ -269,7 +269,7 @@ namespace storm {
              * @param target The target vector.
              */
             template<class InValueType1, class InValueType2, class OutValueType>
-            void applyPointwise(std::vector<InValueType1> const& firstOperand, std::vector<InValueType2> const& secondOperand, std::vector<OutValueType>& target, std::function<OutValueType (InValueType1 const&, InValueType2 const&)> function) {
+            void applyPointwise(std::vector<InValueType1> const& firstOperand, std::vector<InValueType2> const& secondOperand, std::vector<OutValueType>& target, std::function<OutValueType (InValueType1 const&, InValueType2 const&)> const& function) {
 #ifdef STORM_HAVE_INTELTBB
                 tbb::parallel_for(tbb::blocked_range<uint_fast64_t>(0, target.size()),
                                   [&](tbb::blocked_range<uint_fast64_t> const& range) {

From 4eaf8f84433f521d2fbf72d97ae46d1577a8058f Mon Sep 17 00:00:00 2001
From: dehnert <dehnert@cs.rwth-aachen.de>
Date: Mon, 1 Feb 2016 16:18:11 +0100
Subject: [PATCH 043/246] changed ration number to the boost version again
 (this time in the correct version)

Former-commit-id: 2c97e6e43ecc52dc93bd9e0c525a6689fd56f9c2
---
 src/adapters/CarlAdapter.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/adapters/CarlAdapter.h b/src/adapters/CarlAdapter.h
index 093ea6ae7..4fd2a98a0 100644
--- a/src/adapters/CarlAdapter.h
+++ b/src/adapters/CarlAdapter.h
@@ -45,7 +45,7 @@ namespace carl {
 
 namespace storm {
 //    typedef boost::multiprecision::gmp_rational RationalNumber;
-    typedef mpq_class RationalNumber;
+    typedef boost::multiprecision::number<boost::multiprecision::gmp_rational> RationalNumber;
     
     typedef cln::cl_RA CarlRationalNumber;
     typedef carl::Variable Variable;

From dd17955a3e752f219a2d432d8f5d71b564ff29e0 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 1 Feb 2016 18:36:43 +0100
Subject: [PATCH 044/246] Added functionality to BitVectorHashMap

Former-commit-id: 0d1fa18d16f5a5c9459de99d7516e24a04654961
---
 src/storage/BitVectorHashMap.cpp | 5 +++++
 src/storage/BitVectorHashMap.h   | 8 ++++++++
 src/storage/dft/DFTState.cpp     | 2 +-
 src/storage/dft/DFTState.h       | 6 +++---
 4 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/src/storage/BitVectorHashMap.cpp b/src/storage/BitVectorHashMap.cpp
index c184b764b..9237dfde3 100644
--- a/src/storage/BitVectorHashMap.cpp
+++ b/src/storage/BitVectorHashMap.cpp
@@ -168,6 +168,11 @@ namespace storm {
             return values[flagBucketPair.second];
         }
         
+        template<class ValueType, class Hash1, class Hash2>
+        bool BitVectorHashMap<ValueType, Hash1, Hash2>::contains(storm::storage::BitVector const& key) const {
+            return findBucket(key).first;
+        }
+
         template<class ValueType, class Hash1, class Hash2>
         typename BitVectorHashMap<ValueType, Hash1, Hash2>::const_iterator BitVectorHashMap<ValueType, Hash1, Hash2>::begin() const {
             return const_iterator(*this, occupied.begin());
diff --git a/src/storage/BitVectorHashMap.h b/src/storage/BitVectorHashMap.h
index 3b0c7aa70..d50dac59e 100644
--- a/src/storage/BitVectorHashMap.h
+++ b/src/storage/BitVectorHashMap.h
@@ -95,6 +95,14 @@ namespace storm {
              */
             ValueType getValue(storm::storage::BitVector const& key) const;
             
+            /*!
+             * Checks if the given key is already contained in the map.
+             *
+             * @param key The key to search
+             * @return True if the key is already contained in the map
+             */
+            bool contains(storm::storage::BitVector const& key) const;
+
             /*!
              * Retrieves an iterator to the elements of the map.
              *
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index e6e410760..ebf3c770b 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -123,7 +123,7 @@ namespace storm {
         }
 
         template<typename ValueType>
-        bool DFTState<ValueType>::isUsed(size_t child) {
+        bool DFTState<ValueType>::isUsed(size_t child) const {
             return (std::find(mUsedRepresentants.begin(), mUsedRepresentants.end(), child) != mUsedRepresentants.end());
         }
 
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index b084e1a82..4ea11a991 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -61,7 +61,7 @@ namespace storm {
                 mValid = false;
             }
            
-            bool isInvalid() {
+            bool isInvalid() const {
                 return !mValid;
             }
             
@@ -88,7 +88,7 @@ namespace storm {
              * @param child The id of the child for which we want to know whether it is currently used.
              * @return true iff it is currently used by any of the spares.
              */
-            bool isUsed(size_t child);
+            bool isUsed(size_t child) const;
             
             /**
              * Sets to to the usageIndex which child is now used.
@@ -114,7 +114,7 @@ namespace storm {
              */
             std::pair<std::shared_ptr<DFTBE<ValueType>>, bool> letNextBEFail(size_t smallestIndex = 0);
             
-            std::string getCurrentlyFailableString() {
+            std::string getCurrentlyFailableString() const {
                 std::stringstream stream;
                 auto it = mIsCurrentlyFailableBE.begin();
                 stream << "{";

From 69a464d5ef6d3ed3187b3291f8acfd25560e9c5a Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 1 Feb 2016 18:45:18 +0100
Subject: [PATCH 045/246] Changed unordered_set to BitVectorHashMap for
 DFTState

Former-commit-id: 35f57aa25040796690fadc21d764f53efb103be4
---
 src/builder/ExplicitDFTModelBuilder.cpp | 66 ++++++++++++-------------
 src/builder/ExplicitDFTModelBuilder.h   | 11 +++--
 src/storage/BitVectorHashMap.cpp        |  7 +++
 src/storage/dft/DFT.cpp                 | 18 +++----
 src/storage/dft/DFT.h                   | 13 ++---
 5 files changed, 63 insertions(+), 52 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 10534d0a5..1b777fb54 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -14,10 +14,10 @@ namespace storm {
         template<typename ValueType, typename RewardModelType, typename IndexType>
         std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>> ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::buildCTMC() {
             // Initialize
-            storm::storage::DFTState<ValueType> state(mDft, newIndex++);
-            mStates.insert(state);
+            DFTStatePointer state = std::make_shared<storm::storage::DFTState<ValueType>>(mDft, newIndex++);
+            mStates.findOrAdd(state->status(), state);
 
-            std::queue<storm::storage::DFTState<ValueType>> stateQueue;
+            std::queue<DFTStatePointer> stateQueue;
             stateQueue.push(state);
 
             bool deterministicModel = true;
@@ -47,17 +47,18 @@ namespace storm {
                 modelComponents.stateLabeling.addLabel(elem->name() + "_fail");
             }
 
-            for (storm::storage::DFTState<ValueType> state : mStates) {
+            for (auto const& stateVectorPair : mStates) {
+                DFTStatePointer state = stateVectorPair.second;
                 if (mDft.hasFailed(state)) {
-                    modelComponents.stateLabeling.addLabelToState("failed", state.getId());
+                    modelComponents.stateLabeling.addLabelToState("failed", state->getId());
                 }
                 if (mDft.isFailsafe(state)) {
-                    modelComponents.stateLabeling.addLabelToState("failsafe", state.getId());
+                    modelComponents.stateLabeling.addLabelToState("failsafe", state->getId());
                 };
                 // Set fail status for each BE
                 for (std::shared_ptr<storage::DFTBE<ValueType>> elem : basicElements) {
-                    if (state.hasFailed(elem->id())) {
-                        modelComponents.stateLabeling.addLabelToState(elem->name() + "_fail", state.getId());
+                    if (state->hasFailed(elem->id())) {
+                        modelComponents.stateLabeling.addLabelToState(elem->name() + "_fail", state->getId());
                     }
                 }
             }
@@ -69,7 +70,7 @@ namespace storm {
         }
 
         template<typename ValueType, typename RewardModelType, typename IndexType>
-        void ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::exploreStates(std::queue<storm::storage::DFTState<ValueType>>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder) {
+        void ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder) {
 
             std::map<size_t, ValueType> outgoingTransitions;
 
@@ -79,25 +80,26 @@ namespace storm {
                 ValueType sum = storm::utility::zero<ValueType>();
 
                 // Consider next state
-                storm::storage::DFTState<ValueType> state = stateQueue.front();
+                DFTStatePointer state = stateQueue.front();
                 stateQueue.pop();
 
                 size_t smallest = 0;
 
                 // Add self loop for target states
                 if (mDft.hasFailed(state) || mDft.isFailsafe(state)) {
-                    transitionMatrixBuilder.addNextValue(state.getId(), state.getId(), storm::utility::one<ValueType>());
-                    STORM_LOG_TRACE("Added self loop for " << state.getId());
+                    transitionMatrixBuilder.addNextValue(state->getId(), state->getId(), storm::utility::one<ValueType>());
+                    STORM_LOG_TRACE("Added self loop for " << state->getId());
                     // No further exploration required
                     continue;
                 }
 
                 // Let BE fail
-                while (smallest < state.nrFailableBEs()) {
+                while (smallest < state->nrFailableBEs()) {
                     STORM_LOG_TRACE("exploring from: " << mDft.getStateString(state));
 
-                    storm::storage::DFTState<ValueType> newState(state);
-                    std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType>>, bool> nextBEPair = newState.letNextBEFail(smallest++);
+                    // Construct new state as copy from original one
+                    DFTStatePointer newState = std::make_shared<storm::storage::DFTState<ValueType>>(*state);
+                    std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType>>, bool> nextBEPair = newState->letNextBEFail(smallest++);
                     std::shared_ptr<storm::storage::DFTBE<ValueType>> nextBE = nextBEPair.first;
                     if (nextBE == nullptr) {
                         break;
@@ -107,57 +109,55 @@ namespace storm {
                     storm::storage::DFTStateSpaceGenerationQueues<ValueType> queues;
 
                     for (DFTGatePointer parent : nextBE->parents()) {
-                        if (newState.isOperational(parent->id())) {
+                        if (newState->isOperational(parent->id())) {
                             queues.propagateFailure(parent);
                         }
                     }
 
                     while (!queues.failurePropagationDone()) {
                         DFTGatePointer next = queues.nextFailurePropagation();
-                        next->checkFails(newState, queues);
+                        next->checkFails(*newState, queues);
                     }
 
                     while (!queues.failsafePropagationDone()) {
                         DFTGatePointer next = queues.nextFailsafePropagation();
-                        next->checkFailsafe(newState, queues);
+                        next->checkFailsafe(*newState, queues);
                     }
 
                     while (!queues.dontCarePropagationDone()) {
                         DFTElementPointer next = queues.nextDontCarePropagation();
-                        next->checkDontCareAnymore(newState, queues);
+                        next->checkDontCareAnymore(*newState, queues);
                     }
 
-                    auto itState = mStates.find(newState);
-                    if (itState == mStates.end()) {
+                    if (mStates.contains(newState->status())) {
+                        // State already exists
+                        newState = mStates.findOrAdd(newState->status(), newState);
+                        STORM_LOG_TRACE("State " << mDft.getStateString(newState) << " already exists");
+                    } else {
                         // New state
-                        newState.setId(newIndex++);
-                        auto itInsert = mStates.insert(newState);
-                        assert(itInsert.second);
-                        itState = itInsert.first;
+                        newState->setId(newIndex++);
+                        mStates.findOrAdd(newState->status(), newState);
                         STORM_LOG_TRACE("New state " << mDft.getStateString(newState));
 
                         // Add state to search
                         stateQueue.push(newState);
-                    } else {
-                        // State already exists
-                        STORM_LOG_TRACE("State " << mDft.getStateString(*itState) << " already exists");
                     }
 
                     // Set failure rate according to usage
                     bool isUsed = true;
                     if (mDft.hasRepresentant(nextBE->id())) {
                         DFTElementPointer representant = mDft.getRepresentant(nextBE->id());
-                        isUsed = newState.isUsed(representant->id());
+                        isUsed = newState->isUsed(representant->id());
                     }
                     STORM_LOG_TRACE("BE " << nextBE->name() << " is " << (isUsed ? "used" : "not used"));
                     ValueType rate = isUsed ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
-                    auto resultFind = outgoingTransitions.find(itState->getId());
+                    auto resultFind = outgoingTransitions.find(newState->getId());
                     if (resultFind != outgoingTransitions.end()) {
                         // Add to existing transition
                         resultFind->second += rate;
                     } else {
                         // Insert new transition
-                        outgoingTransitions.insert(std::make_pair(itState->getId(), rate));
+                        outgoingTransitions.insert(std::make_pair(newState->getId(), rate));
                     }
                     sum += rate;
                 } // end while failing BE
@@ -167,8 +167,8 @@ namespace storm {
                 {
                     // TODO Matthias: correct?
                     ValueType rate = it->second;// / sum;
-                    transitionMatrixBuilder.addNextValue(state.getId(), it->first, rate);
-                    STORM_LOG_TRACE("Added transition from " << state.getId() << " to " << it->first << " with " << rate);
+                    transitionMatrixBuilder.addNextValue(state->getId(), it->first, rate);
+                    STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << it->first << " with " << rate);
                 }
 
             } // end while queue
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 8148559c3..ed02e60d4 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -7,6 +7,7 @@
 #include <src/models/sparse/StandardRewardModel.h>
 #include <src/models/sparse/Model.h>
 #include <src/storage/SparseMatrix.h>
+#include <src/storage/BitVectorHashMap.h>
 #include <boost/container/flat_set.hpp>
 #include <boost/optional/optional.hpp>
 #include <stack>
@@ -20,6 +21,7 @@ namespace storm {
 
             using DFTElementPointer = std::shared_ptr<storm::storage::DFTElement<ValueType>>;
             using DFTGatePointer = std::shared_ptr<storm::storage::DFTGate<ValueType>>;
+            using DFTStatePointer = std::shared_ptr<storm::storage::DFTState<ValueType>>;
 
             // A structure holding the individual components of a model.
             struct ModelComponents {
@@ -39,18 +41,19 @@ namespace storm {
             };
 
             storm::storage::DFT<ValueType> const &mDft;
-            std::unordered_set<storm::storage::DFTState<ValueType>> mStates;
+            storm::storage::BitVectorHashMap<DFTStatePointer> mStates;
             size_t newIndex = 0;
 
         public:
-            ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const &dft) : mDft(dft) {
-
+            ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const &dft) : mDft(dft), mStates(((mDft.stateSize() / 64) + 1) * 64, std::pow(2, mDft.nrBasicElements())) {
+                // stateSize is bound for size of bitvector
+                // 2^nrBE is upper bound for state space
             }
 
             std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>> buildCTMC();
 
         private:
-            void exploreStates(std::queue<storm::storage::DFTState<ValueType>>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder);
+            void exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder);
 
         };
     }
diff --git a/src/storage/BitVectorHashMap.cpp b/src/storage/BitVectorHashMap.cpp
index 9237dfde3..be0e32325 100644
--- a/src/storage/BitVectorHashMap.cpp
+++ b/src/storage/BitVectorHashMap.cpp
@@ -4,6 +4,9 @@
 
 #include "src/utility/macros.h"
 
+#include "src/storage/dft/DFTState.h"
+#include "src/adapters/CarlAdapter.h"
+
 namespace storm {
     namespace storage {
         template<class ValueType, class Hash1, class Hash2>
@@ -240,5 +243,9 @@ namespace storm {
         
         template class BitVectorHashMap<uint_fast64_t>;
         template class BitVectorHashMap<uint32_t>;
+        template class BitVectorHashMap<std::shared_ptr<DFTState<double>>>;
+#ifdef STORM_HAVE_CARL
+        template class BitVectorHashMap<std::shared_ptr<DFTState<storm::RationalFunction>>>;
+#endif
     }
 }
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index ae4ec62eb..c36f0a9e0 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -109,17 +109,17 @@ namespace storm {
         }
 
         template<typename ValueType>
-        std::string DFT<ValueType>::getElementsWithStateString(DFTState<ValueType> const& state) const{
+        std::string DFT<ValueType>::getElementsWithStateString(DFTStatePointer const& state) const{
             std::stringstream stream;
             for (auto const& elem : mElements) {
                 stream << "[" << elem->id() << "]";
                 stream << elem->toString();
-                stream << "\t** " << state.getElementState(elem->id());
+                stream << "\t** " << state->getElementState(elem->id());
                 if(elem->isSpareGate()) {
-                    if(state.isActiveSpare(elem->id())) {
+                    if(state->isActiveSpare(elem->id())) {
                         stream << " actively";
                     }
-                    stream << " using " << state.uses(elem->id());
+                    stream << " using " << state->uses(elem->id());
                 } 
                 stream << std::endl;
             }
@@ -127,16 +127,16 @@ namespace storm {
         }
 
         template<typename ValueType>
-        std::string DFT<ValueType>::getStateString(DFTState<ValueType> const& state) const{
+        std::string DFT<ValueType>::getStateString(DFTStatePointer const& state) const{
             std::stringstream stream;
-            stream << "(" << state.getId() << ") ";
+            stream << "(" << state->getId() << ") ";
             for (auto const& elem : mElements) {
-                stream << state.getElementStateInt(elem->id());
+                stream << state->getElementStateInt(elem->id());
                 if(elem->isSpareGate()) {
-                    if(state.isActiveSpare(elem->id())) {
+                    if(state->isActiveSpare(elem->id())) {
                         stream << " actively";
                     }
-                    stream << " using " << state.uses(elem->id());
+                    stream << " using " << state->uses(elem->id());
                 }
             }
             return stream.str();
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 17d6c7fd5..81cfdf99b 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -37,6 +37,7 @@ namespace storm {
             using DFTElementVector = std::vector<DFTElementPointer>;
             using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
             using DFTGateVector = std::vector<DFTGatePointer>;
+            using DFTStatePointer = std::shared_ptr<DFTState<ValueType>>;
 
         private:
             DFTElementVector mElements;
@@ -164,12 +165,12 @@ namespace storm {
                 return getElement(mRepresentants.find(id)->second);
             }
 
-            bool hasFailed(DFTState<ValueType> const& state) const {
-                return state.hasFailed(mTopLevelIndex);
+            bool hasFailed(DFTStatePointer const& state) const {
+                return state->hasFailed(mTopLevelIndex);
             }
             
-            bool isFailsafe(DFTState<ValueType> const& state) const {
-                return state.isFailsafe(mTopLevelIndex);
+            bool isFailsafe(DFTStatePointer const& state) const {
+                return state->isFailsafe(mTopLevelIndex);
             }
             
             std::string getElementsString() const;
@@ -178,9 +179,9 @@ namespace storm {
 
             std::string getSpareModulesString() const;
 
-            std::string getElementsWithStateString(DFTState<ValueType> const& state) const;
+            std::string getElementsWithStateString(DFTStatePointer const& state) const;
 
-            std::string getStateString(DFTState<ValueType> const& state) const;
+            std::string getStateString(DFTStatePointer const& state) const;
             
         private:
             bool elementIndicesCorrect() const {

From b55cc3276e245e5b77d784074054e251723589df Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 3 Feb 2016 18:04:14 +0100
Subject: [PATCH 046/246] Reachability probabilities for CTMCs

Former-commit-id: fad855c59abe578f6945e2adc3fc553d3a332016
---
 .../csl/SparseCtmcCslModelChecker.cpp         |  2 +-
 .../csl/helper/SparseCtmcCslHelper.cpp        | 35 +++++++++++--
 .../csl/helper/SparseCtmcCslHelper.h          |  4 +-
 .../SparseDtmcEliminationModelChecker.cpp     | 50 +++++++++++--------
 .../SparseDtmcEliminationModelChecker.h       |  7 +++
 src/utility/storm.h                           | 44 ++++++++++++++--
 6 files changed, 110 insertions(+), 32 deletions(-)

diff --git a/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp b/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
index a9b86d8c8..b7e42e1db 100644
--- a/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
+++ b/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
@@ -108,7 +108,7 @@ namespace storm {
             std::unique_ptr<CheckResult> subResultPointer = this->check(eventuallyFormula.getSubformula());
             ExplicitQualitativeCheckResult& subResult = subResultPointer->asExplicitQualitativeCheckResult();
 
-            std::vector<ValueType> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<ValueType>::computeExpectedTimes(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), this->getModel().getExitRateVector(), this->getModel().getInitialStates(), subResult.getTruthValuesVector(), qualitative/*, *linearEquationSolverFactory*/);
+            std::vector<ValueType> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<ValueType>::computeExpectedTimes(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), this->getModel().getExitRateVector(), this->getModel().getInitialStates(), subResult.getTruthValuesVector(), qualitative, *linearEquationSolverFactory);
             return std::unique_ptr<CheckResult>(new ExplicitQuantitativeCheckResult<ValueType>(std::move(numericResult)));
         }
 
diff --git a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
index a8471c990..ae656b5ee 100644
--- a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
+++ b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
@@ -195,6 +195,12 @@ namespace storm {
                 return SparseDtmcPrctlHelper<ValueType>::computeUntilProbabilities(computeProbabilityMatrix(rateMatrix, exitRateVector), backwardTransitions, phiStates, psiStates, qualitative, linearEquationSolverFactory);
             }
             
+            template <typename ValueType>
+            std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeUntilProbabilitiesElimination(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, bool qualitative) {
+                // Use "normal" function again, if RationalFunction finally is supported.
+                return storm::modelchecker::SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<ValueType>>::computeUntilProbabilities(computeProbabilityMatrix(rateMatrix, exitRateVector), backwardTransitions, initialStates, phiStates, psiStates, false);
+            }
+
             template <typename ValueType>
             std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeNextProbabilities(storm::storage::SparseMatrix<ValueType> const& rateMatrix, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& nextStates, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory) {
                 return SparseDtmcPrctlHelper<ValueType>::computeNextProbabilities(computeProbabilityMatrix(rateMatrix, exitRateVector), nextStates, linearEquationSolverFactory);
@@ -648,9 +654,31 @@ namespace storm {
                 
                 return result;
             }
+
+            template <typename ValueType>
+            std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory) {
+                // Compute expected time on CTMC by reduction to DTMC with rewards.
+                storm::storage::SparseMatrix<ValueType> probabilityMatrix = computeProbabilityMatrix(rateMatrix, exitRateVector);
+
+                // Initialize rewards.
+                std::vector<ValueType> totalRewardVector;
+                for (size_t i = 0; i < exitRateVector.size(); ++i) {
+                    if (targetStates[i]) {
+                        // Set reward for target states to 0.
+                        totalRewardVector.push_back(storm::utility::zero<ValueType>());
+                    } else {
+                        // Reward is (1 / exitRate).
+                        totalRewardVector.push_back(storm::utility::one<ValueType>() / exitRateVector[i]);
+                    }
+                }
+
+                return storm::modelchecker::helper::SparseDtmcPrctlHelper<ValueType>::computeReachabilityRewards(probabilityMatrix, backwardTransitions, totalRewardVector, targetStates, qualitative, linearEquationSolverFactory);
+            }
+
             
             template <typename ValueType>
-            std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative/*, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory*/) {
+            std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeExpectedTimesElimination(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative) {
+                // Use "normal" function again, if RationalFunction finally is supported.
                 // Compute expected time on CTMC by reduction to DTMC with rewards.
                 storm::storage::SparseMatrix<ValueType> probabilityMatrix = computeProbabilityMatrix(rateMatrix, exitRateVector);
 
@@ -667,8 +695,6 @@ namespace storm {
                 }
 
                 return storm::modelchecker::SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<ValueType>>::computeReachabilityRewards(probabilityMatrix, backwardTransitions, initialStates, targetStates, totalRewardVector, false, qualitative);
-                // Enable again, if RationalFunction finally is supported.
-                //return storm::modelchecker::helper::SparseDtmcPrctlHelper<ValueType>::computeReachabilityRewards(probabilityMatrix, backwardTransitions, totalRewardVector, targetStates, qualitative, linearEquationSolverFactory);
             }
 
             template class SparseCtmcCslHelper<double>;
@@ -677,7 +703,8 @@ namespace storm {
             template std::vector<double> SparseCtmcCslHelper<double>::computeReachabilityRewards(storm::storage::SparseMatrix<double> const& rateMatrix, storm::storage::SparseMatrix<double> const& backwardTransitions, std::vector<double> const& exitRateVector, storm::models::sparse::StandardRewardModel<double> const& rewardModel, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<double> const& linearEquationSolverFactory);
 
 #ifdef STORM_HAVE_CARL
-            template std::vector<storm::RationalFunction> SparseCtmcCslHelper<storm::RationalFunction>::computeExpectedTimes(storm::storage::SparseMatrix<storm::RationalFunction> const& rateMatrix, storm::storage::SparseMatrix<storm::RationalFunction> const& backwardTransitions, std::vector<storm::RationalFunction> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative/*, storm::utility::solver::LinearEquationSolverFactory<storm::RationalFunction> const& linearEquationSolverFactory*/);
+            template std::vector<storm::RationalFunction> SparseCtmcCslHelper<storm::RationalFunction>::computeUntilProbabilitiesElimination(storm::storage::SparseMatrix<storm::RationalFunction> const& rateMatrix, storm::storage::SparseMatrix<storm::RationalFunction> const& backwardTransitions, std::vector<storm::RationalFunction> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, bool qualitative);
+            template std::vector<storm::RationalFunction> SparseCtmcCslHelper<storm::RationalFunction>::computeExpectedTimesElimination(storm::storage::SparseMatrix<storm::RationalFunction> const& rateMatrix, storm::storage::SparseMatrix<storm::RationalFunction> const& backwardTransitions, std::vector<storm::RationalFunction> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative);
 #endif
         }
     }
diff --git a/src/modelchecker/csl/helper/SparseCtmcCslHelper.h b/src/modelchecker/csl/helper/SparseCtmcCslHelper.h
index 94752a974..14a98f752 100644
--- a/src/modelchecker/csl/helper/SparseCtmcCslHelper.h
+++ b/src/modelchecker/csl/helper/SparseCtmcCslHelper.h
@@ -16,6 +16,7 @@ namespace storm {
                 static std::vector<ValueType> computeNextProbabilities(storm::storage::SparseMatrix<ValueType> const& rateMatrix, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& nextStates, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory);
                 
                 static std::vector<ValueType> computeUntilProbabilities(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory);
+                static std::vector<ValueType> computeUntilProbabilitiesElimination(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, bool qualitative);
                 
                 template <typename RewardModelType>
                 static std::vector<ValueType> computeInstantaneousRewards(storm::storage::SparseMatrix<ValueType> const& rateMatrix, std::vector<ValueType> const& exitRateVector, RewardModelType const& rewardModel, double timeBound, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory);
@@ -28,7 +29,8 @@ namespace storm {
                 
                 static std::vector<ValueType> computeLongRunAverageProbabilities(storm::storage::SparseMatrix<ValueType> const& probabilityMatrix, storm::storage::BitVector const& psiStates, std::vector<ValueType> const* exitRateVector, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory);
                 
-                static std::vector<ValueType> computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative/*, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory*/);
+                static std::vector<ValueType> computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory);
+                static std::vector<ValueType> computeExpectedTimesElimination(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative);
 
                 /*!
                  * Computes the matrix representing the transitions of the uniformized CTMC.
diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
index 41324957b..279ef5089 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
@@ -512,66 +512,74 @@ namespace storm {
         
         template<typename SparseDtmcModelType>
         std::unique_ptr<CheckResult> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::computeUntilProbabilities(storm::logic::UntilFormula const& pathFormula, bool qualitative, boost::optional<OptimizationDirection> const& optimalityType) {
+
             // Retrieve the appropriate bitvectors by model checking the subformulas.
             std::unique_ptr<CheckResult> leftResultPointer = this->check(pathFormula.getLeftSubformula());
             std::unique_ptr<CheckResult> rightResultPointer = this->check(pathFormula.getRightSubformula());
             storm::storage::BitVector const& phiStates = leftResultPointer->asExplicitQualitativeCheckResult().getTruthValuesVector();
             storm::storage::BitVector const& psiStates = rightResultPointer->asExplicitQualitativeCheckResult().getTruthValuesVector();
-            
+
+            std::vector<ValueType> result = computeUntilProbabilities(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), this->getModel().getInitialStates(), phiStates, psiStates, this->computeResultsForInitialStatesOnly);
+
+            // Construct check result.
+            std::unique_ptr<CheckResult> checkResult(new ExplicitQuantitativeCheckResult<ValueType>(result));
+            return checkResult;
+        }
+
+        template<typename SparseDtmcModelType>
+        std::vector<typename SparseDtmcModelType::ValueType> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::computeUntilProbabilities(storm::storage::SparseMatrix<ValueType> const& probabilityMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, bool computeForInitialStatesOnly) {
+
             // Then, compute the subset of states that has a probability of 0 or 1, respectively.
-            std::pair<storm::storage::BitVector, storm::storage::BitVector> statesWithProbability01 = storm::utility::graph::performProb01(this->getModel(), phiStates, psiStates);
+            std::pair<storm::storage::BitVector, storm::storage::BitVector> statesWithProbability01 = storm::utility::graph::performProb01(backwardTransitions, phiStates, psiStates);
             storm::storage::BitVector statesWithProbability0 = statesWithProbability01.first;
             storm::storage::BitVector statesWithProbability1 = statesWithProbability01.second;
             storm::storage::BitVector maybeStates = ~(statesWithProbability0 | statesWithProbability1);
 
             // Determine whether we need to perform some further computation.
             bool furtherComputationNeeded = true;
-            if (computeResultsForInitialStatesOnly && this->getModel().getInitialStates().isDisjointFrom(maybeStates)) {
+            if (computeForInitialStatesOnly && initialStates.isDisjointFrom(maybeStates)) {
                 STORM_LOG_DEBUG("The probability for all initial states was found in a preprocessing step.");
                 furtherComputationNeeded = false;
             } else if (maybeStates.empty()) {
                 STORM_LOG_DEBUG("The probability for all states was found in a preprocessing step.");
                 furtherComputationNeeded = false;
             }
-            
+
             std::vector<ValueType> result(maybeStates.size());
             if (furtherComputationNeeded) {
                 // If we compute the results for the initial states only, we can cut off all maybe state that are not
                 // reachable from them.
-                if (computeResultsForInitialStatesOnly) {
+                if (computeForInitialStatesOnly) {
                     // Determine the set of states that is reachable from the initial state without jumping over a target state.
-                    storm::storage::BitVector reachableStates = storm::utility::graph::getReachableStates(this->getModel().getTransitionMatrix(), this->getModel().getInitialStates(), maybeStates, statesWithProbability1);
+                    storm::storage::BitVector reachableStates = storm::utility::graph::getReachableStates(probabilityMatrix, initialStates, maybeStates, statesWithProbability1);
                 
                     // Subtract from the maybe states the set of states that is not reachable (on a path from the initial to a target state).
                     maybeStates &= reachableStates;
                 }
-                
+
                 // Create a vector for the probabilities to go to a state with probability 1 in one step.
-                std::vector<ValueType> oneStepProbabilities = this->getModel().getTransitionMatrix().getConstrainedRowSumVector(maybeStates, statesWithProbability1);
-                
+                std::vector<ValueType> oneStepProbabilities = probabilityMatrix.getConstrainedRowSumVector(maybeStates, statesWithProbability1);
+
                 // Determine the set of initial states of the sub-model.
-                storm::storage::BitVector newInitialStates = this->getModel().getInitialStates() % maybeStates;
-                
+                storm::storage::BitVector newInitialStates = initialStates % maybeStates;
+
                 // We then build the submatrix that only has the transitions of the maybe states.
-                storm::storage::SparseMatrix<ValueType> submatrix = this->getModel().getTransitionMatrix().getSubmatrix(false, maybeStates, maybeStates);
+                storm::storage::SparseMatrix<ValueType> submatrix = probabilityMatrix.getSubmatrix(false, maybeStates, maybeStates);
                 storm::storage::SparseMatrix<ValueType> submatrixTransposed = submatrix.transpose();
-                
-                std::vector<ValueType> subresult = computeReachabilityValues(submatrix, oneStepProbabilities, submatrixTransposed, newInitialStates, computeResultsForInitialStatesOnly, phiStates, psiStates, oneStepProbabilities);
+
+                std::vector<ValueType> subresult = computeReachabilityValues(submatrix, oneStepProbabilities, submatrixTransposed, newInitialStates, computeForInitialStatesOnly, phiStates, psiStates, oneStepProbabilities);
                 storm::utility::vector::setVectorValues<ValueType>(result, maybeStates, subresult);
             }
 
             // Construct full result.
             storm::utility::vector::setVectorValues<ValueType>(result, statesWithProbability0, storm::utility::zero<ValueType>());
             storm::utility::vector::setVectorValues<ValueType>(result, statesWithProbability1, storm::utility::one<ValueType>());
-
-            // Construct check result based on whether we have computed values for all states or just the initial states.
-            std::unique_ptr<CheckResult> checkResult(new ExplicitQuantitativeCheckResult<ValueType>(result));
-            if (computeResultsForInitialStatesOnly) {
+            if (computeForInitialStatesOnly) {
                 // If we computed the results for the initial (and prob 0 and prob1) states only, we need to filter the
                 // result to only communicate these results.
-                checkResult->filter(ExplicitQualitativeCheckResult(~maybeStates | this->getModel().getInitialStates()));
+                result = storm::utility::vector::filterVector(result, ~maybeStates | initialStates);
             }
-            return checkResult;
+            return result;
         }
         
         template<typename SparseDtmcModelType>
@@ -588,7 +596,7 @@ namespace storm {
             STORM_LOG_THROW(!rewardModel.empty(), storm::exceptions::IllegalArgumentException, "Input model does not have a reward model.");
             std::vector<ValueType> result = computeReachabilityRewards(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), this->getModel().getInitialStates(), targetStates, stateRewardValues, this->computeResultsForInitialStatesOnly, qualitative, optimalityType);
 
-            // Construct check result
+            // Construct check result.
             std::unique_ptr<CheckResult> checkResult(new ExplicitQuantitativeCheckResult<ValueType>(result));
             return checkResult;
         }
diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
index a840cef88..5b000b4f2 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
@@ -25,12 +25,19 @@ namespace storm {
             
             // The implemented methods of the AbstractModelChecker interface.
             virtual bool canHandle(storm::logic::Formula const& formula) const override;
+
             virtual std::unique_ptr<CheckResult> computeBoundedUntilProbabilities(storm::logic::BoundedUntilFormula const& pathFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
+
             virtual std::unique_ptr<CheckResult> computeUntilProbabilities(storm::logic::UntilFormula const& pathFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
+            static std::vector<ValueType> computeUntilProbabilities(storm::storage::SparseMatrix<ValueType> const& probabilityMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, bool computeForInitialStatesOnly);
+
             virtual std::unique_ptr<CheckResult> computeReachabilityRewards(storm::logic::ReachabilityRewardFormula const& rewardPathFormula, boost::optional<std::string> const& rewardModelName = boost::optional<std::string>(), bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
             static std::vector<ValueType> computeReachabilityRewards(storm::storage::SparseMatrix<ValueType> const& probabilityMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, std::vector<ValueType> const& stateRewardValues, bool computeForInitialStatesOnly, bool qualitative, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>());
+
             virtual std::unique_ptr<CheckResult> computeLongRunAverageRewards(storm::logic::LongRunAverageRewardFormula const& rewardPathFormula, boost::optional<std::string> const& rewardModelName = boost::optional<std::string>(), bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
+
             virtual std::unique_ptr<CheckResult> computeConditionalProbabilities(storm::logic::ConditionalPathFormula const& pathFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
+
             virtual std::unique_ptr<CheckResult> computeLongRunAverageProbabilities(storm::logic::StateFormula const& stateFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
 
         private:
diff --git a/src/utility/storm.h b/src/utility/storm.h
index 4bdf22556..2b08aa6ae 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -332,17 +332,51 @@ namespace storm {
         } else if (model->getType() == storm::models::ModelType::Ctmc) {
             // Hack to avoid instantiating the CTMC Model Checker which currently does not work for rational functions
             if (formula->isExpectedTimeOperatorFormula()) {
-                // We can only solve expected time for pCTMCs at the moment
-                std::shared_ptr<storm::models::sparse::Ctmc<storm::RationalFunction>> ctmc = model->template as<storm::models::sparse::Ctmc<storm::RationalFunction>>();
+                // Compute expected time for pCTMCs
+                STORM_LOG_THROW(formula->asExpectedTimeOperatorFormula().getSubformula().isEventuallyFormula(), storm::exceptions::NotSupportedException, "The parametric engine only supports Eventually formulas for this property");
+                storm::logic::EventuallyFormula eventuallyFormula = formula->asExpectedTimeOperatorFormula().getSubformula().asEventuallyFormula();
+                STORM_LOG_THROW(eventuallyFormula.getSubformula().isPropositionalFormula(), storm::exceptions::NotSupportedException, "The parametric engine does not support nested formulas on CTMCs");
 
                 // Compute goal states
-                storm::logic::EventuallyFormula eventuallyFormula = formula->asExpectedTimeOperatorFormula().getSubformula().asEventuallyFormula();
+                std::shared_ptr<storm::models::sparse::Ctmc<storm::RationalFunction>> ctmc = model->template as<storm::models::sparse::Ctmc<storm::RationalFunction>>();
                 storm::modelchecker::SparsePropositionalModelChecker<storm::models::sparse::Ctmc<storm::RationalFunction>> propositionalModelchecker(*ctmc);
                 std::unique_ptr<storm::modelchecker::CheckResult> subResultPointer = propositionalModelchecker.check(eventuallyFormula.getSubformula());
-                storm::modelchecker::ExplicitQualitativeCheckResult& subResult = subResultPointer->asExplicitQualitativeCheckResult();
+                storm::storage::BitVector const& targetStates = subResultPointer->asExplicitQualitativeCheckResult().getTruthValuesVector();
 
-                std::vector<storm::RationalFunction> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<storm::RationalFunction>::computeExpectedTimes(ctmc->getTransitionMatrix(), ctmc->getBackwardTransitions(), ctmc->getExitRateVector(), ctmc->getInitialStates(), subResult.getTruthValuesVector(), false);
+                std::vector<storm::RationalFunction> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<storm::RationalFunction>::computeExpectedTimesElimination(ctmc->getTransitionMatrix(), ctmc->getBackwardTransitions(), ctmc->getExitRateVector(), ctmc->getInitialStates(), targetStates, false);
                 result = std::unique_ptr<storm::modelchecker::CheckResult>(new storm::modelchecker::ExplicitQuantitativeCheckResult<storm::RationalFunction>(std::move(numericResult)));
+
+            } else if (formula->isProbabilityOperatorFormula()) {
+                // Compute reachability probability for pCTMCs
+                storm::logic::ProbabilityOperatorFormula probOpFormula = formula->asProbabilityOperatorFormula();
+                STORM_LOG_THROW(probOpFormula.getSubformula().isUntilFormula() || probOpFormula.getSubformula().isEventuallyFormula(), storm::exceptions::NotSupportedException, "The parametric engine only supports Until formulas for this property");
+
+                // Compute phi and psi states
+                std::shared_ptr<storm::models::sparse::Ctmc<storm::RationalFunction>> ctmc = model->template as<storm::models::sparse::Ctmc<storm::RationalFunction>>();
+                storm::modelchecker::SparsePropositionalModelChecker<storm::models::sparse::Ctmc<storm::RationalFunction>> propositionalModelchecker(*ctmc);
+                storm::storage::BitVector phiStates(model->getNumberOfStates(), true);
+                storm::storage::BitVector psiStates;
+                if (probOpFormula.getSubformula().isUntilFormula()) {
+                    // Until formula
+                    storm::logic::UntilFormula untilFormula = formula->asProbabilityOperatorFormula().getSubformula().asUntilFormula();
+                    STORM_LOG_THROW(untilFormula.getLeftSubformula().isPropositionalFormula(), storm::exceptions::NotSupportedException, "The parametric engine does not support nested formulas on CTMCs");
+                    STORM_LOG_THROW(untilFormula.getRightSubformula().isPropositionalFormula(), storm::exceptions::NotSupportedException, "The parametric engine does not support nested formulas on CTMCs");
+                    std::unique_ptr<storm::modelchecker::CheckResult> leftResultPointer = propositionalModelchecker.check(untilFormula.getLeftSubformula());
+                    std::unique_ptr<storm::modelchecker::CheckResult> rightResultPointer = propositionalModelchecker.check(untilFormula.getRightSubformula());
+                    phiStates = leftResultPointer->asExplicitQualitativeCheckResult().getTruthValuesVector();
+                    psiStates = rightResultPointer->asExplicitQualitativeCheckResult().getTruthValuesVector();
+                } else {
+                    // Eventually formula
+                    assert(probOpFormula.getSubformula().isEventuallyFormula());
+                    storm::logic::EventuallyFormula eventuallyFormula = probOpFormula.getSubformula().asEventuallyFormula();
+                    STORM_LOG_THROW(eventuallyFormula.getSubformula().isPropositionalFormula(), storm::exceptions::NotSupportedException, "The parametric engine does not support nested formulas on CTMCs");
+                    std::unique_ptr<storm::modelchecker::CheckResult> resultPointer = propositionalModelchecker.check(eventuallyFormula.getSubformula());
+                    psiStates = resultPointer->asExplicitQualitativeCheckResult().getTruthValuesVector();
+                }
+
+                std::vector<storm::RationalFunction> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<storm::RationalFunction>::computeUntilProbabilitiesElimination(ctmc->getTransitionMatrix(), ctmc->getBackwardTransitions(), ctmc->getExitRateVector(), ctmc->getInitialStates(), phiStates, psiStates, false);
+                result = std::unique_ptr<storm::modelchecker::CheckResult>(new storm::modelchecker::ExplicitQuantitativeCheckResult<storm::RationalFunction>(std::move(numericResult)));
+
             } else {
                 STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The parametric engine currently does not support this property on CTMCs.");
             }

From 2c969eff3b1d60a19c95f93ab71d6c217b98fae7 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 3 Feb 2016 18:04:45 +0100
Subject: [PATCH 047/246] Updated benchmark script for reachability
 probabilities

Former-commit-id: 717c099ae1cdc4fcd81afcd4a3201fc7a4a4d062
---
 benchmark_dft.py | 106 ++++++++++++++++++++++++-----------------------
 1 file changed, 54 insertions(+), 52 deletions(-)

diff --git a/benchmark_dft.py b/benchmark_dft.py
index 54fb06593..a6109ff45 100644
--- a/benchmark_dft.py
+++ b/benchmark_dft.py
@@ -10,43 +10,42 @@ EXAMPLE_DIR= "/Users/mvolk/develop/storm/examples/dft/"
 
 
 benchmarks = [ 
-    ("and", False, 3),
-    ("and_param", True, "(4*x^2+2*x+1)/((x) * (2*x+1))"),
-    ("cm2", False, 0.256272),
-    #("cm4", False, 0),
-    ("cps", False, "inf"),
-    #("fdep", False, 0),
-    ("mdcs", False, 2.85414),
-    ("mdcs2", False, 2.85414),
-    ("mp", False, 1.66667),
-    ("or", False, 1),
-    ("pand", False, "inf"),
-    ("pand_param", True, "-1"),
-    ("spare", False, 3.53846),
-    ("spare2", False, 1.86957),
-    ("spare3", False, 1.27273),
-    ("spare4", False, 4.8459),
-    ("spare5", False, 2.16667),
-    ("spare6", False, 1.4),
-    ("tripple_and1", False, 4.16667),
-    ("tripple_and2", False, 3.66667),
-    ("tripple_and2_c", False, 3.6667),
-    ("tripple_and_c", False, 4.16667),
-    ("tripple_or", False, 0.5),
-    ("tripple_or2", False, 0.666667),
-    ("tripple_or2_c", False, 0.66667),
-    ("tripple_or_c", False, 0.5),
-    ("tripple_pand", False, "inf"),
-    ("tripple_pand2", False, "inf"),
-    ("tripple_pand2_c", False, "inf"),
-    ("tripple_pand_c", False, "inf"),
-    ("voting", False, 1.66667),
-    ("voting2", False, 0.588235)
+    ("and", False, [3, 1]),
+    ("and_param", True, ["(4*x^2+2*x+1)/((x) * (2*x+1))", "1"]),
+    ("cm2", False, [0.256272, 1]),
+    #("cm4", False, [0, 1]),
+    ("cps", False, ["inf", 0.333333]),
+    #("fdep", False, [0, 1]),
+    ("mdcs", False, [2.85414, 1]),
+    ("mdcs2", False, [2.85414, 1]),
+    ("mp", False, [1.66667, 1]),
+    ("or", False, [1, 1]),
+    ("pand", False, ["inf", 0.666667]),
+    ("pand_param", True, ["-1", "(x)/(y+x)"]),
+    ("spare", False, [3.53846, 1]),
+    ("spare2", False, [1.86957, 1]),
+    ("spare3", False, [1.27273, 1]),
+    ("spare4", False, [4.8459, 1]),
+    ("spare5", False, [2.16667, 1]),
+    ("spare6", False, [1.4, 1]),
+    ("tripple_and1", False, [4.16667, 1]),
+    ("tripple_and2", False, [3.66667, 1]),
+    ("tripple_and2_c", False, [3.6667, 1]),
+    ("tripple_and_c", False, [4.16667, 1]),
+    ("tripple_or", False, [0.5, 1]),
+    ("tripple_or2", False, [0.666667, 1]),
+    ("tripple_or2_c", False, [0.66667, 1]),
+    ("tripple_or_c", False, [0.5, 1]),
+    ("tripple_pand", False, ["inf", 0.0416667]),
+    ("tripple_pand2", False, ["inf", 0.166667]),
+    ("tripple_pand2_c", False, ["inf", 0.166667]),
+    ("tripple_pand_c", False, ["inf", 0.0416667]),
+    ("voting", False, [1.66667, 1]),
+    ("voting2", False, [0.588235, 1])
 ]
 
-def run_storm_dft(filename, parametric, quiet):
+def run_storm_dft(filename, prop, parametric, quiet):
     # Run storm-dft on filename and return result
-    prop = "ET=? [F \"failed\"]"
     dft_file = os.path.join(EXAMPLE_DIR, filename + ".dft")
     args = [STORM_PATH,
             dft_file,
@@ -84,24 +83,27 @@ def run_tool(args, quiet=False):
 if __name__ == "__main__":
     count = 0
     correct = 0
+    properties = ["ET=? [F \"failed\"]", "P=? [F \"failed\"]"]
     start = time.time()
-    for (benchmark, parametric, result_original) in benchmarks:
-        # Run benchmark and check result
-        count += 1;
-        print("Running '{}'".format(benchmark))
-        result = run_storm_dft(benchmark, parametric, True)
-        if not parametric:
-            # Float
-            result = float(result)
-            if not math.isclose(result, float(result_original), rel_tol=1e-05):
-                print("!!! File '{}': result: {}, Expected: {}".format(benchmark, result, result_original))
+    for index, prop in enumerate(properties):
+        for (benchmark, parametric, result_original) in benchmarks:
+            expected_result = result_original[index]
+            # Run benchmark and check result
+            count += 1;
+            print("Running '{}' with property '{}'".format(benchmark, prop))
+            result = run_storm_dft(benchmark, prop, parametric, True)
+            if not parametric:
+                # Float
+                result = float(result)
+                if not math.isclose(result, float(expected_result), rel_tol=1e-05):
+                    print("!!! File '{}': result: {}, Expected: {}".format(benchmark, result, expected_result))
+                else:
+                    correct += 1
             else:
-                correct += 1
-        else:
-            # Parametric
-            if result != result_original:
-                print("!!! File {}: result: {}, Expected: {}".format(benchmark, result, result_original))
-            else:
-                correct += 1
+                # Parametric
+                if result != expected_result:
+                    print("!!! File {}: result: {}, Expected: {}".format(benchmark, result, expected_result))
+                else:
+                    correct += 1
     end = time.time()
-    print("Correct results for {} of {} DFTs in {}s".format(correct, count, end-start))
+    print("Correct results for {} of {} DFT checks in {}s".format(correct, count, end-start))

From 7dd1bb67ea2d488e1f291c12698fce9fd8ef8303 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 4 Feb 2016 13:38:02 +0100
Subject: [PATCH 048/246] Some refactoring

Former-commit-id: 95441da721315691ef2b9e57b0c418218edf0e26
---
 src/builder/ExplicitDFTModelBuilder.cpp | 13 ++++++-------
 src/storage/dft/DFTBuilder.cpp          |  3 +--
 src/storage/dft/DFTElements.h           |  8 +-------
 src/storage/dft/DFTState.cpp            | 18 +++++++++++-------
 src/storage/dft/DFTState.h              |  4 +++-
 5 files changed, 22 insertions(+), 24 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 1b777fb54..9332044f2 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -77,7 +77,6 @@ namespace storm {
             while (!stateQueue.empty()) {
                 // Initialization
                 outgoingTransitions.clear();
-                ValueType sum = storm::utility::zero<ValueType>();
 
                 // Consider next state
                 DFTStatePointer state = stateQueue.front();
@@ -147,7 +146,9 @@ namespace storm {
                     bool isUsed = true;
                     if (mDft.hasRepresentant(nextBE->id())) {
                         DFTElementPointer representant = mDft.getRepresentant(nextBE->id());
-                        isUsed = newState->isUsed(representant->id());
+                        // Used must be checked for the state we are coming from as this state is responsible for the
+                        // rate and not the new state we are going to
+                        isUsed = state->isUsed(representant->id());
                     }
                     STORM_LOG_TRACE("BE " << nextBE->name() << " is " << (isUsed ? "used" : "not used"));
                     ValueType rate = isUsed ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
@@ -155,20 +156,18 @@ namespace storm {
                     if (resultFind != outgoingTransitions.end()) {
                         // Add to existing transition
                         resultFind->second += rate;
+                        STORM_LOG_TRACE("Updated transition from " << state->getId() << " to " << resultFind->first << " with " << rate << " to " << resultFind->second);
                     } else {
                         // Insert new transition
                         outgoingTransitions.insert(std::make_pair(newState->getId(), rate));
+                        STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newState->getId() << " with " << rate);
                     }
-                    sum += rate;
                 } // end while failing BE
 
                 // Add all transitions
                 for (auto it = outgoingTransitions.begin(); it != outgoingTransitions.end(); ++it)
                 {
-                    // TODO Matthias: correct?
-                    ValueType rate = it->second;// / sum;
-                    transitionMatrixBuilder.addNextValue(state->getId(), it->first, rate);
-                    STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << it->first << " with " << rate);
+                    transitionMatrixBuilder.addNextValue(state->getId(), it->first, it->second);
                 }
 
             } // end while queue
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index 870b7f8bf..fd068bf7c 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -16,15 +16,14 @@ namespace storm {
         template<typename ValueType>
         DFT<ValueType> DFTBuilder<ValueType>::build() {
             for(auto& elem : mChildNames) {
+                DFTGatePointer gate = std::static_pointer_cast<DFTGate<ValueType>>(elem.first);
                 for(auto const& child : elem.second) {
-                    DFTGatePointer gate = std::static_pointer_cast<DFTGate<ValueType>>(elem.first);
                     gate->pushBackChild(mElements[child]);
                     mElements[child]->addParent(gate);
                 }
             }
 
             // Sort elements topologically
-
             // compute rank
             for (auto& elem : mElements) {
                 computeRank(elem.second);
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index daa1d3d54..7f92ebb19 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -657,13 +657,7 @@ namespace storm {
                 if(state.isOperational(this->mId)) {
                     size_t uses = state.extractUses(mUseIndex);
                     if(!state.isOperational(uses)) {
-                        // TODO compute children ids before.
-                        std::vector<size_t> childrenIds;
-                        for(auto const& child : this->mChildren) {
-                            childrenIds.push_back(child->id());
-                        }
-                        
-                        bool claimingSuccessful = state.claimNew(this->mId, mUseIndex, uses, childrenIds);
+                        bool claimingSuccessful = state.claimNew(this->mId, mUseIndex, uses, this->mChildren);
                         if(!claimingSuccessful) {
                             this->fail(state, queues);
                         }
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index ebf3c770b..d760129e0 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -134,15 +134,19 @@ namespace storm {
         }
 
         template<typename ValueType>
-        bool DFTState<ValueType>::claimNew(size_t spareId, size_t usageIndex, size_t currentlyUses, std::vector<size_t> const& childIds) {
-            auto it = find(childIds.begin(), childIds.end(), currentlyUses);
-            assert(it != childIds.end());
+        bool DFTState<ValueType>::claimNew(size_t spareId, size_t usageIndex, size_t currentlyUses, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children) {
+            auto it = children.begin();
+            while ((*it)->id() != currentlyUses) {
+                assert(it != children.end());
+                ++it;
+            }
             ++it;
-            while(it != childIds.end()) {
-                if(!hasFailed(*it) && !isUsed(*it)) {
-                    setUsesAtPosition(usageIndex, *it);
+            while(it != children.end()) {
+                size_t childId = (*it)->id();
+                if(!hasFailed(childId) && !isUsed(childId)) {
+                    setUsesAtPosition(usageIndex, childId);
                     if(isActiveSpare(spareId)) {
-                        mDft.propagateActivation(*this,*it);
+                        mDft.propagateActivation(*this, childId);
                     }
                     return true;
                 }
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 4ea11a991..7cb5eaf4a 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -13,6 +13,8 @@ namespace storm {
         class DFT;
         template<typename ValueType>
         class DFTBE;
+        template<typename ValueType>
+        class DFTElement;
 
         template<typename ValueType>
         class DFTState {
@@ -97,7 +99,7 @@ namespace storm {
              */
             void setUsesAtPosition(size_t usageIndex, size_t child);
             
-            bool claimNew(size_t spareId, size_t usageIndex, size_t currentlyUses, std::vector<size_t> const& childIds);
+            bool claimNew(size_t spareId, size_t usageIndex, size_t currentlyUses, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children);
             
             bool hasOutgoingEdges() const {
                 return !mIsCurrentlyFailableBE.empty();

From d7e3d10272b3f4fc74839f25cc59029c9f4e0f9c Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 4 Feb 2016 13:45:08 +0100
Subject: [PATCH 049/246] Small refactoring

Former-commit-id: c800918d3e8f1a62d2df0419089cae591cfa858e
---
 src/storage/dft/DFTBuilder.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index fd068bf7c..d49bfd067 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -119,12 +119,12 @@ namespace storm {
         // TODO Matthias: use typedefs
         template<typename ValueType>
         std::vector<std::shared_ptr<DFTElement<ValueType>>> DFTBuilder<ValueType>::topoSort() {
-            std::map<std::shared_ptr<DFTElement<ValueType>>, topoSortColour> visited;
+            std::map<DFTElementPointer, topoSortColour> visited;
             for(auto const& e : mElements) {
                 visited.insert(std::make_pair(e.second, topoSortColour::WHITE)); 
             }
 
-            std::vector<std::shared_ptr<DFTElement<ValueType>>> L;
+            DFTElementVector L;
             for(auto const& e : visited) {
                 topoVisit(e.first, visited, L);
             }

From efdd9f25ae80e0c98b00a554f0e6098b9fc0ff61 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 4 Feb 2016 14:00:18 +0100
Subject: [PATCH 050/246] Changed expected result

Former-commit-id: 0fb88af944862ce83804cd3fc14d989816d031cb
---
 benchmark_dft.py        | 2 +-
 examples/dft/spare5.dft | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/benchmark_dft.py b/benchmark_dft.py
index a6109ff45..425d8ae80 100644
--- a/benchmark_dft.py
+++ b/benchmark_dft.py
@@ -26,7 +26,7 @@ benchmarks = [
     ("spare2", False, [1.86957, 1]),
     ("spare3", False, [1.27273, 1]),
     ("spare4", False, [4.8459, 1]),
-    ("spare5", False, [2.16667, 1]),
+    ("spare5", False, [2.66667, 1]), # We discard the result 2.16667 from DFTCalc
     ("spare6", False, [1.4, 1]),
     ("tripple_and1", False, [4.16667, 1]),
     ("tripple_and2", False, [3.66667, 1]),
diff --git a/examples/dft/spare5.dft b/examples/dft/spare5.dft
index dcb4d80a4..0cd15bf0e 100644
--- a/examples/dft/spare5.dft
+++ b/examples/dft/spare5.dft
@@ -1,6 +1,6 @@
 toplevel "A";
 "A" wsp "I" "B";
-"B" or "K" "J";
+"B" or "C" "J";
 "C" or "K" "L";
 "I" lambda=0.5 dorm=0;
 "J" lambda=0.5 dorm=0;

From 957ce0193fa9cf25f3a09410bb64fa6436c37c06 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 4 Feb 2016 14:00:39 +0100
Subject: [PATCH 051/246] Set log level from commandline

Former-commit-id: b86a4d4e35b49bdd56f798201f04b04ed75e9a49
---
 src/storm-dyftee.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index c187e5057..fc113e438 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -52,19 +52,23 @@ int main(int argc, char** argv) {
 
     // Parse cli arguments
     bool parametric = false;
+    log4cplus::LogLevel level = log4cplus::WARN_LOG_LEVEL;
     std::string filename = argv[1];
     std::string pctlFormula = "Pmax=?[true U \"failed\"]";
     for (int i = 2; i < argc; ++i) {
         std::string option = argv[i];
         if (option == "--parametric") {
             parametric = true;
+        } else if (option == "--trace") {
+            level = log4cplus::TRACE_LOG_LEVEL;
+        } else if (option == "--debug") {
+            level = log4cplus::DEBUG_LOG_LEVEL;
         } else {
             pctlFormula = option;
         }
     }
 
     storm::utility::setUp();
-    log4cplus::LogLevel level = log4cplus::WARN_LOG_LEVEL;
     logger.setLogLevel(level);
     logger.getAppender("mainConsoleAppender")->setThreshold(level);
 

From 933194c155f946803204e846d768c79da4029240 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 4 Feb 2016 14:16:46 +0100
Subject: [PATCH 052/246] Added debuglevel to benchmark script

Former-commit-id: 79040662612db50bce0fe7bb2b4db7593cfe26d9
---
 benchmark_dft.py        | 14 ++++++++++----
 examples/dft/spare7.dft |  5 +++++
 2 files changed, 15 insertions(+), 4 deletions(-)
 create mode 100644 examples/dft/spare7.dft

diff --git a/benchmark_dft.py b/benchmark_dft.py
index 425d8ae80..b12d4f185 100644
--- a/benchmark_dft.py
+++ b/benchmark_dft.py
@@ -4,6 +4,7 @@ import subprocess
 import re
 import time
 import math
+import argparse
 
 STORM_PATH= "/Users/mvolk/develop/storm/build/src/storm-dft"
 EXAMPLE_DIR= "/Users/mvolk/develop/storm/examples/dft/"
@@ -28,6 +29,7 @@ benchmarks = [
     ("spare4", False, [4.8459, 1]),
     ("spare5", False, [2.66667, 1]), # We discard the result 2.16667 from DFTCalc
     ("spare6", False, [1.4, 1]),
+    ("spare7", False, [3.67333, 1]),
     ("tripple_and1", False, [4.16667, 1]),
     ("tripple_and2", False, [3.66667, 1]),
     ("tripple_and2_c", False, [3.6667, 1]),
@@ -81,6 +83,9 @@ def run_tool(args, quiet=False):
     return result
 
 if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Benchmarking DFTs via Storm')
+    parser.add_argument('--debuglevel', type=int, default=0, help='the debug level (0=silent, 1=print benchmarks, 2=print output from storm')
+    args = parser.parse_args()
     count = 0
     correct = 0
     properties = ["ET=? [F \"failed\"]", "P=? [F \"failed\"]"]
@@ -90,19 +95,20 @@ if __name__ == "__main__":
             expected_result = result_original[index]
             # Run benchmark and check result
             count += 1;
-            print("Running '{}' with property '{}'".format(benchmark, prop))
-            result = run_storm_dft(benchmark, prop, parametric, True)
+            if args.debuglevel > 0:
+                print("Running '{}' with property '{}'".format(benchmark, prop))
+            result = run_storm_dft(benchmark, prop, parametric, args.debuglevel<2)
             if not parametric:
                 # Float
                 result = float(result)
                 if not math.isclose(result, float(expected_result), rel_tol=1e-05):
-                    print("!!! File '{}': result: {}, Expected: {}".format(benchmark, result, expected_result))
+                    print("Wrong result on example '{}' with property '{}': result: {}, Expected: {}".format(benchmark, prop, result, expected_result))
                 else:
                     correct += 1
             else:
                 # Parametric
                 if result != expected_result:
-                    print("!!! File {}: result: {}, Expected: {}".format(benchmark, result, expected_result))
+                    print("Wrong result on example '{}' with property '{}': result: {}, Expected: {}".format(benchmark, prop, result, expected_result))
                 else:
                     correct += 1
     end = time.time()
diff --git a/examples/dft/spare7.dft b/examples/dft/spare7.dft
new file mode 100644
index 000000000..a16429e6f
--- /dev/null
+++ b/examples/dft/spare7.dft
@@ -0,0 +1,5 @@
+toplevel "A";
+"A" wsp "K" "J" "I";
+"I" lambda=0.5 dorm=0.5;
+"J" lambda=1 dorm=0.5;
+"K" lambda=0.5 dorm=0.5;

From d88bc115c46884277d66eb10454ffe494d7dd13b Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 4 Feb 2016 14:23:57 +0100
Subject: [PATCH 053/246] Use keywords for pctl properties

Former-commit-id: c0217aacb6b8a5fcafc409b4050cc8280ff208ed
---
 src/storm-dyftee.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index fc113e438..fd9d67c12 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -54,19 +54,27 @@ int main(int argc, char** argv) {
     bool parametric = false;
     log4cplus::LogLevel level = log4cplus::WARN_LOG_LEVEL;
     std::string filename = argv[1];
-    std::string pctlFormula = "Pmax=?[true U \"failed\"]";
+    std::string pctlFormula = "";
     for (int i = 2; i < argc; ++i) {
         std::string option = argv[i];
         if (option == "--parametric") {
             parametric = true;
+        } else if (option == "--expectedtime") {
+            assert(pctlFormula.empty());
+            pctlFormula = "ET=?[F \"failed\"]";
+        } else if (option == "--probability") {
+            assert(pctlFormula.empty());
+            pctlFormula = "P=? [F \"failed\"]";
         } else if (option == "--trace") {
             level = log4cplus::TRACE_LOG_LEVEL;
         } else if (option == "--debug") {
             level = log4cplus::DEBUG_LOG_LEVEL;
         } else {
+            assert(pctlFormula.empty());
             pctlFormula = option;
         }
     }
+    assert(!pctlFormula.empty());
 
     storm::utility::setUp();
     logger.setLogLevel(level);

From ed9ac339e69d73153c31d53a73e3b312165d0490 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 5 Feb 2016 13:14:48 +0100
Subject: [PATCH 054/246] dft isomorphism

Former-commit-id: 1404390f5a2fbdac56705132a2ed9558085ef7d9
---
 src/storage/dft/DFT.cpp          |  2 ++
 src/storage/dft/DFT.h            | 23 ++++++++++++++++-------
 src/storage/dft/DFTIsomorphism.h | 25 +++++++++++++++++++++++++
 3 files changed, 43 insertions(+), 7 deletions(-)
 create mode 100644 src/storage/dft/DFTIsomorphism.h

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index c36f0a9e0..29f97d77c 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -142,6 +142,8 @@ namespace storm {
             return stream.str();
         }
 
+
+
         // Explicitly instantiate the class.
         template class DFT<double>;
 
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 81cfdf99b..2cfbf6422 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -2,17 +2,19 @@
 #ifndef DFT_H
 #define	DFT_H
 
-
-#include "DFTElements.h"
-#include "../BitVector.h"
 #include <memory>
 #include <unordered_map>
 #include <list>
 #include <map>
 
+#include <boost/iterator/counting_iterator.hpp>
+
+#include "DFTIsomorphism.h"
+#include "DFTElements.h"
+#include "../BitVector.h"
+
 #include "../../utility/math.h"
 #include "src/utility/macros.h"
-#include <boost/iterator/counting_iterator.hpp>
 
 namespace storm {
     namespace storage {
@@ -28,8 +30,9 @@ namespace storm {
             }
         };
 
-
-
+        /**
+         * Represents a Dynamic Fault Tree
+         */
         template<typename ValueType>
         class DFT {
 
@@ -136,12 +139,17 @@ namespace storm {
                 return result;
             }
 
+            /**
+             *  Get a pointer to an element in the DFT
+             *  @param index The id of the element
+             */
             DFTElementPointer const& getElement(size_t index) const {
                 assert(index < nrElements());
                 return mElements[index];
             }
 
             std::shared_ptr<DFTBE<ValueType>> getBasicElement(size_t index) const {
+                assert(index < nrElements());
                 assert(mElements[index]->isBasicElement());
                 return std::static_pointer_cast<DFTBE<ValueType>>(mElements[index]);
             }
@@ -182,7 +190,8 @@ namespace storm {
             std::string getElementsWithStateString(DFTStatePointer const& state) const;
 
             std::string getStateString(DFTStatePointer const& state) const;
-            
+
+            DFTIsomorphisms detectIsomorphicChildren() const;
         private:
             bool elementIndicesCorrect() const {
                 for(size_t i = 0; i < mElements.size(); ++i) {
diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
new file mode 100644
index 000000000..2b6016ca4
--- /dev/null
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <vector>
+
+namespace storm {
+namespace storage {
+    /**
+     * Saves isomorphism between subtrees
+     */
+    class DFTIsomorphism {
+        std::vector<std::vector<size_t>> classes;
+    };
+
+    /**
+     * Saves sets of isomorphic subtrees
+     */
+    class DFTIsomorphisms {
+        std::vector<DFTIsomorphism> isomorphisms;
+
+        void addIsomorphismClass(DFTIsomorphism const &) {
+
+        }
+    };
+} // namespace storm::dft
+} // namespace storm

From 50e37217de2dfc9b09b6e55f4e762817d3a16f63 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 5 Feb 2016 13:59:21 +0100
Subject: [PATCH 055/246] Fixed compile problem

Former-commit-id: 718456a293ed121ad644718453505dfa01c6233c
---
 src/parser/DFTGalileoParser.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index 163bc1488..8bc96ed78 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -54,7 +54,7 @@ namespace storm {
                 STORM_LOG_THROW(false, storm::exceptions::FileIoException, "Exception during file opening on " << filename << ".");
                 return false;
             }
-            file.exceptions( 0 );
+            file.exceptions( std::ifstream::goodbit );
 
             std::string line;
             bool generalSuccess = true;
@@ -156,4 +156,4 @@ namespace storm {
 #endif
         
     }
-}
\ No newline at end of file
+}

From 739963cfe1e022852f419439ed71207f9d910d52 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 5 Feb 2016 16:28:36 +0100
Subject: [PATCH 056/246] find independent subdfts

Former-commit-id: fca8c8fab3992c2982fa085e94ec27509483bcfa
---
 src/storage/dft/DFT.cpp         |   8 +++
 src/storage/dft/DFT.h           |   2 +-
 src/storage/dft/DFTElements.cpp |  25 ++++++-
 src/storage/dft/DFTElements.h   | 112 ++++++++++++++++++++++++++------
 4 files changed, 124 insertions(+), 23 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 29f97d77c..b05e57eda 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -1,3 +1,5 @@
+#include <boost/container/flat_set.hpp>
+
 #include "DFT.h"
 
 namespace storm {
@@ -142,7 +144,13 @@ namespace storm {
             return stream.str();
         }
 
+        template <typename ValueType>
+        bool DFT<ValueType>::rootOfClosedSubDFT(size_t index) const {
+            //boost::container::flat_set<size_t> marked;
+            //DFTElementPointer elem = getElement(index);
+
 
+        }
 
         // Explicitly instantiate the class.
         template class DFT<double>;
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 2cfbf6422..ec68e1f30 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -191,7 +191,7 @@ namespace storm {
 
             std::string getStateString(DFTStatePointer const& state) const;
 
-            DFTIsomorphisms detectIsomorphicChildren() const;
+            bool rootOfClosedSubDFT(size_t id) const;
         private:
             bool elementIndicesCorrect() const {
                 for(size_t i = 0; i < mElements.size(); ++i) {
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index 0c18e3be6..761975762 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -34,9 +34,30 @@ namespace storm {
         template<typename ValueType>
         void DFTElement<ValueType>::extendUnit(std::set<size_t>& unit) const {
             unit.insert(mId);
+        }
+
+        template<typename ValueType>
+        std::vector<size_t> DFTElement<ValueType>::independentSubDft() const {
+            std::vector<size_t> res;
+            res.push_back(this->id());
+            // Extend for pdeps.
+            return res;
+        }
+
+        template<typename ValueType>
+        void DFTElement<ValueType>::extendSubDft(std::set<size_t> elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const {
+            if(std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), mId) != parentsOfSubRoot.end()) {
+                // This is a parent of the suspected root, thus it is not a subdft.
+                elemsInSubtree.clear();
+                return;
+            }
+            elemsInSubtree.insert(mId);
             for(auto const& parent : mParents) {
-                if(unit.count(parent->id()) != 0) {
-                    parent->extendUnit(unit);
+                if(elemsInSubtree.count(parent->id()) != 0) {
+                    parent->extendUnit(elemsInSubtree);
+                    if(elemsInSubtree.empty()) {
+                        return;
+                    }
                 }
             }
         }
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 7f92ebb19..b047ddbd1 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -42,11 +42,13 @@ namespace storm {
 
             virtual ~DFTElement() {}
 
-            
+            /**
+             * Returns the id
+             */
             virtual size_t id() const {
                 return mId;
             }
-            
+
             virtual void setRank(size_t rank) {
                 mRank = rank;
             }
@@ -62,7 +64,10 @@ namespace storm {
             virtual bool isGate() const {
                 return false;
             }
-            
+
+            /**
+             *  Returns true if the element is a BE
+             */
             virtual bool isBasicElement() const {
                 return false;
             }
@@ -70,7 +75,10 @@ namespace storm {
             virtual bool isColdBasicElement() const {
                 return false;
             }
-            
+
+            /**
+             * Returns true if the element is a spare gate
+             */
             virtual bool isSpareGate() const {
                 return false;
             }
@@ -78,7 +86,10 @@ namespace storm {
             virtual void setId(size_t newId) {
                 mId = newId;
             }
-            
+
+            /**
+             * Returns the name
+             */
             virtual std::string const& name() const {
                 return mName;
             }
@@ -101,7 +112,15 @@ namespace storm {
             DFTGateVector const& parents() const {
                 return mParents;
             }
-            
+
+            std::vector<size_t> parentIds() const {
+                std::vector<size_t> res;
+                for(auto parent : parents()) {
+                    res.push_back(parent->id());
+                }
+                return res;
+            }
+
             virtual void extendSpareModule(std::set<size_t>& elementsInModule) const;
             
             virtual size_t nrChildren() const = 0;
@@ -109,12 +128,33 @@ namespace storm {
             virtual std::string toString() const = 0;
 
             virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const;
-            
+
+            /**
+             *  Computes the independent unit of this element, that is, all elements which are direct or indirect successors of an element.
+             */
             virtual std::vector<size_t> independentUnit() const = 0;
-        
+
+            /**
+             *  Helper to independent unit computation
+             *  @see independentUnit
+             */
             virtual void extendUnit(std::set<size_t>& unit) const;
 
+            /**
+             *  Computes independent subtrees starting with this element (this), that is, all elements (x) which are connected to either
+             *  - one of the children of the element,
+             *  - a propabilisistic dependency
+             *  such that there exists a  path from x to a child of this does not go through this.
+             */
+            virtual std::vector<size_t> independentSubDft() const;
+            /**
+             * Helper to the independent subtree computation
+             * @see independentSubDft
+             */
+            virtual void extendSubDft(std::set<size_t> elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const;
+
             void checkForSymmetricChildren() const;
+
         };
 
 
@@ -197,13 +237,50 @@ namespace storm {
                 for(auto const& child : mChildren) {
                     child->extendUnit(unit);
                 }
-                for(auto const& parent : this->mParents) {
-                    if(unit.count(parent->id()) != 0) {
-                        return {};
-                    } 
+                return std::vector<size_t>(unit.begin(), unit.end());
+            }
+
+            virtual void extendUnit(std::set<size_t>& unit) const override {
+                DFTElement<ValueType>::extendUnit(unit);
+                for(auto const& child : mChildren) {
+                    child->extendUnit(unit);
+                }
+            }
+
+            virtual std::vector<size_t> independentSubDft() const override {
+                auto prelRes = DFTElement<ValueType>::independentSubDft();
+                if(prelRes.empty()) {
+                    // No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft.
+                    return prelRes;
+                }
+                std::set<size_t> unit(prelRes.begin(), prelRes.end());
+                std::vector<size_t> pids = this->parentIds();
+                for(auto const& child : mChildren) {
+                    child->extendSubDft(unit, pids);
+                    if(unit.empty()) {
+                        // Parent in the subdft, ie it is *not* a subdft
+                        break;
+                    }
                 }
                 return std::vector<size_t>(unit.begin(), unit.end());
             }
+
+            virtual void extendSubDft(std::set<size_t> elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                if(!elemsInSubtree.empty()) {
+                    // Parent in the subdft, ie it is *not* a subdft
+                    return;
+                }
+                for(auto const& child : mChildren) {
+                    child->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                    if(elemsInSubtree.empty()) {
+                        // Parent in the subdft, ie it is *not* a subdft
+                        break;
+                    }
+                }
+            }
+
+
             
             virtual std::string toString() const override {
                 std::stringstream stream;
@@ -226,13 +303,7 @@ namespace storm {
                 }
                 return false;
             }
-            
-            virtual void extendUnit(std::set<size_t>& unit) const override {
-                DFTElement<ValueType>::extendUnit(unit);
-                for(auto const& child : mChildren) {
-                    child->extendUnit(unit);
-                }
-            }
+
             
         protected:
 
@@ -318,10 +389,11 @@ namespace storm {
                 return storm::utility::isZero(mPassiveFailureRate);
             }
 
-            virtual std::vector<size_t> independentUnit() const {
+            virtual std::vector<size_t> independentUnit() const override {
                 return {this->mId};
             }
 
+
             virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const;
         };
 

From 3b1c695b5d2c4b7f9b4c3b05249addcd24e76dae Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 5 Feb 2016 16:33:57 +0100
Subject: [PATCH 057/246] Another compile fix

Former-commit-id: 6bb97a0505e07d4952fad582c75e9d04d2f16481
---
 src/storage/dft/DFTState.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 7cb5eaf4a..fed33eee3 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -5,6 +5,7 @@
 #include "DFTElementState.h"
 
 #include <sstream>
+#include <memory>
 
 namespace storm {
     namespace storage {

From da90b5fcd077ff78082b0d50375b54d812e681bc Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 5 Feb 2016 20:31:43 +0100
Subject: [PATCH 058/246] Fixed benchmark script for new command line options

Former-commit-id: d2df6bd5a4c70914b44bbb23bc96e2edbedd9c92
---
 benchmark_dft.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/benchmark_dft.py b/benchmark_dft.py
index b12d4f185..1b8e29972 100644
--- a/benchmark_dft.py
+++ b/benchmark_dft.py
@@ -51,7 +51,7 @@ def run_storm_dft(filename, prop, parametric, quiet):
     dft_file = os.path.join(EXAMPLE_DIR, filename + ".dft")
     args = [STORM_PATH,
             dft_file,
-            '--prop', prop]
+            prop]
     if parametric:
         args.append('--parametric')
 
@@ -88,7 +88,7 @@ if __name__ == "__main__":
     args = parser.parse_args()
     count = 0
     correct = 0
-    properties = ["ET=? [F \"failed\"]", "P=? [F \"failed\"]"]
+    properties = ['--expectedtime', '--probability']
     start = time.time()
     for index, prop in enumerate(properties):
         for (benchmark, parametric, result_original) in benchmarks:

From ff69fcab98627c2b5ec61083e748ff587704d8e2 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Sat, 6 Feb 2016 18:30:37 +0100
Subject: [PATCH 059/246] refactored DFTElementType, fixed some minor things

Former-commit-id: d147e03bd74e5965e0cd27d177e3642e222a2989
---
 src/storage/dft/DFTBuilder.cpp   | 22 ++++++++---------
 src/storage/dft/DFTBuilder.h     | 12 +++++-----
 src/storage/dft/DFTElementType.h | 32 +++++++++++++++++++++++++
 src/storage/dft/DFTElements.cpp  | 13 ++++++----
 src/storage/dft/DFTElements.h    | 41 +++++++-------------------------
 5 files changed, 66 insertions(+), 54 deletions(-)
 create mode 100644 src/storage/dft/DFTElementType.h

diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index d49bfd067..f6fff39ff 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -61,7 +61,7 @@ namespace storm {
         }
 
         template<typename ValueType>
-        bool DFTBuilder<ValueType>::addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementTypes tp) {
+        bool DFTBuilder<ValueType>::addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementType tp) {
             assert(children.size() > 0);
             if(mElements.count(name) != 0) {
                 // Element with that name already exists.
@@ -69,28 +69,28 @@ namespace storm {
             }
             DFTElementPointer element;
             switch(tp) {
-                case DFTElementTypes::AND:
+                case DFTElementType::AND:
                     element = std::make_shared<DFTAnd<ValueType>>(mNextId++, name);
                     break;
-                case DFTElementTypes::OR:
+                case DFTElementType::OR:
                     element = std::make_shared<DFTOr<ValueType>>(mNextId++, name);
                     break;
-                case DFTElementTypes::PAND:
+                case DFTElementType::PAND:
                     element = std::make_shared<DFTPand<ValueType>>(mNextId++, name);
                     break;
-                case DFTElementTypes::POR:
+                case DFTElementType::POR:
                     element = std::make_shared<DFTPor<ValueType>>(mNextId++, name);
                     break;
-                case DFTElementTypes::SPARE:
+                case DFTElementType::SPARE:
                    element = std::make_shared<DFTSpare<ValueType>>(mNextId++, name);
                    break;
-                case DFTElementTypes::BE:
-                case DFTElementTypes::VOT:
+                case DFTElementType::BE:
+                case DFTElementType::VOT:
                     // Handled separately
                     STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type handled separately.");
-                case DFTElementTypes::CONSTF:
-                case DFTElementTypes::CONSTS:
-                case DFTElementTypes::FDEP:
+                case DFTElementType::CONSTF:
+                case DFTElementType::CONSTS:
+                case DFTElementType::FDEP:
                     STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type not supported.");
                 default:
                     STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type not known.");
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index 12d5e88c3..0cb0efab5 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -32,23 +32,23 @@ namespace storm {
             }
             
             bool addAndElement(std::string const& name, std::vector<std::string> const& children) {
-                return addStandardGate(name, children, DFTElementTypes::AND);
+                return addStandardGate(name, children, DFTElementType::AND);
             }
             
             bool addOrElement(std::string const& name, std::vector<std::string> const& children) {
-                return addStandardGate(name, children, DFTElementTypes::OR);
+                return addStandardGate(name, children, DFTElementType::OR);
             }
             
             bool addPandElement(std::string const& name, std::vector<std::string> const& children) {
-                return addStandardGate(name, children, DFTElementTypes::PAND);
+                return addStandardGate(name, children, DFTElementType::PAND);
             }
             
             bool addPorElement(std::string const& name, std::vector<std::string> const& children) {
-                return addStandardGate(name, children, DFTElementTypes::POR);
+                return addStandardGate(name, children, DFTElementType::POR);
             }
             
             bool addSpareElement(std::string const& name, std::vector<std::string> const& children) {
-                return addStandardGate(name, children, DFTElementTypes::SPARE);
+                return addStandardGate(name, children, DFTElementType::SPARE);
             }
             
             bool addVotElement(std::string const& name, unsigned threshold, std::vector<std::string> const& children) {
@@ -98,7 +98,7 @@ namespace storm {
             
             unsigned computeRank(DFTElementPointer const& elem);
             
-            bool addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementTypes tp);
+            bool addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementType tp);
             
             enum class topoSortColour {WHITE, BLACK, GREY}; 
             
diff --git a/src/storage/dft/DFTElementType.h b/src/storage/dft/DFTElementType.h
new file mode 100644
index 000000000..9aba9fa54
--- /dev/null
+++ b/src/storage/dft/DFTElementType.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <cassert>
+namespace storm {
+    namespace storage {
+
+        enum class DFTElementType : int {AND = 0, COUNTING = 1, OR = 2, VOT = 3, BE = 4, CONSTF = 5, CONSTS = 6, PAND = 7, SPARE = 8, POR = 9, FDEP = 10, SEQAND = 11};
+
+        inline bool isGateType(DFTElementType const& tp) {
+            switch(tp) {
+                case DFTElementType::AND:
+                case DFTElementType::COUNTING:
+                case DFTElementType::OR:
+                case DFTElementType::VOT:
+                case DFTElementType::PAND:
+                case DFTElementType::SPARE:
+                case DFTElementType::POR:
+                case DFTElementType::SEQAND:
+                    return true;
+                case DFTElementType::BE:
+                case DFTElementType::CONSTF:
+                case DFTElementType::CONSTS:
+                case DFTElementType::FDEP:
+                    return false;
+                default:
+                    assert(false);
+            }
+        }
+
+    }
+}
+
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index 761975762..d5b089c84 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -31,6 +31,14 @@ namespace storm {
             }
         }
 
+        template<typename ValueType>
+        std::vector<size_t> DFTElement<ValueType>::independentUnit() const {
+            std::vector<size_t> res;
+            res.push_back(this->id());
+            // Extend for pdeps.
+            return res;
+        }
+
         template<typename ValueType>
         void DFTElement<ValueType>::extendUnit(std::set<size_t>& unit) const {
             unit.insert(mId);
@@ -62,11 +70,6 @@ namespace storm {
             }
         }
 
-        template<typename ValueType>
-        void DFTElement<ValueType>::checkForSymmetricChildren() const {
-            STORM_LOG_THROW(false, storm::exceptions::NotImplementedException, "Not implemented.");
-            assert(false);
-        }
 
         template<typename ValueType>
         bool DFTBE<ValueType>::checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index b047ddbd1..663c5b230 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -8,7 +8,9 @@
 #include <cassert>
 #include <cstdlib>
 #include <iostream>
+#include <functional>
 
+#include "DFTElementType.h"
 #include "DFTState.h"
 #include "DFTStateSpaceGenerationQueues.h"
 #include "src/utility/constants.h"
@@ -132,7 +134,7 @@ namespace storm {
             /**
              *  Computes the independent unit of this element, that is, all elements which are direct or indirect successors of an element.
              */
-            virtual std::vector<size_t> independentUnit() const = 0;
+            virtual std::vector<size_t> independentUnit() const;
 
             /**
              *  Helper to independent unit computation
@@ -153,33 +155,15 @@ namespace storm {
              */
             virtual void extendSubDft(std::set<size_t> elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const;
 
-            void checkForSymmetricChildren() const;
 
-        };
 
 
-        enum class DFTElementTypes {AND, COUNTING, OR, VOT, BE, CONSTF, CONSTS, PAND, SPARE, POR, FDEP, SEQAND};
 
-        inline bool isGateType(DFTElementTypes const& tp) {
-            switch(tp) {
-                case DFTElementTypes::AND:
-                case DFTElementTypes::COUNTING:
-                case DFTElementTypes::OR:
-                case DFTElementTypes::VOT:
-                case DFTElementTypes::PAND:
-                case DFTElementTypes::SPARE:
-                case DFTElementTypes::POR:
-                case DFTElementTypes::SEQAND:
-                    return true;
-                case DFTElementTypes::BE:
-                case DFTElementTypes::CONSTF:
-                case DFTElementTypes::CONSTS:
-                case DFTElementTypes::FDEP:
-                    return false;
-                default:
-                    assert(false);
-            }
-        }
+        protected:
+           // virtual bool checkIsomorphicSubDftHelper(DFTElement const& otherElem, std::vector<std::pair<DFTElement const&, DFTElement const&>>& mapping, std::vector<DFTElement const&> const& order ) const = 0;
+
+        };
+
 
 
 
@@ -281,7 +265,6 @@ namespace storm {
             }
 
 
-            
             virtual std::string toString() const override {
                 std::stringstream stream;
                 stream << "{" << this->name() << "} " << typestring() << "( ";
@@ -304,7 +287,7 @@ namespace storm {
                 return false;
             }
 
-            
+
         protected:
 
             void fail(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
@@ -388,12 +371,6 @@ namespace storm {
             bool isColdBasicElement() const {
                 return storm::utility::isZero(mPassiveFailureRate);
             }
-
-            virtual std::vector<size_t> independentUnit() const override {
-                return {this->mId};
-            }
-
-
             virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const;
         };
 

From e38648f6a7331fe31475a789b1503d15c90d04e2 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 8 Feb 2016 16:26:07 +0100
Subject: [PATCH 060/246] FDeps are parsed and constructed but not used yet

Former-commit-id: fbd2a95f9c8e4236841f137bc63c58c53221517f
---
 src/parser/DFTGalileoParser.cpp |  2 +-
 src/storage/dft/DFTBuilder.cpp  | 25 +++++++++--
 src/storage/dft/DFTBuilder.h    | 25 +++++++++++
 src/storage/dft/DFTElements.h   | 79 ++++++++++++++++++++++++++++++++-
 4 files changed, 126 insertions(+), 5 deletions(-)

diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index 163bc1488..d623821e6 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -107,7 +107,7 @@ namespace storm {
                     } else if (tokens[1] == "wsp" || tokens[1] == "csp") {
                         success = builder.addSpareElement(name, childNames);
                     } else if (boost::starts_with(tokens[1], "fdep")) {
-                        STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Functional dependencies currently not supported");
+                        success = builder.addFDepElement(name, childNames);
                     } else if (boost::starts_with(tokens[1], "lambda=")) {
                         ValueType failureRate = parseRationalExpression(tokens[1].substr(7));
                         ValueType dormancyFactor = parseRationalExpression(tokens[2].substr(5));
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index d49bfd067..4ee258dd1 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -18,11 +18,30 @@ namespace storm {
             for(auto& elem : mChildNames) {
                 DFTGatePointer gate = std::static_pointer_cast<DFTGate<ValueType>>(elem.first);
                 for(auto const& child : elem.second) {
-                    gate->pushBackChild(mElements[child]);
-                    mElements[child]->addParent(gate);
+                    auto itFind = mElements.find(child);
+                    if (itFind != mElements.end()) {
+                        // Child found
+                        DFTElementPointer childElement = itFind->second;
+                        assert(!childElement->isDependency());
+                        gate->pushBackChild(childElement);
+                        childElement->addParent(gate);
+                    } else {
+                        // Child not found -> find first dependent event to assure that child is dependency
+                        auto itFind = mElements.find(child + "_1");
+                        assert(itFind != mElements.end());
+                        assert(itFind->second->isDependency());
+                        STORM_LOG_TRACE("Ignore functional dependency " << child << " in gate " << gate->name());
+                    }
                 }
             }
 
+            // Initialize dependencies
+            for (auto& dependency : mDependencies) {
+                DFTGatePointer triggerEvent = std::static_pointer_cast<DFTGate<ValueType>>(mElements[dependency->nameTrigger()]);
+                std::shared_ptr<DFTBE<ValueType>> dependentEvent = std::static_pointer_cast<DFTBE<ValueType>>(mElements[dependency->nameDependent()]);
+                dependency->initialize(triggerEvent, dependentEvent);
+            }
+
             // Sort elements topologically
             // compute rank
             for (auto& elem : mElements) {
@@ -40,7 +59,7 @@ namespace storm {
         template<typename ValueType>
         unsigned DFTBuilder<ValueType>::computeRank(DFTElementPointer const& elem) {
             if(elem->rank() == -1) {
-                if(elem->nrChildren() == 0) {
+                if(elem->nrChildren() == 0 || elem->isDependency()) {
                     elem->setRank(0);
                 } else {
                     DFTGatePointer gate = std::static_pointer_cast<DFTGate<ValueType>>(elem);
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index 12d5e88c3..9dfb80ac2 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -19,12 +19,14 @@ namespace storm {
             using DFTElementVector = std::vector<DFTElementPointer>;
             using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
             using DFTGateVector = std::vector<DFTGatePointer>;
+            using DFTDependencyPointer = std::shared_ptr<DFTDependency<ValueType>>;
 
         private:
             std::size_t mNextId = 0;
             std::string topLevelIdentifier;
             std::unordered_map<std::string, DFTElementPointer> mElements;
             std::unordered_map<DFTElementPointer, std::vector<std::string>> mChildNames;
+            std::vector<DFTDependencyPointer> mDependencies;
             
         public:
             DFTBuilder() {
@@ -51,6 +53,29 @@ namespace storm {
                 return addStandardGate(name, children, DFTElementTypes::SPARE);
             }
             
+            bool addFDepElement(std::string const& name, std::vector<std::string> const& children) {
+                assert(children.size() > 1);
+                if(mElements.count(name) != 0) {
+                    // Element with that name already exists.
+                    return false;
+                }
+                std::string trigger = children[0];
+                for (size_t i = 1; i < children.size(); ++i) {
+                    // TODO Matthias: better code
+                    std::stringstream stream;
+                    stream << name << "_" << i;
+                    std::string s = stream.str();
+                    if(mElements.count(s) != 0) {
+                        // Element with that name already exists.
+                        return false;
+                    }
+                    DFTDependencyPointer element = std::make_shared<DFTDependency<ValueType>>(mNextId++, s, trigger, children[i]);
+                    mElements[element->name()] = element;
+                    mDependencies.push_back(element);
+                }
+                return true;
+            }
+
             bool addVotElement(std::string const& name, unsigned threshold, std::vector<std::string> const& children) {
                 assert(children.size() > 0);
                 if(mElements.count(name) != 0) {
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 7f92ebb19..d8f9e19b1 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -74,7 +74,11 @@ namespace storm {
             virtual bool isSpareGate() const {
                 return false;
             }
-            
+
+            virtual bool isDependency() const {
+                return false;
+            }
+
             virtual void setId(size_t newId) {
                 mId = newId;
             }
@@ -357,6 +361,79 @@ namespace storm {
         };
 
 
+        template<typename ValueType>
+        class DFTDependency : public DFTElement<ValueType> {
+
+            using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
+            using DFTBEPointer = std::shared_ptr<DFTBE<ValueType>>;
+            using DFTBEVector = std::vector<DFTBEPointer>;
+
+        protected:
+            std::string mNameTrigger;
+            std::string mNameDependent;
+            DFTGatePointer mTriggerEvent;
+            DFTBEPointer mDependentEvent;
+
+        public:
+            DFTDependency(size_t id, std::string const& name, std::string const& trigger, std::string const& dependent) :
+                DFTElement<ValueType>(id, name), mNameTrigger(trigger), mNameDependent(dependent)
+            {
+            }
+
+            virtual ~DFTDependency() {}
+
+            void initialize(DFTGatePointer triggerEvent, DFTBEPointer dependentEvent) {
+                assert(triggerEvent->name() == mNameTrigger);
+                assert(dependentEvent->name() == mNameDependent);
+                mTriggerEvent = triggerEvent;
+                mDependentEvent = dependentEvent;
+            }
+
+            std::string nameTrigger() {
+                return mNameTrigger;
+            }
+
+            std::string nameDependent() {
+                return mNameDependent;
+            }
+
+            DFTGatePointer const& triggerEvent() const {
+                assert(mTriggerEvent);
+                return mTriggerEvent;
+            }
+
+            DFTBEPointer const& dependentEvent() const {
+                assert(mDependentEvent);
+                return mDependentEvent;
+            }
+
+            virtual size_t nrChildren() const override {
+                return 1;
+            }
+
+            virtual bool isDependency() const override {
+                return true;
+            }
+
+            virtual std::vector<size_t> independentUnit() const override {
+                std::set<size_t> unit = {this->mId};
+                mDependentEvent->extendUnit(unit);
+                if(unit.count(mTriggerEvent->id()) != 0) {
+                    return {};
+                }
+                return std::vector<size_t>(unit.begin(), unit.end());
+            }
+
+            virtual std::string toString() const override {
+                std::stringstream stream;
+                stream << "{" << this->name() << "} FDEP(" << mTriggerEvent->name() << " => " << mDependentEvent->name() << ")";
+                return stream.str();
+            }
+
+        protected:
+
+        };
+
 
         template<typename ValueType>
         class DFTAnd : public DFTGate<ValueType> {

From d45ea9cbdeb17fc199a7608f07d8056c4d8ff9ff Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 8 Feb 2016 16:27:08 +0100
Subject: [PATCH 061/246] Improved cmdl options

Former-commit-id: b2ecba9ea10e8123683b3860d7bad6bac02a46ae
---
 src/storm-dyftee.cpp | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index fd9d67c12..4986469e7 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -46,7 +46,7 @@ void analyzeDFT(std::string filename, std::string property) {
 int main(int argc, char** argv) {
     if(argc < 2) {
         std::cout << "Storm-DyFTeE should be called with a filename as argument." << std::endl;
-        std::cout << "./storm-dft <filename> <optional pctl-formula> <optional --parametric>" << std::endl;
+        std::cout << "./storm-dft <filename> <--prop pctl-formula> <--parametric>" << std::endl;
         return 1;
     }
 
@@ -69,9 +69,14 @@ int main(int argc, char** argv) {
             level = log4cplus::TRACE_LOG_LEVEL;
         } else if (option == "--debug") {
             level = log4cplus::DEBUG_LOG_LEVEL;
-        } else {
+        } else if (option == "--prop") {
             assert(pctlFormula.empty());
-            pctlFormula = option;
+            ++i;
+            assert(i < argc);
+            pctlFormula = argv[i];
+        } else {
+            std::cout << "Option '" << option << "' not recognized." << std::endl;
+            return 1;
         }
     }
     assert(!pctlFormula.empty());

From c6663ba74a66e34ae008f2e264793c9e86a5d5a8 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 8 Feb 2016 17:11:47 +0100
Subject: [PATCH 062/246] Added FDep bechmarks

Former-commit-id: 885b7a9531aa0146b52708ff0ffb0067486e9011
---
 examples/dft/cardiac.dft       |  21 ++++++
 examples/dft/cas.dft           |  24 ++++++
 examples/dft/deathegg.dft      |  16 ++++
 examples/dft/fdep.dft          |   8 ++
 examples/dft/ftpp_complex.dft  | 129 +++++++++++++++++++++++++++++++++
 examples/dft/ftpp_large.dft    |  63 ++++++++++++++++
 examples/dft/ftpp_standard.dft |  53 ++++++++++++++
 7 files changed, 314 insertions(+)
 create mode 100644 examples/dft/cardiac.dft
 create mode 100644 examples/dft/cas.dft
 create mode 100644 examples/dft/deathegg.dft
 create mode 100644 examples/dft/fdep.dft
 create mode 100644 examples/dft/ftpp_complex.dft
 create mode 100644 examples/dft/ftpp_large.dft
 create mode 100644 examples/dft/ftpp_standard.dft

diff --git a/examples/dft/cardiac.dft b/examples/dft/cardiac.dft
new file mode 100644
index 000000000..505f002b1
--- /dev/null
+++ b/examples/dft/cardiac.dft
@@ -0,0 +1,21 @@
+toplevel "SYSTEM";
+"SYSTEM" or "FDEP" "CPU" "MOTOR" "PUMPS";
+"FDEP" fdep "TRIGGER" "P" "B";
+"TRIGGER" or "CS" "SS";
+"CPU" wsp "P" "B";
+"MOTOR" or "SWITCH" "MOTORS";
+"SWITCH" pand "MS" "MA";
+"MOTORS" csp "MA" "MB";
+"PUMPS" and "PUMP1" "PUMP2";
+"PUMP1" csp "PA" "PS";
+"PUMP2" csp "PB" "PS";
+"P" lambda=5.0e-5 dorm=0;
+"B" lambda=5.0e-5 dorm=0.5;
+"CS" lambda=2.0e-5 dorm=0;
+"SS" lambda=2.0e-5 dorm=0;
+"MS" lambda=1.0e-6 dorm=0;
+"MA" lambda=1.0e-4 dorm=0;
+"MB" lambda=1.0e-4 dorm=0;
+"PA" lambda=1.0e-4 dorm=0;
+"PB" lambda=1.0e-4 dorm=0;
+"PS" lambda=1.0e-4 dorm=0;
diff --git a/examples/dft/cas.dft b/examples/dft/cas.dft
new file mode 100644
index 000000000..812a3f30a
--- /dev/null
+++ b/examples/dft/cas.dft
@@ -0,0 +1,24 @@
+toplevel "System";
+"System" or "CPUfdep" "CPUunit" "Motorunit" "Pumpunit";
+
+"CPUfdep" fdep "trigger" "P" "B";
+"trigger" or "CS" "SS";
+"CS" lambda=0.2 dorm=0;
+"SS" lambda=0.2 dorm=0;
+"CPUunit" wsp "P" "B";
+"P" lambda=0.5 dorm=0;
+"B" lambda=0.5 dorm=0.5;
+
+"Motorunit" or "MP" "Motors";
+"MP" pand "MS" "MA";
+"Motors" csp "MA" "MB";
+"MS" lambda=0.01 dorm=0;
+"MA" lambda=1 dorm=0;
+"MB" lambda=1 dorm=0;
+
+"Pumpunit" and "PumpA" "PumpB";
+"PumpA" csp "PA" "PS";
+"PumpB" csp "PB" "PS";
+"PA" lambda=1 dorm=0;
+"PB" lambda=1 dorm=0;
+"PS" lambda=1 dorm=0;
diff --git a/examples/dft/deathegg.dft b/examples/dft/deathegg.dft
new file mode 100644
index 000000000..618684c4e
--- /dev/null
+++ b/examples/dft/deathegg.dft
@@ -0,0 +1,16 @@
+toplevel "DeathEgg";
+"DeathEgg" or "DeathEggProxy" "DeathEggServer" "CampusPowerDependency" "ProxyPowerDependency";
+"DeathEggServer" or "CampusNET" "DES_Disks";
+"DES_Disks" and "DES_Disks_RAID1" "DES_Disks_RAID2";
+"DES_Disks_RAID1" and "DES_Disk_1" "DES_Disk_2";
+"DES_Disks_RAID2" and "DES_Disk_3" "DES_Disk_4";
+"DeathEggProxy" lambda=0.01 dorm=0;
+"DES_Disk_1" lambda=0.01 dorm=0;
+"DES_Disk_2" lambda=0.01 dorm=0;
+"DES_Disk_3" lambda=0.01 dorm=0;
+"DES_Disk_4" lambda=0.01 dorm=0;
+"CampusPowerDependency" fdep "CampusPower" "DeathEggServer";
+"ProxyPowerDependency" fdep "ProxyPower" "DeathEggProxy";
+"CampusPower" lambda=0.01 dorm=0;
+"CampusNET" lambda=0.01 dorm=0;
+"ProxyPower" lambda=0.01 dorm=0;
\ No newline at end of file
diff --git a/examples/dft/fdep.dft b/examples/dft/fdep.dft
new file mode 100644
index 000000000..e597c46ce
--- /dev/null
+++ b/examples/dft/fdep.dft
@@ -0,0 +1,8 @@
+toplevel "System";
+"System" or "Power" "Machine";
+"Power" fdep "B_Power" "P" "B";
+"Machine" or "P" "B";
+
+"B_Power" lambda=0.5 dorm=0;
+"P" lambda=0.5 dorm=0;
+"B" lambda=0.5 dorm=0.5;
diff --git a/examples/dft/ftpp_complex.dft b/examples/dft/ftpp_complex.dft
new file mode 100644
index 000000000..1b836ee6b
--- /dev/null
+++ b/examples/dft/ftpp_complex.dft
@@ -0,0 +1,129 @@
+toplevel "System";
+"System" or "triadA" "triadB" "triadC" "triadD" "fA" "fB" "fC" "fD";
+
+"triadA" 2of3 "aA" "bA" "cA";
+"aA" csp "TAA" "TAS";
+"bA" csp "TAB" "TAS";
+"cA" csp "TAC" "TAS";
+
+"triadB" 2of3 "aB" "bB" "cB";
+"aB" csp "TBA" "TBS";
+"bB" csp "TBB" "TBS";
+"cB" csp "TBC" "TBS";
+
+"triadC" 2of3 "aC" "bC" "cC";
+"aC" csp "TCA" "TCS";
+"bC" csp "TCB" "TCS";
+"cC" csp "TCC" "TCS";
+
+"triadD" 2of3 "aD" "bD" "cD";
+"aD" csp "TDA" "TDS";
+"bD" csp "TDB" "TDS";
+"cD" csp "TDC" "TDS";
+
+"fA" fdep "NEA" "TAA" "TBA" "TCA" "TDA";
+"fB" fdep "NEB" "TAB" "TBB" "TCB" "TDB";
+"fC" fdep "NEC" "TAC" "TBC" "TCC" "TDC";
+"fD" fdep "NED" "TAS" "TBS" "TCS" "TDS";
+
+
+"NEA" lambda=0.017 dorm=1;
+"NEB" lambda=0.017 dorm=1;
+"NEC" lambda=0.017 dorm=1;
+"NED" lambda=0.017 dorm=1;
+
+"TAA" or "cpuAA" "memAA";
+"memAA" csp "memAA1" "memAA2";
+"cpuAA" lambda=0.11 dorm=0;
+"memAA1" lambda=0.11 dorm=0;
+"memAA2" lambda=0.11 dorm=0;
+
+"TAB" or "cpuAB" "memAB";
+"memAB" csp "memAB1" "memAB2";
+"cpuAB" lambda=0.11 dorm=0;
+"memAB1" lambda=0.11 dorm=0;
+"memAB2" lambda=0.11 dorm=0;
+
+"TAC" or "cpuAC" "memAC";
+"memAC" csp "memAC1" "memAC2";
+"cpuAC" lambda=0.11 dorm=0;
+"memAC1" lambda=0.11 dorm=0;
+"memAC2" lambda=0.11 dorm=0;
+
+"TAS" or "cpuAS" "memAS";
+"memAS" csp "memAS1" "memAS2";
+"cpuAS" lambda=0.11 dorm=0;
+"memAS1" lambda=0.11 dorm=0;
+"memAS2" lambda=0.11 dorm=0;
+
+"TBA" or "cpuBA" "memBA";
+"memBA" csp "memBA1" "memBA2";
+"cpuBA" lambda=0.11 dorm=0;
+"memBA1" lambda=0.11 dorm=0;
+"memBA2" lambda=0.11 dorm=0;
+
+"TBB" or "cpuBB" "memBB";
+"memBB" csp "memBB1" "memBB2";
+"cpuBB" lambda=0.11 dorm=0;
+"memBB1" lambda=0.11 dorm=0;
+"memBB2" lambda=0.11 dorm=0;
+
+"TBC" or "cpuBC" "memBC";
+"memBC" csp "memBC1" "memBC2";
+"cpuBC" lambda=0.11 dorm=0;
+"memBC1" lambda=0.11 dorm=0;
+"memBC2" lambda=0.11 dorm=0;
+
+"TBS" or "cpuBS" "memBS";
+"memBS" csp "memBS1" "memBS2";
+"cpuBS" lambda=0.11 dorm=0;
+"memBS1" lambda=0.11 dorm=0;
+"memBS2" lambda=0.11 dorm=0;
+
+"TCA" or "cpuCA" "memCA";
+"memCA" csp "memCA1" "memCA2";
+"cpuCA" lambda=0.11 dorm=0;
+"memCA1" lambda=0.11 dorm=0;
+"memCA2" lambda=0.11 dorm=0;
+
+"TCB" or "cpuCB" "memCB";
+"memCB" csp "memCB1" "memCB2";
+"cpuCB" lambda=0.11 dorm=0;
+"memCB1" lambda=0.11 dorm=0;
+"memCB2" lambda=0.11 dorm=0;
+
+"TCC" or "cpuCC" "memCC";
+"memCC" csp "memCC1" "memCC2";
+"cpuCC" lambda=0.11 dorm=0;
+"memCC1" lambda=0.11 dorm=0;
+"memCC2" lambda=0.11 dorm=0;
+
+"TCS" or "cpuCS" "memCS";
+"memCS" csp "memCS1" "memCS2";
+"cpuCS" lambda=0.11 dorm=0;
+"memCS1" lambda=0.11 dorm=0;
+"memCS2" lambda=0.11 dorm=0;
+
+"TDA" or "cpuDA" "memDA";
+"memDA" csp "memDA1" "memDA2";
+"cpuDA" lambda=0.11 dorm=0;
+"memDA1" lambda=0.11 dorm=0;
+"memDA2" lambda=0.11 dorm=0;
+
+"TDB" or "cpuDB" "memDB";
+"memDB" csp "memDB1" "memDB2";
+"cpuDB" lambda=0.11 dorm=0;
+"memDB1" lambda=0.11 dorm=0;
+"memDB2" lambda=0.11 dorm=0;
+
+"TDC" or "cpuDC" "memDC";
+"memDC" csp "memDC1" "memDC2";
+"cpuDC" lambda=0.11 dorm=0;
+"memDC1" lambda=0.11 dorm=0;
+"memDC2" lambda=0.11 dorm=0;
+
+"TDS" or "cpuDS" "memDS";
+"memDS" csp "memDS1" "memDS2";
+"cpuDS" lambda=0.11 dorm=0;
+"memDS1" lambda=0.11 dorm=0;
+"memDS2" lambda=0.11 dorm=0;
diff --git a/examples/dft/ftpp_large.dft b/examples/dft/ftpp_large.dft
new file mode 100644
index 000000000..cdc8032e7
--- /dev/null
+++ b/examples/dft/ftpp_large.dft
@@ -0,0 +1,63 @@
+toplevel "System";
+"System" or "triadA" "triadB" "triadC" "triadD" "fA" "fB" "fC" "fD" "fE";
+
+"triadA" 3of4 "aA" "bA" "cA" "dA";
+"aA" csp "TAA" "TAS";
+"bA" csp "TAB" "TAS";
+"cA" csp "TAC" "TAS";
+"dA" csp "TAD" "TAS";
+
+"triadB" 3of4 "aB" "bB" "cB" "dB";
+"aB" csp "TBA" "TBS";
+"bB" csp "TBB" "TBS";
+"cB" csp "TBC" "TBS";
+"dB" csp "TBD" "TBS";
+
+"triadC" 3of4 "aC" "bC" "cC" "dC";
+"aC" csp "TCA" "TCS";
+"bC" csp "TCB" "TCS";
+"cC" csp "TCC" "TCS";
+"dC" csp "TCD" "TCS";
+
+"triadD" 3of4 "aD" "bD" "cD" "dD";
+"aD" csp "TDA" "TDS";
+"bD" csp "TDB" "TDS";
+"cD" csp "TDC" "TDS";
+"dD" csp "TDD" "TDS";
+
+"fA" fdep "NEA" "TAA" "TBA" "TCA" "TDA";
+"fB" fdep "NEB" "TAB" "TBB" "TCB" "TDB";
+"fC" fdep "NEC" "TAC" "TBC" "TCC" "TDC";
+"fD" fdep "NED" "TAD" "TBD" "TCD" "TDD";
+"fE" fdep "NEE" "TAS" "TBS" "TCS" "TDS";
+
+
+"NEA" lambda=0.017 dorm=1;
+"NEB" lambda=0.017 dorm=1;
+"NEC" lambda=0.017 dorm=1;
+"NED" lambda=0.017 dorm=1;
+"NEE" lambda=0.017 dorm=1;
+
+"TAA" lambda=0.11 dorm=0;
+"TAB" lambda=0.11 dorm=0;
+"TAC" lambda=0.11 dorm=0;
+"TAD" lambda=0.11 dorm=0;
+"TAS" lambda=0.11 dorm=0;
+
+"TBA" lambda=0.11 dorm=0;
+"TBB" lambda=0.11 dorm=0;
+"TBC" lambda=0.11 dorm=0;
+"TBD" lambda=0.11 dorm=0;
+"TBS" lambda=0.11 dorm=0;
+
+"TCA" lambda=0.11 dorm=0;
+"TCB" lambda=0.11 dorm=0;
+"TCC" lambda=0.11 dorm=0;
+"TCD" lambda=0.11 dorm=0;
+"TCS" lambda=0.11 dorm=0;
+
+"TDA" lambda=0.11 dorm=0;
+"TDB" lambda=0.11 dorm=0;
+"TDC" lambda=0.11 dorm=0;
+"TDD" lambda=0.11 dorm=0;
+"TDS" lambda=0.11 dorm=0;
diff --git a/examples/dft/ftpp_standard.dft b/examples/dft/ftpp_standard.dft
new file mode 100644
index 000000000..9eaa7720e
--- /dev/null
+++ b/examples/dft/ftpp_standard.dft
@@ -0,0 +1,53 @@
+toplevel "System";
+"System" or "triadA" "triadB" "triadC" "triadD" "fA" "fB" "fC" "fD";
+
+"triadA" 2of3 "aA" "bA" "cA";
+"aA" csp "TAA" "TAS";
+"bA" csp "TAB" "TAS";
+"cA" csp "TAC" "TAS";
+
+"triadB" 2of3 "aB" "bB" "cB";
+"aB" csp "TBA" "TBS";
+"bB" csp "TBB" "TBS";
+"cB" csp "TBC" "TBS";
+
+"triadC" 2of3 "aC" "bC" "cC";
+"aC" csp "TCA" "TCS";
+"bC" csp "TCB" "TCS";
+"cC" csp "TCC" "TCS";
+
+"triadD" 2of3 "aD" "bD" "cD";
+"aD" csp "TDA" "TDS";
+"bD" csp "TDB" "TDS";
+"cD" csp "TDC" "TDS";
+
+"fA" fdep "NEA" "TAA" "TBA" "TCA" "TDA";
+"fB" fdep "NEB" "TAB" "TBB" "TCB" "TDB";
+"fC" fdep "NEC" "TAC" "TBC" "TCC" "TDC";
+"fD" fdep "NED" "TAS" "TBS" "TCS" "TDS";
+
+
+"NEA" lambda=0.017 dorm=1;
+"NEB" lambda=0.017 dorm=1;
+"NEC" lambda=0.017 dorm=1;
+"NED" lambda=0.017 dorm=1;
+
+"TAA" lambda=0.11 dorm=0;
+"TAB" lambda=0.11 dorm=0;
+"TAC" lambda=0.11 dorm=0;
+"TAS" lambda=0.11 dorm=0;
+
+"TBA" lambda=0.11 dorm=0;
+"TBB" lambda=0.11 dorm=0;
+"TBC" lambda=0.11 dorm=0;
+"TBS" lambda=0.11 dorm=0;
+
+"TCA" lambda=0.11 dorm=0;
+"TCB" lambda=0.11 dorm=0;
+"TCC" lambda=0.11 dorm=0;
+"TCS" lambda=0.11 dorm=0;
+
+"TDA" lambda=0.11 dorm=0;
+"TDB" lambda=0.11 dorm=0;
+"TDC" lambda=0.11 dorm=0;
+"TDS" lambda=0.11 dorm=0;

From 4ece7e45a9a02f3f3b1388cd6a3b63662f6a645f Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 8 Feb 2016 17:15:09 +0100
Subject: [PATCH 063/246] Added assertions

Former-commit-id: c84ad697299c03af471654a2f71431cf9365d136
---
 src/builder/ExplicitDFTModelBuilder.cpp | 4 ++++
 src/storage/dft/DFT.cpp                 | 5 +++--
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 9332044f2..8fab93b8b 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -1,6 +1,7 @@
 #include "src/builder/ExplicitDFTModelBuilder.h"
 #include <src/models/sparse/Ctmc.h>
 #include <src/utility/constants.h>
+#include <src/exceptions/UnexpectedException.h>
 #include <map>
 
 namespace storm {
@@ -32,6 +33,7 @@ namespace storm {
             // Build transition matrix
             modelComponents.transitionMatrix = transitionMatrixBuilder.build();
             STORM_LOG_DEBUG("TransitionMatrix: " << std::endl << modelComponents.transitionMatrix);
+            assert(modelComponents.transitionMatrix.getRowCount() == modelComponents.transitionMatrix.getColumnCount());
 
             // Build state labeling
             modelComponents.stateLabeling = storm::models::sparse::StateLabeling(mStates.size());
@@ -90,6 +92,8 @@ namespace storm {
                     STORM_LOG_TRACE("Added self loop for " << state->getId());
                     // No further exploration required
                     continue;
+                } else {
+                    STORM_LOG_THROW(state->nrFailableBEs() > 0, storm::exceptions::UnexpectedException, "State " << state->getId() << " is no target state but behaves like one");
                 }
 
                 // Let BE fail
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index c36f0a9e0..49c92e05a 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -133,10 +133,11 @@ namespace storm {
             for (auto const& elem : mElements) {
                 stream << state->getElementStateInt(elem->id());
                 if(elem->isSpareGate()) {
+                    stream << "[";
                     if(state->isActiveSpare(elem->id())) {
-                        stream << " actively";
+                        stream << "actively ";
                     }
-                    stream << " using " << state->uses(elem->id());
+                    stream << "using " << state->uses(elem->id()) << "]";
                 }
             }
             return stream.str();

From 8896bc55ddd11bb3b52dd4134e34e75df8257c02 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 8 Feb 2016 17:50:59 +0100
Subject: [PATCH 064/246] Added probabilities for FDeps

Former-commit-id: c679ebb321d742dea13ceb88cea687e46e48fc75
---
 src/parser/DFTGalileoParser.cpp |  2 +-
 src/storage/dft/DFTBuilder.h    | 12 ++++++++++--
 src/storage/dft/DFTElements.h   | 12 ++++++++++--
 3 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index d623821e6..d56899d20 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -107,7 +107,7 @@ namespace storm {
                     } else if (tokens[1] == "wsp" || tokens[1] == "csp") {
                         success = builder.addSpareElement(name, childNames);
                     } else if (boost::starts_with(tokens[1], "fdep")) {
-                        success = builder.addFDepElement(name, childNames);
+                        success = builder.addFDepElement(name, childNames, storm::utility::one<ValueType>());
                     } else if (boost::starts_with(tokens[1], "lambda=")) {
                         ValueType failureRate = parseRationalExpression(tokens[1].substr(7));
                         ValueType dormancyFactor = parseRationalExpression(tokens[2].substr(5));
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index 9dfb80ac2..8fc65b0b5 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -53,13 +53,21 @@ namespace storm {
                 return addStandardGate(name, children, DFTElementTypes::SPARE);
             }
             
-            bool addFDepElement(std::string const& name, std::vector<std::string> const& children) {
+            bool addFDepElement(std::string const& name, std::vector<std::string> const& children, ValueType probability) {
                 assert(children.size() > 1);
                 if(mElements.count(name) != 0) {
                     // Element with that name already exists.
                     return false;
                 }
                 std::string trigger = children[0];
+
+                //TODO Matthias: collect constraints for SMT solving
+                //0 <= probability <= 1
+                if (!storm::utility::isOne(probability) && children.size() > 2) {
+                    //TODO Matthias: introduce additional element for probability and then add fdeps with probability 1 to children
+                    std::cerr << "Probability != 1 currently not supported." << std::endl;
+                }
+
                 for (size_t i = 1; i < children.size(); ++i) {
                     // TODO Matthias: better code
                     std::stringstream stream;
@@ -69,7 +77,7 @@ namespace storm {
                         // Element with that name already exists.
                         return false;
                     }
-                    DFTDependencyPointer element = std::make_shared<DFTDependency<ValueType>>(mNextId++, s, trigger, children[i]);
+                    DFTDependencyPointer element = std::make_shared<DFTDependency<ValueType>>(mNextId++, s, trigger, children[i], storm::utility::one<ValueType>());
                     mElements[element->name()] = element;
                     mDependencies.push_back(element);
                 }
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index d8f9e19b1..063a8a414 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -371,12 +371,13 @@ namespace storm {
         protected:
             std::string mNameTrigger;
             std::string mNameDependent;
+            ValueType mProbability;
             DFTGatePointer mTriggerEvent;
             DFTBEPointer mDependentEvent;
 
         public:
-            DFTDependency(size_t id, std::string const& name, std::string const& trigger, std::string const& dependent) :
-                DFTElement<ValueType>(id, name), mNameTrigger(trigger), mNameDependent(dependent)
+            DFTDependency(size_t id, std::string const& name, std::string const& trigger, std::string const& dependent, ValueType probability) :
+                DFTElement<ValueType>(id, name), mNameTrigger(trigger), mNameDependent(dependent), mProbability(probability)
             {
             }
 
@@ -397,6 +398,10 @@ namespace storm {
                 return mNameDependent;
             }
 
+            ValueType probability() {
+                return mProbability;
+            }
+
             DFTGatePointer const& triggerEvent() const {
                 assert(mTriggerEvent);
                 return mTriggerEvent;
@@ -427,6 +432,9 @@ namespace storm {
             virtual std::string toString() const override {
                 std::stringstream stream;
                 stream << "{" << this->name() << "} FDEP(" << mTriggerEvent->name() << " => " << mDependentEvent->name() << ")";
+                if (!storm::utility::isOne(mProbability)) {
+                    stream << " with probability " << mProbability;
+                }
                 return stream.str();
             }
 

From d507eab7f38003d652c17e18ec5eccd86a87645a Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 9 Feb 2016 09:42:57 +0100
Subject: [PATCH 065/246] Build Markov Automaton instead of CTMC

Former-commit-id: 26c299ad345d562542841ae288c80cdc693e238c
---
 src/builder/ExplicitDFTModelBuilder.cpp | 41 +++++++++++++++----------
 src/builder/ExplicitDFTModelBuilder.h   | 13 +++++---
 src/storage/dft/DFTBuilder.h            |  9 ++----
 src/storm-dyftee.cpp                    | 18 +++++------
 4 files changed, 45 insertions(+), 36 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 8fab93b8b..d4de53d64 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -1,5 +1,5 @@
 #include "src/builder/ExplicitDFTModelBuilder.h"
-#include <src/models/sparse/Ctmc.h>
+#include <src/models/sparse/MarkovAutomaton.h>
 #include <src/utility/constants.h>
 #include <src/exceptions/UnexpectedException.h>
 #include <map>
@@ -7,13 +7,13 @@
 namespace storm {
     namespace builder {
 
-        template <typename ValueType, typename RewardModelType, typename IndexType>
-        ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::ModelComponents::ModelComponents() : transitionMatrix(), stateLabeling(), rewardModels(), choiceLabeling() {
+        template <typename ValueType>
+        ExplicitDFTModelBuilder<ValueType>::ModelComponents::ModelComponents() : transitionMatrix(), stateLabeling(), markovianStates(), exitRates(), choiceLabeling() {
             // Intentionally left empty.
         }
 
-        template<typename ValueType, typename RewardModelType, typename IndexType>
-        std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>> ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::buildCTMC() {
+        template <typename ValueType>
+        std::shared_ptr<storm::models::sparse::Model<ValueType>> ExplicitDFTModelBuilder<ValueType>::buildMA() {
             // Initialize
             DFTStatePointer state = std::make_shared<storm::storage::DFTState<ValueType>>(mDft, newIndex++);
             mStates.findOrAdd(state->status(), state);
@@ -21,15 +21,17 @@ namespace storm {
             std::queue<DFTStatePointer> stateQueue;
             stateQueue.push(state);
 
-            bool deterministicModel = true;
+            bool deterministicModel = false;
+            ModelComponents modelComponents;
+            std::vector<uint_fast64_t> tmpMarkovianStates;
             storm::storage::SparseMatrixBuilder<ValueType> transitionMatrixBuilder(0, 0, 0, false, !deterministicModel, 0);
 
             // Begin model generation
-            exploreStates(stateQueue, transitionMatrixBuilder);
+            exploreStates(stateQueue, transitionMatrixBuilder, tmpMarkovianStates, modelComponents.exitRates);
             STORM_LOG_DEBUG("Generated " << mStates.size() << " states");
 
-            // Build CTMC
-            ModelComponents modelComponents;
+            // Build Markov Automaton
+            modelComponents.markovianStates = storm::storage::BitVector(mStates.size(), tmpMarkovianStates);
             // Build transition matrix
             modelComponents.transitionMatrix = transitionMatrixBuilder.build();
             STORM_LOG_DEBUG("TransitionMatrix: " << std::endl << modelComponents.transitionMatrix);
@@ -65,15 +67,17 @@ namespace storm {
                 }
             }
 
-            std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>> model;
-            model = std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>>(new storm::models::sparse::Ctmc<ValueType, RewardModelType>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling)));
+            std::shared_ptr<storm::models::sparse::Model<ValueType>> model = std::make_shared<storm::models::sparse::MarkovAutomaton<ValueType>>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.markovianStates), std::move(modelComponents.exitRates));
             model->printModelInformationToStream(std::cout);
             return model;
         }
 
-        template<typename ValueType, typename RewardModelType, typename IndexType>
-        void ExplicitDFTModelBuilder<ValueType, RewardModelType, IndexType>::exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder) {
+        template <typename ValueType>
+        void ExplicitDFTModelBuilder<ValueType>::exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates) {
 
+            assert(exitRates.empty());
+            assert(markovianStates.empty());
+            // TODO Matthias: set Markovian states
             std::map<size_t, ValueType> outgoingTransitions;
 
             while (!stateQueue.empty()) {
@@ -90,6 +94,8 @@ namespace storm {
                 if (mDft.hasFailed(state) || mDft.isFailsafe(state)) {
                     transitionMatrixBuilder.addNextValue(state->getId(), state->getId(), storm::utility::one<ValueType>());
                     STORM_LOG_TRACE("Added self loop for " << state->getId());
+                    exitRates.push_back(storm::utility::one<ValueType>());
+                    assert(exitRates.size()-1 == state->getId());
                     // No further exploration required
                     continue;
                 } else {
@@ -169,20 +175,23 @@ namespace storm {
                 } // end while failing BE
 
                 // Add all transitions
+                ValueType exitRate = storm::utility::zero<ValueType>();
                 for (auto it = outgoingTransitions.begin(); it != outgoingTransitions.end(); ++it)
                 {
                     transitionMatrixBuilder.addNextValue(state->getId(), it->first, it->second);
+                    exitRate += it->second;
                 }
+                exitRates.push_back(exitRate);
+                assert(exitRates.size()-1 == state->getId());
 
             } // end while queue
         }
 
         // Explicitly instantiate the class.
-        template class ExplicitDFTModelBuilder<double, storm::models::sparse::StandardRewardModel<double>, uint32_t>;
+        template class ExplicitDFTModelBuilder<double>;
 
 #ifdef STORM_HAVE_CARL
-        template class ExplicitDFTModelBuilder<double, storm::models::sparse::StandardRewardModel<storm::Interval>, uint32_t>;
-        template class ExplicitDFTModelBuilder<RationalFunction, storm::models::sparse::StandardRewardModel<RationalFunction>, uint32_t>;
+        template class ExplicitDFTModelBuilder<storm::RationalFunction>;
 #endif
 
     } // namespace builder
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index ed02e60d4..edb2e1a94 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -16,7 +16,7 @@
 namespace storm {
     namespace builder {
 
-        template<typename ValueType, typename RewardModelType = storm::models::sparse::StandardRewardModel<ValueType>, typename IndexType = uint32_t>
+        template<typename ValueType>
         class ExplicitDFTModelBuilder {
 
             using DFTElementPointer = std::shared_ptr<storm::storage::DFTElement<ValueType>>;
@@ -33,8 +33,11 @@ namespace storm {
                 // The state labeling.
                 storm::models::sparse::StateLabeling stateLabeling;
 
-                // The reward models associated with the model.
-                std::unordered_map<std::string, storm::models::sparse::StandardRewardModel<typename RewardModelType::ValueType>> rewardModels;
+                // The Markovian states.
+                storm::storage::BitVector markovianStates;
+
+                // The exit rates.
+                std::vector<ValueType> exitRates;
 
                 // A vector that stores a labeling for each choice.
                 boost::optional<std::vector<boost::container::flat_set<uint_fast64_t>>> choiceLabeling;
@@ -50,10 +53,10 @@ namespace storm {
                 // 2^nrBE is upper bound for state space
             }
 
-            std::shared_ptr<storm::models::sparse::Model<ValueType, RewardModelType>> buildCTMC();
+            std::shared_ptr<storm::models::sparse::Model<ValueType>> buildMA();
 
         private:
-            void exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder);
+            void exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates);
 
         };
     }
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index 8fc65b0b5..9297d90cf 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -69,15 +69,12 @@ namespace storm {
                 }
 
                 for (size_t i = 1; i < children.size(); ++i) {
-                    // TODO Matthias: better code
-                    std::stringstream stream;
-                    stream << name << "_" << i;
-                    std::string s = stream.str();
-                    if(mElements.count(s) != 0) {
+                    std::string nameFdep = name + "_" + std::to_string(i);
+                    if(mElements.count(nameFdep) != 0) {
                         // Element with that name already exists.
                         return false;
                     }
-                    DFTDependencyPointer element = std::make_shared<DFTDependency<ValueType>>(mNextId++, s, trigger, children[i], storm::utility::one<ValueType>());
+                    DFTDependencyPointer element = std::make_shared<DFTDependency<ValueType>>(mNextId++, nameFdep, trigger, children[i], storm::utility::one<ValueType>());
                     mElements[element->name()] = element;
                     mDependencies.push_back(element);
                 }
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 4986469e7..a86347e3b 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -6,7 +6,7 @@
 #include "utility/storm.h"
 
 /*!
- * Load DFT from filename, build corresponding CTMC and check against given property.
+ * Load DFT from filename, build corresponding Markov Automaton and check against given property.
  *
  * @param filename Path to DFT file in Galileo format.
  * @param property PCTC formula capturing the property to check.
@@ -19,21 +19,21 @@ void analyzeDFT(std::string filename, std::string property) {
     storm::storage::DFT<ValueType> dft = parser.parseDFT(filename);
     std::cout << "Built data structure" << std::endl;
 
-    // Building CTMC
-    std::cout << "Building CTMC..." << std::endl;
+    // Building Markov Automaton
+    std::cout << "Building Markov Automaton..." << std::endl;
     storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft);
-    std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildCTMC();
-    std::cout << "Built CTMC" << std::endl;
+    std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildMA();
+    std::cout << "Built Markov Automaton" << std::endl;
 
     // Model checking
     std::cout << "Model checking..." << std::endl;
     std::vector<std::shared_ptr<storm::logic::Formula>> formulas = storm::parseFormulasForExplicit(property);
     assert(formulas.size() == 1);
-    std::unique_ptr<storm::modelchecker::CheckResult> resultCtmc(storm::verifySparseModel(model, formulas[0]));
-    assert(resultCtmc);
+    std::unique_ptr<storm::modelchecker::CheckResult> resultMA(storm::verifySparseModel(model, formulas[0]));
+    assert(resultMA);
     std::cout << "Result: ";
-    resultCtmc->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
-    std::cout << *resultCtmc << std::endl;
+    resultMA->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
+    std::cout << *resultMA << std::endl;
 }
 
 /*!

From 32c52d227141fa5caf37b26ae816730722db5e0a Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 9 Feb 2016 11:12:20 +0100
Subject: [PATCH 066/246] Parse PDEPs

Former-commit-id: 623afd494f3b5ba6ce0453416922bf4bd2dc1daa
---
 examples/dft/pdep.dft           | 12 ++++++++++++
 src/parser/DFTGalileoParser.cpp |  7 +++++--
 src/storage/dft/DFTBuilder.h    | 20 ++++++++++++++------
 src/storage/dft/DFTElements.h   |  5 +++--
 4 files changed, 34 insertions(+), 10 deletions(-)
 create mode 100644 examples/dft/pdep.dft

diff --git a/examples/dft/pdep.dft b/examples/dft/pdep.dft
new file mode 100644
index 000000000..f8cb0382b
--- /dev/null
+++ b/examples/dft/pdep.dft
@@ -0,0 +1,12 @@
+// From Junges2015
+// Example 3.19
+
+toplevel "SF";
+"SF" or "A" "B" "PDEP";
+"A" pand "S" "MA";
+"B" and "MA" "MB";
+"PDEP" pdep=0.2 "MA" "S";
+
+"S" lambda=0.5 dorm=0;
+"MA" lambda=0.5 dorm=0;
+"MB" lambda=0.5 dorm=0;
diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index 262098a68..c8639ae30 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -106,8 +106,11 @@ namespace storm {
                         success = builder.addPandElement(name, childNames);
                     } else if (tokens[1] == "wsp" || tokens[1] == "csp") {
                         success = builder.addSpareElement(name, childNames);
-                    } else if (boost::starts_with(tokens[1], "fdep")) {
-                        success = builder.addFDepElement(name, childNames, storm::utility::one<ValueType>());
+                    } else if (tokens[1] == "fdep") {
+                        success = builder.addDepElement(name, childNames, storm::utility::one<ValueType>());
+                    } else if (boost::starts_with(tokens[1], "pdep=")) {
+                        ValueType probability = parseRationalExpression(tokens[1].substr(5));
+                        success = builder.addDepElement(name, childNames, probability);
                     } else if (boost::starts_with(tokens[1], "lambda=")) {
                         ValueType failureRate = parseRationalExpression(tokens[1].substr(7));
                         ValueType dormancyFactor = parseRationalExpression(tokens[2].substr(5));
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index 9297d90cf..a2422522c 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -53,28 +53,36 @@ namespace storm {
                 return addStandardGate(name, children, DFTElementTypes::SPARE);
             }
             
-            bool addFDepElement(std::string const& name, std::vector<std::string> const& children, ValueType probability) {
+            bool addDepElement(std::string const& name, std::vector<std::string> const& children, ValueType probability) {
                 assert(children.size() > 1);
                 if(mElements.count(name) != 0) {
                     // Element with that name already exists.
                     return false;
                 }
+
+                if (storm::utility::isZero(probability)) {
+                    // Element is superfluous
+                    return true;
+                }
                 std::string trigger = children[0];
 
                 //TODO Matthias: collect constraints for SMT solving
                 //0 <= probability <= 1
                 if (!storm::utility::isOne(probability) && children.size() > 2) {
-                    //TODO Matthias: introduce additional element for probability and then add fdeps with probability 1 to children
-                    std::cerr << "Probability != 1 currently not supported." << std::endl;
+                    //TODO Matthias: introduce additional element for probability and then add pdeps with probability 1 to children
+                    std::cerr << "Probability != 1 for more than one child currently not supported." << std::endl;
+                    return false;
                 }
 
                 for (size_t i = 1; i < children.size(); ++i) {
-                    std::string nameFdep = name + "_" + std::to_string(i);
-                    if(mElements.count(nameFdep) != 0) {
+                    std::string nameDep = name + "_" + std::to_string(i);
+                    if(mElements.count(nameDep) != 0) {
                         // Element with that name already exists.
+                        std::cerr << "Element with name: " << nameDep << " already exists." << std::endl;
                         return false;
                     }
-                    DFTDependencyPointer element = std::make_shared<DFTDependency<ValueType>>(mNextId++, nameFdep, trigger, children[i], storm::utility::one<ValueType>());
+                    assert(storm::utility::isOne(probability) || children.size() == 2);
+                    DFTDependencyPointer element = std::make_shared<DFTDependency<ValueType>>(mNextId++, nameDep, trigger, children[i], probability);
                     mElements[element->name()] = element;
                     mDependencies.push_back(element);
                 }
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 063a8a414..9dcc42b8d 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -431,8 +431,9 @@ namespace storm {
 
             virtual std::string toString() const override {
                 std::stringstream stream;
-                stream << "{" << this->name() << "} FDEP(" << mTriggerEvent->name() << " => " << mDependentEvent->name() << ")";
-                if (!storm::utility::isOne(mProbability)) {
+                bool fdep = storm::utility::isOne(mProbability);
+                stream << "{" << this->name() << "} " << (fdep ? "FDEP" : "PDEP") << "(" << mTriggerEvent->name() << " => " << mDependentEvent->name() << ")";
+                if (!fdep) {
                     stream << " with probability " << mProbability;
                 }
                 return stream.str();

From 35f5f9de1529b780a2c21b00b695d80f2de0dc72 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 9 Feb 2016 11:42:07 +0100
Subject: [PATCH 067/246] Small refactoring

Former-commit-id: 102054c6043d08de0caf3db6db0ee85684aa1c98
---
 src/builder/ExplicitDFTModelBuilder.cpp |  3 ++-
 src/builder/ExplicitDFTModelBuilder.h   |  2 +-
 src/storm-dyftee.cpp                    | 16 ++++++++--------
 3 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index d4de53d64..1bfc445e7 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -1,5 +1,6 @@
 #include "src/builder/ExplicitDFTModelBuilder.h"
 #include <src/models/sparse/MarkovAutomaton.h>
+#include <src/models/sparse/CTMC.h>
 #include <src/utility/constants.h>
 #include <src/exceptions/UnexpectedException.h>
 #include <map>
@@ -13,7 +14,7 @@ namespace storm {
         }
 
         template <typename ValueType>
-        std::shared_ptr<storm::models::sparse::Model<ValueType>> ExplicitDFTModelBuilder<ValueType>::buildMA() {
+        std::shared_ptr<storm::models::sparse::Model<ValueType>> ExplicitDFTModelBuilder<ValueType>::buildModel() {
             // Initialize
             DFTStatePointer state = std::make_shared<storm::storage::DFTState<ValueType>>(mDft, newIndex++);
             mStates.findOrAdd(state->status(), state);
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index edb2e1a94..b2d27aadd 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -53,7 +53,7 @@ namespace storm {
                 // 2^nrBE is upper bound for state space
             }
 
-            std::shared_ptr<storm::models::sparse::Model<ValueType>> buildMA();
+            std::shared_ptr<storm::models::sparse::Model<ValueType>> buildModel();
 
         private:
             void exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates);
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index a86347e3b..a8122f2bd 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -6,7 +6,7 @@
 #include "utility/storm.h"
 
 /*!
- * Load DFT from filename, build corresponding Markov Automaton and check against given property.
+ * Load DFT from filename, build corresponding Model and check against given property.
  *
  * @param filename Path to DFT file in Galileo format.
  * @param property PCTC formula capturing the property to check.
@@ -20,20 +20,20 @@ void analyzeDFT(std::string filename, std::string property) {
     std::cout << "Built data structure" << std::endl;
 
     // Building Markov Automaton
-    std::cout << "Building Markov Automaton..." << std::endl;
+    std::cout << "Building Model..." << std::endl;
     storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft);
-    std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildMA();
-    std::cout << "Built Markov Automaton" << std::endl;
+    std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildModel();
+    std::cout << "Built Model" << std::endl;
 
     // Model checking
     std::cout << "Model checking..." << std::endl;
     std::vector<std::shared_ptr<storm::logic::Formula>> formulas = storm::parseFormulasForExplicit(property);
     assert(formulas.size() == 1);
-    std::unique_ptr<storm::modelchecker::CheckResult> resultMA(storm::verifySparseModel(model, formulas[0]));
-    assert(resultMA);
+    std::unique_ptr<storm::modelchecker::CheckResult> result(storm::verifySparseModel(model, formulas[0]));
+    assert(result);
     std::cout << "Result: ";
-    resultMA->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
-    std::cout << *resultMA << std::endl;
+    result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
+    std::cout << *result << std::endl;
 }
 
 /*!

From 46642f2bcad04e386e16bc6e5503ec585936ee28 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 9 Feb 2016 13:11:57 +0100
Subject: [PATCH 068/246] CTMCs are working again

Former-commit-id: 259bfefa547dec09cf82849b9a1bbc525aff4c4b
---
 src/builder/ExplicitDFTModelBuilder.cpp | 53 ++++++++++++++++++++-----
 src/builder/ExplicitDFTModelBuilder.h   |  2 +-
 2 files changed, 45 insertions(+), 10 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 1bfc445e7..30ed5fcbe 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -28,14 +28,23 @@ namespace storm {
             storm::storage::SparseMatrixBuilder<ValueType> transitionMatrixBuilder(0, 0, 0, false, !deterministicModel, 0);
 
             // Begin model generation
-            exploreStates(stateQueue, transitionMatrixBuilder, tmpMarkovianStates, modelComponents.exitRates);
+            bool deterministic = exploreStates(stateQueue, transitionMatrixBuilder, tmpMarkovianStates, modelComponents.exitRates);
             STORM_LOG_DEBUG("Generated " << mStates.size() << " states");
+            STORM_LOG_DEBUG("Model is " << (deterministic ? "deterministic" : "non-deterministic"));
 
             // Build Markov Automaton
             modelComponents.markovianStates = storm::storage::BitVector(mStates.size(), tmpMarkovianStates);
             // Build transition matrix
             modelComponents.transitionMatrix = transitionMatrixBuilder.build();
-            STORM_LOG_DEBUG("TransitionMatrix: " << std::endl << modelComponents.transitionMatrix);
+            STORM_LOG_DEBUG("Transition matrix: " << std::endl << modelComponents.transitionMatrix);
+            // TODO: easier output for vectors
+            std::stringstream stream;
+            for (uint_fast64_t i = 0; i < modelComponents.exitRates.size() - 1; ++i) {
+                stream << modelComponents.exitRates[i] << ", ";
+            }
+            stream << modelComponents.exitRates.back();
+            STORM_LOG_DEBUG("Exit rates: " << stream.str());
+            STORM_LOG_DEBUG("Markovian states: " << modelComponents.markovianStates);
             assert(modelComponents.transitionMatrix.getRowCount() == modelComponents.transitionMatrix.getColumnCount());
 
             // Build state labeling
@@ -68,22 +77,42 @@ namespace storm {
                 }
             }
 
-            std::shared_ptr<storm::models::sparse::Model<ValueType>> model = std::make_shared<storm::models::sparse::MarkovAutomaton<ValueType>>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.markovianStates), std::move(modelComponents.exitRates));
+            std::shared_ptr<storm::models::sparse::Model<ValueType>> model;
+            if (deterministic) {
+                // Turn the probabilities into rates by multiplying each row with the exit rate of the state.
+                // TODO Matthias: avoid transforming back and forth
+                storm::storage::SparseMatrix<ValueType> rateMatrix(modelComponents.transitionMatrix);
+                for (uint_fast64_t row = 0; row < rateMatrix.getRowCount(); ++row) {
+                    for (auto& entry : rateMatrix.getRow(row)) {
+                        entry.setValue(entry.getValue() * modelComponents.exitRates[row]);
+                    }
+                }
+
+                model = std::make_shared<storm::models::sparse::Ctmc<ValueType>>(std::move(rateMatrix), std::move(modelComponents.stateLabeling));
+            } else {
+                model = std::make_shared<storm::models::sparse::MarkovAutomaton<ValueType>>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.markovianStates), std::move(modelComponents.exitRates));
+
+            }
             model->printModelInformationToStream(std::cout);
             return model;
         }
 
         template <typename ValueType>
-        void ExplicitDFTModelBuilder<ValueType>::exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates) {
+        bool ExplicitDFTModelBuilder<ValueType>::exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates) {
 
             assert(exitRates.empty());
             assert(markovianStates.empty());
-            // TODO Matthias: set Markovian states
+            // TODO Matthias: set Markovian states directly as bitvector?
             std::map<size_t, ValueType> outgoingTransitions;
+            size_t rowOffset = 0; // Captures number of non-deterministic choices
+            ValueType exitRate;
+            bool deterministic = true;
+            //TODO Matthias: Handle dependencies!
 
             while (!stateQueue.empty()) {
                 // Initialization
                 outgoingTransitions.clear();
+                exitRate = storm::utility::zero<ValueType>();
 
                 // Consider next state
                 DFTStatePointer state = stateQueue.front();
@@ -93,10 +122,12 @@ namespace storm {
 
                 // Add self loop for target states
                 if (mDft.hasFailed(state) || mDft.isFailsafe(state)) {
-                    transitionMatrixBuilder.addNextValue(state->getId(), state->getId(), storm::utility::one<ValueType>());
+                    transitionMatrixBuilder.newRowGroup(state->getId() + rowOffset);
+                    transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, state->getId(), storm::utility::one<ValueType>());
                     STORM_LOG_TRACE("Added self loop for " << state->getId());
                     exitRates.push_back(storm::utility::one<ValueType>());
                     assert(exitRates.size()-1 == state->getId());
+                    markovianStates.push_back(state->getId());
                     // No further exploration required
                     continue;
                 } else {
@@ -173,19 +204,23 @@ namespace storm {
                         outgoingTransitions.insert(std::make_pair(newState->getId(), rate));
                         STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newState->getId() << " with " << rate);
                     }
+                    exitRate += rate;
+
                 } // end while failing BE
 
                 // Add all transitions
-                ValueType exitRate = storm::utility::zero<ValueType>();
+                transitionMatrixBuilder.newRowGroup(state->getId() + rowOffset);
                 for (auto it = outgoingTransitions.begin(); it != outgoingTransitions.end(); ++it)
                 {
-                    transitionMatrixBuilder.addNextValue(state->getId(), it->first, it->second);
-                    exitRate += it->second;
+                    ValueType probability = it->second / exitRate; // Transform rate to probability
+                    transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, it->first, probability);
                 }
                 exitRates.push_back(exitRate);
                 assert(exitRates.size()-1 == state->getId());
+                markovianStates.push_back(state->getId());
 
             } // end while queue
+            return deterministic;
         }
 
         // Explicitly instantiate the class.
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index b2d27aadd..6125b6fa1 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -56,7 +56,7 @@ namespace storm {
             std::shared_ptr<storm::models::sparse::Model<ValueType>> buildModel();
 
         private:
-            void exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates);
+            bool exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates);
 
         };
     }

From 24cd1ec597be2d81bd7566cf3c2beeddf9e9234d Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 9 Feb 2016 14:01:04 +0100
Subject: [PATCH 069/246] Vector output without template seems to work

Former-commit-id: 3627729e256d2d14ebd20781fa89a86d2b350776
---
 src/builder/ExplicitDFTModelBuilder.cpp | 9 ++-------
 src/utility/vector.cpp                  | 9 +++++----
 src/utility/vector.h                    | 6 ++++--
 3 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 30ed5fcbe..0bd92b069 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -2,6 +2,7 @@
 #include <src/models/sparse/MarkovAutomaton.h>
 #include <src/models/sparse/CTMC.h>
 #include <src/utility/constants.h>
+#include <src/utility/vector.h>
 #include <src/exceptions/UnexpectedException.h>
 #include <map>
 
@@ -37,13 +38,7 @@ namespace storm {
             // Build transition matrix
             modelComponents.transitionMatrix = transitionMatrixBuilder.build();
             STORM_LOG_DEBUG("Transition matrix: " << std::endl << modelComponents.transitionMatrix);
-            // TODO: easier output for vectors
-            std::stringstream stream;
-            for (uint_fast64_t i = 0; i < modelComponents.exitRates.size() - 1; ++i) {
-                stream << modelComponents.exitRates[i] << ", ";
-            }
-            stream << modelComponents.exitRates.back();
-            STORM_LOG_DEBUG("Exit rates: " << stream.str());
+            STORM_LOG_DEBUG("Exit rates: " << modelComponents.exitRates);
             STORM_LOG_DEBUG("Markovian states: " << modelComponents.markovianStates);
             assert(modelComponents.transitionMatrix.getRowCount() == modelComponents.transitionMatrix.getColumnCount());
 
diff --git a/src/utility/vector.cpp b/src/utility/vector.cpp
index e4a1dd05c..20af3c628 100644
--- a/src/utility/vector.cpp
+++ b/src/utility/vector.cpp
@@ -1,7 +1,8 @@
 #include "src/utility/vector.h"
 
-template<typename ValueType>
-std::ostream& operator<<(std::ostream& out, std::vector<ValueType> const& vector) {
+//template<typename ValueType>
+//std::ostream& operator<<(std::ostream& out, std::vector<ValueType> const& vector) {
+std::ostream& operator<<(std::ostream& out, std::vector<double> const& vector) {
     out << "vector (" << vector.size() << ") [ ";
     for (uint_fast64_t i = 0; i < vector.size() - 1; ++i) {
         out << vector[i] << ", ";
@@ -12,5 +13,5 @@ std::ostream& operator<<(std::ostream& out, std::vector<ValueType> const& vector
 }
 
 // Explicitly instantiate functions.
-template std::ostream& operator<<(std::ostream& out, std::vector<double> const& vector);
-template std::ostream& operator<<(std::ostream& out, std::vector<uint_fast64_t> const& vector);
+//template std::ostream& operator<<(std::ostream& out, std::vector<double> const& vector);
+//template std::ostream& operator<<(std::ostream& out, std::vector<uint_fast64_t> const& vector);
\ No newline at end of file
diff --git a/src/utility/vector.h b/src/utility/vector.h
index 665569645..6b09f0467 100644
--- a/src/utility/vector.h
+++ b/src/utility/vector.h
@@ -15,8 +15,10 @@
 #include "src/utility/macros.h"
 #include "src/solver/OptimizationDirection.h"
 
-template<typename ValueType>
-std::ostream& operator<<(std::ostream& out, std::vector<ValueType> const& vector);
+// Template was causing problems as Carl has the same function
+//template<typename ValueType>
+//std::ostream& operator<<(std::ostream& out, std::vector<ValueType> const& vector);
+std::ostream& operator<<(std::ostream& out, std::vector<double> const& vector);
 
 namespace storm {
     namespace utility {

From 87e51e04b5ea492af71df15544f66b2ee398f7af Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 9 Feb 2016 14:01:35 +0100
Subject: [PATCH 070/246] Improved benchmark script

Former-commit-id: 78f0d49a03b3f6157e7c56577dfe0bd58d00bb0f
---
 benchmark_dft.py | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/benchmark_dft.py b/benchmark_dft.py
index 1b8e29972..7fe59a276 100644
--- a/benchmark_dft.py
+++ b/benchmark_dft.py
@@ -13,10 +13,16 @@ EXAMPLE_DIR= "/Users/mvolk/develop/storm/examples/dft/"
 benchmarks = [ 
     ("and", False, [3, 1]),
     ("and_param", True, ["(4*x^2+2*x+1)/((x) * (2*x+1))", "1"]),
+    ("cardiac", False, [11378, 1]),
+    ("cas", False, [0.859736, 1]),
     ("cm2", False, [0.256272, 1]),
     #("cm4", False, [0, 1]),
     ("cps", False, ["inf", 0.333333]),
-    #("fdep", False, [0, 1]),
+    ("deathegg", False, [46.667, 1]),
+    ("fdep", False, [0.666667, 1]),
+    #("ftpp_complex", False, [0, 1]), # Compute
+    #("ftpp_large", False, [0, 1]), # Compute
+    #("ftpp_standard", False, [0, 1]), # Compute
     ("mdcs", False, [2.85414, 1]),
     ("mdcs2", False, [2.85414, 1]),
     ("mp", False, [1.66667, 1]),
@@ -59,8 +65,7 @@ def run_storm_dft(filename, prop, parametric, quiet):
     # Get result
     match = re.search(r'Result: \[(.*)\]', output)
     if not match:
-        print("No valid result found in: " + output)
-        return
+        return None
     
     result = match.group(1)
     return result
@@ -98,6 +103,10 @@ if __name__ == "__main__":
             if args.debuglevel > 0:
                 print("Running '{}' with property '{}'".format(benchmark, prop))
             result = run_storm_dft(benchmark, prop, parametric, args.debuglevel<2)
+            if result is None:
+                print("Error occurred on example '{}' with property '{}'".format(benchmark, prop))
+                continue
+
             if not parametric:
                 # Float
                 result = float(result)

From 64b24043c57c30efccac7892fb53e2f96071adaf Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 9 Feb 2016 18:08:20 +0100
Subject: [PATCH 071/246] Dependencies working

Former-commit-id: e262bfc5aa6631ce9c2b4c795b80922977faa90c
---
 src/builder/ExplicitDFTModelBuilder.cpp | 86 +++++++++++++++----------
 src/storage/dft/DFT.cpp                 |  6 +-
 src/storage/dft/DFT.h                   |  5 ++
 src/storage/dft/DFTState.cpp            | 38 +++++++++--
 src/storage/dft/DFTState.h              | 44 ++++++++++---
 5 files changed, 126 insertions(+), 53 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 0bd92b069..817295346 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -40,7 +40,7 @@ namespace storm {
             STORM_LOG_DEBUG("Transition matrix: " << std::endl << modelComponents.transitionMatrix);
             STORM_LOG_DEBUG("Exit rates: " << modelComponents.exitRates);
             STORM_LOG_DEBUG("Markovian states: " << modelComponents.markovianStates);
-            assert(modelComponents.transitionMatrix.getRowCount() == modelComponents.transitionMatrix.getColumnCount());
+            assert(!deterministic || modelComponents.transitionMatrix.getRowCount() == modelComponents.transitionMatrix.getColumnCount());
 
             // Build state labeling
             modelComponents.stateLabeling = storm::models::sparse::StateLabeling(mStates.size());
@@ -100,24 +100,26 @@ namespace storm {
             // TODO Matthias: set Markovian states directly as bitvector?
             std::map<size_t, ValueType> outgoingTransitions;
             size_t rowOffset = 0; // Captures number of non-deterministic choices
-            ValueType exitRate;
             bool deterministic = true;
-            //TODO Matthias: Handle dependencies!
 
             while (!stateQueue.empty()) {
                 // Initialization
                 outgoingTransitions.clear();
-                exitRate = storm::utility::zero<ValueType>();
+                ValueType exitRate = storm::utility::zero<ValueType>();
 
                 // Consider next state
                 DFTStatePointer state = stateQueue.front();
                 stateQueue.pop();
 
+                bool hasDependencies = state->nrFailableDependencies() > 0;
+                deterministic &= !hasDependencies;
+                size_t failableCount = hasDependencies ? state->nrFailableDependencies() : state->nrFailableBEs();
                 size_t smallest = 0;
 
+                transitionMatrixBuilder.newRowGroup(state->getId() + rowOffset);
+
                 // Add self loop for target states
                 if (mDft.hasFailed(state) || mDft.isFailsafe(state)) {
-                    transitionMatrixBuilder.newRowGroup(state->getId() + rowOffset);
                     transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, state->getId(), storm::utility::one<ValueType>());
                     STORM_LOG_TRACE("Added self loop for " << state->getId());
                     exitRates.push_back(storm::utility::one<ValueType>());
@@ -130,18 +132,21 @@ namespace storm {
                 }
 
                 // Let BE fail
-                while (smallest < state->nrFailableBEs()) {
+                while (smallest < failableCount) {
                     STORM_LOG_TRACE("exploring from: " << mDft.getStateString(state));
 
                     // Construct new state as copy from original one
                     DFTStatePointer newState = std::make_shared<storm::storage::DFTState<ValueType>>(*state);
                     std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType>>, bool> nextBEPair = newState->letNextBEFail(smallest++);
                     std::shared_ptr<storm::storage::DFTBE<ValueType>> nextBE = nextBEPair.first;
-                    if (nextBE == nullptr) {
-                        break;
-                    }
+                    assert(nextBE);
+                    assert(nextBEPair.second == hasDependencies);
                     STORM_LOG_TRACE("with the failure of: " << nextBE->name() << " [" << nextBE->id() << "]");
 
+                    // Update failable dependencies
+                    newState->updateFailableDependencies(nextBE->id());
+
+                    // Propagate failures
                     storm::storage::DFTStateSpaceGenerationQueues<ValueType> queues;
 
                     for (DFTGatePointer parent : nextBE->parents()) {
@@ -179,42 +184,53 @@ namespace storm {
                         stateQueue.push(newState);
                     }
 
-                    // Set failure rate according to usage
-                    bool isUsed = true;
-                    if (mDft.hasRepresentant(nextBE->id())) {
-                        DFTElementPointer representant = mDft.getRepresentant(nextBE->id());
-                        // Used must be checked for the state we are coming from as this state is responsible for the
-                        // rate and not the new state we are going to
-                        isUsed = state->isUsed(representant->id());
-                    }
-                    STORM_LOG_TRACE("BE " << nextBE->name() << " is " << (isUsed ? "used" : "not used"));
-                    ValueType rate = isUsed ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
-                    auto resultFind = outgoingTransitions.find(newState->getId());
-                    if (resultFind != outgoingTransitions.end()) {
-                        // Add to existing transition
-                        resultFind->second += rate;
-                        STORM_LOG_TRACE("Updated transition from " << state->getId() << " to " << resultFind->first << " with " << rate << " to " << resultFind->second);
+                    // Set transitions
+                    if (hasDependencies) {
+                        // Failure is due to dependency -> add non-deterministic choice
+                        transitionMatrixBuilder.addNextValue(state->getId() + rowOffset++, newState->getId(), storm::utility::one<ValueType>());
                     } else {
-                        // Insert new transition
-                        outgoingTransitions.insert(std::make_pair(newState->getId(), rate));
-                        STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newState->getId() << " with " << rate);
+                        // Set failure rate according to usage
+                        bool isUsed = true;
+                        if (mDft.hasRepresentant(nextBE->id())) {
+                            DFTElementPointer representant = mDft.getRepresentant(nextBE->id());
+                            // Used must be checked for the state we are coming from as this state is responsible for the
+                            // rate and not the new state we are going to
+                            isUsed = state->isUsed(representant->id());
+                        }
+                        STORM_LOG_TRACE("BE " << nextBE->name() << " is " << (isUsed ? "used" : "not used"));
+                        ValueType rate = isUsed ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
+                        auto resultFind = outgoingTransitions.find(newState->getId());
+                        if (resultFind != outgoingTransitions.end()) {
+                            // Add to existing transition
+                            resultFind->second += rate;
+                            STORM_LOG_TRACE("Updated transition from " << state->getId() << " to " << resultFind->first << " with " << rate << " to " << resultFind->second);
+                        } else {
+                            // Insert new transition
+                            outgoingTransitions.insert(std::make_pair(newState->getId(), rate));
+                            STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newState->getId() << " with " << rate);
+                        }
+                        exitRate += rate;
                     }
-                    exitRate += rate;
 
                 } // end while failing BE
 
-                // Add all transitions
-                transitionMatrixBuilder.newRowGroup(state->getId() + rowOffset);
-                for (auto it = outgoingTransitions.begin(); it != outgoingTransitions.end(); ++it)
-                {
-                    ValueType probability = it->second / exitRate; // Transform rate to probability
-                    transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, it->first, probability);
+                if (hasDependencies) {
+                    rowOffset--; // One increment to many
+                } else {
+                    // Add all probability transitions
+                    for (auto it = outgoingTransitions.begin(); it != outgoingTransitions.end(); ++it)
+                    {
+                        ValueType probability = it->second / exitRate; // Transform rate to probability
+                        transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, it->first, probability);
+                    }
+
+                    markovianStates.push_back(state->getId());
                 }
                 exitRates.push_back(exitRate);
                 assert(exitRates.size()-1 == state->getId());
-                markovianStates.push_back(state->getId());
 
             } // end while queue
+            assert(!deterministic || rowOffset == 0);
             return deterministic;
         }
 
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 112a9273b..1329cab38 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -11,13 +11,13 @@ namespace storm {
             size_t stateIndex = 0;
             mUsageInfoBits = storm::utility::math::uint64_log2(mElements.size()-1)+1;
 
-            for(auto& elem : mElements) {
+            for (auto& elem : mElements) {
                 mIdToFailureIndex.push_back(stateIndex);
                 stateIndex += 2;
                 if(elem->isBasicElement()) {
                     ++mNrOfBEs;
                 }
-                else if(elem->isSpareGate()) {
+                else if (elem->isSpareGate()) {
                     ++mNrOfSpares;
                     for(auto const& spareReprs : std::static_pointer_cast<DFTSpare<ValueType>>(elem)->children()) {
                         if(mActivationIndex.count(spareReprs->id()) == 0) {
@@ -39,6 +39,8 @@ namespace storm {
                     mUsageIndex.insert(std::make_pair(elem->id(), stateIndex));
                     stateIndex += mUsageInfoBits;
 
+                } else if (elem->isDependency()) {
+                    mDependencies.push_back(elem->id());
                 }
             }
 
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 2cfbf6422..cff6db0cb 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -51,6 +51,7 @@ namespace storm {
             size_t mStateSize;
             std::map<size_t, size_t> mActivationIndex;
             std::map<size_t, std::vector<size_t>> mSpareModules;
+            std::vector<size_t> mDependencies;
             std::vector<size_t> mTopModule;
             std::vector<size_t> mIdToFailureIndex;
             std::map<size_t, size_t> mUsageIndex;
@@ -120,6 +121,10 @@ namespace storm {
                 }
             }
             
+            std::vector<size_t> const& getDependencies() const {
+                return mDependencies;
+            }
+
             void propagateActivation(DFTState<ValueType>& state, size_t representativeId) const {
                 state.activate(representativeId);
                 for(size_t id : module(representativeId)) {
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index d760129e0..17bb4aee8 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -78,17 +78,41 @@ namespace storm {
             }
         }
 
+        template<typename ValueType>
+        bool DFTState<ValueType>::updateFailableDependencies(size_t id) {
+            assert(hasFailed(id));
+            for (size_t i = 0; i < mDft.getDependencies().size(); ++i) {
+                std::shared_ptr<DFTDependency<ValueType>> dependency = std::static_pointer_cast<DFTDependency<ValueType>>(mDft.getElement(mDft.getDependencies()[i]));
+                if (dependency->triggerEvent()->id() == id) {
+                    if (!hasFailed(dependency->dependentEvent()->id())) {
+                        mFailableDependencies.push_back(dependency->id());
+                        STORM_LOG_TRACE("New dependency failure: " << dependency->toString());
+                    }
+                }
+            }
+            return nrFailableDependencies() > 0;
+        }
+
         template<typename ValueType>
         std::pair<std::shared_ptr<DFTBE<ValueType>>, bool> DFTState<ValueType>::letNextBEFail(size_t index)
         {
-            assert(index < mIsCurrentlyFailableBE.size());
             STORM_LOG_TRACE("currently failable: " << getCurrentlyFailableString());
-            // TODO set when implementing functional dependencies
-            bool dueToFdep = false;
-            std::pair<std::shared_ptr<DFTBE<ValueType>>,bool> res(mDft.getBasicElement(mIsCurrentlyFailableBE[index]), dueToFdep);
-            mIsCurrentlyFailableBE.erase(mIsCurrentlyFailableBE.begin() + index);
-            setFailed(res.first->id());
-            return res;
+            if (nrFailableDependencies() > 0) {
+                // Consider failure due to dependency
+                assert(index < nrFailableDependencies());
+                std::shared_ptr<DFTDependency<ValueType>> dependency = std::static_pointer_cast<DFTDependency<ValueType>>(mDft.getElement(mFailableDependencies[index]));
+                std::pair<std::shared_ptr<DFTBE<ValueType>>,bool> res(mDft.getBasicElement(dependency->dependentEvent()->id()), true);
+                mFailableDependencies.erase(mFailableDependencies.begin() + index);
+                setFailed(res.first->id());
+                return res;
+            } else {
+                // Consider "normal" failure
+                assert(index < nrFailableBEs());
+                std::pair<std::shared_ptr<DFTBE<ValueType>>,bool> res(mDft.getBasicElement(mIsCurrentlyFailableBE[index]), false);
+                mIsCurrentlyFailableBE.erase(mIsCurrentlyFailableBE.begin() + index);
+                setFailed(res.first->id());
+                return res;
+            }
         }
 
         template<typename ValueType>
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index fed33eee3..a1bab2583 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -25,6 +25,7 @@ namespace storm {
             size_t mId;
             std::vector<size_t> mInactiveSpares;
             std::vector<size_t> mIsCurrentlyFailableBE;
+            std::vector<size_t> mFailableDependencies;
             std::vector<size_t> mUsedRepresentants;
             bool mValid = true;
             const DFT<ValueType>& mDft;
@@ -110,6 +111,17 @@ namespace storm {
                 return mIsCurrentlyFailableBE.size();
             }
 
+            size_t nrFailableDependencies() const {
+                return mFailableDependencies.size();
+            }
+
+            /**
+             * Sets all failable BEs due to dependencies from newly failed element
+             * @param id Id of the newly failed element
+             * @return true if failable dependent events exist
+             */
+            bool updateFailableDependencies(size_t id);
+
             /**
              * Sets the next BE as failed
              * @param smallestIndex Index in currentlyFailableBE of BE to fail
@@ -119,17 +131,31 @@ namespace storm {
             
             std::string getCurrentlyFailableString() const {
                 std::stringstream stream;
-                auto it = mIsCurrentlyFailableBE.begin();
-                stream << "{";
-                if(it != mIsCurrentlyFailableBE.end()) {
-                    stream << *it;
-                }
-                ++it;
-                while(it != mIsCurrentlyFailableBE.end()) {
-                    stream << ", " << *it;
+                if (nrFailableDependencies() > 0) {
+                    auto it = mFailableDependencies.begin();
+                    stream << "{Dependencies: ";
+                    if (it != mFailableDependencies.end()) {
+                        stream << *it;
+                    }
+                    ++it;
+                    while(it != mFailableDependencies.end()) {
+                        stream << ", " << *it;
+                        ++it;
+                    }
+                    stream << "} ";
+                } else {
+                    auto it = mIsCurrentlyFailableBE.begin();
+                    stream << "{";
+                    if(it != mIsCurrentlyFailableBE.end()) {
+                        stream << *it;
+                    }
                     ++it;
+                    while(it != mIsCurrentlyFailableBE.end()) {
+                        stream << ", " << *it;
+                        ++it;
+                    }
+                    stream << "}";
                 }
-                stream << "}";
                 return stream.str();
             }
 

From 72b09a693c37bf01cefc63af108eaefd5e197b40 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 9 Feb 2016 18:09:06 +0100
Subject: [PATCH 072/246] More examples

Former-commit-id: e4ea9cf5dc3bd60844d91fae4c6a8a5d9da71188
---
 benchmark_dft.py       | 1 +
 examples/dft/fdep2.dft | 5 +++++
 2 files changed, 6 insertions(+)
 create mode 100644 examples/dft/fdep2.dft

diff --git a/benchmark_dft.py b/benchmark_dft.py
index 7fe59a276..54dadeacc 100644
--- a/benchmark_dft.py
+++ b/benchmark_dft.py
@@ -20,6 +20,7 @@ benchmarks = [
     ("cps", False, ["inf", 0.333333]),
     ("deathegg", False, [46.667, 1]),
     ("fdep", False, [0.666667, 1]),
+    ("fdep2", False, [2, 1]),
     #("ftpp_complex", False, [0, 1]), # Compute
     #("ftpp_large", False, [0, 1]), # Compute
     #("ftpp_standard", False, [0, 1]), # Compute
diff --git a/examples/dft/fdep2.dft b/examples/dft/fdep2.dft
new file mode 100644
index 000000000..a444ed4be
--- /dev/null
+++ b/examples/dft/fdep2.dft
@@ -0,0 +1,5 @@
+toplevel "A";
+"A" and "B" "C";
+"F" fdep "B" "C";
+"B" lambda=0.5 dorm=0;
+"C" lambda=0.5 dorm=0;

From 64d3273630181d7fedeef91f6987d7be1fea4126 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Tue, 9 Feb 2016 23:40:03 +0100
Subject: [PATCH 073/246] updates on isomorphism

Former-commit-id: 7bc9a91eab0a2c9906cf17e00a9d5bbd03e73722
---
 src/storage/dft/DFTElements.h    |   1 -
 src/storage/dft/DFTIsomorphism.h | 190 +++++++++++++++++++++++++++++--
 2 files changed, 183 insertions(+), 8 deletions(-)

diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 663c5b230..fe340a43a 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -158,7 +158,6 @@ namespace storm {
 
 
 
-
         protected:
            // virtual bool checkIsomorphicSubDftHelper(DFTElement const& otherElem, std::vector<std::pair<DFTElement const&, DFTElement const&>>& mapping, std::vector<DFTElement const&> const& order ) const = 0;
 
diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
index 2b6016ca4..e9a58d559 100644
--- a/src/storage/dft/DFTIsomorphism.h
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -1,25 +1,201 @@
 #pragma once
 
 #include <vector>
+#include <unordered_map>
+#include "DFTElementType.h"
+#include "DFTElements.h"
 
 namespace storm {
 namespace storage {
+
+
+    struct GateGroupToHash {
+        static constexpr uint_fast64_t fivebitmask = (1 << 6) - 1;
+        static constexpr uint_fast64_t eightbitmaks = (1 << 8) - 1;
+
+        /**
+         * Hash function, which ensures that the colours are sorted according to their rank.
+         */
+        uint_fast64_t operator()(DFTElementType type, size_t nrChildren, size_t nrParents, size_t nrPDEPs, size_t rank) const {
+            // Sets first bit to 1
+            uint_fast64_t groupHash = static_cast<uint_fast64_t>(1) << 63;
+            //Assumes 5 bits for the rank,
+            groupHash |= (static_cast<uint_fast64_t>(rank) & fivebitmask) << (62 - 5);
+            // 8 bits for the nrChildren,
+            groupHash |= (static_cast<uint_fast64_t>(nrChildren) & eightbitmaks) << (62 - 5 - 8);
+            // 5 bits for nrParents,
+            groupHash |= (static_cast<uint_fast64_t>(nrParents) & fivebitmask) << (62 - 5 - 8 - 5);
+            // 5 bits for nrPDEPs,
+            groupHash |= (static_cast<uint_fast64_t>(nrPDEPs) & fivebitmask) << (62 - 5 - 8 - 5 - 5);
+            // 5 bits for the type
+            groupHash |= (static_cast<uint_fast64_t>(type) & fivebitmask) << (62 - 5 - 8 - 5 - 5 - 5);
+            return groupHash;
+        }
+
+    };
+
     /**
-     * Saves isomorphism between subtrees
+     *
      */
-    class DFTIsomorphism {
-        std::vector<std::vector<size_t>> classes;
+    template<typename ValueType>
+    class BijectionCandidates {
+        std::unordered_map<size_t, std::vector<size_t>> groupCandidates;
+        std::unordered_map<std::pair<ValueType, ValueType>, std::vector<size_t>> beCandidates;
+
     };
 
+
+
+
     /**
-     * Saves sets of isomorphic subtrees
+     * Saves isomorphism between subtrees
      */
-    class DFTIsomorphisms {
-        std::vector<DFTIsomorphism> isomorphisms;
+    template<typename ValueType>
+    class DFTIsomorphismCheck {
+        /// Coloured nodes as provided by the input: left hand side
+        BijectionCandidates<ValueType> const& bleft;
+        /// Coloured nodes as provided by the input: right hand side.
+        BijectionCandidates<ValueType> const& bright;
+        /// Whether the colourings are compatible
+        bool candidatesCompatible = true;
+        /// Current bijection
+        std::map<size_t, size_t> bijection;
+        /// Current permutations of right hand side groups which lead to the homomorphism.
+        /// Contains only colours with more than one member.
+        BijectionCandidates<ValueType> currentPermutations;
+
+    public:
+        DFTIsomorphismCheck(BijectionCandidates<ValueType> const& left, BijectionCandidates<ValueType> const& right) : bleft(left), bright(right)
+        {
+            checkCompatibility();
+        }
+
+        /**
+         * Checks whether the candidates are compatible, that is, checks the colours and the number of members for each colour.
+         * @return True iff compatible, ie if the preliminary check allows for a isomorphism.
+         */
+        bool compatible() {
+            return candidatesCompatible;
+        }
+
+
+        /**
+         * Returns the isomorphism
+         * Can only be called after the findIsomorphism procedure returned that an isomorphism has found.
+         * @see findIsomorphism
+         */
+        std::vector<std::pair<size_t, size_t>> getIsomorphism() const {
+
+        }
 
-        void addIsomorphismClass(DFTIsomorphism const &) {
+        /**
+         * Check whether an isomorphism exists.
+         *
+         * @return true iff an isomorphism exists.
+         */
+        bool findIsomorphism() {
+            if(!candidatesCompatible) return false;
+            constructInitialBijection();
+            while(!check()) {
+                // continue our search
+                if(!findNextBijection()) {
+                    // No further bijections to check, no is
+                    return false;
+                }
+            }
+            return true;
+        }
+
+    protected:
+
+        void constructInitialBijection() {
+            assert(candidatesCompatible);
+            // We first construct the currentPermutations, which helps to determine the current state of the check.
+            for(auto const& colour : bright.beCandidates) {
+                if(colour.second.size()>1) {
+                    currentPermutations.beCandidates.insert(colour);
+                }
+            }
+
+            for(auto const& colour : bright.groupCandidates) {
+                if(colour.second.size()>1) {
+                    currentPermutations.groupCandidates.insert(colour);
+                }
+            }
+
+            // Constructing the initial homomorphism based on the right hand side instead of the current permutations allows us
+            // to treat trivial and non-trivial classes in one go.
+            for(auto const& colour : bleft.beCandidates) {
+                zipVectorsIntoMap(colour.second, bright.beCandidates.find(colour.first)->second, bijection);
+            }
+
+            for(auto const& colour : bleft.groupCandidates) {
+                zipVectorsIntoMap(colour.second, bright.groupCandidates.find(colour.first)->second, bijection);
+            }
 
         }
+
+        bool findNextBijection() {
+            return false;
+        }
+
+
+        /**
+         *
+         */
+        bool check() {
+
+        }
+
+    private:
+        /**
+         * Returns true if the colours are compatible.
+         */
+        bool checkCompatibility() {
+            if(bleft.groupCandidates.size() != bright.groupCandidates.size()) {
+                candidatesCompatible = false;
+            }
+            else if(bleft.beCandidates.size() != bright.beCandidates.size()) {
+                candidatesCompatible = false;
+            }
+            else {
+                for (auto const &gc : bleft.groupCandidates) {
+                    if (bright.groupCandidates.count(gc.first) == 0) {
+                        candidatesCompatible = false;
+                        break;
+                    }
+                }
+                if(candidatesCompatible) {
+                    for(auto const& bc : bleft.groupCandidates) {
+                        if(bright.beCandidates.count(bc.first) == 0) {
+                            candidatesCompatible = false;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        /**
+         * Local helper function for the creation of bijections, should be hidden from api.
+         */
+        void zipVectorsIntoMap(std::vector<size_t> const& a, std::vector<size_t> const& b, std::map<size_t, size_t>& map) const {
+            // Assert should pass due to compatibility check
+            assert(a.size() == b.size());
+            auto it = b.cbegin();
+            for(size_t lIndex : a) {
+                assert(map.count(lIndex) == 0);
+                map[lIndex] = *it;
+                ++it;
+            }
+        }
+
+
+        //std::vector<std::pair<size_t, size_t>> computeNextCandidate(){
+
+        //}
     };
+
+
 } // namespace storm::dft
 } // namespace storm

From 3636b9ac0d1483ba5731230fba3cd3bd1250fba3 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 10 Feb 2016 09:49:09 +0100
Subject: [PATCH 074/246] Added more benchmarks

Former-commit-id: b6936dfb7b8f0095aaa9678e9cae2f26ee8cd8b3
---
 benchmark_dft.py           | 8 ++++++--
 examples/dft/pdep2.dft     | 9 +++++++++
 examples/dft/symmetry.dft  | 8 ++++++++
 examples/dft/symmetry2.dft | 8 ++++++++
 4 files changed, 31 insertions(+), 2 deletions(-)
 create mode 100644 examples/dft/pdep2.dft
 create mode 100644 examples/dft/symmetry.dft
 create mode 100644 examples/dft/symmetry2.dft

diff --git a/benchmark_dft.py b/benchmark_dft.py
index 54dadeacc..d2c43bf80 100644
--- a/benchmark_dft.py
+++ b/benchmark_dft.py
@@ -6,8 +6,8 @@ import time
 import math
 import argparse
 
-STORM_PATH= "/Users/mvolk/develop/storm/build/src/storm-dft"
-EXAMPLE_DIR= "/Users/mvolk/develop/storm/examples/dft/"
+STORM_PATH= "/Users/mvolk/develop/dft-storm/build/src/storm-dft"
+EXAMPLE_DIR= "/Users/mvolk/develop/dft-storm/examples/dft/"
 
 
 benchmarks = [ 
@@ -30,6 +30,8 @@ benchmarks = [
     ("or", False, [1, 1]),
     ("pand", False, ["inf", 0.666667]),
     ("pand_param", True, ["-1", "(x)/(y+x)"]),
+    ("pdep", False, [0, 1]), #Compute
+    ("pdep2", False, [0, 1]), #Compute
     ("spare", False, [3.53846, 1]),
     ("spare2", False, [1.86957, 1]),
     ("spare3", False, [1.27273, 1]),
@@ -37,6 +39,8 @@ benchmarks = [
     ("spare5", False, [2.66667, 1]), # We discard the result 2.16667 from DFTCalc
     ("spare6", False, [1.4, 1]),
     ("spare7", False, [3.67333, 1]),
+    ("symmetry", False, [4.16667, 1]),
+    ("symmetry2", False, [3.06111, 1]),
     ("tripple_and1", False, [4.16667, 1]),
     ("tripple_and2", False, [3.66667, 1]),
     ("tripple_and2_c", False, [3.6667, 1]),
diff --git a/examples/dft/pdep2.dft b/examples/dft/pdep2.dft
new file mode 100644
index 000000000..ab1c7a9b8
--- /dev/null
+++ b/examples/dft/pdep2.dft
@@ -0,0 +1,9 @@
+toplevel "SF";
+"SF" or "A" "B" "PDEP";
+"A" pand "S" "MA";
+"B" and "MA" "MB";
+"PDEP" pdep=0.2 "MA" "S" "MB";
+
+"S" lambda=0.5 dorm=0;
+"MA" lambda=0.5 dorm=0;
+"MB" lambda=0.5 dorm=0;
diff --git a/examples/dft/symmetry.dft b/examples/dft/symmetry.dft
new file mode 100644
index 000000000..6f4031d0b
--- /dev/null
+++ b/examples/dft/symmetry.dft
@@ -0,0 +1,8 @@
+toplevel "A";
+"A" and "B" "B'";
+"B" and "C" "D";
+"B'" and "C'" "D'";
+"C" lambda=0.5 dorm=0;
+"D" lambda=0.5 dorm=0;
+"C'" lambda=0.5 dorm=0;
+"D'" lambda=0.5 dorm=0;
diff --git a/examples/dft/symmetry2.dft b/examples/dft/symmetry2.dft
new file mode 100644
index 000000000..6d04021bb
--- /dev/null
+++ b/examples/dft/symmetry2.dft
@@ -0,0 +1,8 @@
+toplevel "A";
+"A" and "B" "B'";
+"B" and "C" "D";
+"B'" and "C'" "D'";
+"C" lambda=0.5 dorm=0;
+"D" lambda=2 dorm=0;
+"C'" lambda=0.5 dorm=0;
+"D'" lambda=2 dorm=0;

From f67c92b526b4a618e8e2d75b7f2a339182496e0e Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 10 Feb 2016 16:36:54 +0100
Subject: [PATCH 075/246] FlexibleSparseMatrix is in own class now

Former-commit-id: fdc569e4438bb1ae9687c7fe7db3de51d015d8cb
---
 .../SparseDtmcEliminationModelChecker.cpp     | 205 +++++-------------
 .../SparseDtmcEliminationModelChecker.h       |  70 ++----
 src/storage/FlexibleSparseMatrix.cpp          | 114 +++++++---
 src/storage/FlexibleSparseMatrix.h            | 115 ++++++++--
 4 files changed, 252 insertions(+), 252 deletions(-)

diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
index 6ec1e6d86..0b520c168 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
@@ -260,10 +260,10 @@ namespace storm {
             std::chrono::high_resolution_clock::time_point conversionStart = std::chrono::high_resolution_clock::now();
             
             // Then, we convert the reduced matrix to a more flexible format to be able to perform state elimination more easily.
-            FlexibleSparseMatrix flexibleMatrix = getFlexibleSparseMatrix(transitionMatrix);
-            flexibleMatrix.filter(maybeStates, maybeStates);
-            FlexibleSparseMatrix flexibleBackwardTransitions = getFlexibleSparseMatrix(backwardTransitions);
-            flexibleBackwardTransitions.filter(maybeStates, maybeStates);
+            storm::storage::FlexibleSparseMatrix<ValueType> flexibleMatrix(transitionMatrix);
+            flexibleMatrix.createSubmatrix(maybeStates, maybeStates);
+            storm::storage::FlexibleSparseMatrix<ValueType> flexibleBackwardTransitions(backwardTransitions);
+            flexibleBackwardTransitions.createSubmatrix(maybeStates, maybeStates);
             auto conversionEnd = std::chrono::high_resolution_clock::now();
             
             std::chrono::high_resolution_clock::time_point modelCheckingStart = std::chrono::high_resolution_clock::now();
@@ -345,11 +345,11 @@ namespace storm {
                     stateValues[*representativeIt] = bsccValue;
                 }
 
-                typename SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::row_type& representativeForwardRow = flexibleMatrix.getRow(*representativeIt);
+                FlexibleRowType& representativeForwardRow = flexibleMatrix.getRow(*representativeIt);
                 representativeForwardRow.clear();
                 representativeForwardRow.shrink_to_fit();
                 
-                typename SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::row_type& representativeBackwardRow = flexibleBackwardTransitions.getRow(*representativeIt);
+                FlexibleRowType& representativeBackwardRow = flexibleBackwardTransitions.getRow(*representativeIt);
                 auto it = representativeBackwardRow.begin(), ite = representativeBackwardRow.end();
                 for (; it != ite; ++it) {
                     if (it->getColumn() == *representativeIt) {
@@ -739,8 +739,8 @@ namespace storm {
             }
             
             std::chrono::high_resolution_clock::time_point conversionStart = std::chrono::high_resolution_clock::now();
-            FlexibleSparseMatrix flexibleMatrix = getFlexibleSparseMatrix(submatrix);
-            FlexibleSparseMatrix flexibleBackwardTransitions = getFlexibleSparseMatrix(submatrixTransposed, true);
+            storm::storage::FlexibleSparseMatrix<ValueType> flexibleMatrix(submatrix);
+            storm::storage::FlexibleSparseMatrix<ValueType> flexibleBackwardTransitions(submatrixTransposed, true);
             std::chrono::high_resolution_clock::time_point conversionEnd = std::chrono::high_resolution_clock::now();
             
             std::unique_ptr<StatePriorityQueue> statePriorities = createStatePriorityQueue(distanceBasedPriorities, flexibleMatrix, flexibleBackwardTransitions, oneStepProbabilities, statesToEliminate);
@@ -791,7 +791,7 @@ namespace storm {
                             for (auto const& element : currentRow) {
                                 // If any of the successors is a phi state, we eliminate it (wrt. all its phi predecessors).
                                 if (!psiStates.get(element.getColumn())) {
-                                    typename FlexibleSparseMatrix::row_type const& successorRow = flexibleMatrix.getRow(element.getColumn());
+                                    FlexibleRowType const& successorRow = flexibleMatrix.getRow(element.getColumn());
                                     // Eliminate the successor only if there possibly is a psi state reachable through it.
                                     if (successorRow.size() > 1 || (!successorRow.empty() && successorRow.front().getColumn() != element.getColumn())) {
                                         STORM_LOG_TRACE("Found non-psi successor " << element.getColumn() << " that needs to be eliminated.");
@@ -821,7 +821,7 @@ namespace storm {
                             for (auto const& element : currentRow) {
                                 // If any of the successors is a psi state, we eliminate it (wrt. all its psi predecessors).
                                 if (!phiStates.get(element.getColumn())) {
-                                    typename FlexibleSparseMatrix::row_type const& successorRow = flexibleMatrix.getRow(element.getColumn());
+                                    FlexibleRowType const& successorRow = flexibleMatrix.getRow(element.getColumn());
                                     if (successorRow.size() > 1 || (!successorRow.empty() && successorRow.front().getColumn() != element.getColumn())) {
                                         STORM_LOG_TRACE("Found non-phi successor " << element.getColumn() << " that needs to be eliminated.");
                                         eliminateState(element.getColumn(), flexibleMatrix, flexibleBackwardTransitions, valueUpdateCallback, predecessorUpdateCallback, boost::none, psiFilterCallback, false);
@@ -890,7 +890,7 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        std::unique_ptr<typename SparseDtmcEliminationModelChecker<SparseDtmcModelType>::StatePriorityQueue> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& distanceBasedStatePriorities, FlexibleSparseMatrix const& transitionMatrix, FlexibleSparseMatrix const& backwardTransitions, std::vector<typename SparseDtmcModelType::ValueType>& oneStepProbabilities, storm::storage::BitVector const& states) {
+        std::unique_ptr<typename SparseDtmcEliminationModelChecker<SparseDtmcModelType>::StatePriorityQueue> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& distanceBasedStatePriorities, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector const& states) {
             
             STORM_LOG_TRACE("Creating state priority queue for states " << states);
             
@@ -940,7 +940,7 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::performPrioritizedStateElimination(std::unique_ptr<StatePriorityQueue>& priorityQueue, FlexibleSparseMatrix& transitionMatrix, FlexibleSparseMatrix& backwardTransitions, std::vector<ValueType>& values, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly) {
+        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::performPrioritizedStateElimination(std::unique_ptr<StatePriorityQueue>& priorityQueue, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, std::vector<ValueType>& values, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly) {
             
             ValueUpdateCallback valueUpdateCallback = [&values] (storm::storage::sparse::state_type const& state, ValueType const& loopProbability) { values[state] = storm::utility::simplify(loopProbability * values[state]); };
             PredecessorUpdateCallback predecessorCallback = [&values] (storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) { values[predecessor] = storm::utility::simplify(values[predecessor] + storm::utility::simplify(probability * values[state])); };
@@ -959,7 +959,7 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::performOrdinaryStateElimination(FlexibleSparseMatrix& transitionMatrix, FlexibleSparseMatrix& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities) {
+        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::performOrdinaryStateElimination(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities) {
             std::unique_ptr<StatePriorityQueue> statePriorities = createStatePriorityQueue(distanceBasedPriorities, transitionMatrix, backwardTransitions, values, subsystem);
             
             std::size_t numberOfStatesToEliminate = statePriorities->size();
@@ -969,7 +969,7 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        uint_fast64_t SparseDtmcEliminationModelChecker<SparseDtmcModelType>::performHybridStateElimination(storm::storage::SparseMatrix<ValueType> const& forwardTransitions, FlexibleSparseMatrix& transitionMatrix, FlexibleSparseMatrix& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities) {
+        uint_fast64_t SparseDtmcEliminationModelChecker<SparseDtmcModelType>::performHybridStateElimination(storm::storage::SparseMatrix<ValueType> const& forwardTransitions, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities) {
             // When using the hybrid technique, we recursively treat the SCCs up to some size.
             std::vector<storm::storage::sparse::state_type> entryStateQueue;
             STORM_LOG_DEBUG("Eliminating " << subsystem.size() << " states using the hybrid elimination technique." << std::endl);
@@ -992,8 +992,8 @@ namespace storm {
             
             std::chrono::high_resolution_clock::time_point conversionStart = std::chrono::high_resolution_clock::now();
             // Then, we convert the reduced matrix to a more flexible format to be able to perform state elimination more easily.
-            FlexibleSparseMatrix flexibleMatrix = getFlexibleSparseMatrix(transitionMatrix);
-            FlexibleSparseMatrix flexibleBackwardTransitions = getFlexibleSparseMatrix(backwardTransitions);
+            storm::storage::FlexibleSparseMatrix<ValueType> flexibleMatrix(transitionMatrix);
+            storm::storage::FlexibleSparseMatrix<ValueType> flexibleBackwardTransitions(backwardTransitions);
             auto conversionEnd = std::chrono::high_resolution_clock::now();
             
             std::chrono::high_resolution_clock::time_point modelCheckingStart = std::chrono::high_resolution_clock::now();
@@ -1052,7 +1052,7 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        uint_fast64_t SparseDtmcEliminationModelChecker<SparseDtmcModelType>::treatScc(FlexibleSparseMatrix& matrix, std::vector<ValueType>& values, storm::storage::BitVector const& entryStates, storm::storage::BitVector const& scc, storm::storage::BitVector const& initialStates, storm::storage::SparseMatrix<ValueType> const& forwardTransitions, FlexibleSparseMatrix& backwardTransitions, bool eliminateEntryStates, uint_fast64_t level, uint_fast64_t maximalSccSize, std::vector<storm::storage::sparse::state_type>& entryStateQueue, bool computeResultsForInitialStatesOnly, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities) {
+        uint_fast64_t SparseDtmcEliminationModelChecker<SparseDtmcModelType>::treatScc(storm::storage::FlexibleSparseMatrix<ValueType>& matrix, std::vector<ValueType>& values, storm::storage::BitVector const& entryStates, storm::storage::BitVector const& scc, storm::storage::BitVector const& initialStates, storm::storage::SparseMatrix<ValueType> const& forwardTransitions, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, bool eliminateEntryStates, uint_fast64_t level, uint_fast64_t maximalSccSize, std::vector<storm::storage::sparse::state_type>& entryStateQueue, bool computeResultsForInitialStatesOnly, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities) {
             uint_fast64_t maximalDepth = level;
             
             // If the SCCs are large enough, we try to split them further.
@@ -1068,7 +1068,7 @@ namespace storm {
                 storm::storage::BitVector remainingSccs(decomposition.size(), true);
                 
                 // First, get rid of the trivial SCCs.
-                storm::storage::BitVector statesInTrivialSccs(matrix.getNumberOfRows());
+                storm::storage::BitVector statesInTrivialSccs(matrix.getRowCount());
                 for (uint_fast64_t sccIndex = 0; sccIndex < decomposition.size(); ++sccIndex) {
                     storm::storage::StronglyConnectedComponent const& scc = decomposition.getBlock(sccIndex);
                     if (scc.isTrivial()) {
@@ -1130,17 +1130,14 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::eliminateState(storm::storage::sparse::state_type state, FlexibleSparseMatrix& matrix, FlexibleSparseMatrix& backwardTransitions,
-                                                                                    ValueUpdateCallback const& callback, PredecessorUpdateCallback const& predecessorCallback,
-                                                                                    boost::optional<PriorityUpdateCallback> const& priorityUpdateCallback,
-                                                                                    boost::optional<PredecessorFilterCallback> const& predecessorFilterCallback, bool removeForwardTransitions) {
+        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::eliminateState(storm::storage::sparse::state_type state, storm::storage::FlexibleSparseMatrix<ValueType>& matrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, ValueUpdateCallback const& callback, PredecessorUpdateCallback const& predecessorCallback, boost::optional<PriorityUpdateCallback> const& priorityUpdateCallback, boost::optional<PredecessorFilterCallback> const& predecessorFilterCallback, bool removeForwardTransitions) {
             
             STORM_LOG_TRACE("Eliminating state " << state << ".");
             
             // Start by finding loop probability.
             bool hasSelfLoop = false;
             ValueType loopProbability = storm::utility::zero<ValueType>();
-            typename FlexibleSparseMatrix::row_type& currentStateSuccessors = matrix.getRow(state);
+            FlexibleRowType& currentStateSuccessors = matrix.getRow(state);
             for (auto entryIt = currentStateSuccessors.begin(), entryIte = currentStateSuccessors.end(); entryIt != entryIte; ++entryIt) {
                 if (entryIt->getColumn() >= state) {
                     if (entryIt->getColumn() == state) {
@@ -1172,12 +1169,12 @@ namespace storm {
             }
             
             // Now connect the predecessors of the state being eliminated with its successors.
-            typename FlexibleSparseMatrix::row_type& currentStatePredecessors = backwardTransitions.getRow(state);
+            FlexibleRowType& currentStatePredecessors = backwardTransitions.getRow(state);
             
             // In case we have a constrained elimination, we need to keep track of the new predecessors.
-            typename FlexibleSparseMatrix::row_type newCurrentStatePredecessors;
+            FlexibleRowType newCurrentStatePredecessors;
 
-            std::vector<typename FlexibleSparseMatrix::row_type> newBackwardProbabilities(currentStateSuccessors.size());
+            std::vector<FlexibleRowType> newBackwardProbabilities(currentStateSuccessors.size());
             for (auto& backwardProbabilities : newBackwardProbabilities) {
                 backwardProbabilities.reserve(currentStatePredecessors.size());
             }
@@ -1203,8 +1200,8 @@ namespace storm {
                 
                 // First, find the probability with which the predecessor can move to the current state, because
                 // the forward probabilities of the state to be eliminated need to be scaled with this factor.
-                typename FlexibleSparseMatrix::row_type& predecessorForwardTransitions = matrix.getRow(predecessor);
-                typename FlexibleSparseMatrix::row_type::iterator multiplyElement = std::find_if(predecessorForwardTransitions.begin(), predecessorForwardTransitions.end(), [&](storm::storage::MatrixEntry<typename FlexibleSparseMatrix::index_type, typename FlexibleSparseMatrix::value_type> const& a) { return a.getColumn() == state; });
+                FlexibleRowType& predecessorForwardTransitions = matrix.getRow(predecessor);
+                FlexibleRowIterator multiplyElement = std::find_if(predecessorForwardTransitions.begin(), predecessorForwardTransitions.end(), [&](storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() == state; });
                 
                 // Make sure we have found the probability and set it to zero.
                 STORM_LOG_THROW(multiplyElement != predecessorForwardTransitions.end(), storm::exceptions::InvalidStateException, "No probability for successor found.");
@@ -1212,14 +1209,14 @@ namespace storm {
                 multiplyElement->setValue(storm::utility::zero<ValueType>());
                 
                 // At this point, we need to update the (forward) transitions of the predecessor.
-                typename FlexibleSparseMatrix::row_type::iterator first1 = predecessorForwardTransitions.begin();
-                typename FlexibleSparseMatrix::row_type::iterator last1 = predecessorForwardTransitions.end();
-                typename FlexibleSparseMatrix::row_type::iterator first2 = currentStateSuccessors.begin();
-                typename FlexibleSparseMatrix::row_type::iterator last2 = currentStateSuccessors.end();
+                FlexibleRowIterator first1 = predecessorForwardTransitions.begin();
+                FlexibleRowIterator last1 = predecessorForwardTransitions.end();
+                FlexibleRowIterator first2 = currentStateSuccessors.begin();
+                FlexibleRowIterator last2 = currentStateSuccessors.end();
                 
-                typename FlexibleSparseMatrix::row_type newSuccessors;
+                FlexibleRowType newSuccessors;
                 newSuccessors.reserve((last1 - first1) + (last2 - first2));
-                std::insert_iterator<typename FlexibleSparseMatrix::row_type> result(newSuccessors, newSuccessors.end());
+                std::insert_iterator<FlexibleRowType> result(newSuccessors, newSuccessors.end());
                 
                 uint_fast64_t successorOffsetInNewBackwardTransitions = 0;
                 // Now we merge the two successor lists. (Code taken from std::set_union and modified to suit our needs).
@@ -1236,7 +1233,7 @@ namespace storm {
                     }
                     
                     if (first2 == last2) {
-                        std::copy_if(first1, last1, result, [&] (storm::storage::MatrixEntry<typename FlexibleSparseMatrix::index_type, typename FlexibleSparseMatrix::value_type> const& a) { return a.getColumn() != state; } );
+                        std::copy_if(first1, last1, result, [&] (storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() != state; } );
                         break;
                     }
                     if (first2->getColumn() < first1->getColumn()) {
@@ -1251,7 +1248,7 @@ namespace storm {
                         ++first1;
                     } else {
                         auto probability = storm::utility::simplify(first1->getValue() + storm::utility::simplify(multiplyFactor * first2->getValue()));
-                        *result = storm::storage::MatrixEntry<typename FlexibleSparseMatrix::index_type, typename FlexibleSparseMatrix::value_type>(first1->getColumn(), probability);
+                        *result = storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type>(first1->getColumn(), probability);
                         newBackwardProbabilities[successorOffsetInNewBackwardTransitions].emplace_back(predecessor, probability);
 //                        std::cout << "(2) adding " << first2->getColumn() << " -> " << newBackwardProbabilities[successorOffsetInNewBackwardTransitions].back() << "[" << successorOffsetInNewBackwardTransitions << "]" << std::endl;
                         ++first1;
@@ -1288,7 +1285,7 @@ namespace storm {
                     continue;
                 }
                 
-                typename FlexibleSparseMatrix::row_type& successorBackwardTransitions = backwardTransitions.getRow(successorEntry.getColumn());
+                FlexibleRowType& successorBackwardTransitions = backwardTransitions.getRow(successorEntry.getColumn());
 //                std::cout << "old backward trans of " << successorEntry.getColumn() << std::endl;
 //                for (auto const& trans : successorBackwardTransitions) {
 //                    std::cout << trans << std::endl;
@@ -1297,24 +1294,24 @@ namespace storm {
                 // Delete the current state as a predecessor of the successor state only if we are going to remove the
                 // current state's forward transitions.
                 if (removeForwardTransitions) {
-                    typename FlexibleSparseMatrix::row_type::iterator elimIt = std::find_if(successorBackwardTransitions.begin(), successorBackwardTransitions.end(), [&](storm::storage::MatrixEntry<typename FlexibleSparseMatrix::index_type, typename FlexibleSparseMatrix::value_type> const& a) { return a.getColumn() == state; });
+                    FlexibleRowIterator elimIt = std::find_if(successorBackwardTransitions.begin(), successorBackwardTransitions.end(), [&](storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() == state; });
                     STORM_LOG_ASSERT(elimIt != successorBackwardTransitions.end(), "Expected a proper backward transition from " << successorEntry.getColumn() << " to " << state << ", but found none.");
                     successorBackwardTransitions.erase(elimIt);
                 }
                 
-                typename FlexibleSparseMatrix::row_type::iterator first1 = successorBackwardTransitions.begin();
-                typename FlexibleSparseMatrix::row_type::iterator last1 = successorBackwardTransitions.end();
-                typename FlexibleSparseMatrix::row_type::iterator first2 = newBackwardProbabilities[successorOffsetInNewBackwardTransitions].begin();
-                typename FlexibleSparseMatrix::row_type::iterator last2 = newBackwardProbabilities[successorOffsetInNewBackwardTransitions].end();
+                FlexibleRowIterator first1 = successorBackwardTransitions.begin();
+                FlexibleRowIterator last1 = successorBackwardTransitions.end();
+                FlexibleRowIterator first2 = newBackwardProbabilities[successorOffsetInNewBackwardTransitions].begin();
+                FlexibleRowIterator last2 = newBackwardProbabilities[successorOffsetInNewBackwardTransitions].end();
                 
 //                std::cout << "adding backward trans " << successorEntry.getColumn() << "[" << successorOffsetInNewBackwardTransitions << "]" << std::endl;
 //                for (auto const& trans : newBackwardProbabilities[successorOffsetInNewBackwardTransitions]) {
 //                    std::cout << trans << std::endl;
 //                }
                 
-                typename FlexibleSparseMatrix::row_type newPredecessors;
+                FlexibleRowType newPredecessors;
                 newPredecessors.reserve((last1 - first1) + (last2 - first2));
-                std::insert_iterator<typename FlexibleSparseMatrix::row_type> result(newPredecessors, newPredecessors.end());
+                std::insert_iterator<FlexibleRowType> result(newPredecessors, newPredecessors.end());
                 
                 for (; first1 != last1; ++result) {
                     if (first2 == last2) {
@@ -1340,9 +1337,9 @@ namespace storm {
                     }
                 }
                 if (predecessorFilterCallback) {
-                    std::copy_if(first2, last2, result, [&] (storm::storage::MatrixEntry<typename FlexibleSparseMatrix::index_type, typename FlexibleSparseMatrix::value_type> const& a) { return a.getColumn() != state && predecessorFilterCallback.get()(a.getColumn()); });
+                    std::copy_if(first2, last2, result, [&] (storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() != state && predecessorFilterCallback.get()(a.getColumn()); });
                 } else {
-                    std::copy_if(first2, last2, result, [&] (storm::storage::MatrixEntry<typename FlexibleSparseMatrix::index_type, typename FlexibleSparseMatrix::value_type> const& a) { return a.getColumn() != state; });
+                    std::copy_if(first2, last2, result, [&] (storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() != state; });
                 }
                 
                 // Now move the new predecessors in place.
@@ -1416,111 +1413,7 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::FlexibleSparseMatrix(index_type rows) : data(rows) {
-            // Intentionally left empty.
-        }
-        
-        template<typename SparseDtmcModelType>
-        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::reserveInRow(index_type row, index_type numberOfElements) {
-            this->data[row].reserve(numberOfElements);
-        }
-        
-        template<typename SparseDtmcModelType>
-        typename SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::row_type& SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::getRow(index_type index) {
-            return this->data[index];
-        }
-        
-        template<typename SparseDtmcModelType>
-        typename SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::row_type const& SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::getRow(index_type index) const {
-            return this->data[index];
-        }
-        
-        template<typename SparseDtmcModelType>
-        typename SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::index_type SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::getNumberOfRows() const {
-            return this->data.size();
-        }
-        
-        template<typename SparseDtmcModelType>
-        bool SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::hasSelfLoop(storm::storage::sparse::state_type state) {
-            for (auto const& entry : this->getRow(state)) {
-                if (entry.getColumn() < state) {
-                    continue;
-                } else if (entry.getColumn() > state) {
-                    return false;
-                } else if (entry.getColumn() == state) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        
-        template<typename SparseDtmcModelType>
-        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::print() const {
-            for (uint_fast64_t index = 0; index < this->data.size(); ++index) {
-                std::cout << index << " - ";
-                for (auto const& element : this->getRow(index)) {
-                    std::cout << "(" << element.getColumn() << ", " << element.getValue() << ") ";
-                }
-                std::cout << std::endl;
-            }
-        }
-        
-        template<typename SparseDtmcModelType>
-        bool SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::empty() const {
-            for (auto const& row : this->data) {
-                if (!row.empty()) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        
-        template<typename SparseDtmcModelType>
-        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix::filter(storm::storage::BitVector const& rowFilter, storm::storage::BitVector const& columnFilter) {
-            for (uint_fast64_t rowIndex = 0; rowIndex < this->data.size(); ++rowIndex) {
-                auto& row = this->data[rowIndex];
-                if (!rowFilter.get(rowIndex)) {
-                    row.clear();
-                    row.shrink_to_fit();
-                    continue;
-                }
-                row_type newRow;
-                for (auto const& element : row) {
-                    if (columnFilter.get(element.getColumn())) {
-                        newRow.push_back(element);
-                    }
-                }
-                row = std::move(newRow);
-            }
-        }
-        
-        template<typename SparseDtmcModelType>
-        typename SparseDtmcEliminationModelChecker<SparseDtmcModelType>::FlexibleSparseMatrix SparseDtmcEliminationModelChecker<SparseDtmcModelType>::getFlexibleSparseMatrix(storm::storage::SparseMatrix<ValueType> const& matrix, bool setAllValuesToOne) {
-            FlexibleSparseMatrix flexibleMatrix(matrix.getRowCount());
-            
-            for (typename FlexibleSparseMatrix::index_type rowIndex = 0; rowIndex < matrix.getRowCount(); ++rowIndex) {
-                typename storm::storage::SparseMatrix<ValueType>::const_rows row = matrix.getRow(rowIndex);
-                flexibleMatrix.reserveInRow(rowIndex, row.getNumberOfEntries());
-                
-                for (auto const& element : row) {
-                    // If the probability is zero, we skip this entry.
-                    if (storm::utility::isZero(element.getValue())) {
-                        continue;
-                    }
-                    
-                    if (setAllValuesToOne) {
-                        flexibleMatrix.getRow(rowIndex).emplace_back(element.getColumn(), storm::utility::one<ValueType>());
-                    } else {
-                        flexibleMatrix.getRow(rowIndex).emplace_back(element);
-                    }
-                }
-            }
-            
-            return flexibleMatrix;
-        }
-        
-        template<typename SparseDtmcModelType>
-        uint_fast64_t SparseDtmcEliminationModelChecker<SparseDtmcModelType>::computeStatePenalty(storm::storage::sparse::state_type const& state, FlexibleSparseMatrix const& transitionMatrix, FlexibleSparseMatrix const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities) {
+        uint_fast64_t SparseDtmcEliminationModelChecker<SparseDtmcModelType>::computeStatePenalty(storm::storage::sparse::state_type const& state, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities) {
             uint_fast64_t penalty = 0;
             bool hasParametricSelfLoop = false;
             
@@ -1547,12 +1440,12 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        uint_fast64_t SparseDtmcEliminationModelChecker<SparseDtmcModelType>::computeStatePenaltyRegularExpression(storm::storage::sparse::state_type const& state, FlexibleSparseMatrix const& transitionMatrix, FlexibleSparseMatrix const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities) {
+        uint_fast64_t SparseDtmcEliminationModelChecker<SparseDtmcModelType>::computeStatePenaltyRegularExpression(storm::storage::sparse::state_type const& state, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities) {
             return backwardTransitions.getRow(state).size() * transitionMatrix.getRow(state).size();
         }
         
         template<typename SparseDtmcModelType>
-        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::StatePriorityQueue::update(storm::storage::sparse::state_type, FlexibleSparseMatrix const& transitionMatrix, FlexibleSparseMatrix const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities) {
+        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::StatePriorityQueue::update(storm::storage::sparse::state_type, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities) {
             // Intentionally left empty.
         }
         
@@ -1605,7 +1498,7 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::DynamicPenaltyStatePriorityQueue::update(storm::storage::sparse::state_type state, FlexibleSparseMatrix const& transitionMatrix, FlexibleSparseMatrix const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities) {
+        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::DynamicPenaltyStatePriorityQueue::update(storm::storage::sparse::state_type state, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities) {
             // First, we need to find the priority until now.
             auto priorityIt = stateToPriorityMapping.find(state);
             
@@ -1634,8 +1527,8 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        bool SparseDtmcEliminationModelChecker<SparseDtmcModelType>::checkConsistent(FlexibleSparseMatrix& transitionMatrix, FlexibleSparseMatrix& backwardTransitions) {
-            for (uint_fast64_t forwardIndex = 0; forwardIndex < transitionMatrix.getNumberOfRows(); ++forwardIndex) {
+        bool SparseDtmcEliminationModelChecker<SparseDtmcModelType>::checkConsistent(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions) {
+            for (uint_fast64_t forwardIndex = 0; forwardIndex < transitionMatrix.getRowCount(); ++forwardIndex) {
                 for (auto const& forwardEntry : transitionMatrix.getRow(forwardIndex)) {
                     if (forwardEntry.getColumn() == forwardIndex) {
                         continue;
diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
index 692a6be57..30c8e528a 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
@@ -2,6 +2,7 @@
 #define STORM_MODELCHECKER_REACHABILITY_SPARSEDTMCELIMINATIONMODELCHECKER_H_
 
 #include "src/storage/sparse/StateType.h"
+#include "src/storage/FlexibleSparseMatrix.h"
 #include "src/models/sparse/Dtmc.h"
 #include "src/modelchecker/propositional/SparsePropositionalModelChecker.h"
 #include "src/utility/constants.h"
@@ -14,7 +15,9 @@ namespace storm {
         public:
             typedef typename SparseDtmcModelType::ValueType ValueType;
             typedef typename SparseDtmcModelType::RewardModelType RewardModelType;
-            
+            typedef typename storm::storage::FlexibleSparseMatrix<ValueType>::row_type FlexibleRowType;
+            typedef typename FlexibleRowType::iterator FlexibleRowIterator;
+
             /*!
              * Creates an elimination-based model checker for the given model.
              *
@@ -33,47 +36,12 @@ namespace storm {
             virtual std::unique_ptr<CheckResult> computeLongRunAverageProbabilities(storm::logic::StateFormula const& stateFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
 
         private:
-            class FlexibleSparseMatrix {
-            public:
-                typedef uint_fast64_t index_type;
-                typedef ValueType value_type;
-                typedef std::vector<storm::storage::MatrixEntry<index_type, value_type>> row_type;
-                typedef typename row_type::iterator iterator;
-                typedef typename row_type::const_iterator const_iterator;
-                
-                FlexibleSparseMatrix() = default;
-                FlexibleSparseMatrix(index_type rows);
-                
-                void reserveInRow(index_type row, index_type numberOfElements);
-                
-                row_type& getRow(index_type);
-                row_type const& getRow(index_type) const;
-                
-                index_type getNumberOfRows() const;
-                
-                void print() const;
-                
-                bool empty() const;
-                
-                void filter(storm::storage::BitVector const& rowFilter, storm::storage::BitVector const& columnFilter);
-                
-                /*!
-                 * Checks whether the given state has a self-loop with an arbitrary probability in the probability matrix.
-                 *
-                 * @param state The state for which to check whether it possesses a self-loop.
-                 * @return True iff the given state has a self-loop with an arbitrary probability in the probability matrix.
-                 */
-                bool hasSelfLoop(storm::storage::sparse::state_type state);
-                
-            private:
-                std::vector<row_type> data;
-            };
-            
+                        
             class StatePriorityQueue {
             public:
                 virtual bool hasNextState() const = 0;
                 virtual storm::storage::sparse::state_type popNextState() = 0;
-                virtual void update(storm::storage::sparse::state_type state, FlexibleSparseMatrix const& transitionMatrix, FlexibleSparseMatrix const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities);
+                virtual void update(storm::storage::sparse::state_type state, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities);
                 virtual std::size_t size() const = 0;
             };
             
@@ -96,7 +64,7 @@ namespace storm {
                 }
             };
             
-            typedef std::function<uint_fast64_t (storm::storage::sparse::state_type const& state, FlexibleSparseMatrix const& transitionMatrix, FlexibleSparseMatrix const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities)> PenaltyFunctionType;
+            typedef std::function<uint_fast64_t (storm::storage::sparse::state_type const& state, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities)> PenaltyFunctionType;
             
             class DynamicPenaltyStatePriorityQueue : public StatePriorityQueue {
             public:
@@ -104,7 +72,7 @@ namespace storm {
                 
                 virtual bool hasNextState() const override;
                 virtual storm::storage::sparse::state_type popNextState() override;
-                virtual void update(storm::storage::sparse::state_type state, FlexibleSparseMatrix const& transitionMatrix, FlexibleSparseMatrix const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities) override;
+                virtual void update(storm::storage::sparse::state_type state, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities) override;
                 virtual std::size_t size() const override;
 
             private:
@@ -117,38 +85,36 @@ namespace storm {
             
             static std::vector<ValueType> computeReachabilityValues(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, std::vector<ValueType>& values, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, std::vector<ValueType> const& oneStepProbabilitiesToTarget);
             
-            static std::unique_ptr<StatePriorityQueue> createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& stateDistances, FlexibleSparseMatrix const& transitionMatrix, FlexibleSparseMatrix const& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector const& states);
+            static std::unique_ptr<StatePriorityQueue> createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& stateDistances, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector const& states);
 
             static std::unique_ptr<StatePriorityQueue> createNaivePriorityQueue(storm::storage::BitVector const& states);
             
-            static void performPrioritizedStateElimination(std::unique_ptr<StatePriorityQueue>& priorityQueue, FlexibleSparseMatrix& transitionMatrix, FlexibleSparseMatrix& backwardTransitions, std::vector<ValueType>& values, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly);
+            static void performPrioritizedStateElimination(std::unique_ptr<StatePriorityQueue>& priorityQueue, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, std::vector<ValueType>& values, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly);
             
-            static void performOrdinaryStateElimination(FlexibleSparseMatrix& transitionMatrix, FlexibleSparseMatrix& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<ValueType>>& additionalStateValues, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities);
+            static void performOrdinaryStateElimination(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<ValueType>>& additionalStateValues, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities);
 
-            static void performOrdinaryStateElimination(FlexibleSparseMatrix& transitionMatrix, FlexibleSparseMatrix& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities);
+            static void performOrdinaryStateElimination(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities);
             
-            static uint_fast64_t performHybridStateElimination(storm::storage::SparseMatrix<ValueType> const& forwardTransitions, FlexibleSparseMatrix& transitionMatrix, FlexibleSparseMatrix& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities);
+            static uint_fast64_t performHybridStateElimination(storm::storage::SparseMatrix<ValueType> const& forwardTransitions, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities);
             
-            static uint_fast64_t treatScc(FlexibleSparseMatrix& matrix, std::vector<ValueType>& values, storm::storage::BitVector const& entryStates, storm::storage::BitVector const& scc, storm::storage::BitVector const& initialStates, storm::storage::SparseMatrix<ValueType> const& forwardTransitions, FlexibleSparseMatrix& backwardTransitions, bool eliminateEntryStates, uint_fast64_t level, uint_fast64_t maximalSccSize, std::vector<storm::storage::sparse::state_type>& entryStateQueue, bool computeResultsForInitialStatesOnly, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities = boost::none);
+            static uint_fast64_t treatScc(storm::storage::FlexibleSparseMatrix<ValueType>& matrix, std::vector<ValueType>& values, storm::storage::BitVector const& entryStates, storm::storage::BitVector const& scc, storm::storage::BitVector const& initialStates, storm::storage::SparseMatrix<ValueType> const& forwardTransitions, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, bool eliminateEntryStates, uint_fast64_t level, uint_fast64_t maximalSccSize, std::vector<storm::storage::sparse::state_type>& entryStateQueue, bool computeResultsForInitialStatesOnly, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities = boost::none);
             
-            static FlexibleSparseMatrix getFlexibleSparseMatrix(storm::storage::SparseMatrix<ValueType> const& matrix, bool setAllValuesToOne = false);
-                        
             typedef std::function<void (storm::storage::sparse::state_type const& state, ValueType const& loopProbability)> ValueUpdateCallback;
             typedef std::function<void (storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state)> PredecessorUpdateCallback;
             typedef std::function<void (storm::storage::sparse::state_type const& state)> PriorityUpdateCallback;
             typedef std::function<bool (storm::storage::sparse::state_type const& state)> PredecessorFilterCallback;
             
-            static void eliminateState(storm::storage::sparse::state_type state, FlexibleSparseMatrix& matrix, FlexibleSparseMatrix& backwardTransitions, ValueUpdateCallback const& valueUpdateCallback, PredecessorUpdateCallback const& predecessorCallback, boost::optional<PriorityUpdateCallback> const& priorityUpdateCallback = boost::none, boost::optional<PredecessorFilterCallback> const& predecessorFilterCallback = boost::none, bool removeForwardTransitions = true);
+            static void eliminateState(storm::storage::sparse::state_type state, storm::storage::FlexibleSparseMatrix<ValueType>& matrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, ValueUpdateCallback const& valueUpdateCallback, PredecessorUpdateCallback const& predecessorCallback, boost::optional<PriorityUpdateCallback> const& priorityUpdateCallback = boost::none, boost::optional<PredecessorFilterCallback> const& predecessorFilterCallback = boost::none, bool removeForwardTransitions = true);
             
             static std::vector<uint_fast64_t> getDistanceBasedPriorities(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& transitionMatrixTransposed, storm::storage::BitVector const& initialStates, std::vector<ValueType> const& oneStepProbabilities, bool forward, bool reverse);
             
             static std::vector<std::size_t> getStateDistances(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& transitionMatrixTransposed, storm::storage::BitVector const& initialStates, std::vector<ValueType> const& oneStepProbabilities, bool forward);
             
-            static uint_fast64_t computeStatePenalty(storm::storage::sparse::state_type const& state, FlexibleSparseMatrix const& transitionMatrix, FlexibleSparseMatrix const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities);
+            static uint_fast64_t computeStatePenalty(storm::storage::sparse::state_type const& state, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities);
             
-            static uint_fast64_t computeStatePenaltyRegularExpression(storm::storage::sparse::state_type const& state, FlexibleSparseMatrix const& transitionMatrix, FlexibleSparseMatrix const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities);
+            static uint_fast64_t computeStatePenaltyRegularExpression(storm::storage::sparse::state_type const& state, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities);
             
-            static bool checkConsistent(FlexibleSparseMatrix& transitionMatrix, FlexibleSparseMatrix& backwardTransitions);
+            static bool checkConsistent(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions);
             
             // A flag that indicates whether this model checker is supposed to produce results for all states or just for the initial states.
             bool computeResultsForInitialStatesOnly;
diff --git a/src/storage/FlexibleSparseMatrix.cpp b/src/storage/FlexibleSparseMatrix.cpp
index b77f59736..10cda2ab2 100644
--- a/src/storage/FlexibleSparseMatrix.cpp
+++ b/src/storage/FlexibleSparseMatrix.cpp
@@ -2,14 +2,35 @@
 
 #include "src/storage/SparseMatrix.h"
 #include "src/storage/BitVector.h"
+#include "src/adapters/CarlAdapter.h"
+#include "src/utility/constants.h"
 
 namespace storm {
     namespace storage {
         template<typename ValueType>
-        FlexibleSparseMatrix<ValueType>::FlexibleSparseMatrix(index_type rows) : data(rows) {
+        FlexibleSparseMatrix<ValueType>::FlexibleSparseMatrix(index_type rows) : data(rows), columnCount(0), nonzeroEntryCount(0) {
             // Intentionally left empty.
         }
         
+        template<typename ValueType>
+        FlexibleSparseMatrix<ValueType>::FlexibleSparseMatrix(storm::storage::SparseMatrix<ValueType> const& matrix, bool setAllValuesToOne) : data(matrix.getRowCount()), columnCount(matrix.getColumnCount()), nonzeroEntryCount(matrix.getNonzeroEntryCount()) {
+            for (index_type rowIndex = 0; rowIndex < matrix.getRowCount(); ++rowIndex) {
+                typename storm::storage::SparseMatrix<ValueType>::const_rows row = matrix.getRow(rowIndex);
+                reserveInRow(rowIndex, row.getNumberOfEntries());
+                for (auto const& element : row) {
+                    // If the probability is zero, we skip this entry.
+                    if (storm::utility::isZero(element.getValue())) {
+                        continue;
+                    }
+                    if (setAllValuesToOne) {
+                        getRow(rowIndex).emplace_back(element.getColumn(), storm::utility::one<ValueType>());
+                    } else {
+                        getRow(rowIndex).emplace_back(element);
+                    }
+                }
+            }
+        }
+
         template<typename ValueType>
         void FlexibleSparseMatrix<ValueType>::reserveInRow(index_type row, index_type numberOfElements) {
             this->data[row].reserve(numberOfElements);
@@ -26,35 +47,33 @@ namespace storm {
         }
         
         template<typename ValueType>
-        typename FlexibleSparseMatrix<ValueType>::index_type FlexibleSparseMatrix<ValueType>::getNumberOfRows() const {
+        typename FlexibleSparseMatrix<ValueType>::index_type FlexibleSparseMatrix<ValueType>::getRowCount() const {
             return this->data.size();
         }
         
         template<typename ValueType>
-        bool FlexibleSparseMatrix<ValueType>::hasSelfLoop(storm::storage::sparse::state_type state) {
-            for (auto const& entry : this->getRow(state)) {
-                if (entry.getColumn() < state) {
-                    continue;
-                } else if (entry.getColumn() > state) {
-                    return false;
-                } else if (entry.getColumn() == state) {
-                    return true;
-                }
-            }
-            return false;
+        typename FlexibleSparseMatrix<ValueType>::index_type FlexibleSparseMatrix<ValueType>::getColumnCount() const {
+            return columnCount;
         }
         
         template<typename ValueType>
-        void FlexibleSparseMatrix<ValueType>::print() const {
-            for (uint_fast64_t index = 0; index < this->data.size(); ++index) {
-                std::cout << index << " - ";
-                for (auto const& element : this->getRow(index)) {
-                    std::cout << "(" << element.getColumn() << ", " << element.getValue() << ") ";
+        typename FlexibleSparseMatrix<ValueType>::index_type FlexibleSparseMatrix<ValueType>::getNonzeroEntryCount() const {
+            return nonzeroEntryCount;
+        }
+
+        template<typename ValueType>
+        void FlexibleSparseMatrix<ValueType>::updateDimensions() {
+            this->nonzeroEntryCount = 0;
+            this->columnCount = 0;
+            for (auto const& row : this->data) {
+                for (auto const& element : row) {
+                    assert(!storm::utility::isZero(element.getValue()));
+                    ++this->nonzeroEntryCount;
+                    this->columnCount = std::max(element.getColumn() + 1, this->columnCount);
                 }
-                std::cout << std::endl;
             }
         }
-        
+
         template<typename ValueType>
         bool FlexibleSparseMatrix<ValueType>::empty() const {
             for (auto const& row : this->data) {
@@ -64,25 +83,68 @@ namespace storm {
             }
             return true;
         }
-        
+
         template<typename ValueType>
-        void FlexibleSparseMatrix<ValueType>::filter(storm::storage::BitVector const& rowFilter, storm::storage::BitVector const& columnFilter) {
+        void FlexibleSparseMatrix<ValueType>::createSubmatrix(storm::storage::BitVector const& rowConstraint, storm::storage::BitVector const& columnConstraint) {
             for (uint_fast64_t rowIndex = 0; rowIndex < this->data.size(); ++rowIndex) {
                 auto& row = this->data[rowIndex];
-                if (!rowFilter.get(rowIndex)) {
+                if (!rowConstraint.get(rowIndex)) {
                     row.clear();
                     row.shrink_to_fit();
                     continue;
                 }
                 row_type newRow;
                 for (auto const& element : row) {
-                    if (columnFilter.get(element.getColumn())) {
+                    if (columnConstraint.get(element.getColumn())) {
                         newRow.push_back(element);
                     }
                 }
                 row = std::move(newRow);
             }
         }
+        
+        template<typename ValueType>
+        storm::storage::SparseMatrix<ValueType> FlexibleSparseMatrix<ValueType>::createSparseMatrix() {
+            storm::storage::SparseMatrixBuilder<ValueType> matrixBuilder(getRowCount(), getColumnCount());
+            for (uint_fast64_t rowIndex = 0; rowIndex < getRowCount(); ++rowIndex) {
+                auto& row = this->data[rowIndex];
+                for (auto const& entry : row) {
+                    matrixBuilder.addNextValue(rowIndex, entry.getColumn(), entry.getValue());
+                }
+            }
+            return matrixBuilder.build();
+        }
+
+        template<typename ValueType>
+        bool FlexibleSparseMatrix<ValueType>::rowHasDiagonalElement(storm::storage::sparse::state_type state) {
+            for (auto const& entry : this->getRow(state)) {
+                if (entry.getColumn() < state) {
+                    continue;
+                } else if (entry.getColumn() > state) {
+                    return false;
+                } else if (entry.getColumn() == state) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        template<typename ValueType>
+        std::ostream& operator<<(std::ostream& out, FlexibleSparseMatrix<ValueType> const& matrix) {
+            for (uint_fast64_t index = 0; index < matrix->data.size(); ++index) {
+                out << index << " - ";
+                for (auto const& element : matrix->getRow(index)) {
+                    out << "(" << element.getColumn() << ", " << element.getValue() << ") ";
+                }
+                return out;
+            }
+        }
+
+        // Explicitly instantiate the matrix.
+        template class FlexibleSparseMatrix<double>;
+#ifdef STORM_HAVE_CARL
+        template class FlexibleSparseMatrix<storm::RationalFunction>;
+#endif
 
-    }
-}
\ No newline at end of file
+    } // namespace storage
+} // namespace storm
\ No newline at end of file
diff --git a/src/storage/FlexibleSparseMatrix.h b/src/storage/FlexibleSparseMatrix.h
index 6a30109ac..e6ac6c97d 100644
--- a/src/storage/FlexibleSparseMatrix.h
+++ b/src/storage/FlexibleSparseMatrix.h
@@ -5,6 +5,7 @@
 #include <vector>
 
 #include "src/storage/sparse/StateType.h"
+#include "src/storage/SparseMatrix.h"
 
 namespace storm {
     namespace storage {
@@ -13,17 +14,14 @@ namespace storm {
         
         class BitVector;
         
+        /*!
+         * The flexible sparse matrix is used during state elimination.
+         */
         template<typename ValueType>
         class FlexibleSparseMatrix {
         public:
             // TODO: make this class a bit more consistent with the big sparse matrix and improve it:
-            // * rename getNumberOfRows -> getRowCount
-            // * store number of columns to also provide getColumnCount
-            // * rename hasSelfLoop -> rowHasDiagonalElement
             // * add output iterator and improve the way the matrix is printed
-            // * add conversion functionality from/to sparse matrix
-            // * add documentation
-            // * rename filter to something more appropriate (getSubmatrix?)
             // * add stuff like clearRow, multiplyRowWithScalar
             
             typedef uint_fast64_t index_type;
@@ -32,32 +30,113 @@ namespace storm {
             typedef typename row_type::iterator iterator;
             typedef typename row_type::const_iterator const_iterator;
             
+            /*!
+             * Constructs an empty flexible sparse matrix.
+             */
             FlexibleSparseMatrix() = default;
+
+            /*!
+             * Constructs a flexible sparse matrix with rows many rows.
+             * @param rows number of rows.
+             */
             FlexibleSparseMatrix(index_type rows);
-            
+
+            /*!
+             * Constructs a flexible sparse matrix from a sparse matrix.
+             * @param matrix Sparse matrix to construct from.
+             * @param setAllValuesToOne If true, all set entries are set to one. Default is false.
+             */
+            FlexibleSparseMatrix(storm::storage::SparseMatrix<ValueType> const& matrix, bool setAllValuesToOne = false);
+
+            /*!
+             * Reserves space for elements in row.
+             * @param row Row to reserve in.
+             * @param numberOfElements Number of elements to reserve space for.
+             */
             void reserveInRow(index_type row, index_type numberOfElements);
-            
+
+            /*!
+             * Returns an object representing the given row.
+             *
+             * @param row The row to get.
+             * @return An object representing the given row.
+             */
             row_type& getRow(index_type);
+
+            /*!
+             * Returns an object representing the given row.
+             *
+             * @param row The row to get.
+             * @return An object representing the given row.
+             */
             row_type const& getRow(index_type) const;
-            
-            index_type getNumberOfRows() const;
-            
-            void print() const;
-            
+
+            /*!
+             * Returns the number of rows of the matrix.
+             *
+             * @return The number of rows of the matrix.
+             */
+            index_type getRowCount() const;
+
+            /*!
+             * Returns the number of columns of the matrix.
+             *
+             * @return The number of columns of the matrix.
+             */
+            index_type getColumnCount() const;
+
+            /*!
+             * Returns the cached number of nonzero entries in the matrix.
+             *
+             * @return The number of nonzero entries in the matrix.
+             */
+            index_type getNonzeroEntryCount() const;
+
+            /*!
+             * Recomputes the number of columns and the number of non-zero entries.
+             */
+            void updateDimensions();
+
+            /*!
+             * Checks if the matrix has no elements.
+             * @return True, if the matrix is empty.
+             */
             bool empty() const;
-            
-            void filter(storm::storage::BitVector const& rowFilter, storm::storage::BitVector const& columnFilter);
-            
+
+            /*!
+             * Creates a submatrix of the current matrix in place by dropping all rows and columns whose bits are not
+             * set to one in the given bit vector.
+             *
+             * @param rowConstraint A bit vector indicating which rows to keep.
+             * @param columnConstraint A bit vector indicating which columns to keep.
+             */
+            void createSubmatrix(storm::storage::BitVector const& rowConstraint, storm::storage::BitVector const& columnConstraint);
+
+            /*!
+             * Creates a sparse matrix from the flexible sparse matrix.
+             * @return The sparse matrix.
+             */
+            storm::storage::SparseMatrix<ValueType> createSparseMatrix();
+
             /*!
              * Checks whether the given state has a self-loop with an arbitrary probability in the probability matrix.
              *
              * @param state The state for which to check whether it possesses a self-loop.
              * @return True iff the given state has a self-loop with an arbitrary probability in the probability matrix.
              */
-            bool hasSelfLoop(storm::storage::sparse::state_type state);
-            
+            bool rowHasDiagonalElement(storm::storage::sparse::state_type state);
+
+            template<typename TPrime>
+            friend std::ostream& operator<<(std::ostream& out, FlexibleSparseMatrix<TPrime> const& matrix);
+
         private:
             std::vector<row_type> data;
+
+            // The number of columns of the matrix.
+            index_type columnCount;
+
+            // The number of entries in the matrix.
+            index_type nonzeroEntryCount;
         };
     }
 }

From 49dc27077c2d3e5546456cfb13da65af6015a206 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 10 Feb 2016 17:23:38 +0100
Subject: [PATCH 076/246] Added row grouping members (but not the needed logic)

Former-commit-id: c4f7319e854fdc39e8a6d08caaa5099a923088ed
---
 src/storage/FlexibleSparseMatrix.cpp | 13 ++++++++++++-
 src/storage/FlexibleSparseMatrix.h   | 19 +++++++++++++++++++
 src/storage/SparseMatrix.cpp         |  5 +++++
 src/storage/SparseMatrix.h           |  7 +++++++
 4 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/src/storage/FlexibleSparseMatrix.cpp b/src/storage/FlexibleSparseMatrix.cpp
index 10cda2ab2..81e87ce20 100644
--- a/src/storage/FlexibleSparseMatrix.cpp
+++ b/src/storage/FlexibleSparseMatrix.cpp
@@ -13,7 +13,13 @@ namespace storm {
         }
         
         template<typename ValueType>
-        FlexibleSparseMatrix<ValueType>::FlexibleSparseMatrix(storm::storage::SparseMatrix<ValueType> const& matrix, bool setAllValuesToOne) : data(matrix.getRowCount()), columnCount(matrix.getColumnCount()), nonzeroEntryCount(matrix.getNonzeroEntryCount()) {
+        FlexibleSparseMatrix<ValueType>::FlexibleSparseMatrix(storm::storage::SparseMatrix<ValueType> const& matrix, bool setAllValuesToOne) : data(matrix.getRowCount()), columnCount(matrix.getColumnCount()), nonzeroEntryCount(matrix.getNonzeroEntryCount()), nontrivialRowGrouping(matrix.hasNontrivialRowGrouping()) {
+            if (nontrivialRowGrouping) {
+                rowGroupIndices = matrix.getRowGroupIndices();
+                rowIndications = matrix.getRowIndications();
+                // Not fully implemented yet
+                assert(false);
+            }
             for (index_type rowIndex = 0; rowIndex < matrix.getRowCount(); ++rowIndex) {
                 typename storm::storage::SparseMatrix<ValueType>::const_rows row = matrix.getRow(rowIndex);
                 reserveInRow(rowIndex, row.getNumberOfEntries());
@@ -83,6 +89,11 @@ namespace storm {
             }
             return true;
         }
+        
+        template<typename ValueType>
+        bool SparseMatrix<ValueType>::hasNontrivialRowGrouping() const {
+            return nontrivialRowGrouping;
+        }
 
         template<typename ValueType>
         void FlexibleSparseMatrix<ValueType>::createSubmatrix(storm::storage::BitVector const& rowConstraint, storm::storage::BitVector const& columnConstraint) {
diff --git a/src/storage/FlexibleSparseMatrix.h b/src/storage/FlexibleSparseMatrix.h
index e6ac6c97d..295b0337b 100644
--- a/src/storage/FlexibleSparseMatrix.h
+++ b/src/storage/FlexibleSparseMatrix.h
@@ -23,6 +23,7 @@ namespace storm {
             // TODO: make this class a bit more consistent with the big sparse matrix and improve it:
             // * add output iterator and improve the way the matrix is printed
             // * add stuff like clearRow, multiplyRowWithScalar
+            // * implement row grouping
             
             typedef uint_fast64_t index_type;
             typedef ValueType value_type;
@@ -102,6 +103,13 @@ namespace storm {
              * @return True, if the matrix is empty.
              */
             bool empty() const;
+            
+            /*!
+             * Retrieves whether the matrix has a (possibly) non-trivial row grouping.
+             *
+             * @return True iff the matrix has a (possibly) non-trivial row grouping.
+             */
+            bool hasNontrivialRowGrouping() const;
 
             /*!
              * Creates a submatrix of the current matrix in place by dropping all rows and columns whose bits are not
@@ -137,6 +145,17 @@ namespace storm {
 
             // The number of entries in the matrix.
             index_type nonzeroEntryCount;
+            
+            // A vector containing the indices at which each given row begins. The values of the entries in row i are
+            // data[rowIndications[i]] to data[rowIndications[i + 1]] where the last entry is not included anymore.
+            std::vector<index_type> rowIndications;
+            
+            // A flag that indicates whether the matrix has a non-trivial row-grouping, i.e. (possibly) more than one
+            // row per row group.
+            bool nontrivialRowGrouping;
+            
+            // A vector indicating the row groups of the matrix.
+            std::vector<index_type> rowGroupIndices;
         };
     }
 }
diff --git a/src/storage/SparseMatrix.cpp b/src/storage/SparseMatrix.cpp
index 253609210..04e941561 100644
--- a/src/storage/SparseMatrix.cpp
+++ b/src/storage/SparseMatrix.cpp
@@ -451,6 +451,11 @@ namespace storm {
         std::vector<typename SparseMatrix<ValueType>::index_type> const& SparseMatrix<ValueType>::getRowGroupIndices() const {
             return rowGroupIndices;
         }
+
+        template<typename ValueType>
+        std::vector<typename SparseMatrix<ValueType>::index_type> const& SparseMatrix<ValueType>::getRowIndications() const {
+            return rowIndications;
+        }
         
         template<typename ValueType>
         void SparseMatrix<ValueType>::makeRowsAbsorbing(storm::storage::BitVector const& rows) {
diff --git a/src/storage/SparseMatrix.h b/src/storage/SparseMatrix.h
index f9d9916c4..94defdfa5 100644
--- a/src/storage/SparseMatrix.h
+++ b/src/storage/SparseMatrix.h
@@ -549,6 +549,13 @@ namespace storm {
              */
             std::vector<index_type> const& getRowGroupIndices() const;
             
+            /*!
+             * Returns the indices where new row groups start.
+             *
+             * @return The indices where new row groups start.
+             */
+            std::vector<index_type> const& getRowIndications() const;
+            
             /*!
              * This function makes the given rows absorbing.
              *

From c319a997dad06c0deb8a156ebf278483ac569be0 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 10 Feb 2016 18:10:44 +0100
Subject: [PATCH 077/246] cmake lists from future

Former-commit-id: b3bc2f1bfb37a28baa6fbf503db1909a4c21c93d
---
 CMakeLists.txt                               | 4 ++--
 resources/3rdparty/cudd-2.5.0/CMakeLists.txt | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9f6a50f70..76d554806 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -132,7 +132,7 @@ else(CLANG)
     endif()
 
     add_definitions(-DBOOST_RESULT_OF_USE_DECLTYPE)
-    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -stdlib=${CLANG_STDLIB} -Wall -pedantic -Wno-newline-eof -Wno-mismatched-tags -Wno-unused-local-typedefs -ftemplate-depth=1024")
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -stdlib=${CLANG_STDLIB} -Wall -pedantic -Wno-newline-eof -Wno-mismatched-tags -Wno-unused-local-typedefs -ftemplate-depth=1024 -Wno-parentheses-equality")
 
     if(FORCE_COLOR)
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics")
@@ -188,7 +188,7 @@ if(CUSTOM_BOOST_ROOT)
 	set(BOOST_ROOT "${CUSTOM_BOOST_ROOT}")
 endif(CUSTOM_BOOST_ROOT)
 
-find_package(Boost REQUIRED)
+find_package(Boost 1.56.0 REQUIRED)
 
 if ((NOT Boost_LIBRARY_DIRS) OR ("${Boost_LIBRARY_DIRS}" STREQUAL ""))
 	set(Boost_LIBRARY_DIRS "${Boost_INCLUDE_DIRS}/stage/lib")
diff --git a/resources/3rdparty/cudd-2.5.0/CMakeLists.txt b/resources/3rdparty/cudd-2.5.0/CMakeLists.txt
index 4a39bd5da..5df298c34 100644
--- a/resources/3rdparty/cudd-2.5.0/CMakeLists.txt
+++ b/resources/3rdparty/cudd-2.5.0/CMakeLists.txt
@@ -26,7 +26,7 @@ elseif(MSVC)
 	# required for GMM to compile, ugly error directive in their code
 	add_definitions(/D_SCL_SECURE_NO_DEPRECATE /D_CRT_SECURE_NO_WARNINGS)
 else(CLANG)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-newline-eof -Wno-unneeded-internal-declaration -Wno-unused-variable -Wno-unused-const-variable")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-newline-eof -Wno-unneeded-internal-declaration -Wno-unused-variable -Wno-unused-const-variable -Wno-parentheses-equality")
 endif()
 
 # Since we do not target Alphas, this symbol is always set

From 42eb6714358d412d74590dc256d6bbab4b18ef13 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 10 Feb 2016 21:48:26 +0100
Subject: [PATCH 078/246] work towards const correctness and additional methods

Former-commit-id: 2c4667412c5b690e187a9f299b48c698e0ccf91c
---
 src/builder/ExplicitDFTModelBuilder.cpp |  6 ++--
 src/builder/ExplicitDFTModelBuilder.h   |  1 +
 src/storage/dft/DFT.cpp                 |  9 +++---
 src/storage/dft/DFT.h                   | 41 ++++++++++++++++++++-----
 src/storage/dft/DFTState.cpp            | 10 +++---
 src/storage/dft/DFTState.h              |  2 +-
 6 files changed, 47 insertions(+), 22 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 817295346..084b5fe7a 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -137,8 +137,8 @@ namespace storm {
 
                     // Construct new state as copy from original one
                     DFTStatePointer newState = std::make_shared<storm::storage::DFTState<ValueType>>(*state);
-                    std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType>>, bool> nextBEPair = newState->letNextBEFail(smallest++);
-                    std::shared_ptr<storm::storage::DFTBE<ValueType>> nextBE = nextBEPair.first;
+                    std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType> const>, bool> nextBEPair = newState->letNextBEFail(smallest++);
+                    std::shared_ptr<storm::storage::DFTBE<ValueType> const>& nextBE = nextBEPair.first;
                     assert(nextBE);
                     assert(nextBEPair.second == hasDependencies);
                     STORM_LOG_TRACE("with the failure of: " << nextBE->name() << " [" << nextBE->id() << "]");
@@ -192,7 +192,7 @@ namespace storm {
                         // Set failure rate according to usage
                         bool isUsed = true;
                         if (mDft.hasRepresentant(nextBE->id())) {
-                            DFTElementPointer representant = mDft.getRepresentant(nextBE->id());
+                            DFTElementCPointer representant = mDft.getRepresentant(nextBE->id());
                             // Used must be checked for the state we are coming from as this state is responsible for the
                             // rate and not the new state we are going to
                             isUsed = state->isUsed(representant->id());
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 6125b6fa1..67dec3dc4 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -20,6 +20,7 @@ namespace storm {
         class ExplicitDFTModelBuilder {
 
             using DFTElementPointer = std::shared_ptr<storm::storage::DFTElement<ValueType>>;
+            using DFTElementCPointer = std::shared_ptr<storm::storage::DFTElement<ValueType> const>;
             using DFTGatePointer = std::shared_ptr<storm::storage::DFTGate<ValueType>>;
             using DFTStatePointer = std::shared_ptr<storm::storage::DFTState<ValueType>>;
 
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 319a08925..b3f0dce7a 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -148,11 +148,10 @@ namespace storm {
         }
 
         template <typename ValueType>
-        bool DFT<ValueType>::rootOfClosedSubDFT(size_t index) const {
-            //boost::container::flat_set<size_t> marked;
-            //DFTElementPointer elem = getElement(index);
-
-
+        std::vector<size_t> DFT<ValueType>::getIndependentSubDftRoots(size_t index) const {
+            auto elem = getElement(index);
+            auto ISD = elem->independentSubDft();
+            return ISD;
         }
 
         // Explicitly instantiate the class.
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 92f1c0531..ecea467e4 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -9,7 +9,6 @@
 
 #include <boost/iterator/counting_iterator.hpp>
 
-#include "DFTIsomorphism.h"
 #include "DFTElements.h"
 #include "../BitVector.h"
 
@@ -37,6 +36,7 @@ namespace storm {
         class DFT {
 
             using DFTElementPointer = std::shared_ptr<DFTElement<ValueType>>;
+            using DFTElementCPointer = std::shared_ptr<DFTElement<ValueType> const>;
             using DFTElementVector = std::vector<DFTElementPointer>;
             using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
             using DFTGateVector = std::vector<DFTGatePointer>;
@@ -148,15 +148,40 @@ namespace storm {
              *  Get a pointer to an element in the DFT
              *  @param index The id of the element
              */
-            DFTElementPointer const& getElement(size_t index) const {
+            DFTElementCPointer getElement(size_t index) const {
                 assert(index < nrElements());
                 return mElements[index];
             }
 
-            std::shared_ptr<DFTBE<ValueType>> getBasicElement(size_t index) const {
-                assert(index < nrElements());
-                assert(mElements[index]->isBasicElement());
-                return std::static_pointer_cast<DFTBE<ValueType>>(mElements[index]);
+            bool isBasicElement(size_t index) const {
+                return getElement(index)->isBasicElement();
+            }
+
+            bool isGate(size_t index) const {
+                return getElement(index)->isGate();
+            }
+
+            bool isDependency(size_t index) const {
+                return getElement(index)->isDependency();
+            }
+
+//            std::shared_ptr<DFTGate<ValueType> const> getGate(size_t index) const {
+//                return
+//            }
+
+            std::shared_ptr<DFTBE<ValueType> const> getBasicElement(size_t index) const {
+                assert(isBasicElement(index));
+                return std::static_pointer_cast<DFTBE<ValueType> const>(mElements[index]);
+            }
+
+            std::shared_ptr<DFTGate<ValueType> const> getGate(size_t index) const {
+                assert(isGate(index));
+                return std::static_pointer_cast<DFTGate<ValueType> const>(mElements[index]);
+            }
+
+            std::shared_ptr<DFTDependency<ValueType> const> getDependency(size_t index) const {
+                assert(isDependency(index));
+                return std::static_pointer_cast<DFTDependency<ValueType> const>(mElements[index]);
             }
 
             std::vector<std::shared_ptr<DFTBE<ValueType>>> getBasicElements() const {
@@ -173,7 +198,7 @@ namespace storm {
                 return mRepresentants.find(id) != mRepresentants.end();
             }
 
-            DFTElementPointer getRepresentant(size_t id) const {
+            DFTElementCPointer getRepresentant(size_t id) const {
                 assert(hasRepresentant(id));
                 return getElement(mRepresentants.find(id)->second);
             }
@@ -196,7 +221,7 @@ namespace storm {
 
             std::string getStateString(DFTStatePointer const& state) const;
 
-            bool rootOfClosedSubDFT(size_t id) const;
+            std::vector<size_t> getIndependentSubDftRoots(size_t index) const;
         private:
             bool elementIndicesCorrect() const {
                 for(size_t i = 0; i < mElements.size(); ++i) {
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 17bb4aee8..672ca14a7 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -82,7 +82,7 @@ namespace storm {
         bool DFTState<ValueType>::updateFailableDependencies(size_t id) {
             assert(hasFailed(id));
             for (size_t i = 0; i < mDft.getDependencies().size(); ++i) {
-                std::shared_ptr<DFTDependency<ValueType>> dependency = std::static_pointer_cast<DFTDependency<ValueType>>(mDft.getElement(mDft.getDependencies()[i]));
+                std::shared_ptr<DFTDependency<ValueType> const> dependency = mDft.getDependency(mDft.getDependencies()[i]);
                 if (dependency->triggerEvent()->id() == id) {
                     if (!hasFailed(dependency->dependentEvent()->id())) {
                         mFailableDependencies.push_back(dependency->id());
@@ -94,21 +94,21 @@ namespace storm {
         }
 
         template<typename ValueType>
-        std::pair<std::shared_ptr<DFTBE<ValueType>>, bool> DFTState<ValueType>::letNextBEFail(size_t index)
+        std::pair<std::shared_ptr<DFTBE<ValueType> const>, bool> DFTState<ValueType>::letNextBEFail(size_t index)
         {
             STORM_LOG_TRACE("currently failable: " << getCurrentlyFailableString());
             if (nrFailableDependencies() > 0) {
                 // Consider failure due to dependency
                 assert(index < nrFailableDependencies());
-                std::shared_ptr<DFTDependency<ValueType>> dependency = std::static_pointer_cast<DFTDependency<ValueType>>(mDft.getElement(mFailableDependencies[index]));
-                std::pair<std::shared_ptr<DFTBE<ValueType>>,bool> res(mDft.getBasicElement(dependency->dependentEvent()->id()), true);
+                std::shared_ptr<DFTDependency<ValueType> const> dependency = mDft.getDependency(mFailableDependencies[index]);
+                std::pair<std::shared_ptr<DFTBE<ValueType> const>,bool> res(mDft.getBasicElement(dependency->dependentEvent()->id()), true);
                 mFailableDependencies.erase(mFailableDependencies.begin() + index);
                 setFailed(res.first->id());
                 return res;
             } else {
                 // Consider "normal" failure
                 assert(index < nrFailableBEs());
-                std::pair<std::shared_ptr<DFTBE<ValueType>>,bool> res(mDft.getBasicElement(mIsCurrentlyFailableBE[index]), false);
+                std::pair<std::shared_ptr<DFTBE<ValueType> const>,bool> res(mDft.getBasicElement(mIsCurrentlyFailableBE[index]), false);
                 mIsCurrentlyFailableBE.erase(mIsCurrentlyFailableBE.begin() + index);
                 setFailed(res.first->id());
                 return res;
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index a1bab2583..17a9c2d3b 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -127,7 +127,7 @@ namespace storm {
              * @param smallestIndex Index in currentlyFailableBE of BE to fail
              * @return Pair of BE which fails and flag indicating if the failure was due to functional dependencies
              */
-            std::pair<std::shared_ptr<DFTBE<ValueType>>, bool> letNextBEFail(size_t smallestIndex = 0);
+            std::pair<std::shared_ptr<DFTBE<ValueType> const>, bool> letNextBEFail(size_t smallestIndex = 0);
             
             std::string getCurrentlyFailableString() const {
                 std::stringstream stream;

From 0e38738e099de659707bc17fac9d51051a1afa7a Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 11 Feb 2016 00:16:12 +0100
Subject: [PATCH 079/246] DFT element types and some extensions to the elements
 API

Former-commit-id: cb70dee35af68d359e3f011cc4ff962813fdc508
---
 src/storage/dft/DFTBuilder.cpp   |  2 +-
 src/storage/dft/DFTElementType.h |  4 +-
 src/storage/dft/DFTElements.h    | 77 ++++++++++++++++++++++++++------
 3 files changed, 67 insertions(+), 16 deletions(-)

diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index fffd33946..00e416d54 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -109,7 +109,7 @@ namespace storm {
                     STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type handled separately.");
                 case DFTElementType::CONSTF:
                 case DFTElementType::CONSTS:
-                case DFTElementType::FDEP:
+                case DFTElementType::PDEP:
                     STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type not supported.");
                 default:
                     STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type not known.");
diff --git a/src/storage/dft/DFTElementType.h b/src/storage/dft/DFTElementType.h
index 9aba9fa54..98d58df5c 100644
--- a/src/storage/dft/DFTElementType.h
+++ b/src/storage/dft/DFTElementType.h
@@ -4,7 +4,7 @@
 namespace storm {
     namespace storage {
 
-        enum class DFTElementType : int {AND = 0, COUNTING = 1, OR = 2, VOT = 3, BE = 4, CONSTF = 5, CONSTS = 6, PAND = 7, SPARE = 8, POR = 9, FDEP = 10, SEQAND = 11};
+        enum class DFTElementType : int {AND = 0, COUNTING = 1, OR = 2, VOT = 3, BE = 4, CONSTF = 5, CONSTS = 6, PAND = 7, SPARE = 8, POR = 9, PDEP = 10, SEQAND = 11};
 
         inline bool isGateType(DFTElementType const& tp) {
             switch(tp) {
@@ -20,7 +20,7 @@ namespace storm {
                 case DFTElementType::BE:
                 case DFTElementType::CONSTF:
                 case DFTElementType::CONSTS:
-                case DFTElementType::FDEP:
+                case DFTElementType::PDEP:
                     return false;
                 default:
                     assert(false);
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index fb5123180..a6ee87ea5 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -51,6 +51,8 @@ namespace storm {
                 return mId;
             }
 
+            virtual DFTElementType type() const = 0;
+
             virtual void setRank(size_t rank) {
                 mRank = rank;
             }
@@ -114,7 +116,11 @@ namespace storm {
             bool hasParents() const {
                 return !mParents.empty();
             }
-            
+
+            size_t nrParents() const {
+                return mParents.size();
+            }
+
             DFTGateVector const& parents() const {
                 return mParents;
             }
@@ -348,7 +354,11 @@ namespace storm {
             DFTBE(size_t id, std::string const& name, ValueType failureRate, ValueType dormancyFactor) :
                     DFTElement<ValueType>(id, name), mActiveFailureRate(failureRate), mPassiveFailureRate(dormancyFactor * failureRate)
             {}
-                        
+
+            DFTElementType type() const override {
+                return DFTElementType::BE;
+            }
+
             virtual size_t nrChildren() const {
                 return 0;
             }
@@ -393,7 +403,16 @@ namespace storm {
             DFTConst(size_t id, std::string const& name, bool failed) :
                     DFTElement<ValueType>(id, name), mFailed(failed)
             {}
-            
+
+            DFTElementType type() const override {
+                if(mFailed) {
+                    return DFTElementType::CONSTF;
+                } else {
+                    return DFTElementType::CONSTS;
+                }
+            }
+
+
             bool failed() const {
                 return mFailed;
             }
@@ -438,15 +457,15 @@ namespace storm {
                 mDependentEvent = dependentEvent;
             }
 
-            std::string nameTrigger() {
+            std::string nameTrigger() const {
                 return mNameTrigger;
             }
 
-            std::string nameDependent() {
+            std::string nameDependent() const {
                 return mNameDependent;
             }
 
-            ValueType probability() {
+            ValueType const& probability() const {
                 return mProbability;
             }
 
@@ -460,6 +479,10 @@ namespace storm {
                 return mDependentEvent;
             }
 
+            DFTElementType type() const override {
+                return DFTElementType::PDEP;
+            }
+
             virtual size_t nrChildren() const override {
                 return 1;
             }
@@ -519,6 +542,10 @@ namespace storm {
                     this->childrenDontCare(state, queues);
                 }
             }
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::AND;
+            }
             
             std::string typestring() const {
                 return "AND";
@@ -555,6 +582,10 @@ namespace storm {
                  }
                  this->failsafe(state, queues);
             }
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::OR;
+            }
             
             std::string typestring() const {
                 return "OR";
@@ -606,8 +637,12 @@ namespace storm {
                 }
                 //return false;
             }
-            
-            std::string  typestring() const {
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::SEQAND;
+            }
+
+            std::string  typestring() const override {
                 return "SEQAND";
             }
         };
@@ -653,8 +688,12 @@ namespace storm {
                     this->childrenDontCare(state, queues);
                 }
             }
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::PAND;
+            }
             
-            std::string typestring() const {
+            std::string typestring() const override {
                 return "PAND";
             }
         };
@@ -680,8 +719,12 @@ namespace storm {
             void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
                 assert(false);
             }
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::POR;
+            }
             
-            std::string  typestring() const {
+            std::string  typestring() const override {
                 return "POR";
             }
         };
@@ -740,6 +783,10 @@ namespace storm {
                     }
                 }
             }
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::VOT;
+            }
             
             std::string typestring() const {
                 return "VOT (" + std::to_string(mThreshold) + ")";
@@ -766,11 +813,15 @@ namespace storm {
                     DFTGate<ValueType>(id, name, children)
             {}
             
-            std::string typestring() const {
+            std::string typestring() const override {
                 return "SPARE";
             }
-            
-            bool isSpareGate() const {
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::SPARE;
+            }
+
+            bool isSpareGate() const override {
                 return true;
             }
             

From 27521fc0272ef031a60ec0f7fa2e4114d414fc5a Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 11 Feb 2016 00:19:29 +0100
Subject: [PATCH 080/246] fixed some warnings

Former-commit-id: ed6fbfc6bae8ac7aeb51faba30e539425109857f
---
 src/storage/dft/DFTElements.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index a6ee87ea5..a1f4a5819 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -359,7 +359,7 @@ namespace storm {
                 return DFTElementType::BE;
             }
 
-            virtual size_t nrChildren() const {
+            virtual size_t nrChildren() const override {
                 return 0;
             }
 
@@ -371,17 +371,17 @@ namespace storm {
                 return mPassiveFailureRate;
             }
         
-            std::string toString() const {
+            std::string toString() const override {
                 std::stringstream stream;
                 stream << *this;
                 return stream.str();
             }
             
-            bool isBasicElement() const {
+            bool isBasicElement() const override{
                 return true;
             }
             
-            bool isColdBasicElement() const {
+            bool isColdBasicElement() const override{
                 return storm::utility::isZero(mPassiveFailureRate);
             }
             virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const;
@@ -421,7 +421,7 @@ namespace storm {
                 return true;
             }
             
-            virtual size_t nrChildren() const {
+            virtual size_t nrChildren() const override {
                 return 0;
             }
             
@@ -547,7 +547,7 @@ namespace storm {
                 return DFTElementType::AND;
             }
             
-            std::string typestring() const {
+            std::string typestring() const override {
                 return "AND";
             }
         };
@@ -587,7 +587,7 @@ namespace storm {
                 return DFTElementType::OR;
             }
             
-            std::string typestring() const {
+            std::string typestring() const override {
                 return "OR";
             }
         };
@@ -788,7 +788,7 @@ namespace storm {
                 return DFTElementType::VOT;
             }
             
-            std::string typestring() const {
+            std::string typestring() const override{
                 return "VOT (" + std::to_string(mThreshold) + ")";
             }
 

From a1f05b185336bb8638c8d5eb24142dc517697c93 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 11 Feb 2016 10:38:26 +0100
Subject: [PATCH 081/246] Set override

Former-commit-id: c8e7c5b690848caf5afbb3fbc15e7301f47e151a
---
 src/storage/dft/DFTElements.h | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index a1f4a5819..9778d9146 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -384,7 +384,7 @@ namespace storm {
             bool isColdBasicElement() const override{
                 return storm::utility::isZero(mPassiveFailureRate);
             }
-            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const;
+            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override;
         };
 
         template<typename ValueType>
@@ -523,7 +523,7 @@ namespace storm {
                     DFTGate<ValueType>(id, name, children)
             {}
 
-            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 if(state.isOperational(this->mId)) {
                     for(auto const& child : this->mChildren)
                     {
@@ -535,7 +535,7 @@ namespace storm {
                 }
             }
 
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 assert(this->hasFailsafeChild(state));
                 if(state.isOperational(this->mId)) {
                     this->failsafe(state, queues);
@@ -567,14 +567,14 @@ namespace storm {
                     DFTGate<ValueType>(id, name, children)
             {}
 
-            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 assert(this->hasFailedChild(state));
                 if(state.isOperational(this->mId)) {
                     this->fail(state, queues);
                 }
             }
 
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                  for(auto const& child : this->mChildren) {
                      if(!state.isFailsafe(child->id())) {
                          return;
@@ -662,7 +662,7 @@ namespace storm {
                     DFTGate<ValueType>(id, name, children)
             {}
 
-            void checkFails(storm::storage::DFTState<ValueType>& state,  DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+            void checkFails(storm::storage::DFTState<ValueType>& state,  DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 if(state.isOperational(this->mId)) {
                     bool childOperationalBefore = false;
                     for(auto const& child : this->mChildren)
@@ -681,7 +681,7 @@ namespace storm {
                 }
             }
 
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 assert(this->hasFailsafeChild(state));
                 if(state.isOperational(this->mId)) {
                     this->failsafe(state, queues);
@@ -712,11 +712,11 @@ namespace storm {
                     DFTGate<ValueType>(id, name, children)
             {}
 
-            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                  assert(false);
             }
 
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 assert(false);
             }
 
@@ -747,7 +747,7 @@ namespace storm {
                     DFTGate<ValueType>(id, name, children), mThreshold(threshold)
             {}
 
-            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 if(state.isOperational(this->mId)) {
                     unsigned nrFailedChildren = 0;
                     for(auto const& child : this->mChildren)
@@ -765,7 +765,7 @@ namespace storm {
                 } 
             }
 
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 assert(this->hasFailsafeChild(state));
                 if(state.isOperational(this->mId)) {
                     unsigned nrFailsafeChildren = 0;
@@ -838,7 +838,7 @@ namespace storm {
                 state.setUsesAtPosition(mUseIndex, this->mChildren[0]->id());
             }
 
-            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 if(state.isOperational(this->mId)) {
                     size_t uses = state.extractUses(mUseIndex);
                     if(!state.isOperational(uses)) {
@@ -850,7 +850,7 @@ namespace storm {
                 } 
             }
 
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 if(state.isOperational(this->mId)) {
                     if(state.isFailsafe(state.extractUses((mUseIndex)))) {
                         this->failsafe(state, queues);

From d60afed273dcef7be7ac6de77c35941ca276c745 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 11 Feb 2016 10:45:20 +0100
Subject: [PATCH 082/246] MA model checking can be called now for doubles

Former-commit-id: a20f2babc4e950e720a8e5f346de5921d6843592
---
 src/utility/storm.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/utility/storm.h b/src/utility/storm.h
index 11dfe6d91..f297d9e41 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -59,6 +59,7 @@
 #include "src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h"
 #include "src/modelchecker/csl/SparseCtmcCslModelChecker.h"
 #include "src/modelchecker/csl/helper/SparseCtmcCslHelper.h"
+#include "src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.h"
 #include "src/modelchecker/csl/HybridCtmcCslModelChecker.h"
 #include "src/modelchecker/results/ExplicitQualitativeCheckResult.h"
 #include "src/modelchecker/results/SymbolicQualitativeCheckResult.h"
@@ -297,6 +298,13 @@ namespace storm {
 
             storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<ValueType>> modelchecker(*ctmc);
             result = modelchecker.check(task);
+        } else if (model->getType() == storm::models::ModelType::MarkovAutomaton) {
+            std::shared_ptr<storm::models::sparse::MarkovAutomaton<ValueType>> ma = model->template as<storm::models::sparse::MarkovAutomaton<ValueType>>();
+
+            storm::modelchecker::SparseMarkovAutomatonCslModelChecker<storm::models::sparse::MarkovAutomaton<ValueType>> modelchecker(*ma);
+            result = modelchecker.check(task);
+        } else {
+            STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The model type " << model->getType() << " is not supported.");
         }
         return result;
 

From 7a10a04cde5e8a9f8ada836449b08ae4462eff2a Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 12 Feb 2016 13:18:04 +0100
Subject: [PATCH 083/246] Created StateEliminator with specialized subclasses

Former-commit-id: 991e3fcfcdb061fbd1f9689692ea60faf48a1958
---
 .../SparseDtmcEliminationModelChecker.cpp     | 326 ++----------------
 .../SparseDtmcEliminationModelChecker.h       |  41 +--
 .../ConditionalEliminator.cpp                 |  53 +++
 .../stateelimination/ConditionalEliminator.h  |  53 +++
 .../LongRunAverageEliminator.cpp              |  47 +++
 .../LongRunAverageEliminator.h                |  36 ++
 .../PrioritizedEliminator.cpp                 |  45 +++
 .../stateelimination/PrioritizedEliminator.h  |  34 ++
 .../stateelimination/StateEliminator.cpp      | 259 ++++++++++++++
 src/solver/stateelimination/StateEliminator.h |  42 +++
 10 files changed, 626 insertions(+), 310 deletions(-)
 create mode 100644 src/solver/stateelimination/ConditionalEliminator.cpp
 create mode 100644 src/solver/stateelimination/ConditionalEliminator.h
 create mode 100644 src/solver/stateelimination/LongRunAverageEliminator.cpp
 create mode 100644 src/solver/stateelimination/LongRunAverageEliminator.h
 create mode 100644 src/solver/stateelimination/PrioritizedEliminator.cpp
 create mode 100644 src/solver/stateelimination/PrioritizedEliminator.h
 create mode 100644 src/solver/stateelimination/StateEliminator.cpp
 create mode 100644 src/solver/stateelimination/StateEliminator.h

diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
index 0b520c168..e01987f3f 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
@@ -25,6 +25,10 @@
 #include "src/exceptions/InvalidSettingsException.h"
 #include "src/exceptions/IllegalArgumentException.h"
 
+#include "src/solver/stateelimination/LongRunAverageEliminator.h"
+#include "src/solver/stateelimination/ConditionalEliminator.h"
+#include "src/solver/stateelimination/PrioritizedEliminator.h"
+
 namespace storm {
     namespace modelchecker {
         
@@ -300,30 +304,13 @@ namespace storm {
             std::vector<ValueType> averageTimeInStates(stateValues.size(), storm::utility::one<ValueType>());
             
             // First, we eliminate all states in BSCCs (except for the representative states).
-            {
-                std::unique_ptr<StatePriorityQueue> priorityQueue = createStatePriorityQueue(distanceBasedPriorities, flexibleMatrix, flexibleBackwardTransitions, stateValues, regularStatesInBsccs);
-                
-                ValueUpdateCallback valueUpdateCallback = [&stateValues,&averageTimeInStates] (storm::storage::sparse::state_type const& state, ValueType const& loopProbability) {
-                    stateValues[state] = storm::utility::simplify(loopProbability * stateValues[state]);
-                    averageTimeInStates[state] = storm::utility::simplify(loopProbability * averageTimeInStates[state]);
-                };
-                
-                PredecessorUpdateCallback predecessorCallback = [&stateValues,&averageTimeInStates] (storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) {
-                    stateValues[predecessor] = storm::utility::simplify(stateValues[predecessor] + storm::utility::simplify(probability * stateValues[state]));
-                    averageTimeInStates[predecessor] = storm::utility::simplify(averageTimeInStates[predecessor] + storm::utility::simplify(probability * averageTimeInStates[state]));
-                };
-                
-                boost::optional<PriorityUpdateCallback> priorityUpdateCallback = PriorityUpdateCallback([&flexibleMatrix,&flexibleBackwardTransitions,&stateValues,&priorityQueue] (storm::storage::sparse::state_type const& state) {
-                    priorityQueue->update(state, flexibleMatrix, flexibleBackwardTransitions, stateValues);
-                });
-                
-                boost::optional<PredecessorFilterCallback> predecessorFilterCallback = boost::none;
-                
-                while (priorityQueue->hasNextState()) {
-                    storm::storage::sparse::state_type state = priorityQueue->popNextState();
-                    eliminateState(state, flexibleMatrix, flexibleBackwardTransitions, valueUpdateCallback, predecessorCallback, priorityUpdateCallback, predecessorFilterCallback, true);
-                    STORM_LOG_ASSERT(checkConsistent(flexibleMatrix, flexibleBackwardTransitions), "The forward and backward transition matrices became inconsistent.");
-                }
+            std::unique_ptr<StatePriorityQueue<ValueType>> priorityQueue = createStatePriorityQueue(distanceBasedPriorities, flexibleMatrix, flexibleBackwardTransitions, stateValues, regularStatesInBsccs);
+            storm::solver::stateelimination::LongRunAverageEliminator<SparseDtmcModelType> stateEliminator(flexibleMatrix, flexibleBackwardTransitions, *priorityQueue, stateValues, averageTimeInStates);
+            
+            while (priorityQueue->hasNextState()) {
+                storm::storage::sparse::state_type state = priorityQueue->popNextState();
+                stateEliminator.eliminateState(state, true);
+                STORM_LOG_ASSERT(checkConsistent(flexibleMatrix, flexibleBackwardTransitions), "The forward and backward transition matrices became inconsistent.");
             }
             
             // Now, we set the values of all states in BSCCs to that of the representative value (and clear the
@@ -743,7 +730,7 @@ namespace storm {
             storm::storage::FlexibleSparseMatrix<ValueType> flexibleBackwardTransitions(submatrixTransposed, true);
             std::chrono::high_resolution_clock::time_point conversionEnd = std::chrono::high_resolution_clock::now();
             
-            std::unique_ptr<StatePriorityQueue> statePriorities = createStatePriorityQueue(distanceBasedPriorities, flexibleMatrix, flexibleBackwardTransitions, oneStepProbabilities, statesToEliminate);
+            std::unique_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, flexibleMatrix, flexibleBackwardTransitions, oneStepProbabilities, statesToEliminate);
 
             STORM_LOG_INFO("Computing conditional probilities." << std::endl);
             std::chrono::high_resolution_clock::time_point modelCheckingStart = std::chrono::high_resolution_clock::now();
@@ -752,15 +739,11 @@ namespace storm {
             performPrioritizedStateElimination(statePriorities, flexibleMatrix, flexibleBackwardTransitions, oneStepProbabilities, this->getModel().getInitialStates(), true);
             STORM_LOG_INFO("Eliminated " << numberOfStatesToEliminate << " states." << std::endl);
             
-            // Prepare some callbacks for the elimination procedure.
-            ValueUpdateCallback valueUpdateCallback = [&oneStepProbabilities] (storm::storage::sparse::state_type const& state, ValueType const& loopProbability) { oneStepProbabilities[state] = storm::utility::simplify(loopProbability * oneStepProbabilities[state]); };
-            PredecessorUpdateCallback predecessorUpdateCallback = [&oneStepProbabilities] (storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) { oneStepProbabilities[predecessor] = storm::utility::simplify(oneStepProbabilities[predecessor] * storm::utility::simplify(probability * oneStepProbabilities[state])); };
-            boost::optional<PredecessorFilterCallback> phiFilterCallback = PredecessorFilterCallback([&phiStates] (storm::storage::sparse::state_type const& state) { return phiStates.get(state); });
-            boost::optional<PredecessorFilterCallback> psiFilterCallback = PredecessorFilterCallback([&psiStates] (storm::storage::sparse::state_type const& state) { return psiStates.get(state); });
+            storm::solver::stateelimination::ConditionalEliminator<SparseDtmcModelType> stateEliminator = storm::solver::stateelimination::ConditionalEliminator<SparseDtmcModelType>(flexibleMatrix, flexibleBackwardTransitions, oneStepProbabilities, phiStates, psiStates);
             
             // Eliminate the transitions going into the initial state (if there are any).
             if (!flexibleBackwardTransitions.getRow(*newInitialStates.begin()).empty()) {
-                eliminateState(*newInitialStates.begin(), flexibleMatrix, flexibleBackwardTransitions, valueUpdateCallback, predecessorUpdateCallback, boost::none, boost::none, false);
+                stateEliminator.eliminateState(*newInitialStates.begin(), false);
             }
             
             // Now we need to basically eliminate all chains of not-psi states after phi states and chains of not-phi
@@ -795,7 +778,9 @@ namespace storm {
                                     // Eliminate the successor only if there possibly is a psi state reachable through it.
                                     if (successorRow.size() > 1 || (!successorRow.empty() && successorRow.front().getColumn() != element.getColumn())) {
                                         STORM_LOG_TRACE("Found non-psi successor " << element.getColumn() << " that needs to be eliminated.");
-                                        eliminateState(element.getColumn(), flexibleMatrix, flexibleBackwardTransitions, valueUpdateCallback, predecessorUpdateCallback, boost::none, phiFilterCallback, false);
+                                        stateEliminator.setStatePhi();
+                                        stateEliminator.eliminateState(element.getColumn(), false);
+                                        stateEliminator.clearState();
                                         hasNonPsiSuccessor = true;
                                     }
                                 }
@@ -824,7 +809,9 @@ namespace storm {
                                     FlexibleRowType const& successorRow = flexibleMatrix.getRow(element.getColumn());
                                     if (successorRow.size() > 1 || (!successorRow.empty() && successorRow.front().getColumn() != element.getColumn())) {
                                         STORM_LOG_TRACE("Found non-phi successor " << element.getColumn() << " that needs to be eliminated.");
-                                        eliminateState(element.getColumn(), flexibleMatrix, flexibleBackwardTransitions, valueUpdateCallback, predecessorUpdateCallback, boost::none, psiFilterCallback, false);
+                                        stateEliminator.setStatePsi();
+                                        stateEliminator.eliminateState(element.getColumn(), false);
+                                        stateEliminator.clearState();
                                         hasNonPhiSuccessor = true;
                                     }
                                 }
@@ -890,7 +877,7 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        std::unique_ptr<typename SparseDtmcEliminationModelChecker<SparseDtmcModelType>::StatePriorityQueue> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& distanceBasedStatePriorities, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector const& states) {
+        std::unique_ptr<StatePriorityQueue<typename SparseDtmcModelType::ValueType>> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& distanceBasedStatePriorities, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector const& states) {
             
             STORM_LOG_TRACE("Creating state priority queue for states " << states);
             
@@ -934,23 +921,20 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        std::unique_ptr<typename SparseDtmcEliminationModelChecker<SparseDtmcModelType>::StatePriorityQueue> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::createNaivePriorityQueue(storm::storage::BitVector const& states) {
+        std::unique_ptr<StatePriorityQueue<typename SparseDtmcModelType::ValueType>> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::createNaivePriorityQueue(storm::storage::BitVector const& states) {
             std::vector<storm::storage::sparse::state_type> sortedStates(states.begin(), states.end());
-            return std::unique_ptr<StatePriorityQueue>(new StaticStatePriorityQueue(sortedStates));
+            return std::unique_ptr<StatePriorityQueue<ValueType>>(new StaticStatePriorityQueue(sortedStates));
         }
         
         template<typename SparseDtmcModelType>
-        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::performPrioritizedStateElimination(std::unique_ptr<StatePriorityQueue>& priorityQueue, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, std::vector<ValueType>& values, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly) {
+        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::performPrioritizedStateElimination(std::unique_ptr<StatePriorityQueue<ValueType>>& priorityQueue, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, std::vector<ValueType>& values, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly) {
             
-            ValueUpdateCallback valueUpdateCallback = [&values] (storm::storage::sparse::state_type const& state, ValueType const& loopProbability) { values[state] = storm::utility::simplify(loopProbability * values[state]); };
-            PredecessorUpdateCallback predecessorCallback = [&values] (storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) { values[predecessor] = storm::utility::simplify(values[predecessor] + storm::utility::simplify(probability * values[state])); };
-            boost::optional<PriorityUpdateCallback> priorityUpdateCallback = PriorityUpdateCallback([&transitionMatrix,&backwardTransitions,&values,&priorityQueue] (storm::storage::sparse::state_type const& state) { priorityQueue->update(state, transitionMatrix, backwardTransitions, values); });
-            boost::optional<PredecessorFilterCallback> predecessorFilterCallback = boost::none;
+            storm::solver::stateelimination::PrioritizedEliminator<SparseDtmcModelType> stateEliminator(transitionMatrix, backwardTransitions, *priorityQueue, values);
             
             while (priorityQueue->hasNextState()) {
                 storm::storage::sparse::state_type state = priorityQueue->popNextState();
                 bool removeForwardTransitions = computeResultsForInitialStatesOnly && !initialStates.get(state);
-                eliminateState(state, transitionMatrix, backwardTransitions, valueUpdateCallback, predecessorCallback, priorityUpdateCallback, predecessorFilterCallback, removeForwardTransitions);
+                stateEliminator.eliminateState(state, removeForwardTransitions);
                 if (removeForwardTransitions) {
                     values[state] = storm::utility::zero<ValueType>();
                 }
@@ -960,7 +944,7 @@ namespace storm {
         
         template<typename SparseDtmcModelType>
         void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::performOrdinaryStateElimination(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities) {
-            std::unique_ptr<StatePriorityQueue> statePriorities = createStatePriorityQueue(distanceBasedPriorities, transitionMatrix, backwardTransitions, values, subsystem);
+            std::unique_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, transitionMatrix, backwardTransitions, values, subsystem);
             
             std::size_t numberOfStatesToEliminate = statePriorities->size();
             STORM_LOG_DEBUG("Eliminating " << numberOfStatesToEliminate << " states using the state elimination technique." << std::endl);
@@ -979,7 +963,7 @@ namespace storm {
             if (storm::settings::sparseDtmcEliminationModelCheckerSettings().isEliminateEntryStatesLastSet()) {
                 STORM_LOG_DEBUG("Eliminating " << entryStateQueue.size() << " entry states as a last step.");
                 std::vector<storm::storage::sparse::state_type> sortedStates(entryStateQueue.begin(), entryStateQueue.end());
-                std::unique_ptr<StatePriorityQueue> queuePriorities = std::unique_ptr<StatePriorityQueue>(new StaticStatePriorityQueue(sortedStates));
+                std::unique_ptr<StatePriorityQueue<ValueType>> queuePriorities = std::unique_ptr<StatePriorityQueue<ValueType>>(new StaticStatePriorityQueue(sortedStates));
                 performPrioritizedStateElimination(queuePriorities, transitionMatrix, backwardTransitions, values, initialStates, computeResultsForInitialStatesOnly);
             }
             STORM_LOG_DEBUG("Eliminated " << subsystem.size() << " states." << std::endl);
@@ -1078,7 +1062,7 @@ namespace storm {
                     }
                 }
                 
-                std::unique_ptr<StatePriorityQueue> statePriorities = createStatePriorityQueue(distanceBasedPriorities, matrix, backwardTransitions, values, statesInTrivialSccs);
+                std::unique_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, matrix, backwardTransitions, values, statesInTrivialSccs);
                 STORM_LOG_TRACE("Eliminating " << statePriorities->size() << " trivial SCCs.");
                 performPrioritizedStateElimination(statePriorities, matrix, backwardTransitions, values, initialStates, computeResultsForInitialStatesOnly);
                 STORM_LOG_TRACE("Eliminated all trivial SCCs.");
@@ -1108,7 +1092,7 @@ namespace storm {
             } else {
                 // In this case, we perform simple state elimination in the current SCC.
                 STORM_LOG_TRACE("SCC of size " << scc.getNumberOfSetBits() << " is small enough to be eliminated directly.");
-                std::unique_ptr<StatePriorityQueue> statePriorities = createStatePriorityQueue(distanceBasedPriorities, matrix, backwardTransitions, values, scc & ~entryStates);
+                std::unique_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, matrix, backwardTransitions, values, scc & ~entryStates);
                 performPrioritizedStateElimination(statePriorities, matrix, backwardTransitions, values, initialStates, computeResultsForInitialStatesOnly);
                 STORM_LOG_TRACE("Eliminated all states of SCC.");
             }
@@ -1116,7 +1100,7 @@ namespace storm {
             // Finally, eliminate the entry states (if we are required to do so).
             if (eliminateEntryStates) {
                 STORM_LOG_TRACE("Finally, eliminating entry states.");
-                std::unique_ptr<StatePriorityQueue> naivePriorities = createNaivePriorityQueue(entryStates);
+                std::unique_ptr<StatePriorityQueue<ValueType>> naivePriorities = createNaivePriorityQueue(entryStates);
                 performPrioritizedStateElimination(naivePriorities, matrix, backwardTransitions, values, initialStates, computeResultsForInitialStatesOnly);
                 STORM_LOG_TRACE("Eliminated/added entry states.");
             } else {
@@ -1129,242 +1113,6 @@ namespace storm {
             return maximalDepth;
         }
         
-        template<typename SparseDtmcModelType>
-        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::eliminateState(storm::storage::sparse::state_type state, storm::storage::FlexibleSparseMatrix<ValueType>& matrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, ValueUpdateCallback const& callback, PredecessorUpdateCallback const& predecessorCallback, boost::optional<PriorityUpdateCallback> const& priorityUpdateCallback, boost::optional<PredecessorFilterCallback> const& predecessorFilterCallback, bool removeForwardTransitions) {
-            
-            STORM_LOG_TRACE("Eliminating state " << state << ".");
-            
-            // Start by finding loop probability.
-            bool hasSelfLoop = false;
-            ValueType loopProbability = storm::utility::zero<ValueType>();
-            FlexibleRowType& currentStateSuccessors = matrix.getRow(state);
-            for (auto entryIt = currentStateSuccessors.begin(), entryIte = currentStateSuccessors.end(); entryIt != entryIte; ++entryIt) {
-                if (entryIt->getColumn() >= state) {
-                    if (entryIt->getColumn() == state) {
-                        loopProbability = entryIt->getValue();
-                        hasSelfLoop = true;
-                        
-                        // If we do not clear the forward transitions completely, we need to remove the self-loop,
-                        // because we scale all the other outgoing transitions with it anyway.
-                        if (!removeForwardTransitions) {
-                            currentStateSuccessors.erase(entryIt);
-                        }
-                    }
-                    break;
-                }
-            }
-            
-            // Scale all entries in this row with (1 / (1 - loopProbability)) only in case there was a self-loop.
-            STORM_LOG_TRACE((hasSelfLoop ? "State has self-loop." : "State does not have a self-loop."));
-            if (hasSelfLoop) {
-                STORM_LOG_ASSERT(loopProbability != storm::utility::one<ValueType>(), "Must not eliminate state with probability 1 self-loop.");
-                loopProbability = storm::utility::simplify(storm::utility::one<ValueType>() / (storm::utility::one<ValueType>() - loopProbability));
-                for (auto& entry : matrix.getRow(state)) {
-                    // Only scale the non-diagonal entries.
-                    if (entry.getColumn() != state) {
-                        entry.setValue(storm::utility::simplify(entry.getValue() * loopProbability));
-                    }
-                }
-                callback(state, loopProbability);
-            }
-            
-            // Now connect the predecessors of the state being eliminated with its successors.
-            FlexibleRowType& currentStatePredecessors = backwardTransitions.getRow(state);
-            
-            // In case we have a constrained elimination, we need to keep track of the new predecessors.
-            FlexibleRowType newCurrentStatePredecessors;
-
-            std::vector<FlexibleRowType> newBackwardProbabilities(currentStateSuccessors.size());
-            for (auto& backwardProbabilities : newBackwardProbabilities) {
-                backwardProbabilities.reserve(currentStatePredecessors.size());
-            }
-            
-            // Now go through the predecessors and eliminate the ones (satisfying the constraint if given).
-            for (auto const& predecessorEntry : currentStatePredecessors) {
-                uint_fast64_t predecessor = predecessorEntry.getColumn();
-                STORM_LOG_TRACE("Found predecessor " << predecessor << ".");
-
-                // Skip the state itself as one of its predecessors.
-                if (predecessor == state) {
-                    assert(hasSelfLoop);
-                    continue;
-                }
-                
-                // Skip the state if the elimination is constrained, but the predecessor is not in the constraint.
-                if (predecessorFilterCallback && !predecessorFilterCallback.get()(predecessor)) {
-                    newCurrentStatePredecessors.emplace_back(predecessorEntry);
-                    STORM_LOG_TRACE("Not eliminating predecessor " << predecessor << ", because it does not fit the filter.");
-                    continue;
-                }
-                STORM_LOG_TRACE("Eliminating predecessor " << predecessor << ".");
-                
-                // First, find the probability with which the predecessor can move to the current state, because
-                // the forward probabilities of the state to be eliminated need to be scaled with this factor.
-                FlexibleRowType& predecessorForwardTransitions = matrix.getRow(predecessor);
-                FlexibleRowIterator multiplyElement = std::find_if(predecessorForwardTransitions.begin(), predecessorForwardTransitions.end(), [&](storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() == state; });
-                
-                // Make sure we have found the probability and set it to zero.
-                STORM_LOG_THROW(multiplyElement != predecessorForwardTransitions.end(), storm::exceptions::InvalidStateException, "No probability for successor found.");
-                ValueType multiplyFactor = multiplyElement->getValue();
-                multiplyElement->setValue(storm::utility::zero<ValueType>());
-                
-                // At this point, we need to update the (forward) transitions of the predecessor.
-                FlexibleRowIterator first1 = predecessorForwardTransitions.begin();
-                FlexibleRowIterator last1 = predecessorForwardTransitions.end();
-                FlexibleRowIterator first2 = currentStateSuccessors.begin();
-                FlexibleRowIterator last2 = currentStateSuccessors.end();
-                
-                FlexibleRowType newSuccessors;
-                newSuccessors.reserve((last1 - first1) + (last2 - first2));
-                std::insert_iterator<FlexibleRowType> result(newSuccessors, newSuccessors.end());
-                
-                uint_fast64_t successorOffsetInNewBackwardTransitions = 0;
-                // Now we merge the two successor lists. (Code taken from std::set_union and modified to suit our needs).
-                for (; first1 != last1; ++result) {
-                    // Skip the transitions to the state that is currently being eliminated.
-                    if (first1->getColumn() == state || (first2 != last2 && first2->getColumn() == state)) {
-                        if (first1->getColumn() == state) {
-                            ++first1;
-                        }
-                        if (first2 != last2 && first2->getColumn() == state) {
-                            ++first2;
-                        }
-                        continue;
-                    }
-                    
-                    if (first2 == last2) {
-                        std::copy_if(first1, last1, result, [&] (storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() != state; } );
-                        break;
-                    }
-                    if (first2->getColumn() < first1->getColumn()) {
-                        auto successorEntry = storm::utility::simplify(std::move(*first2 * multiplyFactor));
-                        *result = successorEntry;
-                        newBackwardProbabilities[successorOffsetInNewBackwardTransitions].emplace_back(predecessor, successorEntry.getValue());
-//                        std::cout << "(1) adding " << first2->getColumn() << " -> " << newBackwardProbabilities[successorOffsetInNewBackwardTransitions].back() << "[" << successorOffsetInNewBackwardTransitions << "]" << std::endl;
-                        ++first2;
-                        ++successorOffsetInNewBackwardTransitions;
-                    } else if (first1->getColumn() < first2->getColumn()) {
-                        *result = *first1;
-                        ++first1;
-                    } else {
-                        auto probability = storm::utility::simplify(first1->getValue() + storm::utility::simplify(multiplyFactor * first2->getValue()));
-                        *result = storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type>(first1->getColumn(), probability);
-                        newBackwardProbabilities[successorOffsetInNewBackwardTransitions].emplace_back(predecessor, probability);
-//                        std::cout << "(2) adding " << first2->getColumn() << " -> " << newBackwardProbabilities[successorOffsetInNewBackwardTransitions].back() << "[" << successorOffsetInNewBackwardTransitions << "]" << std::endl;
-                        ++first1;
-                        ++first2;
-                        ++successorOffsetInNewBackwardTransitions;
-                    }
-                }
-                for (; first2 != last2; ++first2) {
-                    if (first2->getColumn() != state) {
-                        auto stateProbability = storm::utility::simplify(std::move(*first2 * multiplyFactor));
-                        *result = stateProbability;
-                        newBackwardProbabilities[successorOffsetInNewBackwardTransitions].emplace_back(predecessor, stateProbability.getValue());
-//                        std::cout << "(3) adding " << first2->getColumn() << " -> " << newBackwardProbabilities[successorOffsetInNewBackwardTransitions].back() << "[" << successorOffsetInNewBackwardTransitions << "]" << std::endl;
-                        ++successorOffsetInNewBackwardTransitions;
-                    }
-                }
-                
-                // Now move the new transitions in place.
-                predecessorForwardTransitions = std::move(newSuccessors);
-                STORM_LOG_TRACE("Fixed new next-state probabilities of predecessor state " << predecessor << ".");
-
-                predecessorCallback(predecessor, multiplyFactor, state);
-
-                if (priorityUpdateCallback) {
-                    STORM_LOG_TRACE("Updating priority of predecessor.");
-                    priorityUpdateCallback.get()(predecessor);
-                }
-            }
-            
-            // Finally, we need to add the predecessor to the set of predecessors of every successor.
-            uint_fast64_t successorOffsetInNewBackwardTransitions = 0;
-            for (auto const& successorEntry : currentStateSuccessors) {
-                if (successorEntry.getColumn() == state) {
-                    continue;
-                }
-                
-                FlexibleRowType& successorBackwardTransitions = backwardTransitions.getRow(successorEntry.getColumn());
-//                std::cout << "old backward trans of " << successorEntry.getColumn() << std::endl;
-//                for (auto const& trans : successorBackwardTransitions) {
-//                    std::cout << trans << std::endl;
-//                }
-                
-                // Delete the current state as a predecessor of the successor state only if we are going to remove the
-                // current state's forward transitions.
-                if (removeForwardTransitions) {
-                    FlexibleRowIterator elimIt = std::find_if(successorBackwardTransitions.begin(), successorBackwardTransitions.end(), [&](storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() == state; });
-                    STORM_LOG_ASSERT(elimIt != successorBackwardTransitions.end(), "Expected a proper backward transition from " << successorEntry.getColumn() << " to " << state << ", but found none.");
-                    successorBackwardTransitions.erase(elimIt);
-                }
-                
-                FlexibleRowIterator first1 = successorBackwardTransitions.begin();
-                FlexibleRowIterator last1 = successorBackwardTransitions.end();
-                FlexibleRowIterator first2 = newBackwardProbabilities[successorOffsetInNewBackwardTransitions].begin();
-                FlexibleRowIterator last2 = newBackwardProbabilities[successorOffsetInNewBackwardTransitions].end();
-                
-//                std::cout << "adding backward trans " << successorEntry.getColumn() << "[" << successorOffsetInNewBackwardTransitions << "]" << std::endl;
-//                for (auto const& trans : newBackwardProbabilities[successorOffsetInNewBackwardTransitions]) {
-//                    std::cout << trans << std::endl;
-//                }
-                
-                FlexibleRowType newPredecessors;
-                newPredecessors.reserve((last1 - first1) + (last2 - first2));
-                std::insert_iterator<FlexibleRowType> result(newPredecessors, newPredecessors.end());
-                
-                for (; first1 != last1; ++result) {
-                    if (first2 == last2) {
-                        std::copy(first1, last1, result);
-                        break;
-                    }
-                    if (first2->getColumn() < first1->getColumn()) {
-                        if (first2->getColumn() != state) {
-                            *result = *first2;
-                        }
-                        ++first2;
-                    } else if (first1->getColumn() == first2->getColumn()) {
-                        if (estimateComplexity(first1->getValue()) > estimateComplexity(first2->getValue())) {
-                            *result = *first1;
-                        } else {
-                            *result = *first2;
-                        }
-                        ++first1;
-                        ++first2;
-                    } else {
-                        *result = *first1;
-                        ++first1;
-                    }
-                }
-                if (predecessorFilterCallback) {
-                    std::copy_if(first2, last2, result, [&] (storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() != state && predecessorFilterCallback.get()(a.getColumn()); });
-                } else {
-                    std::copy_if(first2, last2, result, [&] (storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() != state; });
-                }
-                
-                // Now move the new predecessors in place.
-                successorBackwardTransitions = std::move(newPredecessors);
-//                std::cout << "new backward trans of " << successorEntry.getColumn() << std::endl;
-//                for (auto const& trans : successorBackwardTransitions) {
-//                    std::cout << trans << std::endl;
-//                }
-                ++successorOffsetInNewBackwardTransitions;
-            }
-            STORM_LOG_TRACE("Fixed predecessor lists of successor states.");
-            
-            if (removeForwardTransitions) {
-                // Clear the eliminated row to reduce memory consumption.
-                currentStateSuccessors.clear();
-                currentStateSuccessors.shrink_to_fit();
-            }
-            if (predecessorFilterCallback) {
-                currentStatePredecessors = std::move(newCurrentStatePredecessors);
-            } else {
-                currentStatePredecessors.clear();
-                currentStatePredecessors.shrink_to_fit();
-            }
-        }
-        
         template<typename SparseDtmcModelType>
         std::vector<uint_fast64_t> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::getDistanceBasedPriorities(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& transitionMatrixTransposed, storm::storage::BitVector const& initialStates, std::vector<ValueType> const& oneStepProbabilities, bool forward, bool reverse) {
             std::vector<uint_fast64_t> statePriorities(transitionMatrix.getRowCount());
@@ -1444,13 +1192,13 @@ namespace storm {
             return backwardTransitions.getRow(state).size() * transitionMatrix.getRow(state).size();
         }
         
-        template<typename SparseDtmcModelType>
-        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::StatePriorityQueue::update(storm::storage::sparse::state_type, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities) {
+        template<typename ValueType>
+        void StatePriorityQueue<ValueType>::update(storm::storage::sparse::state_type, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities) {
             // Intentionally left empty.
         }
         
         template<typename SparseDtmcModelType>
-        SparseDtmcEliminationModelChecker<SparseDtmcModelType>::StaticStatePriorityQueue::StaticStatePriorityQueue(std::vector<storm::storage::sparse::state_type> const& sortedStates) : StatePriorityQueue(), sortedStates(sortedStates), currentPosition(0) {
+        SparseDtmcEliminationModelChecker<SparseDtmcModelType>::StaticStatePriorityQueue::StaticStatePriorityQueue(std::vector<storm::storage::sparse::state_type> const& sortedStates) : StatePriorityQueue<ValueType>(), sortedStates(sortedStates), currentPosition(0) {
             // Intentionally left empty.
         }
         
@@ -1471,7 +1219,7 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        SparseDtmcEliminationModelChecker<SparseDtmcModelType>::DynamicPenaltyStatePriorityQueue::DynamicPenaltyStatePriorityQueue(std::vector<std::pair<storm::storage::sparse::state_type, uint_fast64_t>> const& sortedStatePenaltyPairs, PenaltyFunctionType const& penaltyFunction) : StatePriorityQueue(), priorityQueue(), stateToPriorityMapping(), penaltyFunction(penaltyFunction) {
+        SparseDtmcEliminationModelChecker<SparseDtmcModelType>::DynamicPenaltyStatePriorityQueue::DynamicPenaltyStatePriorityQueue(std::vector<std::pair<storm::storage::sparse::state_type, uint_fast64_t>> const& sortedStatePenaltyPairs, PenaltyFunctionType const& penaltyFunction) : StatePriorityQueue<ValueType>(), priorityQueue(), stateToPriorityMapping(), penaltyFunction(penaltyFunction) {
             // Insert all state-penalty pairs into our priority queue.
             for (auto const& statePenalty : sortedStatePenaltyPairs) {
                 priorityQueue.insert(priorityQueue.end(), statePenalty);
@@ -1552,9 +1300,11 @@ namespace storm {
             return true;
         }
         
+        template class StatePriorityQueue<double>;
         template class SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<double>>;
-        
+            
 #ifdef STORM_HAVE_CARL
+        template class StatePriorityQueue<storm::RationalFunction>;
         template class SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<storm::RationalFunction>>;
 #endif
     } // namespace modelchecker
diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
index 30c8e528a..bfcfbcd31 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
@@ -10,6 +10,18 @@
 namespace storm {
     namespace modelchecker {
         
+        template<typename ValueType>
+        uint_fast64_t estimateComplexity(ValueType const& value);
+
+        template<typename ValueType>
+        class StatePriorityQueue {
+        public:
+            virtual bool hasNextState() const = 0;
+            virtual storm::storage::sparse::state_type popNextState() = 0;
+            virtual void update(storm::storage::sparse::state_type state, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities);
+            virtual std::size_t size() const = 0;
+        };
+        
         template<typename SparseDtmcModelType>
         class SparseDtmcEliminationModelChecker : public SparsePropositionalModelChecker<SparseDtmcModelType> {
         public:
@@ -34,18 +46,10 @@ namespace storm {
             virtual std::unique_ptr<CheckResult> computeLongRunAverageRewards(storm::logic::LongRunAverageRewardFormula const& rewardPathFormula, boost::optional<std::string> const& rewardModelName = boost::optional<std::string>(), bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
             virtual std::unique_ptr<CheckResult> computeConditionalProbabilities(storm::logic::ConditionalPathFormula const& pathFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
             virtual std::unique_ptr<CheckResult> computeLongRunAverageProbabilities(storm::logic::StateFormula const& stateFormula, bool qualitative = false, boost::optional<OptimizationDirection> const& optimalityType = boost::optional<OptimizationDirection>()) override;
-
+            
         private:
-                        
-            class StatePriorityQueue {
-            public:
-                virtual bool hasNextState() const = 0;
-                virtual storm::storage::sparse::state_type popNextState() = 0;
-                virtual void update(storm::storage::sparse::state_type state, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities);
-                virtual std::size_t size() const = 0;
-            };
             
-            class StaticStatePriorityQueue : public StatePriorityQueue {
+            class StaticStatePriorityQueue : public StatePriorityQueue<ValueType> {
             public:
                 StaticStatePriorityQueue(std::vector<storm::storage::sparse::state_type> const& sortedStates);
                 
@@ -66,7 +70,7 @@ namespace storm {
             
             typedef std::function<uint_fast64_t (storm::storage::sparse::state_type const& state, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& oneStepProbabilities)> PenaltyFunctionType;
             
-            class DynamicPenaltyStatePriorityQueue : public StatePriorityQueue {
+            class DynamicPenaltyStatePriorityQueue : public StatePriorityQueue<ValueType> {
             public:
                 DynamicPenaltyStatePriorityQueue(std::vector<std::pair<storm::storage::sparse::state_type, uint_fast64_t>> const& sortedStatePenaltyPairs, PenaltyFunctionType const& penaltyFunction);
                 
@@ -85,11 +89,11 @@ namespace storm {
             
             static std::vector<ValueType> computeReachabilityValues(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, std::vector<ValueType>& values, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, std::vector<ValueType> const& oneStepProbabilitiesToTarget);
             
-            static std::unique_ptr<StatePriorityQueue> createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& stateDistances, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector const& states);
+            static std::unique_ptr<StatePriorityQueue<ValueType>> createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& stateDistances, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector const& states);
 
-            static std::unique_ptr<StatePriorityQueue> createNaivePriorityQueue(storm::storage::BitVector const& states);
+            static std::unique_ptr<StatePriorityQueue<ValueType>> createNaivePriorityQueue(storm::storage::BitVector const& states);
             
-            static void performPrioritizedStateElimination(std::unique_ptr<StatePriorityQueue>& priorityQueue, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, std::vector<ValueType>& values, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly);
+            static void performPrioritizedStateElimination(std::unique_ptr<StatePriorityQueue<ValueType>>& priorityQueue, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, std::vector<ValueType>& values, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly);
             
             static void performOrdinaryStateElimination(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<ValueType>>& additionalStateValues, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities);
 
@@ -98,14 +102,7 @@ namespace storm {
             static uint_fast64_t performHybridStateElimination(storm::storage::SparseMatrix<ValueType> const& forwardTransitions, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities);
             
             static uint_fast64_t treatScc(storm::storage::FlexibleSparseMatrix<ValueType>& matrix, std::vector<ValueType>& values, storm::storage::BitVector const& entryStates, storm::storage::BitVector const& scc, storm::storage::BitVector const& initialStates, storm::storage::SparseMatrix<ValueType> const& forwardTransitions, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, bool eliminateEntryStates, uint_fast64_t level, uint_fast64_t maximalSccSize, std::vector<storm::storage::sparse::state_type>& entryStateQueue, bool computeResultsForInitialStatesOnly, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities = boost::none);
-            
-            typedef std::function<void (storm::storage::sparse::state_type const& state, ValueType const& loopProbability)> ValueUpdateCallback;
-            typedef std::function<void (storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state)> PredecessorUpdateCallback;
-            typedef std::function<void (storm::storage::sparse::state_type const& state)> PriorityUpdateCallback;
-            typedef std::function<bool (storm::storage::sparse::state_type const& state)> PredecessorFilterCallback;
-            
-            static void eliminateState(storm::storage::sparse::state_type state, storm::storage::FlexibleSparseMatrix<ValueType>& matrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, ValueUpdateCallback const& valueUpdateCallback, PredecessorUpdateCallback const& predecessorCallback, boost::optional<PriorityUpdateCallback> const& priorityUpdateCallback = boost::none, boost::optional<PredecessorFilterCallback> const& predecessorFilterCallback = boost::none, bool removeForwardTransitions = true);
-            
+
             static std::vector<uint_fast64_t> getDistanceBasedPriorities(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& transitionMatrixTransposed, storm::storage::BitVector const& initialStates, std::vector<ValueType> const& oneStepProbabilities, bool forward, bool reverse);
             
             static std::vector<std::size_t> getStateDistances(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& transitionMatrixTransposed, storm::storage::BitVector const& initialStates, std::vector<ValueType> const& oneStepProbabilities, bool forward);
diff --git a/src/solver/stateelimination/ConditionalEliminator.cpp b/src/solver/stateelimination/ConditionalEliminator.cpp
new file mode 100644
index 000000000..bba964596
--- /dev/null
+++ b/src/solver/stateelimination/ConditionalEliminator.cpp
@@ -0,0 +1,53 @@
+#include "src/solver/stateelimination/ConditionalEliminator.h"
+
+namespace storm {
+    namespace solver {
+        namespace stateelimination {
+            
+            template<typename SparseModelType>
+            ConditionalEliminator<SparseModelType>::ConditionalEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector& phiStates, storm::storage::BitVector& psiStates) : StateEliminator<SparseModelType>(transitionMatrix, backwardTransitions), oneStepProbabilities(oneStepProbabilities), phiStates(phiStates), psiStates(psiStates), specificState(NONE) {
+            }
+            
+            template<typename SparseModelType>
+            void ConditionalEliminator<SparseModelType>::updateValue(storm::storage::sparse::state_type const& state, ValueType const& loopProbability) {
+                oneStepProbabilities[state] = storm::utility::simplify(loopProbability * oneStepProbabilities[state]);
+            }
+            
+            template<typename SparseModelType>
+            void ConditionalEliminator<SparseModelType>::updatePredecessor(storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) {
+                oneStepProbabilities[predecessor] = storm::utility::simplify(oneStepProbabilities[predecessor] * storm::utility::simplify(probability * oneStepProbabilities[state]));
+            }
+            
+            template<typename SparseModelType>
+            void ConditionalEliminator<SparseModelType>::updatePriority(storm::storage::sparse::state_type const& state) {
+                // Do nothing
+            }
+            
+            template<typename SparseModelType>
+            bool ConditionalEliminator<SparseModelType>::filterPredecessor(storm::storage::sparse::state_type const& state) {
+                // TODO find better solution than flag
+                switch (specificState) {
+                    case PHI:
+                        return phiStates.get(state);
+                    case PSI:
+                        return psiStates.get(state);
+                    case NONE:
+                        assert(false);
+                }
+            }
+            
+            template<typename SparseModelType>
+            bool ConditionalEliminator<SparseModelType>::isFilterPredecessor() const {
+                return true;
+            }
+            
+            
+            template class ConditionalEliminator<storm::models::sparse::Dtmc<double>>;
+            
+#ifdef STORM_HAVE_CARL
+            template class ConditionalEliminator<storm::models::sparse::Dtmc<storm::RationalFunction>>;
+#endif
+            
+        } // namespace stateelimination
+    } // namespace storage
+} // namespace storm
diff --git a/src/solver/stateelimination/ConditionalEliminator.h b/src/solver/stateelimination/ConditionalEliminator.h
new file mode 100644
index 000000000..b98066d3f
--- /dev/null
+++ b/src/solver/stateelimination/ConditionalEliminator.h
@@ -0,0 +1,53 @@
+#ifndef STORM_SOLVER_STATEELIMINATION_CONDITIONALELIMINATOR_H_
+#define STORM_SOLVER_STATEELIMINATION_CONDITIONALELIMINATOR_H_
+
+#include "src/solver/stateelimination/StateEliminator.h"
+
+#include "src/storage/BitVector.h"
+
+namespace storm {
+    namespace solver {
+        namespace stateelimination {
+            
+            template<typename SparseModelType>
+            class ConditionalEliminator : public StateEliminator<SparseModelType> {
+
+                typedef typename SparseModelType::ValueType ValueType;
+
+                enum SpecificState { NONE, PHI, PSI};
+                
+            public:
+                ConditionalEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector& phiStates, storm::storage::BitVector& psiStates);
+                
+                // Instantiaton of Virtual methods
+                void updateValue(storm::storage::sparse::state_type const& state, ValueType const& loopProbability) override;
+                void updatePredecessor(storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) override;
+                void updatePriority(storm::storage::sparse::state_type const& state) override;
+                bool filterPredecessor(storm::storage::sparse::state_type const& state) override;
+                bool isFilterPredecessor() const override;
+                
+                void setStatePsi() {
+                    specificState = PSI;
+                }
+                
+                void setStatePhi() {
+                    specificState = PHI;
+                }
+                
+                void clearState() {
+                    specificState = NONE;
+                }
+                
+            private:
+                std::vector<ValueType>& oneStepProbabilities;
+                storm::storage::BitVector& phiStates;
+                storm::storage::BitVector& psiStates;
+                SpecificState specificState;
+                
+            };
+            
+        } // namespace stateelimination
+    } // namespace storage
+} // namespace storm
+
+#endif // STORM_SOLVER_STATEELIMINATION_CONDITIONALELIMINATOR_H_
diff --git a/src/solver/stateelimination/LongRunAverageEliminator.cpp b/src/solver/stateelimination/LongRunAverageEliminator.cpp
new file mode 100644
index 000000000..250030c54
--- /dev/null
+++ b/src/solver/stateelimination/LongRunAverageEliminator.cpp
@@ -0,0 +1,47 @@
+#include "src/solver/stateelimination/LongRunAverageEliminator.h"
+
+namespace storm {
+    namespace solver {
+        namespace stateelimination {
+            
+            template<typename SparseModelType>
+            LongRunAverageEliminator<SparseModelType>::LongRunAverageEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::modelchecker::StatePriorityQueue<ValueType>& priorityQueue, std::vector<ValueType>& stateValues, std::vector<ValueType>& averageTimeInStates) : StateEliminator<SparseModelType>(transitionMatrix, backwardTransitions), priorityQueue(priorityQueue), stateValues(stateValues), averageTimeInStates(averageTimeInStates) {
+            }
+            
+            template<typename SparseModelType>
+            void LongRunAverageEliminator<SparseModelType>::updateValue(storm::storage::sparse::state_type const& state, ValueType const& loopProbability) {
+                stateValues[state] = storm::utility::simplify(loopProbability * stateValues[state]);
+                averageTimeInStates[state] = storm::utility::simplify(loopProbability * averageTimeInStates[state]);
+            }
+       
+            template<typename SparseModelType>
+            void LongRunAverageEliminator<SparseModelType>::updatePredecessor(storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) {
+                stateValues[predecessor] = storm::utility::simplify(stateValues[predecessor] + storm::utility::simplify(probability * stateValues[state]));
+                averageTimeInStates[predecessor] = storm::utility::simplify(averageTimeInStates[predecessor] + storm::utility::simplify(probability * averageTimeInStates[state]));
+            }
+            
+            template<typename SparseModelType>
+            void LongRunAverageEliminator<SparseModelType>::updatePriority(storm::storage::sparse::state_type const& state) {
+                priorityQueue.update(state, StateEliminator<SparseModelType>::transitionMatrix, StateEliminator<SparseModelType>::backwardTransitions, stateValues);
+            }
+            
+            template<typename SparseModelType>
+            bool LongRunAverageEliminator<SparseModelType>::filterPredecessor(storm::storage::sparse::state_type const& state) {
+                assert(false);
+            }
+            
+            template<typename SparseModelType>
+            bool LongRunAverageEliminator<SparseModelType>::isFilterPredecessor() const {
+                return false;
+            }
+            
+            
+            template class LongRunAverageEliminator<storm::models::sparse::Dtmc<double>>;
+            
+#ifdef STORM_HAVE_CARL
+            template class LongRunAverageEliminator<storm::models::sparse::Dtmc<storm::RationalFunction>>;
+#endif
+            
+        } // namespace stateelimination
+    } // namespace storage
+} // namespace storm
diff --git a/src/solver/stateelimination/LongRunAverageEliminator.h b/src/solver/stateelimination/LongRunAverageEliminator.h
new file mode 100644
index 000000000..0e5522fef
--- /dev/null
+++ b/src/solver/stateelimination/LongRunAverageEliminator.h
@@ -0,0 +1,36 @@
+#ifndef STORM_SOLVER_STATEELIMINATION_LONGRUNAVERAGEELIMINATOR_H_
+#define STORM_SOLVER_STATEELIMINATION_LONGRUNAVERAGEELIMINATOR_H_
+
+#include "src/solver/stateelimination/StateEliminator.h"
+
+namespace storm {
+    namespace solver {
+        namespace stateelimination {
+            
+            template<typename SparseModelType>
+            class LongRunAverageEliminator : public StateEliminator<SparseModelType> {
+
+                typedef typename SparseModelType::ValueType ValueType;
+
+            public:
+                LongRunAverageEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::modelchecker::StatePriorityQueue<ValueType>& priorityQueue, std::vector<ValueType>& stateValues, std::vector<ValueType>& averageTimeInStates);
+                
+                // Instantiaton of Virtual methods
+                void updateValue(storm::storage::sparse::state_type const& state, ValueType const& loopProbability) override;
+                void updatePredecessor(storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) override;
+                void updatePriority(storm::storage::sparse::state_type const& state) override;
+                bool filterPredecessor(storm::storage::sparse::state_type const& state) override;
+                bool isFilterPredecessor() const override;
+                
+            private:
+                
+                storm::modelchecker::StatePriorityQueue<ValueType>& priorityQueue;
+                std::vector<ValueType>& stateValues;
+                std::vector<ValueType>& averageTimeInStates;
+            };
+            
+        } // namespace stateelimination
+    } // namespace storage
+} // namespace storm
+
+#endif // STORM_SOLVER_STATEELIMINATION_LONGRUNAVERAGEELIMINATOR_H_
diff --git a/src/solver/stateelimination/PrioritizedEliminator.cpp b/src/solver/stateelimination/PrioritizedEliminator.cpp
new file mode 100644
index 000000000..de760e66b
--- /dev/null
+++ b/src/solver/stateelimination/PrioritizedEliminator.cpp
@@ -0,0 +1,45 @@
+#include "src/solver/stateelimination/PrioritizedEliminator.h"
+
+namespace storm {
+    namespace solver {
+        namespace stateelimination {
+            
+            template<typename SparseModelType>
+            PrioritizedEliminator<SparseModelType>::PrioritizedEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::modelchecker::StatePriorityQueue<ValueType> priorityQueue, std::vector<ValueType>& stateValues) : StateEliminator<SparseModelType>(transitionMatrix, backwardTransitions), priorityQueue(priorityQueue), stateValues(stateValues) {
+            }
+            
+            template<typename SparseModelType>
+            void PrioritizedEliminator<SparseModelType>::updateValue(storm::storage::sparse::state_type const& state, ValueType const& loopProbability) {
+                stateValues[state] = storm::utility::simplify(loopProbability * stateValues[state]);
+            }
+       
+            template<typename SparseModelType>
+            void PrioritizedEliminator<SparseModelType>::updatePredecessor(storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) {
+                stateValues[predecessor] = storm::utility::simplify(stateValues[predecessor] + storm::utility::simplify(probability * stateValues[state]));
+            }
+            
+            template<typename SparseModelType>
+            void PrioritizedEliminator<SparseModelType>::updatePriority(storm::storage::sparse::state_type const& state) {
+                priorityQueue.update(state, StateEliminator<SparseModelType>::transitionMatrix, StateEliminator<SparseModelType>::backwardTransitions, stateValues);
+            }
+            
+            template<typename SparseModelType>
+            bool PrioritizedEliminator<SparseModelType>::filterPredecessor(storm::storage::sparse::state_type const& state) {
+                assert(false);
+            }
+            
+            template<typename SparseModelType>
+            bool PrioritizedEliminator<SparseModelType>::isFilterPredecessor() const {
+                return false;
+            }
+            
+            
+            template class PrioritizedEliminator<storm::models::sparse::Dtmc<double>>;
+            
+#ifdef STORM_HAVE_CARL
+            template class PrioritizedEliminator<storm::models::sparse::Dtmc<storm::RationalFunction>>;
+#endif
+            
+        } // namespace stateelimination
+    } // namespace storage
+} // namespace storm
diff --git a/src/solver/stateelimination/PrioritizedEliminator.h b/src/solver/stateelimination/PrioritizedEliminator.h
new file mode 100644
index 000000000..7a242ebdf
--- /dev/null
+++ b/src/solver/stateelimination/PrioritizedEliminator.h
@@ -0,0 +1,34 @@
+#ifndef STORM_SOLVER_STATEELIMINATION_PRIORITIZEDELIMINATOR_H_
+#define STORM_SOLVER_STATEELIMINATION_PRIORITIZEDELIMINATOR_H_
+
+#include "src/solver/stateelimination/StateEliminator.h"
+
+namespace storm {
+    namespace solver {
+        namespace stateelimination {
+            
+            template<typename SparseModelType>
+            class PrioritizedEliminator : public StateEliminator<SparseModelType> {
+
+                typedef typename SparseModelType::ValueType ValueType;
+
+            public:
+                PrioritizedEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::modelchecker::StatePriorityQueue<ValueType> priorityQueue, std::vector<ValueType>& stateValues);
+                
+                // Instantiaton of Virtual methods
+                void updateValue(storm::storage::sparse::state_type const& state, ValueType const& loopProbability) override;
+                void updatePredecessor(storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) override;
+                void updatePriority(storm::storage::sparse::state_type const& state) override;
+                bool filterPredecessor(storm::storage::sparse::state_type const& state) override;
+                bool isFilterPredecessor() const override;
+                
+            private:
+                storm::modelchecker::StatePriorityQueue<ValueType>& priorityQueue;
+                std::vector<ValueType>& stateValues;
+            };
+            
+        } // namespace stateelimination
+    } // namespace storage
+} // namespace storm
+
+#endif // STORM_SOLVER_STATEELIMINATION_PRIORITIZEDELIMINATOR_H_
diff --git a/src/solver/stateelimination/StateEliminator.cpp b/src/solver/stateelimination/StateEliminator.cpp
new file mode 100644
index 000000000..3e3d8c53a
--- /dev/null
+++ b/src/solver/stateelimination/StateEliminator.cpp
@@ -0,0 +1,259 @@
+#include "src/solver/stateelimination/StateEliminator.h"
+
+#include "src/storage/BitVector.h"
+#include "src/adapters/CarlAdapter.h"
+#include "src/utility/constants.h"
+#include "src/utility/macros.h"
+#include "src/exceptions/InvalidStateException.h"
+
+namespace storm {
+    namespace solver {
+        namespace stateelimination {
+            
+            template<typename SparseModelType>
+            StateEliminator<SparseModelType>::StateEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions) : transitionMatrix(transitionMatrix), backwardTransitions(backwardTransitions) {
+            }
+            
+            template<typename SparseModelType>
+            void StateEliminator<SparseModelType>::eliminateState(storm::storage::sparse::state_type state, bool removeForwardTransitions, storm::storage::BitVector predecessorConstraint) {
+                
+                STORM_LOG_TRACE("Eliminating state " << state << ".");
+                
+                // Start by finding loop probability.
+                bool hasSelfLoop = false;
+                ValueType loopProbability = storm::utility::zero<ValueType>();
+                FlexibleRowType& currentStateSuccessors = transitionMatrix.getRow(state);
+                for (auto entryIt = currentStateSuccessors.begin(), entryIte = currentStateSuccessors.end(); entryIt != entryIte; ++entryIt) {
+                    if (entryIt->getColumn() >= state) {
+                        if (entryIt->getColumn() == state) {
+                            loopProbability = entryIt->getValue();
+                            hasSelfLoop = true;
+                            
+                            // If we do not clear the forward transitions completely, we need to remove the self-loop,
+                            // because we scale all the other outgoing transitions with it anyway.
+                            if (!removeForwardTransitions) {
+                                currentStateSuccessors.erase(entryIt);
+                            }
+                        }
+                        break;
+                    }
+                }
+                
+                // Scale all entries in this row with (1 / (1 - loopProbability)) only in case there was a self-loop.
+                STORM_LOG_TRACE((hasSelfLoop ? "State has self-loop." : "State does not have a self-loop."));
+                if (hasSelfLoop) {
+                    STORM_LOG_ASSERT(loopProbability != storm::utility::one<ValueType>(), "Must not eliminate state with probability 1 self-loop.");
+                    loopProbability = storm::utility::simplify(storm::utility::one<ValueType>() / (storm::utility::one<ValueType>() - loopProbability));
+                    for (auto& entry : transitionMatrix.getRow(state)) {
+                        // Only scale the non-diagonal entries.
+                        if (entry.getColumn() != state) {
+                            entry.setValue(storm::utility::simplify(entry.getValue() * loopProbability));
+                        }
+                    }
+                    updateValue(state, loopProbability);
+                }
+                
+                // Now connect the predecessors of the state being eliminated with its successors.
+                FlexibleRowType& currentStatePredecessors = backwardTransitions.getRow(state);
+                
+                // In case we have a constrained elimination, we need to keep track of the new predecessors.
+                FlexibleRowType newCurrentStatePredecessors;
+                
+                std::vector<FlexibleRowType> newBackwardProbabilities(currentStateSuccessors.size());
+                for (auto& backwardProbabilities : newBackwardProbabilities) {
+                    backwardProbabilities.reserve(currentStatePredecessors.size());
+                }
+                
+                // Now go through the predecessors and eliminate the ones (satisfying the constraint if given).
+                for (auto const& predecessorEntry : currentStatePredecessors) {
+                    uint_fast64_t predecessor = predecessorEntry.getColumn();
+                    STORM_LOG_TRACE("Found predecessor " << predecessor << ".");
+                    
+                    // Skip the state itself as one of its predecessors.
+                    if (predecessor == state) {
+                        assert(hasSelfLoop);
+                        continue;
+                    }
+                    
+                    // Skip the state if the elimination is constrained, but the predecessor is not in the constraint.
+                    if (isFilterPredecessor() && !filterPredecessor(predecessor)) {
+                        newCurrentStatePredecessors.emplace_back(predecessorEntry);
+                        STORM_LOG_TRACE("Not eliminating predecessor " << predecessor << ", because it does not fit the filter.");
+                        continue;
+                    }
+                    STORM_LOG_TRACE("Eliminating predecessor " << predecessor << ".");
+                    
+                    // First, find the probability with which the predecessor can move to the current state, because
+                    // the forward probabilities of the state to be eliminated need to be scaled with this factor.
+                    FlexibleRowType& predecessorForwardTransitions = transitionMatrix.getRow(predecessor);
+                    FlexibleRowIterator multiplyElement = std::find_if(predecessorForwardTransitions.begin(), predecessorForwardTransitions.end(), [&](storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() == state; });
+                    
+                    // Make sure we have found the probability and set it to zero.
+                    STORM_LOG_THROW(multiplyElement != predecessorForwardTransitions.end(), storm::exceptions::InvalidStateException, "No probability for successor found.");
+                    ValueType multiplyFactor = multiplyElement->getValue();
+                    multiplyElement->setValue(storm::utility::zero<ValueType>());
+                    
+                    // At this point, we need to update the (forward) transitions of the predecessor.
+                    FlexibleRowIterator first1 = predecessorForwardTransitions.begin();
+                    FlexibleRowIterator last1 = predecessorForwardTransitions.end();
+                    FlexibleRowIterator first2 = currentStateSuccessors.begin();
+                    FlexibleRowIterator last2 = currentStateSuccessors.end();
+                    
+                    FlexibleRowType newSuccessors;
+                    newSuccessors.reserve((last1 - first1) + (last2 - first2));
+                    std::insert_iterator<FlexibleRowType> result(newSuccessors, newSuccessors.end());
+                    
+                    uint_fast64_t successorOffsetInNewBackwardTransitions = 0;
+                    // Now we merge the two successor lists. (Code taken from std::set_union and modified to suit our needs).
+                    for (; first1 != last1; ++result) {
+                        // Skip the transitions to the state that is currently being eliminated.
+                        if (first1->getColumn() == state || (first2 != last2 && first2->getColumn() == state)) {
+                            if (first1->getColumn() == state) {
+                                ++first1;
+                            }
+                            if (first2 != last2 && first2->getColumn() == state) {
+                                ++first2;
+                            }
+                            continue;
+                        }
+                        
+                        if (first2 == last2) {
+                            std::copy_if(first1, last1, result, [&] (storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() != state; } );
+                            break;
+                        }
+                        if (first2->getColumn() < first1->getColumn()) {
+                            auto successorEntry = storm::utility::simplify(std::move(*first2 * multiplyFactor));
+                            *result = successorEntry;
+                            newBackwardProbabilities[successorOffsetInNewBackwardTransitions].emplace_back(predecessor, successorEntry.getValue());
+                            //                        std::cout << "(1) adding " << first2->getColumn() << " -> " << newBackwardProbabilities[successorOffsetInNewBackwardTransitions].back() << "[" << successorOffsetInNewBackwardTransitions << "]" << std::endl;
+                            ++first2;
+                            ++successorOffsetInNewBackwardTransitions;
+                        } else if (first1->getColumn() < first2->getColumn()) {
+                            *result = *first1;
+                            ++first1;
+                        } else {
+                            auto probability = storm::utility::simplify(first1->getValue() + storm::utility::simplify(multiplyFactor * first2->getValue()));
+                            *result = storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type>(first1->getColumn(), probability);
+                            newBackwardProbabilities[successorOffsetInNewBackwardTransitions].emplace_back(predecessor, probability);
+                            //                        std::cout << "(2) adding " << first2->getColumn() << " -> " << newBackwardProbabilities[successorOffsetInNewBackwardTransitions].back() << "[" << successorOffsetInNewBackwardTransitions << "]" << std::endl;
+                            ++first1;
+                            ++first2;
+                            ++successorOffsetInNewBackwardTransitions;
+                        }
+                    }
+                    for (; first2 != last2; ++first2) {
+                        if (first2->getColumn() != state) {
+                            auto stateProbability = storm::utility::simplify(std::move(*first2 * multiplyFactor));
+                            *result = stateProbability;
+                            newBackwardProbabilities[successorOffsetInNewBackwardTransitions].emplace_back(predecessor, stateProbability.getValue());
+                            //                        std::cout << "(3) adding " << first2->getColumn() << " -> " << newBackwardProbabilities[successorOffsetInNewBackwardTransitions].back() << "[" << successorOffsetInNewBackwardTransitions << "]" << std::endl;
+                            ++successorOffsetInNewBackwardTransitions;
+                        }
+                    }
+                    
+                    // Now move the new transitions in place.
+                    predecessorForwardTransitions = std::move(newSuccessors);
+                    STORM_LOG_TRACE("Fixed new next-state probabilities of predecessor state " << predecessor << ".");
+                    
+                    updatePredecessor(predecessor, multiplyFactor, state);
+                    
+                    STORM_LOG_TRACE("Updating priority of predecessor.");
+                    updatePriority(predecessor);
+                }
+                
+                // Finally, we need to add the predecessor to the set of predecessors of every successor.
+                uint_fast64_t successorOffsetInNewBackwardTransitions = 0;
+                for (auto const& successorEntry : currentStateSuccessors) {
+                    if (successorEntry.getColumn() == state) {
+                        continue;
+                    }
+                    
+                    FlexibleRowType& successorBackwardTransitions = backwardTransitions.getRow(successorEntry.getColumn());
+                    //                std::cout << "old backward trans of " << successorEntry.getColumn() << std::endl;
+                    //                for (auto const& trans : successorBackwardTransitions) {
+                    //                    std::cout << trans << std::endl;
+                    //                }
+                    
+                    // Delete the current state as a predecessor of the successor state only if we are going to remove the
+                    // current state's forward transitions.
+                    if (removeForwardTransitions) {
+                        FlexibleRowIterator elimIt = std::find_if(successorBackwardTransitions.begin(), successorBackwardTransitions.end(), [&](storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() == state; });
+                        STORM_LOG_ASSERT(elimIt != successorBackwardTransitions.end(), "Expected a proper backward transition from " << successorEntry.getColumn() << " to " << state << ", but found none.");
+                        successorBackwardTransitions.erase(elimIt);
+                    }
+                    
+                    FlexibleRowIterator first1 = successorBackwardTransitions.begin();
+                    FlexibleRowIterator last1 = successorBackwardTransitions.end();
+                    FlexibleRowIterator first2 = newBackwardProbabilities[successorOffsetInNewBackwardTransitions].begin();
+                    FlexibleRowIterator last2 = newBackwardProbabilities[successorOffsetInNewBackwardTransitions].end();
+                    
+                    //                std::cout << "adding backward trans " << successorEntry.getColumn() << "[" << successorOffsetInNewBackwardTransitions << "]" << std::endl;
+                    //                for (auto const& trans : newBackwardProbabilities[successorOffsetInNewBackwardTransitions]) {
+                    //                    std::cout << trans << std::endl;
+                    //                }
+                    
+                    FlexibleRowType newPredecessors;
+                    newPredecessors.reserve((last1 - first1) + (last2 - first2));
+                    std::insert_iterator<FlexibleRowType> result(newPredecessors, newPredecessors.end());
+                    
+                    for (; first1 != last1; ++result) {
+                        if (first2 == last2) {
+                            std::copy(first1, last1, result);
+                            break;
+                        }
+                        if (first2->getColumn() < first1->getColumn()) {
+                            if (first2->getColumn() != state) {
+                                *result = *first2;
+                            }
+                            ++first2;
+                        } else if (first1->getColumn() == first2->getColumn()) {
+                            if (storm::modelchecker::estimateComplexity(first1->getValue()) > storm::modelchecker::estimateComplexity(first2->getValue())) {
+                                *result = *first1;
+                            } else {
+                                *result = *first2;
+                            }
+                            ++first1;
+                            ++first2;
+                        } else {
+                            *result = *first1;
+                            ++first1;
+                        }
+                    }
+                    if (isFilterPredecessor()) {
+                        std::copy_if(first2, last2, result, [&] (storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() != state && filterPredecessor(a.getColumn()); });
+                    } else {
+                        std::copy_if(first2, last2, result, [&] (storm::storage::MatrixEntry<typename storm::storage::FlexibleSparseMatrix<ValueType>::index_type, typename storm::storage::FlexibleSparseMatrix<ValueType>::value_type> const& a) { return a.getColumn() != state; });
+                    }
+                    // Now move the new predecessors in place.
+                    successorBackwardTransitions = std::move(newPredecessors);
+                    //                std::cout << "new backward trans of " << successorEntry.getColumn() << std::endl;
+                    //                for (auto const& trans : successorBackwardTransitions) {
+                    //                    std::cout << trans << std::endl;
+                    //                }
+                    ++successorOffsetInNewBackwardTransitions;
+                }
+                STORM_LOG_TRACE("Fixed predecessor lists of successor states.");
+                
+                if (removeForwardTransitions) {
+                    // Clear the eliminated row to reduce memory consumption.
+                    currentStateSuccessors.clear();
+                    currentStateSuccessors.shrink_to_fit();
+                }
+                if (isFilterPredecessor()) {
+                    currentStatePredecessors = std::move(newCurrentStatePredecessors);
+                } else {
+                    currentStatePredecessors.clear();
+                    currentStatePredecessors.shrink_to_fit();
+                }
+
+            }
+            
+            template class StateEliminator<storm::models::sparse::Dtmc<double>>;
+            
+#ifdef STORM_HAVE_CARL
+            template class StateEliminator<storm::models::sparse::Dtmc<storm::RationalFunction>>;
+#endif
+            
+        } // namespace stateelimination
+    } // namespace storage
+} // namespace storm
\ No newline at end of file
diff --git a/src/solver/stateelimination/StateEliminator.h b/src/solver/stateelimination/StateEliminator.h
new file mode 100644
index 000000000..2a58912e8
--- /dev/null
+++ b/src/solver/stateelimination/StateEliminator.h
@@ -0,0 +1,42 @@
+#ifndef STORM_SOLVER_STATEELIMINATION_STATEELIMINATOR_H_
+#define STORM_SOLVER_STATEELIMINATION_STATEELIMINATOR_H_
+
+#include "src/storage/FlexibleSparseMatrix.h"
+#include "src/storage/SparseMatrix.h"
+#include "src/storage/sparse/StateType.h"
+#include "src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h"
+
+namespace storm {
+    namespace solver {
+        namespace stateelimination {
+            
+            template<typename SparseModelType>
+            class StateEliminator {
+                typedef typename SparseModelType::ValueType ValueType;
+                typedef typename storm::storage::FlexibleSparseMatrix<ValueType>::row_type FlexibleRowType;
+                typedef typename FlexibleRowType::iterator FlexibleRowIterator;
+
+            public:
+                StateEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions);
+                
+                void eliminateState(storm::storage::sparse::state_type state, bool removeForwardTransitions, storm::storage::BitVector predecessorConstraint = storm::storage::BitVector());
+                
+                // Virtual methods for base classes to distinguish between different state elimination approaches
+                virtual void updateValue(storm::storage::sparse::state_type const& state, ValueType const& loopProbability) = 0;
+                virtual void updatePredecessor(storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) = 0;
+                virtual void updatePriority(storm::storage::sparse::state_type const& state) = 0;
+                virtual bool filterPredecessor(storm::storage::sparse::state_type const& state) = 0;
+                virtual bool isFilterPredecessor() const = 0;
+                
+                
+            protected:
+                storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix;
+                storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions;
+                
+            };
+            
+        } // namespace stateelimination
+    } // namespace storage
+} // namespace storm
+
+#endif // STORM_SOLVER_STATEELIMINATION_STATEELIMINATOR_H_
\ No newline at end of file

From 6d84d030bdbf76b7043e1c80c8035b5bc79efe96 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 12 Feb 2016 14:20:45 +0100
Subject: [PATCH 084/246] Fixed lowercase

Former-commit-id: fd323c1e1c5b3025aaad326e7749538d507df779
---
 src/builder/ExplicitDFTModelBuilder.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 817295346..74c3db23d 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -1,6 +1,6 @@
 #include "src/builder/ExplicitDFTModelBuilder.h"
 #include <src/models/sparse/MarkovAutomaton.h>
-#include <src/models/sparse/CTMC.h>
+#include <src/models/sparse/Ctmc.h>
 #include <src/utility/constants.h>
 #include <src/utility/vector.h>
 #include <src/exceptions/UnexpectedException.h>

From acab78ba0e8fee8fb19c2aaa9475e2a2b31a6e63 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 12 Feb 2016 19:01:24 +0100
Subject: [PATCH 085/246] Added row groups to flexible matrix

Former-commit-id: 85c7dc944b7e74b95da48b60c0ce67e66e909097
---
 src/storage/FlexibleSparseMatrix.cpp | 80 ++++++++++++++++++++++++----
 src/storage/FlexibleSparseMatrix.h   | 35 ++++++++++--
 src/storage/SparseMatrix.cpp         |  5 --
 src/storage/SparseMatrix.h           |  7 ---
 4 files changed, 102 insertions(+), 25 deletions(-)

diff --git a/src/storage/FlexibleSparseMatrix.cpp b/src/storage/FlexibleSparseMatrix.cpp
index 81e87ce20..99ed68337 100644
--- a/src/storage/FlexibleSparseMatrix.cpp
+++ b/src/storage/FlexibleSparseMatrix.cpp
@@ -16,9 +16,6 @@ namespace storm {
         FlexibleSparseMatrix<ValueType>::FlexibleSparseMatrix(storm::storage::SparseMatrix<ValueType> const& matrix, bool setAllValuesToOne) : data(matrix.getRowCount()), columnCount(matrix.getColumnCount()), nonzeroEntryCount(matrix.getNonzeroEntryCount()), nontrivialRowGrouping(matrix.hasNontrivialRowGrouping()) {
             if (nontrivialRowGrouping) {
                 rowGroupIndices = matrix.getRowGroupIndices();
-                rowIndications = matrix.getRowIndications();
-                // Not fully implemented yet
-                assert(false);
             }
             for (index_type rowIndex = 0; rowIndex < matrix.getRowCount(); ++rowIndex) {
                 typename storm::storage::SparseMatrix<ValueType>::const_rows row = matrix.getRow(rowIndex);
@@ -52,6 +49,20 @@ namespace storm {
             return this->data[index];
         }
         
+        template<typename ValueType>
+        typename FlexibleSparseMatrix<ValueType>::row_type& FlexibleSparseMatrix<ValueType>::getRow(index_type rowGroup, index_type offset) {
+            assert(rowGroup < this->getRowGroupCount());
+            assert(offset < this->getRowGroupSize(rowGroup));
+            return getRow(rowGroupIndices[rowGroup] + offset);
+        }
+        
+        template<typename ValueType>
+        typename FlexibleSparseMatrix<ValueType>::row_type const& FlexibleSparseMatrix<ValueType>::getRow(index_type rowGroup, index_type offset) const {
+            assert(rowGroup < this->getRowGroupCount());
+            assert(offset < this->getRowGroupSize(rowGroup));
+            return getRow(rowGroupIndices[rowGroup] + offset);
+        }
+        
         template<typename ValueType>
         typename FlexibleSparseMatrix<ValueType>::index_type FlexibleSparseMatrix<ValueType>::getRowCount() const {
             return this->data.size();
@@ -66,6 +77,20 @@ namespace storm {
         typename FlexibleSparseMatrix<ValueType>::index_type FlexibleSparseMatrix<ValueType>::getNonzeroEntryCount() const {
             return nonzeroEntryCount;
         }
+        
+        template<typename ValueType>
+        typename FlexibleSparseMatrix<ValueType>::index_type FlexibleSparseMatrix<ValueType>::getRowGroupCount() const {
+            return rowGroupIndices.size();
+        }
+        
+        template<typename ValueType>
+        typename FlexibleSparseMatrix<ValueType>::index_type FlexibleSparseMatrix<ValueType>::getRowGroupSize(index_type group) const {
+            if (group == getRowGroupCount() - 1) {
+                return getRowCount() - rowGroupIndices[group];
+            } else {
+                return rowGroupIndices[group + 1] - rowGroupIndices[group];
+            }
+        }
 
         template<typename ValueType>
         void FlexibleSparseMatrix<ValueType>::updateDimensions() {
@@ -91,7 +116,7 @@ namespace storm {
         }
         
         template<typename ValueType>
-        bool SparseMatrix<ValueType>::hasNontrivialRowGrouping() const {
+        bool FlexibleSparseMatrix<ValueType>::hasNontrivialRowGrouping() const {
             return nontrivialRowGrouping;
         }
 
@@ -142,13 +167,50 @@ namespace storm {
 
         template<typename ValueType>
         std::ostream& operator<<(std::ostream& out, FlexibleSparseMatrix<ValueType> const& matrix) {
-            for (uint_fast64_t index = 0; index < matrix->data.size(); ++index) {
-                out << index << " - ";
-                for (auto const& element : matrix->getRow(index)) {
-                    out << "(" << element.getColumn() << ", " << element.getValue() << ") ";
+            // Print column numbers in header.
+            out << "\t\t";
+            for (typename FlexibleSparseMatrix<ValueType>::index_type i = 0; i < matrix.getColumnCount(); ++i) {
+                out << i << "\t";
+            }
+            out << std::endl;
+            
+            typename FlexibleSparseMatrix<ValueType>::index_type endIndex = matrix.hasNontrivialRowGrouping() ? matrix.getRowGroupCount() : matrix.getRowCount();
+            // Iterate over all rows.
+            for (typename SparseMatrix<ValueType>::index_type i = 0; i < endIndex; ++i) {
+                if (matrix.hasNontrivialRowGrouping()) {
+                    out << "\t---- group " << i << "/" << (matrix.getRowGroupCount() - 1) << " ---- " << std::endl;
                 }
-                return out;
+                typename FlexibleSparseMatrix<ValueType>::index_type startRow = matrix.hasNontrivialRowGrouping() ? matrix.rowGroupIndices[i] : i;
+                typename FlexibleSparseMatrix<ValueType>::index_type endRow = matrix.hasNontrivialRowGrouping() ? matrix.rowGroupIndices[i + 1] : i+1;
+                for (typename FlexibleSparseMatrix<ValueType>::index_type rowIndex = startRow; rowIndex < endRow; ++rowIndex) {
+                    // Print the actual row.
+                    out << i << "\t(\t";
+                    typename FlexibleSparseMatrix<ValueType>::row_type row = matrix.getRow(rowIndex);
+                    typename FlexibleSparseMatrix<ValueType>::index_type columnIndex = 0;
+                    for (auto const& entry : row) {
+                        //Insert zero between entries.
+                        while (columnIndex < entry.getColumn()) {
+                            out << "0\t";
+                            ++columnIndex;
+                        }
+                        ++columnIndex;
+                        out << entry.getValue() << "\t";
+                    }
+                    //Insert remaining zeros.
+                    while (columnIndex++ <= matrix.getColumnCount()) {
+                        out << "0\t";
+                    }
+                    out << "\t)\t" << i << std::endl;
+                }
+            }
+            
+            // Print column numbers in footer.
+            out << "\t\t";
+            for (typename FlexibleSparseMatrix<ValueType>::index_type i = 0; i < matrix.getColumnCount(); ++i) {
+                out << i << "\t";
             }
+            out << std::endl;
+            return out;
         }
 
         // Explicitly instantiate the matrix.
diff --git a/src/storage/FlexibleSparseMatrix.h b/src/storage/FlexibleSparseMatrix.h
index 295b0337b..5ab573057 100644
--- a/src/storage/FlexibleSparseMatrix.h
+++ b/src/storage/FlexibleSparseMatrix.h
@@ -71,6 +71,22 @@ namespace storm {
              * @return An object representing the given row.
              */
             row_type const& getRow(index_type) const;
+            
+            /*!
+             * Returns an object representing the offset'th row in the rowgroup
+             * @param rowGroup the row group
+             * @param offset which row in the group
+             * @return An object representing the given row.
+             */
+            row_type& getRow(index_type rowGroup, index_type offset);
+            
+            /*!
+             * Returns an object representing the offset'th row in the rowgroup
+             * @param rowGroup the row group
+             * @param offset which row in the group
+             * @return An object representing the given row.
+             */
+            row_type const& getRow(index_type rowGroup, index_type entryInGroup) const;
 
             /*!
              * Returns the number of rows of the matrix.
@@ -92,6 +108,21 @@ namespace storm {
              * @return The number of nonzero entries in the matrix.
              */
             index_type getNonzeroEntryCount() const;
+            
+            /*!
+             * Returns the number of row groups in the matrix.
+             *
+             * @return The number of row groups in the matrix.
+             */
+            index_type getRowGroupCount() const;
+            
+            /*!
+             * Returns the size of the given row group.
+             *
+             * @param group The group whose size to retrieve.
+             * @return The number of rows that belong to the given row group.
+             */
+            index_type getRowGroupSize(index_type group) const;
 
             /*!
              * Recomputes the number of columns and the number of non-zero entries.
@@ -146,10 +177,6 @@ namespace storm {
             // The number of entries in the matrix.
             index_type nonzeroEntryCount;
             
-            // A vector containing the indices at which each given row begins. The values of the entries in row i are
-            // data[rowIndications[i]] to data[rowIndications[i + 1]] where the last entry is not included anymore.
-            std::vector<index_type> rowIndications;
-            
             // A flag that indicates whether the matrix has a non-trivial row-grouping, i.e. (possibly) more than one
             // row per row group.
             bool nontrivialRowGrouping;
diff --git a/src/storage/SparseMatrix.cpp b/src/storage/SparseMatrix.cpp
index 04e941561..65f74d874 100644
--- a/src/storage/SparseMatrix.cpp
+++ b/src/storage/SparseMatrix.cpp
@@ -452,11 +452,6 @@ namespace storm {
             return rowGroupIndices;
         }
 
-        template<typename ValueType>
-        std::vector<typename SparseMatrix<ValueType>::index_type> const& SparseMatrix<ValueType>::getRowIndications() const {
-            return rowIndications;
-        }
-        
         template<typename ValueType>
         void SparseMatrix<ValueType>::makeRowsAbsorbing(storm::storage::BitVector const& rows) {
             for (auto row : rows) {
diff --git a/src/storage/SparseMatrix.h b/src/storage/SparseMatrix.h
index 94defdfa5..f9d9916c4 100644
--- a/src/storage/SparseMatrix.h
+++ b/src/storage/SparseMatrix.h
@@ -549,13 +549,6 @@ namespace storm {
              */
             std::vector<index_type> const& getRowGroupIndices() const;
             
-            /*!
-             * Returns the indices where new row groups start.
-             *
-             * @return The indices where new row groups start.
-             */
-            std::vector<index_type> const& getRowIndications() const;
-            
             /*!
              * This function makes the given rows absorbing.
              *

From 56bcdcc8078c2fed7677577e00da686e116311c0 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 15 Feb 2016 10:06:40 +0100
Subject: [PATCH 086/246] Priority queue as pointer

Former-commit-id: 7e0d0f8c8c16a8035cabe50eba324d6ee930931c
---
 .../SparseDtmcEliminationModelChecker.cpp     | 26 +++++++++----------
 .../SparseDtmcEliminationModelChecker.h       |  6 ++---
 .../LongRunAverageEliminator.cpp              |  4 +--
 .../LongRunAverageEliminator.h                |  5 ++--
 .../PrioritizedEliminator.cpp                 |  4 +--
 .../stateelimination/PrioritizedEliminator.h  |  5 ++--
 src/storage/FlexibleSparseMatrix.h            |  4 +--
 7 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
index bec0e7d3a..c969a639f 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
@@ -304,8 +304,8 @@ namespace storm {
             std::vector<ValueType> averageTimeInStates(stateValues.size(), storm::utility::one<ValueType>());
             
             // First, we eliminate all states in BSCCs (except for the representative states).
-            std::unique_ptr<StatePriorityQueue<ValueType>> priorityQueue = createStatePriorityQueue(distanceBasedPriorities, flexibleMatrix, flexibleBackwardTransitions, stateValues, regularStatesInBsccs);
-            storm::solver::stateelimination::LongRunAverageEliminator<SparseDtmcModelType> stateEliminator(flexibleMatrix, flexibleBackwardTransitions, *priorityQueue, stateValues, averageTimeInStates);
+            std::shared_ptr<StatePriorityQueue<ValueType>> priorityQueue = createStatePriorityQueue(distanceBasedPriorities, flexibleMatrix, flexibleBackwardTransitions, stateValues, regularStatesInBsccs);
+            storm::solver::stateelimination::LongRunAverageEliminator<SparseDtmcModelType> stateEliminator(flexibleMatrix, flexibleBackwardTransitions, priorityQueue, stateValues, averageTimeInStates);
             
             while (priorityQueue->hasNextState()) {
                 storm::storage::sparse::state_type state = priorityQueue->popNextState();
@@ -725,7 +725,7 @@ namespace storm {
             storm::storage::FlexibleSparseMatrix<ValueType> flexibleBackwardTransitions(submatrixTransposed, true);
             std::chrono::high_resolution_clock::time_point conversionEnd = std::chrono::high_resolution_clock::now();
             
-            std::unique_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, flexibleMatrix, flexibleBackwardTransitions, oneStepProbabilities, statesToEliminate);
+            std::shared_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, flexibleMatrix, flexibleBackwardTransitions, oneStepProbabilities, statesToEliminate);
 
             STORM_LOG_INFO("Computing conditional probilities." << std::endl);
             std::chrono::high_resolution_clock::time_point modelCheckingStart = std::chrono::high_resolution_clock::now();
@@ -852,7 +852,7 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        std::unique_ptr<StatePriorityQueue<typename SparseDtmcModelType::ValueType>> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& distanceBasedStatePriorities, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector const& states) {
+        std::shared_ptr<StatePriorityQueue<typename SparseDtmcModelType::ValueType>> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& distanceBasedStatePriorities, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector const& states) {
             
             STORM_LOG_TRACE("Creating state priority queue for states " << states);
             
@@ -896,15 +896,15 @@ namespace storm {
         }
         
         template<typename SparseDtmcModelType>
-        std::unique_ptr<StatePriorityQueue<typename SparseDtmcModelType::ValueType>> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::createNaivePriorityQueue(storm::storage::BitVector const& states) {
+        std::shared_ptr<StatePriorityQueue<typename SparseDtmcModelType::ValueType>> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::createNaivePriorityQueue(storm::storage::BitVector const& states) {
             std::vector<storm::storage::sparse::state_type> sortedStates(states.begin(), states.end());
-            return std::unique_ptr<StatePriorityQueue<ValueType>>(new StaticStatePriorityQueue(sortedStates));
+            return std::shared_ptr<StatePriorityQueue<ValueType>>(new StaticStatePriorityQueue(sortedStates));
         }
         
         template<typename SparseDtmcModelType>
-        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::performPrioritizedStateElimination(std::unique_ptr<StatePriorityQueue<ValueType>>& priorityQueue, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, std::vector<ValueType>& values, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly) {
+        void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::performPrioritizedStateElimination(std::shared_ptr<StatePriorityQueue<ValueType>>& priorityQueue, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, std::vector<ValueType>& values, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly) {
             
-            storm::solver::stateelimination::PrioritizedEliminator<SparseDtmcModelType> stateEliminator(transitionMatrix, backwardTransitions, *priorityQueue, values);
+            storm::solver::stateelimination::PrioritizedEliminator<SparseDtmcModelType> stateEliminator(transitionMatrix, backwardTransitions, priorityQueue, values);
             
             while (priorityQueue->hasNextState()) {
                 storm::storage::sparse::state_type state = priorityQueue->popNextState();
@@ -919,7 +919,7 @@ namespace storm {
         
         template<typename SparseDtmcModelType>
         void SparseDtmcEliminationModelChecker<SparseDtmcModelType>::performOrdinaryStateElimination(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities) {
-            std::unique_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, transitionMatrix, backwardTransitions, values, subsystem);
+            std::shared_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, transitionMatrix, backwardTransitions, values, subsystem);
             
             std::size_t numberOfStatesToEliminate = statePriorities->size();
             STORM_LOG_DEBUG("Eliminating " << numberOfStatesToEliminate << " states using the state elimination technique." << std::endl);
@@ -938,7 +938,7 @@ namespace storm {
             if (storm::settings::sparseDtmcEliminationModelCheckerSettings().isEliminateEntryStatesLastSet()) {
                 STORM_LOG_DEBUG("Eliminating " << entryStateQueue.size() << " entry states as a last step.");
                 std::vector<storm::storage::sparse::state_type> sortedStates(entryStateQueue.begin(), entryStateQueue.end());
-                std::unique_ptr<StatePriorityQueue<ValueType>> queuePriorities = std::unique_ptr<StatePriorityQueue<ValueType>>(new StaticStatePriorityQueue(sortedStates));
+                std::shared_ptr<StatePriorityQueue<ValueType>> queuePriorities = std::shared_ptr<StatePriorityQueue<ValueType>>(new StaticStatePriorityQueue(sortedStates));
                 performPrioritizedStateElimination(queuePriorities, transitionMatrix, backwardTransitions, values, initialStates, computeResultsForInitialStatesOnly);
             }
             STORM_LOG_DEBUG("Eliminated " << subsystem.size() << " states." << std::endl);
@@ -1009,7 +1009,7 @@ namespace storm {
                     }
                 }
                 
-                std::unique_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, matrix, backwardTransitions, values, statesInTrivialSccs);
+                std::shared_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, matrix, backwardTransitions, values, statesInTrivialSccs);
                 STORM_LOG_TRACE("Eliminating " << statePriorities->size() << " trivial SCCs.");
                 performPrioritizedStateElimination(statePriorities, matrix, backwardTransitions, values, initialStates, computeResultsForInitialStatesOnly);
                 STORM_LOG_TRACE("Eliminated all trivial SCCs.");
@@ -1039,7 +1039,7 @@ namespace storm {
             } else {
                 // In this case, we perform simple state elimination in the current SCC.
                 STORM_LOG_TRACE("SCC of size " << scc.getNumberOfSetBits() << " is small enough to be eliminated directly.");
-                std::unique_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, matrix, backwardTransitions, values, scc & ~entryStates);
+                std::shared_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, matrix, backwardTransitions, values, scc & ~entryStates);
                 performPrioritizedStateElimination(statePriorities, matrix, backwardTransitions, values, initialStates, computeResultsForInitialStatesOnly);
                 STORM_LOG_TRACE("Eliminated all states of SCC.");
             }
@@ -1047,7 +1047,7 @@ namespace storm {
             // Finally, eliminate the entry states (if we are required to do so).
             if (eliminateEntryStates) {
                 STORM_LOG_TRACE("Finally, eliminating entry states.");
-                std::unique_ptr<StatePriorityQueue<ValueType>> naivePriorities = createNaivePriorityQueue(entryStates);
+                std::shared_ptr<StatePriorityQueue<ValueType>> naivePriorities = createNaivePriorityQueue(entryStates);
                 performPrioritizedStateElimination(naivePriorities, matrix, backwardTransitions, values, initialStates, computeResultsForInitialStatesOnly);
                 STORM_LOG_TRACE("Eliminated/added entry states.");
             } else {
diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
index 3a77c43fb..65205a41d 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
@@ -88,11 +88,11 @@ namespace storm {
             
             static std::vector<ValueType> computeReachabilityValues(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, std::vector<ValueType>& values, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, std::vector<ValueType> const& oneStepProbabilitiesToTarget);
             
-            static std::unique_ptr<StatePriorityQueue<ValueType>> createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& stateDistances, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector const& states);
+            static std::shared_ptr<StatePriorityQueue<ValueType>> createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& stateDistances, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector const& states);
 
-            static std::unique_ptr<StatePriorityQueue<ValueType>> createNaivePriorityQueue(storm::storage::BitVector const& states);
+            static std::shared_ptr<StatePriorityQueue<ValueType>> createNaivePriorityQueue(storm::storage::BitVector const& states);
             
-            static void performPrioritizedStateElimination(std::unique_ptr<StatePriorityQueue<ValueType>>& priorityQueue, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, std::vector<ValueType>& values, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly);
+            static void performPrioritizedStateElimination(std::shared_ptr<StatePriorityQueue<ValueType>>& priorityQueue, storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, std::vector<ValueType>& values, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly);
             
             static void performOrdinaryStateElimination(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::storage::BitVector const& subsystem, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& values, boost::optional<std::vector<ValueType>>& additionalStateValues, boost::optional<std::vector<uint_fast64_t>> const& distanceBasedPriorities);
 
diff --git a/src/solver/stateelimination/LongRunAverageEliminator.cpp b/src/solver/stateelimination/LongRunAverageEliminator.cpp
index 250030c54..ec59dd1b1 100644
--- a/src/solver/stateelimination/LongRunAverageEliminator.cpp
+++ b/src/solver/stateelimination/LongRunAverageEliminator.cpp
@@ -5,7 +5,7 @@ namespace storm {
         namespace stateelimination {
             
             template<typename SparseModelType>
-            LongRunAverageEliminator<SparseModelType>::LongRunAverageEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::modelchecker::StatePriorityQueue<ValueType>& priorityQueue, std::vector<ValueType>& stateValues, std::vector<ValueType>& averageTimeInStates) : StateEliminator<SparseModelType>(transitionMatrix, backwardTransitions), priorityQueue(priorityQueue), stateValues(stateValues), averageTimeInStates(averageTimeInStates) {
+            LongRunAverageEliminator<SparseModelType>::LongRunAverageEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, PriorityQueuePointer priorityQueue, std::vector<ValueType>& stateValues, std::vector<ValueType>& averageTimeInStates) : StateEliminator<SparseModelType>(transitionMatrix, backwardTransitions), priorityQueue(priorityQueue), stateValues(stateValues), averageTimeInStates(averageTimeInStates) {
             }
             
             template<typename SparseModelType>
@@ -22,7 +22,7 @@ namespace storm {
             
             template<typename SparseModelType>
             void LongRunAverageEliminator<SparseModelType>::updatePriority(storm::storage::sparse::state_type const& state) {
-                priorityQueue.update(state, StateEliminator<SparseModelType>::transitionMatrix, StateEliminator<SparseModelType>::backwardTransitions, stateValues);
+                priorityQueue->update(state, StateEliminator<SparseModelType>::transitionMatrix, StateEliminator<SparseModelType>::backwardTransitions, stateValues);
             }
             
             template<typename SparseModelType>
diff --git a/src/solver/stateelimination/LongRunAverageEliminator.h b/src/solver/stateelimination/LongRunAverageEliminator.h
index 0e5522fef..f9b1e9cce 100644
--- a/src/solver/stateelimination/LongRunAverageEliminator.h
+++ b/src/solver/stateelimination/LongRunAverageEliminator.h
@@ -11,9 +11,10 @@ namespace storm {
             class LongRunAverageEliminator : public StateEliminator<SparseModelType> {
 
                 typedef typename SparseModelType::ValueType ValueType;
+                typedef typename std::shared_ptr<storm::modelchecker::StatePriorityQueue<ValueType>> PriorityQueuePointer;
 
             public:
-                LongRunAverageEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::modelchecker::StatePriorityQueue<ValueType>& priorityQueue, std::vector<ValueType>& stateValues, std::vector<ValueType>& averageTimeInStates);
+                LongRunAverageEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, PriorityQueuePointer priorityQueue, std::vector<ValueType>& stateValues, std::vector<ValueType>& averageTimeInStates);
                 
                 // Instantiaton of Virtual methods
                 void updateValue(storm::storage::sparse::state_type const& state, ValueType const& loopProbability) override;
@@ -24,7 +25,7 @@ namespace storm {
                 
             private:
                 
-                storm::modelchecker::StatePriorityQueue<ValueType>& priorityQueue;
+                PriorityQueuePointer priorityQueue;
                 std::vector<ValueType>& stateValues;
                 std::vector<ValueType>& averageTimeInStates;
             };
diff --git a/src/solver/stateelimination/PrioritizedEliminator.cpp b/src/solver/stateelimination/PrioritizedEliminator.cpp
index de760e66b..567d07df9 100644
--- a/src/solver/stateelimination/PrioritizedEliminator.cpp
+++ b/src/solver/stateelimination/PrioritizedEliminator.cpp
@@ -5,7 +5,7 @@ namespace storm {
         namespace stateelimination {
             
             template<typename SparseModelType>
-            PrioritizedEliminator<SparseModelType>::PrioritizedEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::modelchecker::StatePriorityQueue<ValueType> priorityQueue, std::vector<ValueType>& stateValues) : StateEliminator<SparseModelType>(transitionMatrix, backwardTransitions), priorityQueue(priorityQueue), stateValues(stateValues) {
+            PrioritizedEliminator<SparseModelType>::PrioritizedEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, PriorityQueuePointer priorityQueue, std::vector<ValueType>& stateValues) : StateEliminator<SparseModelType>(transitionMatrix, backwardTransitions), priorityQueue(priorityQueue), stateValues(stateValues) {
             }
             
             template<typename SparseModelType>
@@ -20,7 +20,7 @@ namespace storm {
             
             template<typename SparseModelType>
             void PrioritizedEliminator<SparseModelType>::updatePriority(storm::storage::sparse::state_type const& state) {
-                priorityQueue.update(state, StateEliminator<SparseModelType>::transitionMatrix, StateEliminator<SparseModelType>::backwardTransitions, stateValues);
+                priorityQueue->update(state, StateEliminator<SparseModelType>::transitionMatrix, StateEliminator<SparseModelType>::backwardTransitions, stateValues);
             }
             
             template<typename SparseModelType>
diff --git a/src/solver/stateelimination/PrioritizedEliminator.h b/src/solver/stateelimination/PrioritizedEliminator.h
index 7a242ebdf..1180fad09 100644
--- a/src/solver/stateelimination/PrioritizedEliminator.h
+++ b/src/solver/stateelimination/PrioritizedEliminator.h
@@ -11,9 +11,10 @@ namespace storm {
             class PrioritizedEliminator : public StateEliminator<SparseModelType> {
 
                 typedef typename SparseModelType::ValueType ValueType;
+                typedef typename std::shared_ptr<storm::modelchecker::StatePriorityQueue<ValueType>> PriorityQueuePointer;
 
             public:
-                PrioritizedEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, storm::modelchecker::StatePriorityQueue<ValueType> priorityQueue, std::vector<ValueType>& stateValues);
+                PrioritizedEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions, PriorityQueuePointer priorityQueue, std::vector<ValueType>& stateValues);
                 
                 // Instantiaton of Virtual methods
                 void updateValue(storm::storage::sparse::state_type const& state, ValueType const& loopProbability) override;
@@ -23,7 +24,7 @@ namespace storm {
                 bool isFilterPredecessor() const override;
                 
             private:
-                storm::modelchecker::StatePriorityQueue<ValueType>& priorityQueue;
+                PriorityQueuePointer priorityQueue;
                 std::vector<ValueType>& stateValues;
             };
             
diff --git a/src/storage/FlexibleSparseMatrix.h b/src/storage/FlexibleSparseMatrix.h
index 5ab573057..163a25aa4 100644
--- a/src/storage/FlexibleSparseMatrix.h
+++ b/src/storage/FlexibleSparseMatrix.h
@@ -21,9 +21,7 @@ namespace storm {
         class FlexibleSparseMatrix {
         public:
             // TODO: make this class a bit more consistent with the big sparse matrix and improve it:
-            // * add output iterator and improve the way the matrix is printed
-            // * add stuff like clearRow, multiplyRowWithScalar
-            // * implement row grouping
+            // * add stuff like iterator, clearRow, multiplyRowWithScalar
             
             typedef uint_fast64_t index_type;
             typedef ValueType value_type;

From a64a7cdbf8c4ea06fb3d70bb633f45c83c5cd21d Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 15 Feb 2016 11:50:21 +0100
Subject: [PATCH 087/246] Python script compatible with version 3.4

Former-commit-id: 2e78da799d9d2c0a2f6cb6df216becebf8b12ca7
---
 benchmark_dft.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/benchmark_dft.py b/benchmark_dft.py
index d2c43bf80..8e9a5462b 100644
--- a/benchmark_dft.py
+++ b/benchmark_dft.py
@@ -3,7 +3,6 @@ import os.path
 import subprocess
 import re
 import time
-import math
 import argparse
 
 STORM_PATH= "/Users/mvolk/develop/dft-storm/build/src/storm-dft"
@@ -92,6 +91,11 @@ def run_tool(args, quiet=False):
             result = output
     return result
 
+def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
+    if a == b:
+        return True
+    return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description='Benchmarking DFTs via Storm')
     parser.add_argument('--debuglevel', type=int, default=0, help='the debug level (0=silent, 1=print benchmarks, 2=print output from storm')
@@ -115,7 +119,7 @@ if __name__ == "__main__":
             if not parametric:
                 # Float
                 result = float(result)
-                if not math.isclose(result, float(expected_result), rel_tol=1e-05):
+                if not isclose(result, float(expected_result), rel_tol=1e-05):
                     print("Wrong result on example '{}' with property '{}': result: {}, Expected: {}".format(benchmark, prop, result, expected_result))
                 else:
                     correct += 1

From 7bf5fcb308326f9aacc4aabd860f92f50e857bae Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 15 Feb 2016 11:51:15 +0100
Subject: [PATCH 088/246] Fixed compile issue under Debian

Former-commit-id: 13fe157a96964a825d0eeda81342673763f485a8
---
 src/solver/stateelimination/StateEliminator.cpp | 1 -
 src/solver/stateelimination/StateEliminator.h   | 5 ++++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/solver/stateelimination/StateEliminator.cpp b/src/solver/stateelimination/StateEliminator.cpp
index 3e3d8c53a..09f576e5a 100644
--- a/src/solver/stateelimination/StateEliminator.cpp
+++ b/src/solver/stateelimination/StateEliminator.cpp
@@ -1,7 +1,6 @@
 #include "src/solver/stateelimination/StateEliminator.h"
 
 #include "src/storage/BitVector.h"
-#include "src/adapters/CarlAdapter.h"
 #include "src/utility/constants.h"
 #include "src/utility/macros.h"
 #include "src/exceptions/InvalidStateException.h"
diff --git a/src/solver/stateelimination/StateEliminator.h b/src/solver/stateelimination/StateEliminator.h
index 2a58912e8..a0bf04a98 100644
--- a/src/solver/stateelimination/StateEliminator.h
+++ b/src/solver/stateelimination/StateEliminator.h
@@ -4,6 +4,9 @@
 #include "src/storage/FlexibleSparseMatrix.h"
 #include "src/storage/SparseMatrix.h"
 #include "src/storage/sparse/StateType.h"
+#include "src/models/sparse/Dtmc.h"
+#include "src/models/sparse/StandardRewardModel.h"
+#include "src/adapters/CarlAdapter.h"
 #include "src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h"
 
 namespace storm {
@@ -39,4 +42,4 @@ namespace storm {
     } // namespace storage
 } // namespace storm
 
-#endif // STORM_SOLVER_STATEELIMINATION_STATEELIMINATOR_H_
\ No newline at end of file
+#endif // STORM_SOLVER_STATEELIMINATION_STATEELIMINATOR_H_

From 017fa192815a56d2641cd1c15cd08068f0607a42 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 15 Feb 2016 11:55:42 +0100
Subject: [PATCH 089/246] Fixed compile issue

Former-commit-id: a58c76d17584b72fcb4c04313f3168ffef854975
---
 src/solver/stateelimination/StateEliminator.cpp | 3 +--
 src/solver/stateelimination/StateEliminator.h   | 5 ++++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/solver/stateelimination/StateEliminator.cpp b/src/solver/stateelimination/StateEliminator.cpp
index 3e3d8c53a..01dc8a5af 100644
--- a/src/solver/stateelimination/StateEliminator.cpp
+++ b/src/solver/stateelimination/StateEliminator.cpp
@@ -1,7 +1,6 @@
 #include "src/solver/stateelimination/StateEliminator.h"
 
 #include "src/storage/BitVector.h"
-#include "src/adapters/CarlAdapter.h"
 #include "src/utility/constants.h"
 #include "src/utility/macros.h"
 #include "src/exceptions/InvalidStateException.h"
@@ -256,4 +255,4 @@ namespace storm {
             
         } // namespace stateelimination
     } // namespace storage
-} // namespace storm
\ No newline at end of file
+} // namespace storm
diff --git a/src/solver/stateelimination/StateEliminator.h b/src/solver/stateelimination/StateEliminator.h
index 2a58912e8..a0bf04a98 100644
--- a/src/solver/stateelimination/StateEliminator.h
+++ b/src/solver/stateelimination/StateEliminator.h
@@ -4,6 +4,9 @@
 #include "src/storage/FlexibleSparseMatrix.h"
 #include "src/storage/SparseMatrix.h"
 #include "src/storage/sparse/StateType.h"
+#include "src/models/sparse/Dtmc.h"
+#include "src/models/sparse/StandardRewardModel.h"
+#include "src/adapters/CarlAdapter.h"
 #include "src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h"
 
 namespace storm {
@@ -39,4 +42,4 @@ namespace storm {
     } // namespace storage
 } // namespace storm
 
-#endif // STORM_SOLVER_STATEELIMINATION_STATEELIMINATOR_H_
\ No newline at end of file
+#endif // STORM_SOLVER_STATEELIMINATION_STATEELIMINATOR_H_

From 63b0513f38c74bd06b0254d70df9d32e9636d8ef Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 15 Feb 2016 14:58:26 +0100
Subject: [PATCH 090/246] Set probability for pdeps

Former-commit-id: 2ac06e76c007d05cef74fc3028e967910abacb06
---
 src/builder/ExplicitDFTModelBuilder.cpp |  8 +++++---
 src/storage/dft/DFTState.cpp            |  3 +--
 src/storage/dft/DFTState.h              | 11 +++++++++++
 3 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index cd2704dc6..723d75920 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -187,7 +187,9 @@ namespace storm {
                     // Set transitions
                     if (hasDependencies) {
                         // Failure is due to dependency -> add non-deterministic choice
-                        transitionMatrixBuilder.addNextValue(state->getId() + rowOffset++, newState->getId(), storm::utility::one<ValueType>());
+                        std::shared_ptr<storm::storage::DFTDependency<ValueType> const> dependency = mDft.getDependency(state->getDependencyId(smallest-1));
+                        transitionMatrixBuilder.addNextValue(state->getId() + rowOffset++, newState->getId(), dependency->probability());
+                        STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newState->getId() << " with probability " << dependency->probability());
                     } else {
                         // Set failure rate according to usage
                         bool isUsed = true;
@@ -203,11 +205,11 @@ namespace storm {
                         if (resultFind != outgoingTransitions.end()) {
                             // Add to existing transition
                             resultFind->second += rate;
-                            STORM_LOG_TRACE("Updated transition from " << state->getId() << " to " << resultFind->first << " with " << rate << " to " << resultFind->second);
+                            STORM_LOG_TRACE("Updated transition from " << state->getId() << " to " << resultFind->first << " with rate " << rate << " to new rate " << resultFind->second);
                         } else {
                             // Insert new transition
                             outgoingTransitions.insert(std::make_pair(newState->getId(), rate));
-                            STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newState->getId() << " with " << rate);
+                            STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newState->getId() << " with rate " << rate);
                         }
                         exitRate += rate;
                     }
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 672ca14a7..8714f0130 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -99,8 +99,7 @@ namespace storm {
             STORM_LOG_TRACE("currently failable: " << getCurrentlyFailableString());
             if (nrFailableDependencies() > 0) {
                 // Consider failure due to dependency
-                assert(index < nrFailableDependencies());
-                std::shared_ptr<DFTDependency<ValueType> const> dependency = mDft.getDependency(mFailableDependencies[index]);
+                std::shared_ptr<DFTDependency<ValueType> const> dependency = mDft.getDependency(getDependencyId(index));
                 std::pair<std::shared_ptr<DFTBE<ValueType> const>,bool> res(mDft.getBasicElement(dependency->dependentEvent()->id()), true);
                 mFailableDependencies.erase(mFailableDependencies.begin() + index);
                 setFailed(res.first->id());
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 17a9c2d3b..520587a42 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -6,6 +6,7 @@
 
 #include <sstream>
 #include <memory>
+#include <cassert>
 
 namespace storm {
     namespace storage {
@@ -114,6 +115,16 @@ namespace storm {
             size_t nrFailableDependencies() const {
                 return mFailableDependencies.size();
             }
+            
+            /**
+             * Gets the id of the dependency at index in the list of failable dependencies.
+             * @param index Index in list of failable dependencies.
+             * @return Id of the dependency
+             */
+            size_t getDependencyId(size_t index) const {
+                assert(index < nrFailableDependencies());
+                return mFailableDependencies[index];
+            }
 
             /**
              * Sets all failable BEs due to dependencies from newly failed element

From 3d4c5b3df289d0431000fd9acadaa98aba06a91f Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 15 Feb 2016 17:06:16 +0100
Subject: [PATCH 091/246] Fixed output for flexible matrix

Former-commit-id: e2c9913b6eddb4d5add820623115a0fa21a2cb54
---
 src/storage/FlexibleSparseMatrix.cpp | 77 ++++++++++++++++++----------
 src/storage/FlexibleSparseMatrix.h   | 15 ++++++
 2 files changed, 65 insertions(+), 27 deletions(-)

diff --git a/src/storage/FlexibleSparseMatrix.cpp b/src/storage/FlexibleSparseMatrix.cpp
index 99ed68337..03fcf3d57 100644
--- a/src/storage/FlexibleSparseMatrix.cpp
+++ b/src/storage/FlexibleSparseMatrix.cpp
@@ -63,6 +63,11 @@ namespace storm {
             return getRow(rowGroupIndices[rowGroup] + offset);
         }
         
+        template<typename ValueType>
+        std::vector<typename FlexibleSparseMatrix<ValueType>::index_type> const& FlexibleSparseMatrix<ValueType>::getRowGroupIndices() const {
+            return rowGroupIndices;
+        }
+        
         template<typename ValueType>
         typename FlexibleSparseMatrix<ValueType>::index_type FlexibleSparseMatrix<ValueType>::getRowCount() const {
             return this->data.size();
@@ -164,49 +169,64 @@ namespace storm {
             }
             return false;
         }
+        
+        template<typename ValueType>
+        std::ostream& FlexibleSparseMatrix<ValueType>::printRow(std::ostream& out, index_type const& rowIndex) const {
+            index_type columnIndex = 0;
+            row_type row = this->getRow(rowIndex);
+            for (index_type column = 0; column < this->getColumnCount(); ++column) {
+                if (columnIndex < row.size() && row[columnIndex].getColumn() == column) {
+                    // Insert entry
+                    out << row[columnIndex].getValue() << "\t";
+                    ++columnIndex;
+                } else {
+                    // Insert zero
+                    out << "0\t";
+                }
+            }
+            return out;
+        }
+        
 
         template<typename ValueType>
         std::ostream& operator<<(std::ostream& out, FlexibleSparseMatrix<ValueType> const& matrix) {
+            typedef typename FlexibleSparseMatrix<ValueType>::index_type FlexibleIndex;
+            
             // Print column numbers in header.
             out << "\t\t";
-            for (typename FlexibleSparseMatrix<ValueType>::index_type i = 0; i < matrix.getColumnCount(); ++i) {
+            for (FlexibleIndex i = 0; i < matrix.getColumnCount(); ++i) {
                 out << i << "\t";
             }
             out << std::endl;
             
-            typename FlexibleSparseMatrix<ValueType>::index_type endIndex = matrix.hasNontrivialRowGrouping() ? matrix.getRowGroupCount() : matrix.getRowCount();
-            // Iterate over all rows.
-            for (typename SparseMatrix<ValueType>::index_type i = 0; i < endIndex; ++i) {
-                if (matrix.hasNontrivialRowGrouping()) {
-                    out << "\t---- group " << i << "/" << (matrix.getRowGroupCount() - 1) << " ---- " << std::endl;
+            if (matrix.hasNontrivialRowGrouping()) {
+                // Iterate over all row groups
+                FlexibleIndex rowGroupCount = matrix.getRowGroupCount();
+                for (FlexibleIndex rowGroup = 0; rowGroup < rowGroupCount; ++rowGroup) {
+                    out << "\t---- group " << rowGroup << "/" << (rowGroupCount - 1) << " ---- " << std::endl;
+                    FlexibleIndex endRow = rowGroup+1 < rowGroupCount ? matrix.rowGroupIndices[rowGroup + 1] : matrix.getRowCount();
+                    // Iterate over all rows.
+                    for (FlexibleIndex row = matrix.rowGroupIndices[rowGroup]; row < endRow; ++row) {
+                        // Print the actual row.
+                        out << rowGroup << "\t(\t";
+                        matrix.printRow(out, row);
+                        out << "\t)\t" << rowGroup << std::endl;
+                    }
                 }
-                typename FlexibleSparseMatrix<ValueType>::index_type startRow = matrix.hasNontrivialRowGrouping() ? matrix.rowGroupIndices[i] : i;
-                typename FlexibleSparseMatrix<ValueType>::index_type endRow = matrix.hasNontrivialRowGrouping() ? matrix.rowGroupIndices[i + 1] : i+1;
-                for (typename FlexibleSparseMatrix<ValueType>::index_type rowIndex = startRow; rowIndex < endRow; ++rowIndex) {
+
+            } else {
+                // Iterate over all rows
+                for (FlexibleIndex row = 0; row < matrix.getRowCount(); ++row) {
                     // Print the actual row.
-                    out << i << "\t(\t";
-                    typename FlexibleSparseMatrix<ValueType>::row_type row = matrix.getRow(rowIndex);
-                    typename FlexibleSparseMatrix<ValueType>::index_type columnIndex = 0;
-                    for (auto const& entry : row) {
-                        //Insert zero between entries.
-                        while (columnIndex < entry.getColumn()) {
-                            out << "0\t";
-                            ++columnIndex;
-                        }
-                        ++columnIndex;
-                        out << entry.getValue() << "\t";
-                    }
-                    //Insert remaining zeros.
-                    while (columnIndex++ <= matrix.getColumnCount()) {
-                        out << "0\t";
-                    }
-                    out << "\t)\t" << i << std::endl;
+                    out << row << "\t(\t";
+                    matrix.printRow(out, row);
+                    out << "\t)\t" << row << std::endl;
                 }
             }
             
             // Print column numbers in footer.
             out << "\t\t";
-            for (typename FlexibleSparseMatrix<ValueType>::index_type i = 0; i < matrix.getColumnCount(); ++i) {
+            for (FlexibleIndex i = 0; i < matrix.getColumnCount(); ++i) {
                 out << i << "\t";
             }
             out << std::endl;
@@ -215,8 +235,11 @@ namespace storm {
 
         // Explicitly instantiate the matrix.
         template class FlexibleSparseMatrix<double>;
+        template std::ostream& operator<<(std::ostream& out, FlexibleSparseMatrix<double> const& matrix);
+        
 #ifdef STORM_HAVE_CARL
         template class FlexibleSparseMatrix<storm::RationalFunction>;
+        template std::ostream& operator<<(std::ostream& out, FlexibleSparseMatrix<storm::RationalFunction> const& matrix);
 #endif
 
     } // namespace storage
diff --git a/src/storage/FlexibleSparseMatrix.h b/src/storage/FlexibleSparseMatrix.h
index 163a25aa4..d7e74f062 100644
--- a/src/storage/FlexibleSparseMatrix.h
+++ b/src/storage/FlexibleSparseMatrix.h
@@ -85,6 +85,13 @@ namespace storm {
              * @return An object representing the given row.
              */
             row_type const& getRow(index_type rowGroup, index_type entryInGroup) const;
+            
+            /*!
+             * Returns the grouping of rows of this matrix.
+             *
+             * @return The grouping of rows of this matrix.
+             */
+            std::vector<index_type> const& getRowGroupIndices() const;
 
             /*!
              * Returns the number of rows of the matrix.
@@ -163,6 +170,14 @@ namespace storm {
              */
             bool rowHasDiagonalElement(storm::storage::sparse::state_type state);
 
+            /*!
+             * Print row.
+             * @param out Output stream.
+             * @param rowIndex Index of row to print.
+             * @return Output with printed row.
+             */
+            std::ostream& printRow(std::ostream& out, index_type const& rowIndex) const;
+            
             template<typename TPrime>
             friend std::ostream& operator<<(std::ostream& out, FlexibleSparseMatrix<TPrime> const& matrix);
 

From a6a8e5fff6f7ff08f24d4d1cc0582db8802da923 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 15 Feb 2016 17:14:03 +0100
Subject: [PATCH 092/246] Structure for MA to CTMC

Former-commit-id: 6dee4cec3cf0469658f9542db5a77115b4868f26
---
 src/builder/ExplicitDFTModelBuilder.cpp       | 16 ++++++------
 .../SparseMarkovAutomatonCslModelChecker.cpp  |  2 +-
 src/models/sparse/MarkovAutomaton.cpp         | 25 +++++++++++++++++++
 src/models/sparse/MarkovAutomaton.h           |  5 ++++
 src/utility/storm.h                           | 14 ++++++++---
 5 files changed, 50 insertions(+), 12 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 723d75920..aa4d46f15 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -73,20 +73,20 @@ namespace storm {
             }
 
             std::shared_ptr<storm::models::sparse::Model<ValueType>> model;
-            if (deterministic) {
-                // Turn the probabilities into rates by multiplying each row with the exit rate of the state.
-                // TODO Matthias: avoid transforming back and forth
-                storm::storage::SparseMatrix<ValueType> rateMatrix(modelComponents.transitionMatrix);
-                for (uint_fast64_t row = 0; row < rateMatrix.getRowCount(); ++row) {
+            // Turn the probabilities into rates by multiplying each row with the exit rate of the state.
+            // TODO Matthias: avoid transforming back and forth
+            storm::storage::SparseMatrix<ValueType> rateMatrix(modelComponents.transitionMatrix);
+            for (uint_fast64_t row = 0; row < rateMatrix.getRowCount(); ++row) {
+                if (modelComponents.markovianStates.get(row)) {
                     for (auto& entry : rateMatrix.getRow(row)) {
                         entry.setValue(entry.getValue() * modelComponents.exitRates[row]);
                     }
                 }
-
+            }
+            if (deterministic) {
                 model = std::make_shared<storm::models::sparse::Ctmc<ValueType>>(std::move(rateMatrix), std::move(modelComponents.stateLabeling));
             } else {
-                model = std::make_shared<storm::models::sparse::MarkovAutomaton<ValueType>>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.markovianStates), std::move(modelComponents.exitRates));
-
+                model = std::make_shared<storm::models::sparse::MarkovAutomaton<ValueType>>(std::move(rateMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.markovianStates), std::move(modelComponents.exitRates));
             }
             model->printModelInformationToStream(std::cout);
             return model;
diff --git a/src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.cpp b/src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.cpp
index b33b01436..12db539c8 100644
--- a/src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.cpp
+++ b/src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.cpp
@@ -30,7 +30,7 @@ namespace storm {
         template<typename SparseMarkovAutomatonModelType>
         bool SparseMarkovAutomatonCslModelChecker<SparseMarkovAutomatonModelType>::canHandle(CheckTask<storm::logic::Formula> const& checkTask) const {
             storm::logic::Formula const& formula = checkTask.getFormula();
-            return formula.isCslStateFormula() || formula.isCslPathFormula() || (formula.isRewardPathFormula() && formula.isReachabilityRewardFormula());
+            return formula.isCslStateFormula() || formula.isCslPathFormula() || (formula.isRewardPathFormula() && formula.isReachabilityRewardFormula()) || formula.isExpectedTimeOperatorFormula();
         }
         
         template<typename SparseMarkovAutomatonModelType>
diff --git a/src/models/sparse/MarkovAutomaton.cpp b/src/models/sparse/MarkovAutomaton.cpp
index 56a6400d1..c95957248 100644
--- a/src/models/sparse/MarkovAutomaton.cpp
+++ b/src/models/sparse/MarkovAutomaton.cpp
@@ -3,6 +3,8 @@
 #include "src/exceptions/InvalidArgumentException.h"
 #include "src/utility/constants.h"
 #include "src/adapters/CarlAdapter.h"
+#include "src/storage/FlexibleSparseMatrix.h"
+#include "src/models/sparse/Dtmc.h"
 
 namespace storm {
     namespace models {
@@ -217,6 +219,29 @@ namespace storm {
                 }
             }
             
+            template <typename ValueType, typename RewardModelType>
+            bool MarkovAutomaton<ValueType, RewardModelType>::hasOnlyTrivialNondeterminism() const {
+                // Check every state
+                for (uint_fast64_t state = 0; state < this->getNumberOfStates(); ++state) {
+                    // Get number of choices in current state
+                    uint_fast64_t numberChoices = this->getTransitionMatrix().getRowGroupIndices()[state + 1] - this->getTransitionMatrix().getRowGroupIndices()[state];
+                    if (isMarkovianState(state)) {
+                        assert(numberChoices == 1);
+                    }
+                    if (numberChoices > 1) {
+                        assert(isProbabilisticState(state));
+                        return false;
+                    }
+                }
+                return true;
+            }
+            
+            template <typename ValueType, typename RewardModelType>
+            std::shared_ptr<storm::models::sparse::Ctmc<ValueType, RewardModelType>> MarkovAutomaton<ValueType, RewardModelType>::convertToCTMC() {
+                assert(false)
+            }
+
+            
             template class MarkovAutomaton<double>;
 //            template class MarkovAutomaton<float>;
             
diff --git a/src/models/sparse/MarkovAutomaton.h b/src/models/sparse/MarkovAutomaton.h
index 731b845f3..ed807ab84 100644
--- a/src/models/sparse/MarkovAutomaton.h
+++ b/src/models/sparse/MarkovAutomaton.h
@@ -2,6 +2,7 @@
 #define STORM_MODELS_SPARSE_MARKOVAUTOMATON_H_
 
 #include "src/models/sparse/NondeterministicModel.h"
+#include "src/models/sparse/Ctmc.h"
 #include "src/utility/OsDetection.h"
 
 namespace storm {
@@ -121,6 +122,10 @@ namespace storm {
                  */
                 void close();
                 
+                bool hasOnlyTrivialNondeterminism() const;
+                
+                std::shared_ptr<storm::models::sparse::Ctmc<ValueType, RewardModelType>> convertToCTMC();
+                
                 virtual void writeDotToStream(std::ostream& outStream, bool includeLabeling = true, storm::storage::BitVector const* subsystem = nullptr, std::vector<ValueType> const* firstValue = nullptr, std::vector<ValueType> const* secondValue = nullptr, std::vector<uint_fast64_t> const* stateColoring = nullptr, std::vector<std::string> const* colors = nullptr, std::vector<uint_fast64_t>* scheduler = nullptr, bool finalizeOutput = true) const;
                 
                 std::size_t getSizeInBytes() const;
diff --git a/src/utility/storm.h b/src/utility/storm.h
index f297d9e41..f737b318e 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -277,6 +277,8 @@ namespace storm {
                 storm::modelchecker::SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<ValueType>> modelchecker2(*dtmc);
                 if (modelchecker2.canHandle(task)) {
                     result = modelchecker2.check(task);
+                } else {
+                    STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The property " << *formula << " is not supported on DTMCs.");
                 }
             }
         } else if (model->getType() == storm::models::ModelType::Mdp) {
@@ -300,9 +302,15 @@ namespace storm {
             result = modelchecker.check(task);
         } else if (model->getType() == storm::models::ModelType::MarkovAutomaton) {
             std::shared_ptr<storm::models::sparse::MarkovAutomaton<ValueType>> ma = model->template as<storm::models::sparse::MarkovAutomaton<ValueType>>();
-
-            storm::modelchecker::SparseMarkovAutomatonCslModelChecker<storm::models::sparse::MarkovAutomaton<ValueType>> modelchecker(*ma);
-            result = modelchecker.check(task);
+            if (ma->hasOnlyTrivialNondeterminism()) {
+                // Markov automaton can be converted into CTMC
+                std::shared_ptr<storm::models::sparse::Ctmc<ValueType>> ctmc = ma->convertToCTMC();
+                storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<ValueType>> modelchecker(*ctmc);
+                result = modelchecker.check(task);
+            } else {
+                storm::modelchecker::SparseMarkovAutomatonCslModelChecker<storm::models::sparse::MarkovAutomaton<ValueType>> modelchecker(*ma);
+                result = modelchecker.check(task);
+            }
         } else {
             STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The model type " << model->getType() << " is not supported.");
         }

From 0a78ba13f5540e948c0f4aaecaef9134f34623eb Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 15 Feb 2016 18:45:49 +0100
Subject: [PATCH 093/246] MA to CTMC for trivial nondeterminism

Former-commit-id: 8a342f032eb1b846265b2841b58793d90bd75abc
---
 benchmark_dft.py                             |  1 +
 examples/dft/fdep3.dft                       |  5 ++
 src/models/sparse/MarkovAutomaton.cpp        | 54 +++++++++++++++++++-
 src/solver/stateelimination/MAEliminator.cpp | 45 ++++++++++++++++
 src/solver/stateelimination/MAEliminator.h   | 32 ++++++++++++
 src/storage/FlexibleSparseMatrix.cpp         |  9 ++++
 src/storage/FlexibleSparseMatrix.h           |  8 +++
 7 files changed, 153 insertions(+), 1 deletion(-)
 create mode 100644 examples/dft/fdep3.dft
 create mode 100644 src/solver/stateelimination/MAEliminator.cpp
 create mode 100644 src/solver/stateelimination/MAEliminator.h

diff --git a/benchmark_dft.py b/benchmark_dft.py
index 8e9a5462b..edfc88bda 100644
--- a/benchmark_dft.py
+++ b/benchmark_dft.py
@@ -20,6 +20,7 @@ benchmarks = [
     ("deathegg", False, [46.667, 1]),
     ("fdep", False, [0.666667, 1]),
     ("fdep2", False, [2, 1]),
+    ("fdep3", False, [2.5, 1]),
     #("ftpp_complex", False, [0, 1]), # Compute
     #("ftpp_large", False, [0, 1]), # Compute
     #("ftpp_standard", False, [0, 1]), # Compute
diff --git a/examples/dft/fdep3.dft b/examples/dft/fdep3.dft
new file mode 100644
index 000000000..3815c9973
--- /dev/null
+++ b/examples/dft/fdep3.dft
@@ -0,0 +1,5 @@
+toplevel "A";
+"A" and "B" "C" "F";
+"F" fdep "B" "C";
+"B" lambda=0.4 dorm=0;
+"C" lambda=0.8 dorm=0;
diff --git a/src/models/sparse/MarkovAutomaton.cpp b/src/models/sparse/MarkovAutomaton.cpp
index c95957248..c757af1a0 100644
--- a/src/models/sparse/MarkovAutomaton.cpp
+++ b/src/models/sparse/MarkovAutomaton.cpp
@@ -5,6 +5,8 @@
 #include "src/adapters/CarlAdapter.h"
 #include "src/storage/FlexibleSparseMatrix.h"
 #include "src/models/sparse/Dtmc.h"
+#include "src/solver/stateelimination/MAEliminator.h"
+#include "src/utility/vector.h"
 
 namespace storm {
     namespace models {
@@ -238,7 +240,57 @@ namespace storm {
             
             template <typename ValueType, typename RewardModelType>
             std::shared_ptr<storm::models::sparse::Ctmc<ValueType, RewardModelType>> MarkovAutomaton<ValueType, RewardModelType>::convertToCTMC() {
-                assert(false)
+                STORM_LOG_TRACE("MA matrix:" << std::endl << this->getTransitionMatrix());
+                STORM_LOG_TRACE("Markovian states: " << getMarkovianStates());
+
+                // Eliminate all probabilistic states by state elimination
+                // Initialize
+                storm::storage::FlexibleSparseMatrix<ValueType> flexibleMatrix(this->getTransitionMatrix());
+                storm::storage::FlexibleSparseMatrix<ValueType> flexibleBackwardTransitions(this->getTransitionMatrix().transpose());
+                storm::solver::stateelimination::MAEliminator<storm::models::sparse::Dtmc<ValueType>> stateEliminator(flexibleMatrix, flexibleBackwardTransitions);
+                
+                for (uint_fast64_t state = 0; state < this->getNumberOfStates(); ++state) {
+                    assert(!this->isHybridState(state));
+                    if (this->isProbabilisticState(state)) {
+                        // Eliminate this probabilistic state
+                        stateEliminator.eliminateState(state, true);
+                        STORM_LOG_TRACE("Flexible matrix after eliminating state " << state << ":" << std::endl << flexibleMatrix);
+                    }
+                }
+                
+                // Create the rate matrix for the CTMC
+                storm::storage::SparseMatrixBuilder<ValueType> transitionMatrixBuilder(0, 0, 0, false, false);
+                // Remember state to keep
+                storm::storage::BitVector keepStates(this->getNumberOfStates(), true);
+                for (uint_fast64_t state = 0; state < this->getNumberOfStates(); ++state) {
+                    if (storm::utility::isZero(flexibleMatrix.getRowSum(state))) {
+                        // State is eliminated and can be discarded
+                        keepStates.set(state, false);
+                    } else {
+                        assert(this->isMarkovianState(state));
+                        // Copy transitions
+                        for (uint_fast64_t row = flexibleMatrix.getRowGroupIndices()[state]; row < flexibleMatrix.getRowGroupIndices()[state + 1]; ++row) {
+                            for (auto const& entry : flexibleMatrix.getRow(row)) {
+                                // Convert probabilities into rates
+                                transitionMatrixBuilder.addNextValue(state, entry.getColumn(), entry.getValue() * exitRates[state]);
+                            }
+                        }
+                    }
+                }
+                
+                storm::storage::SparseMatrix<ValueType> rateMatrix = transitionMatrixBuilder.build();
+                rateMatrix = rateMatrix.getSubmatrix(false, keepStates, keepStates, false);
+                STORM_LOG_TRACE("New CTMC matrix:" << std::endl << rateMatrix);
+                // Construct CTMC
+                storm::models::sparse::StateLabeling stateLabeling = this->getStateLabeling().getSubLabeling(keepStates);
+                boost::optional<std::vector<LabelSet>> optionalChoiceLabeling = this->getOptionalChoiceLabeling();
+                if (optionalChoiceLabeling) {
+                    optionalChoiceLabeling = storm::utility::vector::filterVector(optionalChoiceLabeling.get(), keepStates);
+                }
+                //TODO update reward models according to kept states
+                std::unordered_map<std::string, RewardModelType> rewardModels = this->getRewardModels();
+                
+                return std::make_shared<storm::models::sparse::Ctmc<ValueType, RewardModelType>>(std::move(rateMatrix), std::move(stateLabeling), std::move(rewardModels), std::move(optionalChoiceLabeling));
             }
 
             
diff --git a/src/solver/stateelimination/MAEliminator.cpp b/src/solver/stateelimination/MAEliminator.cpp
new file mode 100644
index 000000000..7a26e995c
--- /dev/null
+++ b/src/solver/stateelimination/MAEliminator.cpp
@@ -0,0 +1,45 @@
+#include "src/solver/stateelimination/MAEliminator.h"
+
+namespace storm {
+    namespace solver {
+        namespace stateelimination {
+            
+            template<typename SparseModelType>
+            MAEliminator<SparseModelType>::MAEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions) : StateEliminator<SparseModelType>(transitionMatrix, backwardTransitions){
+            }
+            
+            template<typename SparseModelType>
+            void MAEliminator<SparseModelType>::updateValue(storm::storage::sparse::state_type const& state, ValueType const& loopProbability) {
+                // Do nothing
+            }
+       
+            template<typename SparseModelType>
+            void MAEliminator<SparseModelType>::updatePredecessor(storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) {
+                // Do nothing
+            }
+            
+            template<typename SparseModelType>
+            void MAEliminator<SparseModelType>::updatePriority(storm::storage::sparse::state_type const& state) {
+                // Do nothing
+            }
+            
+            template<typename SparseModelType>
+            bool MAEliminator<SparseModelType>::filterPredecessor(storm::storage::sparse::state_type const& state) {
+                assert(false);
+            }
+            
+            template<typename SparseModelType>
+            bool MAEliminator<SparseModelType>::isFilterPredecessor() const {
+                return false;
+            }
+            
+            
+            template class MAEliminator<storm::models::sparse::Dtmc<double>>;
+            
+#ifdef STORM_HAVE_CARL
+            template class MAEliminator<storm::models::sparse::Dtmc<storm::RationalFunction>>;
+#endif
+            
+        } // namespace stateelimination
+    } // namespace storage
+} // namespace storm
diff --git a/src/solver/stateelimination/MAEliminator.h b/src/solver/stateelimination/MAEliminator.h
new file mode 100644
index 000000000..d4db284c3
--- /dev/null
+++ b/src/solver/stateelimination/MAEliminator.h
@@ -0,0 +1,32 @@
+#ifndef STORM_SOLVER_STATEELIMINATION_MAELIMINATOR_H_
+#define STORM_SOLVER_STATEELIMINATION_MAELIMINATOR_H_
+
+#include "src/solver/stateelimination/StateEliminator.h"
+
+namespace storm {
+    namespace solver {
+        namespace stateelimination {
+            
+            template<typename SparseModelType>
+            class MAEliminator : public StateEliminator<SparseModelType> {
+
+                typedef typename SparseModelType::ValueType ValueType;
+
+            public:
+                MAEliminator(storm::storage::FlexibleSparseMatrix<ValueType>& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType>& backwardTransitions);
+                
+                // Instantiaton of Virtual methods
+                void updateValue(storm::storage::sparse::state_type const& state, ValueType const& loopProbability) override;
+                void updatePredecessor(storm::storage::sparse::state_type const& predecessor, ValueType const& probability, storm::storage::sparse::state_type const& state) override;
+                void updatePriority(storm::storage::sparse::state_type const& state) override;
+                bool filterPredecessor(storm::storage::sparse::state_type const& state) override;
+                bool isFilterPredecessor() const override;
+                
+            private:
+            };
+            
+        } // namespace stateelimination
+    } // namespace storage
+} // namespace storm
+
+#endif // STORM_SOLVER_STATEELIMINATION_MAELIMINATOR_H_
diff --git a/src/storage/FlexibleSparseMatrix.cpp b/src/storage/FlexibleSparseMatrix.cpp
index 03fcf3d57..60422dc08 100644
--- a/src/storage/FlexibleSparseMatrix.cpp
+++ b/src/storage/FlexibleSparseMatrix.cpp
@@ -96,6 +96,15 @@ namespace storm {
                 return rowGroupIndices[group + 1] - rowGroupIndices[group];
             }
         }
+        
+        template<typename ValueType>
+        ValueType FlexibleSparseMatrix<ValueType>::getRowSum(index_type row) const {
+            ValueType sum = storm::utility::zero<ValueType>();
+            for (auto const& element : getRow(row)) {
+                sum += element.getValue();
+            }
+            return sum;
+        }
 
         template<typename ValueType>
         void FlexibleSparseMatrix<ValueType>::updateDimensions() {
diff --git a/src/storage/FlexibleSparseMatrix.h b/src/storage/FlexibleSparseMatrix.h
index d7e74f062..28100e0a2 100644
--- a/src/storage/FlexibleSparseMatrix.h
+++ b/src/storage/FlexibleSparseMatrix.h
@@ -128,6 +128,14 @@ namespace storm {
              * @return The number of rows that belong to the given row group.
              */
             index_type getRowGroupSize(index_type group) const;
+            
+            /*!
+             * Computes the sum of the entries in a given row.
+             *
+             * @param row The row that is to be summed.
+             * @return The sum of the selected row.
+             */
+            value_type getRowSum(index_type row) const;
 
             /*!
              * Recomputes the number of columns and the number of non-zero entries.

From 28bc49ed664988e5a4c6008f3c648c2e3f360ca5 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 15 Feb 2016 19:06:53 +0100
Subject: [PATCH 094/246] Relative paths in benchmark script

Former-commit-id: e360ade8cefc568c9106e99724b2448c6f5ca3d8
---
 benchmark_dft.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/benchmark_dft.py b/benchmark_dft.py
index edfc88bda..dfcecd15f 100644
--- a/benchmark_dft.py
+++ b/benchmark_dft.py
@@ -1,13 +1,14 @@
 import os
 import os.path
+import sys
 import subprocess
 import re
 import time
 import argparse
 
-STORM_PATH= "/Users/mvolk/develop/dft-storm/build/src/storm-dft"
-EXAMPLE_DIR= "/Users/mvolk/develop/dft-storm/examples/dft/"
-
+DIR=os.getcwd()
+STORM_PATH=os.path.join(DIR, "build/src/storm-dft")
+EXAMPLE_DIR=os.path.join(DIR, "examples/dft/")
 
 benchmarks = [ 
     ("and", False, [3, 1]),

From 67626ff9bb4f30f7f13fd9d6a5a3517a5814e8d3 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 16 Feb 2016 11:18:47 +0100
Subject: [PATCH 095/246] Xcode support for new directory

Former-commit-id: 7d3776d555dd6406de30e9d5e13a1bab71ff45d9
---
 src/CMakeLists.txt | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index be3b825a0..b8fbd6953 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -31,7 +31,8 @@ file(GLOB STORM_PARSER_FILES ${PROJECT_SOURCE_DIR}/src/parser/*.h ${PROJECT_SOUR
 file(GLOB_RECURSE STORM_PARSER_PRISMPARSER_FILES ${PROJECT_SOURCE_DIR}/src/parser/prismparser/*.h ${PROJECT_SOURCE_DIR}/src/parser/prismparser/*.cpp)
 file(GLOB STORM_SETTINGS_FILES ${PROJECT_SOURCE_DIR}/src/settings/*.h ${PROJECT_SOURCE_DIR}/src/settings/*.cpp)
 file(GLOB STORM_SETTINGS_MODULES_FILES ${PROJECT_SOURCE_DIR}/src/settings/modules/*.h ${PROJECT_SOURCE_DIR}/src/settings/modules/*.cpp)
-file(GLOB_RECURSE STORM_SOLVER_FILES ${PROJECT_SOURCE_DIR}/src/solver/*.h ${PROJECT_SOURCE_DIR}/src/solver/*.cpp)
+file(GLOB STORM_SOLVER_FILES ${PROJECT_SOURCE_DIR}/src/solver/*.h ${PROJECT_SOURCE_DIR}/src/solver/*.cpp)
+file(GLOB STORM_SOLVER_STATEELIMINATION_FILES ${PROJECT_SOURCE_DIR}/src/solver/stateelimination/*.h ${PROJECT_SOURCE_DIR}/src/solver/stateelimination/*.cpp)
 file(GLOB STORM_STORAGE_FILES ${PROJECT_SOURCE_DIR}/src/storage/*.h ${PROJECT_SOURCE_DIR}/src/storage/*.cpp)
 file(GLOB STORM_STORAGE_BISIMULATION_FILES ${PROJECT_SOURCE_DIR}/src/storage/bisimulation/*.h ${PROJECT_SOURCE_DIR}/src/storage/bisimulation/*.cpp)
 file(GLOB STORM_STORAGE_DD_FILES ${PROJECT_SOURCE_DIR}/src/storage/dd/*.h ${PROJECT_SOURCE_DIR}/src/storage/dd/*.cpp)
@@ -79,6 +80,7 @@ source_group(parser\\prismparser FILES ${STORM_PARSER_PRISMPARSER_FILES})
 source_group(settings FILES ${STORM_SETTINGS_FILES})
 source_group(settings\\modules FILES ${STORM_SETTINGS_MODULES_FILES})
 source_group(solver FILES ${STORM_SOLVER_FILES})
+source_group(solver\\stateelimination FILES ${STORM_SOLVER_STATEELIMINATION_FILES})
 source_group(storage FILES ${STORM_STORAGE_FILES})
 source_group(storage\\bisimulation FILES ${STORM_STORAGE_BISIMULATION_FILES})
 source_group(storage\\dd FILES ${STORM_STORAGE_DD_FILES})

From 6b31b23c624e5c10e54a5421d0bc145c92aed49e Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 16 Feb 2016 11:21:37 +0100
Subject: [PATCH 096/246] Removed unused time keeping variables

Former-commit-id: 67449791d505d85b39295f700ae502adab7d55d4
---
 .../reachability/SparseDtmcEliminationModelChecker.cpp    | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
index c969a639f..5d0bd164c 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
@@ -720,15 +720,12 @@ namespace storm {
                                                              eliminationOrderNeedsReversedDistances(order));
             }
             
-            std::chrono::high_resolution_clock::time_point conversionStart = std::chrono::high_resolution_clock::now();
             storm::storage::FlexibleSparseMatrix<ValueType> flexibleMatrix(submatrix);
             storm::storage::FlexibleSparseMatrix<ValueType> flexibleBackwardTransitions(submatrixTransposed, true);
-            std::chrono::high_resolution_clock::time_point conversionEnd = std::chrono::high_resolution_clock::now();
             
             std::shared_ptr<StatePriorityQueue<ValueType>> statePriorities = createStatePriorityQueue(distanceBasedPriorities, flexibleMatrix, flexibleBackwardTransitions, oneStepProbabilities, statesToEliminate);
 
             STORM_LOG_INFO("Computing conditional probilities." << std::endl);
-            std::chrono::high_resolution_clock::time_point modelCheckingStart = std::chrono::high_resolution_clock::now();
             uint_fast64_t numberOfStatesToEliminate = statePriorities->size();
             STORM_LOG_INFO("Eliminating " << numberOfStatesToEliminate << " states using the state elimination technique." << std::endl);
             performPrioritizedStateElimination(statePriorities, flexibleMatrix, flexibleBackwardTransitions, oneStepProbabilities, this->getModel().getInitialStates(), true);
@@ -950,10 +947,7 @@ namespace storm {
             // Then, we convert the reduced matrix to a more flexible format to be able to perform state elimination more easily.
             storm::storage::FlexibleSparseMatrix<ValueType> flexibleMatrix(transitionMatrix);
             storm::storage::FlexibleSparseMatrix<ValueType> flexibleBackwardTransitions(backwardTransitions);
-            auto conversionEnd = std::chrono::high_resolution_clock::now();
-            
-            std::chrono::high_resolution_clock::time_point modelCheckingStart = std::chrono::high_resolution_clock::now();
-            
+
             storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder order = storm::settings::sparseDtmcEliminationModelCheckerSettings().getEliminationOrder();
             boost::optional<std::vector<uint_fast64_t>> distanceBasedPriorities;
             if (eliminationOrderNeedsDistances(order)) {

From a9c80ef9dc6a1300a5963a0af51a5a0ac0a42052 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 16 Feb 2016 12:06:19 +0100
Subject: [PATCH 097/246] Better error handling

Former-commit-id: 36bd1108226df7010e6749e4f989d4bdc8510336
---
 src/parser/DFTGalileoParser.cpp | 23 ++++++++---------------
 src/parser/DFTGalileoParser.h   |  2 +-
 src/storage/dft/DFTBuilder.h    |  9 +++++----
 3 files changed, 14 insertions(+), 20 deletions(-)

diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index c8639ae30..d11f5ae3b 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -15,14 +15,11 @@ namespace storm {
 
         template<typename ValueType>
         storm::storage::DFT<ValueType> DFTGalileoParser<ValueType>::parseDFT(const std::string& filename) {
-            if(readFile(filename)) {
-                storm::storage::DFT<ValueType> dft = builder.build();
-                STORM_LOG_DEBUG("Elements:" << std::endl << dft.getElementsString());
-                STORM_LOG_DEBUG("Spare Modules:" << std::endl << dft.getSpareModulesString());
-                return dft;
-            } else {
-                throw storm::exceptions::FileIoException();
-            }
+            readFile(filename);
+            storm::storage::DFT<ValueType> dft = builder.build();
+            STORM_LOG_DEBUG("Elements:" << std::endl << dft.getElementsString());
+            STORM_LOG_DEBUG("Spare Modules:" << std::endl << dft.getSpareModulesString());
+            return dft;
         }
 
         template<typename ValueType>
@@ -39,7 +36,7 @@ namespace storm {
         }
 
         template<typename ValueType>
-        bool DFTGalileoParser<ValueType>::readFile(const std::string& filename) {
+        void DFTGalileoParser<ValueType>::readFile(const std::string& filename) {
             // constants
             std::string toplevelToken = "toplevel";
             std::string toplevelId;
@@ -52,12 +49,11 @@ namespace storm {
             }
             catch (std::ifstream::failure e) {
                 STORM_LOG_THROW(false, storm::exceptions::FileIoException, "Exception during file opening on " << filename << ".");
-                return false;
+                return;
             }
             file.exceptions( std::ifstream::goodbit );
 
             std::string line;
-            bool generalSuccess = true;
             while(std::getline(file, line)) {
                 bool success = true;
                 STORM_LOG_TRACE("Parsing: " << line);
@@ -119,16 +115,13 @@ namespace storm {
                         STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Type name: " << tokens[1] << "  not recognized.");
                         success = false;
                     }
-                }
-                if (generalSuccess) {
-                    generalSuccess = success;
+                    STORM_LOG_THROW(success, storm::exceptions::FileIoException, "Error while adding element '" << name << "' of line '" << line << "'.");
                 }
             }
             if(!builder.setTopLevel(toplevelId)) {
                 STORM_LOG_THROW(false, storm::exceptions::FileIoException, "Top level id unknown.");
             }
             file.close();
-            return generalSuccess;
         }
 
         template<typename ValueType>
diff --git a/src/parser/DFTGalileoParser.h b/src/parser/DFTGalileoParser.h
index 557803465..fc64ee80e 100644
--- a/src/parser/DFTGalileoParser.h
+++ b/src/parser/DFTGalileoParser.h
@@ -31,7 +31,7 @@ namespace storm {
             storm::storage::DFT<ValueType> parseDFT(std::string const& filename);
             
         private:
-            bool readFile(std::string const& filename);
+            void readFile(std::string const& filename);
 
             std::string stripQuotsFromName(std::string const& name);
 
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index ef01369c9..37c3c4eaa 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -6,6 +6,7 @@
 #include <iostream>
 #include <unordered_map>
 #include <map>
+#include "src/utility/macros.h"
 
 namespace storm {
     namespace storage {
@@ -70,7 +71,7 @@ namespace storm {
                 //0 <= probability <= 1
                 if (!storm::utility::isOne(probability) && children.size() > 2) {
                     //TODO Matthias: introduce additional element for probability and then add pdeps with probability 1 to children
-                    std::cerr << "Probability != 1 for more than one child currently not supported." << std::endl;
+                    STORM_LOG_ERROR("Probability != 1 for more than one child currently not supported.");
                     return false;
                 }
 
@@ -78,7 +79,7 @@ namespace storm {
                     std::string nameDep = name + "_" + std::to_string(i);
                     if(mElements.count(nameDep) != 0) {
                         // Element with that name already exists.
-                        std::cerr << "Element with name: " << nameDep << " already exists." << std::endl;
+                        STORM_LOG_ERROR("Element with name: " << nameDep << " already exists.");
                         return false;
                     }
                     assert(storm::utility::isOne(probability) || children.size() == 2);
@@ -92,7 +93,7 @@ namespace storm {
             bool addVotElement(std::string const& name, unsigned threshold, std::vector<std::string> const& children) {
                 assert(children.size() > 0);
                 if(mElements.count(name) != 0) {
-                    std::cerr << "Element with name: " << name << " already exists." << std::endl;
+                    STORM_LOG_ERROR("Element with name: " << name << " already exists.");
                     return false;
                 }
                 // It is an and-gate
@@ -105,7 +106,7 @@ namespace storm {
                 }
                 
                 if(threshold > children.size()) {
-                    std::cerr << "Voting gates with threshold higher than the number of children is not supported." << std::endl;
+                    STORM_LOG_ERROR("Voting gates with threshold higher than the number of children is not supported.");
                     return false;
                 }
                 DFTElementPointer element = std::make_shared<DFTVot<ValueType>>(mNextId++, name, threshold);

From c5214c6abafe657dc159b8ea0da28b296dac1790 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 16 Feb 2016 12:06:56 +0100
Subject: [PATCH 098/246] Removed unused include

Former-commit-id: 90b0a9722e514a557a8d26a43b33f938a0e73794
---
 src/storage/BitVector.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/storage/BitVector.cpp b/src/storage/BitVector.cpp
index 00a94e86c..dff4b2f5f 100644
--- a/src/storage/BitVector.cpp
+++ b/src/storage/BitVector.cpp
@@ -9,7 +9,6 @@
 #include "src/utility/OsDetection.h"
 #include "src/utility/Hash.h"
 #include "src/utility/macros.h"
-#include "resources/3rdparty/glpk-4.53/src/zlib/zconf.h"
 
 namespace storm {
     namespace storage {

From c78d9ff80222c373589b4b7af5ce4d77b1a61465 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 17 Feb 2016 11:21:46 +0100
Subject: [PATCH 099/246] Fixed problems with pdeps

Former-commit-id: c46c88b1779b51b6d052fe9cb462d37dc8973e31
---
 benchmark_dft.py                        |  3 +-
 examples/dft/pdep3.dft                  |  5 +++
 src/builder/ExplicitDFTModelBuilder.cpp | 42 ++++++++++++++++++---
 src/storage/dft/DFT.cpp                 | 32 ++++++++++------
 src/storage/dft/DFTBuilder.cpp          |  1 +
 src/storage/dft/DFTElementState.h       | 50 ++++++++++++++++++++++++-
 src/storage/dft/DFTElements.cpp         |  2 +-
 src/storage/dft/DFTElements.h           | 32 +++++++++++++++-
 src/storage/dft/DFTState.cpp            | 42 ++++++++++++++++++++-
 src/storage/dft/DFTState.h              | 23 +++++++++++-
 10 files changed, 207 insertions(+), 25 deletions(-)
 create mode 100644 examples/dft/pdep3.dft

diff --git a/benchmark_dft.py b/benchmark_dft.py
index dfcecd15f..77880d951 100644
--- a/benchmark_dft.py
+++ b/benchmark_dft.py
@@ -31,8 +31,9 @@ benchmarks = [
     ("or", False, [1, 1]),
     ("pand", False, ["inf", 0.666667]),
     ("pand_param", True, ["-1", "(x)/(y+x)"]),
-    ("pdep", False, [0, 1]), #Compute
+    ("pdep", False, [2.66667, 1]),
     ("pdep2", False, [0, 1]), #Compute
+    ("pdep3", False, [2.79167, 1]),
     ("spare", False, [3.53846, 1]),
     ("spare2", False, [1.86957, 1]),
     ("spare3", False, [1.27273, 1]),
diff --git a/examples/dft/pdep3.dft b/examples/dft/pdep3.dft
new file mode 100644
index 000000000..a9a73f472
--- /dev/null
+++ b/examples/dft/pdep3.dft
@@ -0,0 +1,5 @@
+toplevel "A";
+"A" and "B" "C" "F";
+"F" pdep=0.3 "B" "C";
+"B" lambda=0.4 dorm=0;
+"C" lambda=0.8 dorm=0;
diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index aa4d46f15..160535443 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -77,17 +77,20 @@ namespace storm {
             // TODO Matthias: avoid transforming back and forth
             storm::storage::SparseMatrix<ValueType> rateMatrix(modelComponents.transitionMatrix);
             for (uint_fast64_t row = 0; row < rateMatrix.getRowCount(); ++row) {
+                assert(row < modelComponents.markovianStates.size());
                 if (modelComponents.markovianStates.get(row)) {
                     for (auto& entry : rateMatrix.getRow(row)) {
                         entry.setValue(entry.getValue() * modelComponents.exitRates[row]);
                     }
                 }
             }
+            
             if (deterministic) {
                 model = std::make_shared<storm::models::sparse::Ctmc<ValueType>>(std::move(rateMatrix), std::move(modelComponents.stateLabeling));
             } else {
                 model = std::make_shared<storm::models::sparse::MarkovAutomaton<ValueType>>(std::move(rateMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.markovianStates), std::move(modelComponents.exitRates));
             }
+            
             model->printModelInformationToStream(std::cout);
             return model;
         }
@@ -143,9 +146,6 @@ namespace storm {
                     assert(nextBEPair.second == hasDependencies);
                     STORM_LOG_TRACE("with the failure of: " << nextBE->name() << " [" << nextBE->id() << "]");
 
-                    // Update failable dependencies
-                    newState->updateFailableDependencies(nextBE->id());
-
                     // Propagate failures
                     storm::storage::DFTStateSpaceGenerationQueues<ValueType> queues;
 
@@ -169,6 +169,9 @@ namespace storm {
                         DFTElementPointer next = queues.nextDontCarePropagation();
                         next->checkDontCareAnymore(*newState, queues);
                     }
+                    
+                    // Update failable dependencies
+                    newState->updateFailableDependencies(nextBE->id());
 
                     if (mStates.contains(newState->status())) {
                         // State already exists
@@ -180,7 +183,7 @@ namespace storm {
                         mStates.findOrAdd(newState->status(), newState);
                         STORM_LOG_TRACE("New state " << mDft.getStateString(newState));
 
-                        // Add state to search
+                        // Add state to search queue
                         stateQueue.push(newState);
                     }
 
@@ -188,8 +191,37 @@ namespace storm {
                     if (hasDependencies) {
                         // Failure is due to dependency -> add non-deterministic choice
                         std::shared_ptr<storm::storage::DFTDependency<ValueType> const> dependency = mDft.getDependency(state->getDependencyId(smallest-1));
-                        transitionMatrixBuilder.addNextValue(state->getId() + rowOffset++, newState->getId(), dependency->probability());
+                        transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, newState->getId(), dependency->probability());
                         STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newState->getId() << " with probability " << dependency->probability());
+
+                        if (!storm::utility::isOne(dependency->probability())) {
+                            // Add transition to state where dependency was unsuccessful
+                            DFTStatePointer unsuccessfulState = std::make_shared<storm::storage::DFTState<ValueType>>(*state);
+                            unsuccessfulState->letDependencyBeUnsuccessful(smallest-1);
+                            
+                            if (mStates.contains(unsuccessfulState->status())) {
+                                // Unsuccessful state already exists
+                                unsuccessfulState = mStates.findOrAdd(unsuccessfulState->status(), unsuccessfulState);
+                                STORM_LOG_TRACE("State " << mDft.getStateString(unsuccessfulState) << " already exists");
+                            } else {
+                                // New unsuccessful state
+                                unsuccessfulState->setId(newIndex++);
+                                mStates.findOrAdd(unsuccessfulState->status(), unsuccessfulState);
+                                STORM_LOG_TRACE("New state " << mDft.getStateString(unsuccessfulState));
+                                
+                                // Add unsuccessful state to search queue
+                                stateQueue.push(unsuccessfulState);
+                            }
+
+                            ValueType remainingProbability = storm::utility::one<ValueType>() - dependency->probability();
+                            transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, unsuccessfulState->getId(), remainingProbability);
+                            STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << unsuccessfulState->getId() << " with probability " << remainingProbability);
+                        } else {
+                            // Self-loop with probability one cannot be eliminated later one.
+                            assert(state->getId() != newState->getId());
+                        }
+                        ++rowOffset;
+
                     } else {
                         // Set failure rate according to usage
                         bool isUsed = true;
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index b3f0dce7a..83e287b3b 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -118,13 +118,17 @@ namespace storm {
             for (auto const& elem : mElements) {
                 stream << "[" << elem->id() << "]";
                 stream << elem->toString();
-                stream << "\t** " << state->getElementState(elem->id());
-                if(elem->isSpareGate()) {
-                    if(state->isActiveSpare(elem->id())) {
-                        stream << " actively";
+                if (elem->isDependency()) {
+                    stream << "\t** " << storm::storage::toChar(state->getDependencyState(elem->id()));
+                } else {
+                    stream << "\t** " << storm::storage::toChar(state->getElementState(elem->id()));
+                    if(elem->isSpareGate()) {
+                        if(state->isActiveSpare(elem->id())) {
+                            stream << " actively";
+                        }
+                        stream << " using " << state->uses(elem->id());
                     }
-                    stream << " using " << state->uses(elem->id());
-                } 
+                }
                 stream << std::endl;
             }
             return stream.str();
@@ -135,13 +139,17 @@ namespace storm {
             std::stringstream stream;
             stream << "(" << state->getId() << ") ";
             for (auto const& elem : mElements) {
-                stream << state->getElementStateInt(elem->id());
-                if(elem->isSpareGate()) {
-                    stream << "[";
-                    if(state->isActiveSpare(elem->id())) {
-                        stream << "actively ";
+                if (elem->isDependency()) {
+                    stream << storm::storage::toChar(state->getDependencyState(elem->id())) << "[dep]";
+                } else {
+                    stream << storm::storage::toChar(state->getElementState(elem->id()));
+                    if(elem->isSpareGate()) {
+                        stream << "[";
+                        if(state->isActiveSpare(elem->id())) {
+                            stream << "actively ";
+                        }
+                        stream << "using " << state->uses(elem->id()) << "]";
                     }
-                    stream << "using " << state->uses(elem->id()) << "]";
                 }
             }
             return stream.str();
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index 00e416d54..13ed7d7b0 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -40,6 +40,7 @@ namespace storm {
                 DFTGatePointer triggerEvent = std::static_pointer_cast<DFTGate<ValueType>>(mElements[dependency->nameTrigger()]);
                 std::shared_ptr<DFTBE<ValueType>> dependentEvent = std::static_pointer_cast<DFTBE<ValueType>>(mElements[dependency->nameDependent()]);
                 dependency->initialize(triggerEvent, dependentEvent);
+                triggerEvent->addDependency(dependency);
             }
 
             // Sort elements topologically
diff --git a/src/storage/dft/DFTElementState.h b/src/storage/dft/DFTElementState.h
index 1926745bf..d191cc2d9 100644
--- a/src/storage/dft/DFTElementState.h
+++ b/src/storage/dft/DFTElementState.h
@@ -2,9 +2,11 @@
 #ifndef DFTELEMENTSTATE_H
 #define	DFTELEMENTSTATE_H
 
+#include <cassert>
+
 namespace storm {
     namespace storage {
-        enum class DFTElementState  {Operational = 0, Failed = 2, Failsafe = 1, DontCare = 3};
+        enum class DFTElementState {Operational = 0, Failed = 2, Failsafe = 1, DontCare = 3};
         
         inline std::ostream& operator<<(std::ostream& os, DFTElementState st) {
             switch(st) {
@@ -17,7 +19,53 @@ namespace storm {
                 case DFTElementState::DontCare:
                     return os << "Don't Care";
             }
+            assert(false);
+        }
+        
+        inline char toChar(DFTElementState st) {
+            switch(st) {
+                case DFTElementState::Operational:
+                    return 'O';
+                case DFTElementState::Failed:
+                    return 'F';
+                case DFTElementState::Failsafe:
+                    return 'S';
+                case DFTElementState::DontCare:
+                    return '-';
+            }
+            assert(false);
+        }
+        
+        enum class DFTDependencyState {Passive = 0, Unsuccessful = 1, Successful = 2, DontCare = 3};
+        
+        inline std::ostream& operator<<(std::ostream& os, DFTDependencyState st) {
+            switch(st) {
+                case DFTDependencyState::Passive:
+                    return os << "Passive";
+                case DFTDependencyState::Successful:
+                    return os << "Successful";
+                case DFTDependencyState::Unsuccessful:
+                    return os << "Unsuccessful";
+                case DFTDependencyState::DontCare:
+                    return os << "Don't Care";
+            }
+            assert(false);
         }
+        
+        inline char toChar(DFTDependencyState st) {
+            switch(st) {
+                case DFTDependencyState::Passive:
+                    return 'P';
+                case DFTDependencyState::Successful:
+                    return 'S';
+                case DFTDependencyState::Unsuccessful:
+                    return 'U';
+                case DFTDependencyState::DontCare:
+                    return '-';
+            }
+            assert(false);
+        }
+
     }
 }
 
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index d5b089c84..5597f1c5e 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -7,7 +7,7 @@ namespace storm {
 
         template<typename ValueType>
         bool DFTElement<ValueType>::checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-            if(!state.dontCare(mId))
+            if(!state.dontCare(mId) && !hasDependencies())
             {
                 for(DFTGatePointer const& parent : mParents) {
                     if(state.isOperational(parent->id())) {
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 9778d9146..e49b91901 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -23,12 +23,17 @@ namespace storm {
 
         template<typename ValueType>
         class DFTGate;
+        
+        template<typename ValueType>
+        class DFTDependency;
 
         template<typename ValueType>
         class DFTElement {
 
             using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
             using DFTGateVector = std::vector<DFTGatePointer>;
+            using DFTDependencyPointer = std::shared_ptr<DFTDependency<ValueType>>;
+            using DFTDependencyVector = std::vector<DFTDependencyPointer>;
 
 
         protected:
@@ -36,6 +41,7 @@ namespace storm {
             std::string mName;
             size_t mRank = -1;
             DFTGateVector mParents;
+            DFTDependencyVector dependencies;
 
         public:
             DFTElement(size_t id, std::string const& name) :
@@ -132,6 +138,29 @@ namespace storm {
                 }
                 return res;
             }
+            
+            bool addDependency(DFTDependencyPointer const& e) {
+                if(std::find(dependencies.begin(), dependencies.end(), e) != dependencies.end()) {
+                    return false;
+                }
+                else
+                {
+                    dependencies.push_back(e);
+                    return true;
+                }
+            }
+            
+            bool hasDependencies() const {
+                return !dependencies.empty();
+            }
+            
+            size_t nrDependencies() const {
+                return dependencies.size();
+            }
+            
+            DFTDependencyVector const& getDependencies() const {
+                return dependencies;
+            }
 
             virtual void extendSpareModule(std::set<size_t>& elementsInModule) const;
             
@@ -433,8 +462,7 @@ namespace storm {
 
             using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
             using DFTBEPointer = std::shared_ptr<DFTBE<ValueType>>;
-            using DFTBEVector = std::vector<DFTBEPointer>;
-
+            
         protected:
             std::string mNameTrigger;
             std::string mNameDependent;
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 8714f0130..53d0f8761 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -19,6 +19,11 @@ namespace storm {
         DFTElementState DFTState<ValueType>::getElementState(size_t id) const {
             return static_cast<DFTElementState>(getElementStateInt(id));
         }
+        
+        template<typename ValueType>
+        DFTDependencyState DFTState<ValueType>::getDependencyState(size_t id) const {
+            return static_cast<DFTDependencyState>(getElementStateInt(id));
+        }
 
         template<typename ValueType>
         int DFTState<ValueType>::getElementStateInt(size_t id) const {
@@ -54,6 +59,20 @@ namespace storm {
         bool DFTState<ValueType>::dontCare(size_t id) const {
             return getElementState(id) == DFTElementState::DontCare;
         }
+        
+        template<typename ValueType>
+        bool DFTState<ValueType>::dependencyTriggered(size_t id) const {
+            return getElementStateInt(id) > 0;
+        }
+        
+        template<typename ValueType>
+        bool DFTState<ValueType>::dependencySuccessful(size_t id) const {
+            return mStatus[mDft.failureIndex(id)];
+        }
+        template<typename ValueType>
+        bool DFTState<ValueType>::dependencyUnsuccessful(size_t id) const {
+            return mStatus[mDft.failureIndex(id)+1];
+        }
 
         template<typename ValueType>
         void DFTState<ValueType>::setFailed(size_t id) {
@@ -69,6 +88,16 @@ namespace storm {
         void DFTState<ValueType>::setDontCare(size_t id) {
             mStatus.setFromInt(mDft.failureIndex(id), 2, static_cast<uint_fast64_t>(DFTElementState::DontCare) );
         }
+        
+        template<typename ValueType>
+        void DFTState<ValueType>::setDependencySuccessful(size_t id) {
+            mStatus.set(mDft.failureIndex(id));
+        }
+
+        template<typename ValueType>
+        void DFTState<ValueType>::setDependencyUnsuccessful(size_t id) {
+            mStatus.set(mDft.failureIndex(id)+1);
+        }
 
         template<typename ValueType>
         void DFTState<ValueType>::beNoLongerFailable(size_t id) {
@@ -84,7 +113,8 @@ namespace storm {
             for (size_t i = 0; i < mDft.getDependencies().size(); ++i) {
                 std::shared_ptr<DFTDependency<ValueType> const> dependency = mDft.getDependency(mDft.getDependencies()[i]);
                 if (dependency->triggerEvent()->id() == id) {
-                    if (!hasFailed(dependency->dependentEvent()->id())) {
+                    if (getElementState(dependency->dependentEvent()->id()) == DFTElementState::Operational) {
+                        assert(!isFailsafe(dependency->dependentEvent()->id()));
                         mFailableDependencies.push_back(dependency->id());
                         STORM_LOG_TRACE("New dependency failure: " << dependency->toString());
                     }
@@ -99,10 +129,12 @@ namespace storm {
             STORM_LOG_TRACE("currently failable: " << getCurrentlyFailableString());
             if (nrFailableDependencies() > 0) {
                 // Consider failure due to dependency
+                assert(index < nrFailableDependencies());
                 std::shared_ptr<DFTDependency<ValueType> const> dependency = mDft.getDependency(getDependencyId(index));
                 std::pair<std::shared_ptr<DFTBE<ValueType> const>,bool> res(mDft.getBasicElement(dependency->dependentEvent()->id()), true);
                 mFailableDependencies.erase(mFailableDependencies.begin() + index);
                 setFailed(res.first->id());
+                setDependencySuccessful(dependency->id());
                 return res;
             } else {
                 // Consider "normal" failure
@@ -113,6 +145,14 @@ namespace storm {
                 return res;
             }
         }
+ 
+        template<typename ValueType>
+        void DFTState<ValueType>::letDependencyBeUnsuccessful(size_t index) {
+            assert(nrFailableDependencies() > 0 && index < nrFailableDependencies());
+            std::shared_ptr<DFTDependency<ValueType> const> dependency = mDft.getDependency(getDependencyId(index));
+            mFailableDependencies.erase(mFailableDependencies.begin() + index);
+            setDependencyUnsuccessful(dependency->id());
+        }
 
         template<typename ValueType>
         void DFTState<ValueType>::activate(size_t repr) {
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 520587a42..450953bd7 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -22,6 +22,7 @@ namespace storm {
         class DFTState {
             friend struct std::hash<DFTState>;
         private:
+            // Status is bitvector where each element has two bits with the meaning according to DFTElementState
             storm::storage::BitVector mStatus;
             size_t mId;
             std::vector<size_t> mInactiveSpares;
@@ -35,6 +36,8 @@ namespace storm {
             DFTState(DFT<ValueType> const& dft, size_t id);
             
             DFTElementState getElementState(size_t id) const;
+            
+            DFTDependencyState getDependencyState(size_t id) const;
 
             int getElementStateInt(size_t id) const;
 
@@ -50,12 +53,22 @@ namespace storm {
             
             bool dontCare(size_t id) const;
             
+            bool dependencyTriggered(size_t id) const;
+
+            bool dependencySuccessful(size_t id) const;
+
+            bool dependencyUnsuccessful(size_t id) const;
+
             void setFailed(size_t id);
             
             void setFailsafe(size_t id);
             
             void setDontCare(size_t id);
             
+            void setDependencySuccessful(size_t id);
+
+            void setDependencyUnsuccessful(size_t id);
+
             void beNoLongerFailable(size_t id);
             
             void activate(size_t repr);
@@ -135,10 +148,16 @@ namespace storm {
 
             /**
              * Sets the next BE as failed
-             * @param smallestIndex Index in currentlyFailableBE of BE to fail
+             * @param index Index in currentlyFailableBE of BE to fail
              * @return Pair of BE which fails and flag indicating if the failure was due to functional dependencies
              */
-            std::pair<std::shared_ptr<DFTBE<ValueType> const>, bool> letNextBEFail(size_t smallestIndex = 0);
+            std::pair<std::shared_ptr<DFTBE<ValueType> const>, bool> letNextBEFail(size_t index = 0);
+            
+            /**
+             * Sets the dependency as unsuccesful meaning no BE will fail.
+             * @param index Index of dependency to fail.
+             */
+            void letDependencyBeUnsuccessful(size_t index = 0);
             
             std::string getCurrentlyFailableString() const {
                 std::stringstream stream;

From 7788d45ab513c2b26f8e9bee3bcf6c00b3f0fe91 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 17 Feb 2016 11:22:15 +0100
Subject: [PATCH 100/246] No distinction between successful dependency and no
 dependency at all

Former-commit-id: b51149328313e653ac2896ebbb3e294785f2807f
---
 src/storage/dft/DFTState.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 53d0f8761..9916bbe0e 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -91,7 +91,9 @@ namespace storm {
         
         template<typename ValueType>
         void DFTState<ValueType>::setDependencySuccessful(size_t id) {
-            mStatus.set(mDft.failureIndex(id));
+            // No distinction between successful dependency and no dependency at all
+            // -> we do not set bit
+            //mStatus.set(mDft.failureIndex(id));
         }
 
         template<typename ValueType>

From 5655766d36dd9e3d285bda206590e24f8c2364a3 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 17 Feb 2016 11:44:08 +0100
Subject: [PATCH 101/246] Small changes

Former-commit-id: cc2a75289e633e71a3c590309939d70bdfe416c0
---
 benchmark_dft.py               | 12 ++++++------
 src/storage/dft/DFTBuilder.cpp |  1 +
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/benchmark_dft.py b/benchmark_dft.py
index 77880d951..6f25e08ed 100644
--- a/benchmark_dft.py
+++ b/benchmark_dft.py
@@ -13,13 +13,13 @@ EXAMPLE_DIR=os.path.join(DIR, "examples/dft/")
 benchmarks = [ 
     ("and", False, [3, 1]),
     ("and_param", True, ["(4*x^2+2*x+1)/((x) * (2*x+1))", "1"]),
-    ("cardiac", False, [11378, 1]),
+    ("cardiac", False, [8597.360004, 1]),
     ("cas", False, [0.859736, 1]),
     ("cm2", False, [0.256272, 1]),
-    #("cm4", False, [0, 1]),
+    #("cm4", False, [0.338225, 1]), # big
     ("cps", False, ["inf", 0.333333]),
-    ("deathegg", False, [46.667, 1]),
-    ("fdep", False, [0.666667, 1]),
+    #("deathegg", False, [24.642857, 1]), # contains fdep to gate
+    #("fdep", False, [0.666667, 1]), # contains fdep to two elements
     ("fdep2", False, [2, 1]),
     ("fdep3", False, [2.5, 1]),
     #("ftpp_complex", False, [0, 1]), # Compute
@@ -32,13 +32,13 @@ benchmarks = [
     ("pand", False, ["inf", 0.666667]),
     ("pand_param", True, ["-1", "(x)/(y+x)"]),
     ("pdep", False, [2.66667, 1]),
-    ("pdep2", False, [0, 1]), #Compute
+    #("pdep2", False, [0, 1]), #Compute # contains pdep to two elements
     ("pdep3", False, [2.79167, 1]),
     ("spare", False, [3.53846, 1]),
     ("spare2", False, [1.86957, 1]),
     ("spare3", False, [1.27273, 1]),
     ("spare4", False, [4.8459, 1]),
-    ("spare5", False, [2.66667, 1]), # We discard the result 2.16667 from DFTCalc
+    ("spare5", False, [2.66667, 1]),
     ("spare6", False, [1.4, 1]),
     ("spare7", False, [3.67333, 1]),
     ("symmetry", False, [4.16667, 1]),
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index 13ed7d7b0..f35a09f0f 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -38,6 +38,7 @@ namespace storm {
             // Initialize dependencies
             for (auto& dependency : mDependencies) {
                 DFTGatePointer triggerEvent = std::static_pointer_cast<DFTGate<ValueType>>(mElements[dependency->nameTrigger()]);
+                assert(mElements[dependency->nameDependent()]->isBasicElement());
                 std::shared_ptr<DFTBE<ValueType>> dependentEvent = std::static_pointer_cast<DFTBE<ValueType>>(mElements[dependency->nameDependent()]);
                 dependency->initialize(triggerEvent, dependentEvent);
                 triggerEvent->addDependency(dependency);

From b51d997d5b545acb0d3a6fff9b1ffc83250907c2 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 17 Feb 2016 14:31:35 +0100
Subject: [PATCH 102/246] Detect error with more than one spare in a module

Former-commit-id: a0812aa201fce62906f0d1ac054678476f101377
---
 src/storage/dft/DFT.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 83e287b3b..a23a70f71 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -1,6 +1,7 @@
 #include <boost/container/flat_set.hpp>
 
 #include "DFT.h"
+#include "src/exceptions/NotSupportedException.h"
 
 namespace storm {
     namespace storage {
@@ -28,7 +29,12 @@ namespace storm {
                         std::set<size_t> module = {spareReprs->id()};
                         spareReprs->extendSpareModule(module);
                         std::vector<size_t> sparesAndBes;
+                        bool secondSpare = false;
                         for(auto const& modelem : module) {
+                            if (mElements[modelem]->isSpareGate()) {
+                                STORM_LOG_THROW(!secondSpare, storm::exceptions::NotSupportedException, "Module for '" << spareReprs->name() << "' contains more than one spare.");
+                                secondSpare = true;
+                            }
                             if(mElements[modelem]->isSpareGate() || mElements[modelem]->isBasicElement()) {
                                 sparesAndBes.push_back(modelem);
                                 mRepresentants.insert(std::make_pair(modelem, spareReprs->id()));

From 0a9f68ed7478428876a0d5d3c51ddb952945535f Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 17 Feb 2016 19:49:01 +0100
Subject: [PATCH 103/246] update dft towards cnt.abst

Former-commit-id: bce7a7a566ac7f6a9f62d66e8e16429d6a255fac
---
 src/storage/dft/DFT.cpp          |  40 ++++++
 src/storage/dft/DFT.h            |  10 ++
 src/storage/dft/DFTIsomorphism.h | 205 +++++++++++++++++++++++++++----
 src/utility/iota_n.h             |  13 ++
 4 files changed, 242 insertions(+), 26 deletions(-)
 create mode 100644 src/utility/iota_n.h

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index a23a70f71..0dedd9fb3 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -3,6 +3,9 @@
 #include "DFT.h"
 #include "src/exceptions/NotSupportedException.h"
 
+#include "DFTIsomorphism.h"
+#include "utility/iota_n.h"
+
 namespace storm {
     namespace storage {
 
@@ -168,6 +171,43 @@ namespace storm {
             return ISD;
         }
 
+        template<typename ValueType>
+        DFTColouring<ValueType> DFT<ValueType>::colourDFT() const {
+            return DFTColouring<ValueType>(*this);
+        }
+
+        template<typename ValueType>
+        std::vector<std::vector<size_t>> DFT<ValueType>::findSymmetries(DFTColouring<ValueType> const& colouring) const {
+            std::vector<size_t> vec;
+            vec.reserve(nrElements());
+            storm::utility::iota_n(std::back_inserter(vec), 14, 0);
+            BijectionCandidates<ValueType> completeCategories = colouring.colourSubdft(vec);
+            std::vector<std::vector<size_t>> res;
+            for(auto const& colourClass : completeCategories.gateCandidates) {
+                if(colourClass.second.size() > 1) {
+                    for(auto it1 = colourClass.second.cbegin(); it1 != colourClass.second.cend(); ++it1) {
+                        std::vector<size_t> sortedParent1Ids = getGate(*it1)->parentIds();
+                        std::sort(sortedParent1Ids.begin(), sortedParent1Ids.end());
+                        auto it2 = it1;
+                        for(++it2; it2 != colourClass.second.cend(); ++it2) {
+                            std::vector<size_t> sortedParent2Ids = getGate(*it2)->parentIds();
+                            std::sort(sortedParent2Ids.begin(), sortedParent2Ids.end());
+                            if(sortedParent1Ids == sortedParent2Ids) {
+                                std::cout << "Considering ids " << *it1 << ", " << *it2 << " for isomorphism." << std::endl;
+                                std::vector<size_t> isubdft1 = getGate(*it1)->independentSubDft();
+                                std::vector<size_t> isubdft2 = getGate(*it2)->independentSubDft();
+                                if(!isubdft1.empty() && !isubdft2.empty() && isubdft1.size() == isubdft2.size()) {
+                                    std::cout << "Checking subdfts from " << *it1 << ", " << *it2 << " for isomorphism." << std::endl;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return res;
+        }
+
+
         // Explicitly instantiate the class.
         template class DFT<double>;
 
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index ecea467e4..f2036e7d7 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -29,6 +29,11 @@ namespace storm {
             }
         };
 
+
+        // Forward declarations
+        template<typename T> class DFTColouring;
+
+
         /**
          * Represents a Dynamic Fault Tree
          */
@@ -222,6 +227,11 @@ namespace storm {
             std::string getStateString(DFTStatePointer const& state) const;
 
             std::vector<size_t> getIndependentSubDftRoots(size_t index) const;
+
+            DFTColouring<ValueType> colourDFT() const;
+
+            std::vector<std::vector<size_t>> findSymmetries(DFTColouring<ValueType> const& colouring) const;
+
         private:
             bool elementIndicesCorrect() const {
                 for(size_t i = 0; i < mElements.size(); ++i) {
diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
index e9a58d559..6258b05bc 100644
--- a/src/storage/dft/DFTIsomorphism.h
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -1,9 +1,12 @@
 #pragma once
 
+#include <cassert>
 #include <vector>
 #include <unordered_map>
+#include <utility>
 #include "DFTElementType.h"
 #include "DFTElements.h"
+#include "DFT.h"
 
 namespace storm {
 namespace storage {
@@ -34,14 +37,102 @@ namespace storage {
 
     };
 
+
+    template<typename ValueType>
+    struct BEColourClass {
+        BEColourClass() = default;
+        BEColourClass(ValueType a, ValueType p, size_t h) : aRate(a), pRate(p), hash(h) {}
+
+        ValueType aRate;
+        ValueType pRate;
+        size_t    hash;
+    };
+
+    template<typename ValueType>
+    bool operator==(BEColourClass<ValueType> const& lhs, BEColourClass<ValueType> const& rhs) {
+        return lhs.hash == rhs.hash && lhs.aRate == rhs.aRate && lhs.pRate == rhs.pRate;
+    }
+
+
+
+
     /**
      *
      */
     template<typename ValueType>
-    class BijectionCandidates {
-        std::unordered_map<size_t, std::vector<size_t>> groupCandidates;
-        std::unordered_map<std::pair<ValueType, ValueType>, std::vector<size_t>> beCandidates;
+    struct BijectionCandidates {
+        std::unordered_map<size_t, std::vector<size_t>> gateCandidates;
+        std::unordered_map<BEColourClass<ValueType>, std::vector<size_t>> beCandidates;
+        std::unordered_map<std::pair<ValueType, ValueType>, std::vector<size_t>> pdepCandidates;
+    };
+
+    template<typename ValueType>
+    class DFTColouring {
+        DFT<ValueType> const& dft;
+        std::unordered_map<size_t, size_t> gateColour;
+        std::unordered_map<size_t, BEColourClass<ValueType>> beColour;
+        std::unordered_map<size_t, std::pair<ValueType, ValueType>> depColour;
+        GateGroupToHash gateColourizer;
+
+    public:
+        DFTColouring(DFT<ValueType> const& ft) : dft(ft) {
+            for(size_t id = 0; id < dft.nrElements(); ++id ) {
+                if(dft.isBasicElement(id)) {
+                    colourize(dft.getBasicElement(id));
+                } else if(dft.isGate(id)) {
+                    colourize(dft.getGate(id));
+                } else {
+                    assert(dft.isDependency(id));
+                    colourize(dft.getDependency(id));
+                }
+            }
+        }
 
+
+        BijectionCandidates<ValueType> colourSubdft(std::vector<size_t> const& subDftIndices) const {
+            BijectionCandidates<ValueType> res;
+            for (size_t index : subDftIndices) {
+                if(dft.isBasicElement(index)) {
+                    auto it = res.beCandidates.find(beColour.at(index));
+                    if(it != res.beCandidates.end()) {
+                        it->second.push_back(index);
+                    } else {
+                        res.beCandidates[beColour.at(index)] = std::vector<size_t>({index});
+                    }
+                } else if(dft.isGate(index)) {
+                    auto it = res.gateCandidates.find(gateColour.at(index));
+                    if(it != res.gateCandidates.end()) {
+                        it->second.push_back(index);
+                    } else {
+                        res.gateCandidates[gateColour.at(index)] = std::vector<size_t>({index});
+                    }
+                } else {
+                    assert(dft.isDependency(index));
+                    auto it = res.pdepCandidates.find(depColour.at(index));
+                    if(it != res.pdepCandidates.end()) {
+                        it->second.push_back(index);
+                    } else {
+                        res.pdepCandidates[depColour.at(index)] = std::vector<size_t>({index});
+                    }
+                }
+
+            }
+            return res;
+        }
+
+
+    protected:
+        void colourize(std::shared_ptr<const DFTBE<ValueType>> const& be) {
+             beColour[be->id()] = BEColourClass<ValueType>(be->activeFailureRate(), be->passiveFailureRate(), be->nrParents());
+        }
+
+        void colourize(std::shared_ptr<const DFTGate<ValueType>> const& gate) {
+             gateColour[gate->id()] = gateColourizer(gate->type(), gate->nrChildren(), gate->nrParents(), 0, gate->rank());
+        }
+        
+        void colourize(std::shared_ptr<const DFTDependency<ValueType>> const& dep) {
+            depColour[dep->id()] = std::pair<ValueType, ValueType>(dep->probability(), dep->dependentEvent()->activeFailureRate());
+        }
     };
 
 
@@ -107,36 +198,61 @@ namespace storage {
         }
 
     protected:
-
+        /**
+         * Construct the initial bijection.
+         */
         void constructInitialBijection() {
             assert(candidatesCompatible);
             // We first construct the currentPermutations, which helps to determine the current state of the check.
-            for(auto const& colour : bright.beCandidates) {
-                if(colour.second.size()>1) {
-                    currentPermutations.beCandidates.insert(colour);
+            initializePermutationsAndTreatTrivialGroups(bleft.beCandidates, bright.beCandidates, currentPermutations.beCandidates);
+            initializePermutationsAndTreatTrivialGroups(bleft.gateCandidates, bright.gateCandidates, currentPermutations.gateCandidates);
+            initializePermutationsAndTreatTrivialGroups(bleft.pdepCandidates, bright.pdepCandidates, currentPermutations.pdepCandidates);
+        }
+
+        /**
+         * Construct the next bijection
+         * @return true if a next bijection exists.
+         */
+        bool findNextBijection() {
+            bool foundNext = false;
+            if(!currentPermutations.beCandidates.empty()) {
+                auto it = currentPermutations.beCandidates.begin();
+                while(!foundNext && it == currentPermutations.beCandidates.end()) {
+                    foundNext = std::next_permutation(it->second.begin(), it->second.end());
+                    ++it;
                 }
             }
-
-            for(auto const& colour : bright.groupCandidates) {
-                if(colour.second.size()>1) {
-                    currentPermutations.groupCandidates.insert(colour);
+            if(!foundNext && !currentPermutations.gateCandidates.empty()) {
+                auto it = currentPermutations.gateCandidates.begin();
+                while(!foundNext && it == currentPermutations.beCandidates.end()) {
+                    foundNext = std::next_permutation(it->second.begin(), it->second.end());
+                    ++it;
                 }
             }
 
-            // Constructing the initial homomorphism based on the right hand side instead of the current permutations allows us
-            // to treat trivial and non-trivial classes in one go.
-            for(auto const& colour : bleft.beCandidates) {
-                zipVectorsIntoMap(colour.second, bright.beCandidates.find(colour.first)->second, bijection);
+            if(!foundNext && !currentPermutations.pdepCandidates.empty()) {
+                auto it = currentPermutations.pdepCandidates.begin();
+                while(!foundNext && it == currentPermutations.pdepCandidates.end()) {
+                    foundNext = std::next_permutation(it->second.begin(), it->second.end());
+                    ++it;
+                }
             }
 
-            for(auto const& colour : bleft.groupCandidates) {
-                zipVectorsIntoMap(colour.second, bright.groupCandidates.find(colour.first)->second, bijection);
-            }
+            if(foundNext) {
+                for(auto const& colour : bleft.beCandidates) {
+                    zipVectorsIntoMap(colour.second, currentPermutations.beCandidates.find(colour.first)->second, bijection);
+                }
 
-        }
+                for(auto const& colour : bleft.gateCandidates) {
+                    zipVectorsIntoMap(colour.second, currentPermutations.gateCandidates.find(colour.first)->second, bijection);
+                }
 
-        bool findNextBijection() {
-            return false;
+                for(auto const& colour : bleft.pdepCandidates) {
+                    zipVectorsIntoMap(colour.second, currentPermutations.pdepCandidates.find(colour.first)->second, bijection);
+                }
+            }
+
+            return foundNext;
         }
 
 
@@ -152,21 +268,21 @@ namespace storage {
          * Returns true if the colours are compatible.
          */
         bool checkCompatibility() {
-            if(bleft.groupCandidates.size() != bright.groupCandidates.size()) {
+            if(bleft.gateCandidates.size() != bright.gateCandidates.size()) {
                 candidatesCompatible = false;
             }
             else if(bleft.beCandidates.size() != bright.beCandidates.size()) {
                 candidatesCompatible = false;
             }
             else {
-                for (auto const &gc : bleft.groupCandidates) {
-                    if (bright.groupCandidates.count(gc.first) == 0) {
+                for (auto const &gc : bleft.gateCandidates) {
+                    if (bright.gateCandidates.count(gc.first) == 0) {
                         candidatesCompatible = false;
                         break;
                     }
                 }
                 if(candidatesCompatible) {
-                    for(auto const& bc : bleft.groupCandidates) {
+                    for(auto const& bc : bleft.gateCandidates) {
                         if(bright.beCandidates.count(bc.first) == 0) {
                             candidatesCompatible = false;
                             break;
@@ -176,6 +292,26 @@ namespace storage {
             }
         }
 
+        /**
+         *
+         */
+        template<typename ColourType>
+        void initializePermutationsAndTreatTrivialGroups(std::unordered_map<ColourType, std::vector<size_t>> const& left,
+                                                         std::unordered_map<ColourType, std::vector<size_t>> const& right,
+                                                         std::unordered_map<ColourType, std::vector<size_t>>& permutations) {
+            for(auto const& colour : right) {
+                if(colour.second.size()>1) {
+                    auto it = permutations.insert(colour);
+                    std::sort(it->second.begin(), it->second.end());
+                    zipVectorsIntoMap(colour.second, permutations.find(colour.first)->second, bijection);
+                } else {
+                    assert(colour.second.size() == 1);
+                    assert(bijection.count(left[colour.first].front()) == 0);
+                    bijection[left[colour.first].front()] = colour.second.front();
+                }
+            }
+        }
+
         /**
          * Local helper function for the creation of bijections, should be hidden from api.
          */
@@ -184,7 +320,6 @@ namespace storage {
             assert(a.size() == b.size());
             auto it = b.cbegin();
             for(size_t lIndex : a) {
-                assert(map.count(lIndex) == 0);
                 map[lIndex] = *it;
                 ++it;
             }
@@ -199,3 +334,21 @@ namespace storage {
 
 } // namespace storm::dft
 } // namespace storm
+
+namespace std {
+    template<typename ValueType>
+    struct hash<storm::storage::BEColourClass<ValueType>> {
+        size_t operator()(storm::storage::BEColourClass<ValueType> const& bcc) const {
+            std::hash<ValueType> hasher;
+            return (hasher(bcc.aRate) ^ hasher(bcc.pRate) << 8) | bcc.hash;
+        }
+    };
+
+    template<typename ValueType>
+    struct hash<std::pair<ValueType, ValueType>> {
+        size_t operator()(std::pair<ValueType, ValueType> const& p) const {
+            std::hash<ValueType> hasher;
+            return hasher(p.first) ^ hasher(p.second);
+        }
+    };
+}
\ No newline at end of file
diff --git a/src/utility/iota_n.h b/src/utility/iota_n.h
new file mode 100644
index 000000000..a7e4ba829
--- /dev/null
+++ b/src/utility/iota_n.h
@@ -0,0 +1,13 @@
+#pragma once
+
+namespace storm {
+    namespace utility {
+        template<class OutputIterator, class Size, class Assignable>
+        void iota_n(OutputIterator first, Size n, Assignable value)
+        {
+            std::generate_n(first, n, [&value]() {
+                return value++;
+            });
+        }
+    }
+}

From 16a21527944659dbf797b119ebee019b3fc450fb Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 17 Feb 2016 20:44:07 +0100
Subject: [PATCH 104/246] hash_value for cln::cl_ra

Former-commit-id: 934795bd78c7f530ff4e47eda1b7df0a5821d273
---
 src/adapters/CarlAdapter.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/adapters/CarlAdapter.h b/src/adapters/CarlAdapter.h
index 4fd2a98a0..61bd3998b 100644
--- a/src/adapters/CarlAdapter.h
+++ b/src/adapters/CarlAdapter.h
@@ -41,6 +41,14 @@ namespace carl {
         std::hash<Interval<Number>> h;
         return h(i);
     }
+
+}
+
+namespace cln {
+    inline size_t hash_value(cl_RA const& n) {
+        std::hash<cln::cl_RA> h;
+        return h(n);
+    }
 }
 
 namespace storm {

From 266d41716812392911418fec17f6d497dea30361 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 17 Feb 2016 20:44:35 +0100
Subject: [PATCH 105/246] constants.h/cpp extended to treat carl rational
 numbers

Former-commit-id: 12f0dfbc2ce5e76a4afd404dfb697755e6c20210
---
 src/utility/constants.cpp | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/src/utility/constants.cpp b/src/utility/constants.cpp
index 900482a72..be0fcb079 100644
--- a/src/utility/constants.cpp
+++ b/src/utility/constants.cpp
@@ -76,6 +76,17 @@ namespace storm {
             // FIXME: this should be treated more properly.
             return storm::RationalFunction(-1.0);
         }
+        
+        template<>
+        bool isOne(storm::CarlRationalNumber const& a) {
+            return carl::isOne(a);
+        }
+        
+        template<>
+        bool isZero(storm::CarlRationalNumber const& a) {
+            return carl::isZero(a);
+        }
+        
 #endif
         
         template<typename ValueType>
@@ -214,13 +225,21 @@ namespace storm {
         template storm::RationalFunction infinity();
         
         template RationalFunction pow(RationalFunction const& value, uint_fast64_t exponent);
-        
-        template Polynomial one();
-        template Polynomial zero();
         template RationalFunction simplify(RationalFunction value);
         template RationalFunction& simplify(RationalFunction& value);
         template RationalFunction&& simplify(RationalFunction&& value);
         
+        
+        template Polynomial one();
+        template Polynomial zero();
+        
+        template bool isOne(CarlRationalNumber const& value);
+        template bool isZero(CarlRationalNumber const& value);
+        template bool isConstant(CarlRationalNumber const& value);
+        
+        template CarlRationalNumber one();
+        template CarlRationalNumber zero();
+        
         template bool isOne(Interval const& value);
         template bool isZero(Interval const& value);
         template bool isConstant(Interval const& value);

From e24343516c4c49014d272a0841f619a0443533cb Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 17 Feb 2016 20:45:19 +0100
Subject: [PATCH 106/246] constants comparator extended to carlrationalnumber
 (cln/cl_ra)

Former-commit-id: a14c5c4092e2ee17e3f2900cffee79a3c57f2310
---
 src/utility/ConstantsComparator.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/utility/ConstantsComparator.cpp b/src/utility/ConstantsComparator.cpp
index 4ad0a2612..e22efbc5e 100644
--- a/src/utility/ConstantsComparator.cpp
+++ b/src/utility/ConstantsComparator.cpp
@@ -114,6 +114,7 @@ namespace storm {
         template class ConstantsComparator<RationalFunction>;
         template class ConstantsComparator<Polynomial>;
         template class ConstantsComparator<Interval>;
+        template class ConstantsComparator<CarlRationalNumber>;
 #endif
     }
 }
\ No newline at end of file

From aa72d8a158883d2362173f99e036308a151ec3fb Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 17 Feb 2016 20:46:19 +0100
Subject: [PATCH 107/246] added missing instantiation of sparse matrix with
 carl ratnumber

Former-commit-id: c080e9b4a513d376b4bc1a5559b5ef93eee78179
---
 src/storage/SparseMatrix.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/storage/SparseMatrix.cpp b/src/storage/SparseMatrix.cpp
index 65f74d874..d41e2ef2c 100644
--- a/src/storage/SparseMatrix.cpp
+++ b/src/storage/SparseMatrix.cpp
@@ -1257,6 +1257,15 @@ namespace storm {
         template bool SparseMatrix<int>::isSubmatrixOf(SparseMatrix<storm::storage::sparse::state_type> const& matrix) const;
 
 #ifdef STORM_HAVE_CARL
+        // Rat Function
+        template class MatrixEntry<typename SparseMatrix<CarlRationalNumber>::index_type, CarlRationalNumber>;
+        template std::ostream& operator<<(std::ostream& out, MatrixEntry<uint_fast64_t, CarlRationalNumber> const& entry);
+        template class SparseMatrixBuilder<CarlRationalNumber>;
+        template class SparseMatrix<CarlRationalNumber>;
+        template std::ostream& operator<<(std::ostream& out, SparseMatrix<CarlRationalNumber> const& matrix);
+        template std::vector<storm::CarlRationalNumber> SparseMatrix<CarlRationalNumber>::getPointwiseProductRowSumVector(storm::storage::SparseMatrix<storm::CarlRationalNumber> const& otherMatrix) const;
+        template bool SparseMatrix<storm::CarlRationalNumber>::isSubmatrixOf(SparseMatrix<storm::CarlRationalNumber> const& matrix) const;
+        
         // Rat Function
         template class MatrixEntry<typename SparseMatrix<RationalFunction>::index_type, RationalFunction>;
         template std::ostream& operator<<(std::ostream& out, MatrixEntry<uint_fast64_t, RationalFunction> const& entry);

From 3209c52a7cc7ca21d1b066b24920b276f5d6802f Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 17 Feb 2016 20:48:00 +0100
Subject: [PATCH 108/246] elim linear equation solver used the wrong rational
 number

Former-commit-id: ca468397cec8d3039a23eee100cf6106d3467cc9
---
 src/solver/EliminationLinearEquationSolver.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/solver/EliminationLinearEquationSolver.cpp b/src/solver/EliminationLinearEquationSolver.cpp
index 67a281b70..98c791c0a 100644
--- a/src/solver/EliminationLinearEquationSolver.cpp
+++ b/src/solver/EliminationLinearEquationSolver.cpp
@@ -54,7 +54,7 @@ namespace storm {
         template class EliminationLinearEquationSolver<double>;
         
         // TODO: make this work with the proper implementation of solveEquationSystem.
-        template class EliminationLinearEquationSolver<storm::RationalNumber>;
+        template class EliminationLinearEquationSolver<storm::CarlRationalNumber>;
         template class EliminationLinearEquationSolver<storm::RationalFunction>;
         
     }

From 391556cac166c9e461fcc1edd02bd0037459737e Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 00:16:21 +0100
Subject: [PATCH 109/246] work towards sym checks for dfts

Former-commit-id: 8c1b0e86fbfa637709ddf96cd30664d1e83e4228
---
 src/storage/dft/DFT.cpp          |  4 +++
 src/storage/dft/DFTIsomorphism.h | 61 ++++++++++++++++++++------------
 2 files changed, 42 insertions(+), 23 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 0dedd9fb3..5735af2a7 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -198,6 +198,10 @@ namespace storm {
                                 std::vector<size_t> isubdft2 = getGate(*it2)->independentSubDft();
                                 if(!isubdft1.empty() && !isubdft2.empty() && isubdft1.size() == isubdft2.size()) {
                                     std::cout << "Checking subdfts from " << *it1 << ", " << *it2 << " for isomorphism." << std::endl;
+                                    auto LHS = colouring.colourSubdft(isubdft1);
+                                    auto RHS = colouring.colourSubdft(isubdft2);
+                                    auto IsoCheck = DFTIsomorphismCheck<ValueType>(LHS, RHS, *this);
+                                    IsoCheck.findIsomorphism();
                                 }
                             }
                         }
diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
index 6258b05bc..6c4a44ad6 100644
--- a/src/storage/dft/DFTIsomorphism.h
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -55,7 +55,6 @@ namespace storage {
 
 
 
-
     /**
      *
      */
@@ -154,9 +153,10 @@ namespace storage {
         /// Current permutations of right hand side groups which lead to the homomorphism.
         /// Contains only colours with more than one member.
         BijectionCandidates<ValueType> currentPermutations;
+        DFT<ValueType> const& dft;
 
     public:
-        DFTIsomorphismCheck(BijectionCandidates<ValueType> const& left, BijectionCandidates<ValueType> const& right) : bleft(left), bright(right)
+        DFTIsomorphismCheck(BijectionCandidates<ValueType> const& left, BijectionCandidates<ValueType> const& right, DFT<ValueType> const& dft) : bleft(left), bright(right), dft(dft)
         {
             checkCompatibility();
         }
@@ -217,14 +217,14 @@ namespace storage {
             bool foundNext = false;
             if(!currentPermutations.beCandidates.empty()) {
                 auto it = currentPermutations.beCandidates.begin();
-                while(!foundNext && it == currentPermutations.beCandidates.end()) {
+                while(!foundNext && it != currentPermutations.beCandidates.end()) {
                     foundNext = std::next_permutation(it->second.begin(), it->second.end());
                     ++it;
                 }
             }
             if(!foundNext && !currentPermutations.gateCandidates.empty()) {
                 auto it = currentPermutations.gateCandidates.begin();
-                while(!foundNext && it == currentPermutations.beCandidates.end()) {
+                while(!foundNext && it != currentPermutations.gateCandidates.end()) {
                     foundNext = std::next_permutation(it->second.begin(), it->second.end());
                     ++it;
                 }
@@ -232,7 +232,7 @@ namespace storage {
 
             if(!foundNext && !currentPermutations.pdepCandidates.empty()) {
                 auto it = currentPermutations.pdepCandidates.begin();
-                while(!foundNext && it == currentPermutations.pdepCandidates.end()) {
+                while(!foundNext && it != currentPermutations.pdepCandidates.end()) {
                     foundNext = std::next_permutation(it->second.begin(), it->second.end());
                     ++it;
                 }
@@ -260,34 +260,48 @@ namespace storage {
          *
          */
         bool check() {
+            // We can skip BEs, as they are identified by they're homomorphic if they are in the same class
+            for(auto const& index : bijection) {
+                // As they are in the same group, the types are fine already. We just have to check the children.
 
+            }
+            return false;
         }
 
     private:
         /**
          * Returns true if the colours are compatible.
          */
-        bool checkCompatibility() {
+        void checkCompatibility() {
             if(bleft.gateCandidates.size() != bright.gateCandidates.size()) {
                 candidatesCompatible = false;
+                return;
             }
-            else if(bleft.beCandidates.size() != bright.beCandidates.size()) {
+            if(bleft.beCandidates.size() != bright.beCandidates.size()) {
                 candidatesCompatible = false;
+                return;
             }
-            else {
-                for (auto const &gc : bleft.gateCandidates) {
-                    if (bright.gateCandidates.count(gc.first) == 0) {
-                        candidatesCompatible = false;
-                        break;
-                    }
+            if(bleft.beCandidates.size() != bright.beCandidates.size()) {
+                candidatesCompatible = false;
+                return;
+            }
+            
+            for (auto const &gc : bleft.gateCandidates) {
+                if (bright.gateCandidates.count(gc.first) == 0) {
+                    candidatesCompatible = false;
                 }
-                if(candidatesCompatible) {
-                    for(auto const& bc : bleft.gateCandidates) {
-                        if(bright.beCandidates.count(bc.first) == 0) {
-                            candidatesCompatible = false;
-                            break;
-                        }
-                    }
+            }
+            for(auto const& bc : bleft.beCandidates) {
+                if(bright.beCandidates.count(bc.first) == 0) {
+                    candidatesCompatible = false;
+                    return;
+                }
+            }
+               
+            for(auto const& dc : bleft.pdepCandidates) {
+                if(bright.pdepCandidates.count(dc.first) == 0) {
+                    candidatesCompatible = false;
+                    return;
                 }
             }
         }
@@ -302,12 +316,13 @@ namespace storage {
             for(auto const& colour : right) {
                 if(colour.second.size()>1) {
                     auto it = permutations.insert(colour);
-                    std::sort(it->second.begin(), it->second.end());
+                    assert(it.second);
+                    std::sort(it.first->second.begin(), it.first->second.end());
                     zipVectorsIntoMap(colour.second, permutations.find(colour.first)->second, bijection);
                 } else {
                     assert(colour.second.size() == 1);
-                    assert(bijection.count(left[colour.first].front()) == 0);
-                    bijection[left[colour.first].front()] = colour.second.front();
+                    assert(bijection.count(left.at(colour.first).front()) == 0);
+                    bijection[left.at(colour.first).front()] = colour.second.front();
                 }
             }
         }

From 8d0046a9a7a2c2477e9bb0426df801b9f2794e1e Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 15:44:31 +0100
Subject: [PATCH 110/246] Dftelements: equalType Former-commit-id:
 77b9b382462ed78812fe866db851db130a3be68e

---
 src/storage/dft/DFTElements.h | 42 ++++++++++++++++++++++++++++++-----
 1 file changed, 37 insertions(+), 5 deletions(-)

diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index e49b91901..b7fca51c0 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -122,7 +122,7 @@ namespace storm {
             bool hasParents() const {
                 return !mParents.empty();
             }
-
+            
             size_t nrParents() const {
                 return mParents.size();
             }
@@ -194,7 +194,9 @@ namespace storm {
              */
             virtual void extendSubDft(std::set<size_t> elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const;
 
-
+            virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const {
+                return type() == other.type();
+            }
 
 
         protected:
@@ -368,7 +370,7 @@ namespace storm {
                 }
                 return false;
             }
-
+            
         };
         
        
@@ -413,6 +415,13 @@ namespace storm {
             bool isColdBasicElement() const override{
                 return storm::utility::isZero(mPassiveFailureRate);
             }
+            
+            bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
+                if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
+                DFTBE<ValueType> const&  otherBE = static_cast<DFTBE<ValueType> const&>(other);
+                return (mActiveFailureRate == otherBE.mActiveFailureRate) && (mPassiveFailureRate == otherBE.mPassiveFailureRate);
+            }
+            
             virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override;
         };
 
@@ -454,6 +463,12 @@ namespace storm {
                 return 0;
             }
             
+            bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
+                if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
+                DFTConst<ValueType> const& otherCNST = static_cast<DFTConst<ValueType> const&>(other);
+                return (mFailed == otherCNST.mFailed);
+            }
+            
         };
 
 
@@ -518,6 +533,13 @@ namespace storm {
             virtual bool isDependency() const override {
                 return true;
             }
+            
+            virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
+                if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
+                DFTDependency<ValueType> const& otherDEP= static_cast<DFTDependency<ValueType> const&>(other);
+                return (mProbability == otherDEP.mProbability);
+            }
+            
 
             virtual std::vector<size_t> independentUnit() const override {
                 std::set<size_t> unit = {this->mId};
@@ -819,7 +841,12 @@ namespace storm {
             std::string typestring() const override{
                 return "VOT (" + std::to_string(mThreshold) + ")";
             }
-
+            
+            virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
+                if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
+                DFTVot<ValueType> const& otherVOT = static_cast<DFTVot<ValueType> const&>(other);
+                return (mThreshold == otherVOT.mThreshold);
+            }
         };
 
         template<typename ValueType>
@@ -887,7 +914,12 @@ namespace storm {
                 }
             }
         };
-
+        
+        template<typename ValueType>
+        bool equalType(DFTElement<ValueType> const& e1, DFTElement<ValueType> const& e2) {
+            return e1.isTypeEqualTo(e2);
+        }
+        
     }
 }
 

From cd3af54bb5192288b66fd7f40b8b1f8fadc0be20 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 15:44:54 +0100
Subject: [PATCH 111/246] Dftelementstype: is static gate Former-commit-id:
 a7b82e8ea97b61e48b27b88d1d58bea2d19d9416

---
 src/storage/dft/DFTElementType.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/storage/dft/DFTElementType.h b/src/storage/dft/DFTElementType.h
index 98d58df5c..a0d801816 100644
--- a/src/storage/dft/DFTElementType.h
+++ b/src/storage/dft/DFTElementType.h
@@ -6,6 +6,24 @@ namespace storm {
 
         enum class DFTElementType : int {AND = 0, COUNTING = 1, OR = 2, VOT = 3, BE = 4, CONSTF = 5, CONSTS = 6, PAND = 7, SPARE = 8, POR = 9, PDEP = 10, SEQAND = 11};
 
+        inline bool isStaticGateType(DFTElementType const& tp) {
+            if(!isGateType(tp)) return false;
+            switch(tp) {
+                case DFTElementType::AND:
+                case DFTElementType::OR:
+                case DFTElementType::VOT:
+                    return true;
+                case DFTElementType::POR:
+                case DFTElementType::SPARE:
+                case DFTElementType::PAND:
+                case DFTElementType::SEQAND:
+                    return false;
+                default:
+                    assert(false);
+            }
+        }
+        
+        
         inline bool isGateType(DFTElementType const& tp) {
             switch(tp) {
                 case DFTElementType::AND:

From c0dfaef066c965b51bc4907c08f70f85f853b0de Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 15:45:18 +0100
Subject: [PATCH 112/246] DFTElement: hasOnlyStaticParents Former-commit-id:
 449222f331d3f59e65d6291dd109e4258d8f319e

---
 src/storage/dft/DFTElements.h | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index b7fca51c0..747dfb611 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -119,6 +119,16 @@ namespace storm {
                 }
             }
 
+             bool hasOnlyStaticParents() const {
+                for(auto const& parent : parents) {
+                    if(!isStaticGateType(parents->type()) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            
             bool hasParents() const {
                 return !mParents.empty();
             }

From d00b32b5480ac055fee52e5e8f36fa1e30a38215 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 16:04:32 +0100
Subject: [PATCH 113/246] fix of static parents and fixed warning in element
 types

Former-commit-id: 816efd9c557cf59e78bd19c4a23d80c428adbfc4
---
 src/storage/dft/DFTElementType.h | 36 ++++++++++++++++++--------------
 src/storage/dft/DFTElements.h    |  4 ++--
 2 files changed, 22 insertions(+), 18 deletions(-)

diff --git a/src/storage/dft/DFTElementType.h b/src/storage/dft/DFTElementType.h
index a0d801816..a32745cdf 100644
--- a/src/storage/dft/DFTElementType.h
+++ b/src/storage/dft/DFTElementType.h
@@ -6,45 +6,49 @@ namespace storm {
 
         enum class DFTElementType : int {AND = 0, COUNTING = 1, OR = 2, VOT = 3, BE = 4, CONSTF = 5, CONSTS = 6, PAND = 7, SPARE = 8, POR = 9, PDEP = 10, SEQAND = 11};
 
-        inline bool isStaticGateType(DFTElementType const& tp) {
-            if(!isGateType(tp)) return false;
+        
+        inline bool isGateType(DFTElementType const& tp) {
             switch(tp) {
                 case DFTElementType::AND:
+                case DFTElementType::COUNTING:
                 case DFTElementType::OR:
                 case DFTElementType::VOT:
-                    return true;
-                case DFTElementType::POR:
-                case DFTElementType::SPARE:
                 case DFTElementType::PAND:
+                case DFTElementType::SPARE:
+                case DFTElementType::POR:
                 case DFTElementType::SEQAND:
+                    return true;
+                case DFTElementType::BE:
+                case DFTElementType::CONSTF:
+                case DFTElementType::CONSTS:
+                case DFTElementType::PDEP:
                     return false;
                 default:
                     assert(false);
+                    return false;
             }
         }
+
         
-        
-        inline bool isGateType(DFTElementType const& tp) {
+        inline bool isStaticGateType(DFTElementType const& tp) {
+            if(!isGateType(tp)) return false;
             switch(tp) {
                 case DFTElementType::AND:
-                case DFTElementType::COUNTING:
                 case DFTElementType::OR:
                 case DFTElementType::VOT:
-                case DFTElementType::PAND:
-                case DFTElementType::SPARE:
+                    return true;
                 case DFTElementType::POR:
+                case DFTElementType::SPARE:
+                case DFTElementType::PAND:
                 case DFTElementType::SEQAND:
-                    return true;
-                case DFTElementType::BE:
-                case DFTElementType::CONSTF:
-                case DFTElementType::CONSTS:
-                case DFTElementType::PDEP:
                     return false;
                 default:
                     assert(false);
+                    return false;
             }
         }
-
+        
+        
     }
 }
 
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 747dfb611..6ab165a04 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -120,8 +120,8 @@ namespace storm {
             }
 
              bool hasOnlyStaticParents() const {
-                for(auto const& parent : parents) {
-                    if(!isStaticGateType(parents->type()) {
+                for(auto const& parent : mParents) {
+                    if(!isStaticGateType(parent->type())) {
                         return false;
                     }
                 }

From 2e4afbc69b5871b29d67174474d5fe6e6c0697d5 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 18 Feb 2016 16:12:37 +0100
Subject: [PATCH 114/246] Ingoing and outgoing dependencies

Former-commit-id: 191acc897b9e482bea4c12c21c90f36c0165de77
---
 src/storage/dft/DFTBuilder.cpp  |  3 +-
 src/storage/dft/DFTElements.cpp |  2 +-
 src/storage/dft/DFTElements.h   | 53 +++++++++++++++++++++++++--------
 3 files changed, 44 insertions(+), 14 deletions(-)

diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index f35a09f0f..f0d1db5ac 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -41,7 +41,8 @@ namespace storm {
                 assert(mElements[dependency->nameDependent()]->isBasicElement());
                 std::shared_ptr<DFTBE<ValueType>> dependentEvent = std::static_pointer_cast<DFTBE<ValueType>>(mElements[dependency->nameDependent()]);
                 dependency->initialize(triggerEvent, dependentEvent);
-                triggerEvent->addDependency(dependency);
+                triggerEvent->addOutgoingDependency(dependency);
+                dependentEvent->addIngoingDependency(dependency);
             }
 
             // Sort elements topologically
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index 5597f1c5e..c7fc1d960 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -7,7 +7,7 @@ namespace storm {
 
         template<typename ValueType>
         bool DFTElement<ValueType>::checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-            if(!state.dontCare(mId) && !hasDependencies())
+            if(!state.dontCare(mId) && !hasOutgoingDependencies())
             {
                 for(DFTGatePointer const& parent : mParents) {
                     if(state.isOperational(parent->id())) {
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index e49b91901..d7060654f 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -35,13 +35,12 @@ namespace storm {
             using DFTDependencyPointer = std::shared_ptr<DFTDependency<ValueType>>;
             using DFTDependencyVector = std::vector<DFTDependencyPointer>;
 
-
         protected:
             size_t mId;
             std::string mName;
             size_t mRank = -1;
             DFTGateVector mParents;
-            DFTDependencyVector dependencies;
+            DFTDependencyVector mOutgoingDependencies;
 
         public:
             DFTElement(size_t id, std::string const& name) :
@@ -139,29 +138,30 @@ namespace storm {
                 return res;
             }
             
-            bool addDependency(DFTDependencyPointer const& e) {
-                if(std::find(dependencies.begin(), dependencies.end(), e) != dependencies.end()) {
+            bool addOutgoingDependency(DFTDependencyPointer const& e) {
+                assert(e->triggerEvent()->id() == this->id());
+                if(std::find(mOutgoingDependencies.begin(), mOutgoingDependencies.end(), e) != mOutgoingDependencies.end()) {
                     return false;
                 }
                 else
                 {
-                    dependencies.push_back(e);
+                    mOutgoingDependencies.push_back(e);
                     return true;
                 }
             }
             
-            bool hasDependencies() const {
-                return !dependencies.empty();
+            bool hasOutgoingDependencies() const {
+                return !mOutgoingDependencies.empty();
             }
             
-            size_t nrDependencies() const {
-                return dependencies.size();
+            size_t nrOutgoingDependencies() const {
+                return mOutgoingDependencies.size();
             }
             
-            DFTDependencyVector const& getDependencies() const {
-                return dependencies;
+            DFTDependencyVector const& getOutgoingDependencies() const {
+                return mOutgoingDependencies;
             }
-
+            
             virtual void extendSpareModule(std::set<size_t>& elementsInModule) const;
             
             virtual size_t nrChildren() const = 0;
@@ -375,9 +375,14 @@ namespace storm {
 
         template<typename ValueType>
         class DFTBE : public DFTElement<ValueType> {
+            
+            using DFTDependencyPointer = std::shared_ptr<DFTDependency<ValueType>>;
+            using DFTDependencyVector = std::vector<DFTDependencyPointer>;
 
+        protected:
             ValueType mActiveFailureRate;
             ValueType mPassiveFailureRate;
+            DFTDependencyVector mIngoingDependencies;
 
         public:
             DFTBE(size_t id, std::string const& name, ValueType failureRate, ValueType dormancyFactor) :
@@ -399,6 +404,30 @@ namespace storm {
             ValueType const& passiveFailureRate() const {
                 return mPassiveFailureRate;
             }
+            
+            bool addIngoingDependency(DFTDependencyPointer const& e) {
+                assert(e->dependentEvent()->id() == this->id());
+                if(std::find(mIngoingDependencies.begin(), mIngoingDependencies.end(), e) != mIngoingDependencies.end()) {
+                    return false;
+                }
+                else
+                {
+                    mIngoingDependencies.push_back(e);
+                    return true;
+                }
+            }
+            
+            bool hasIngoingDependencies() const {
+                return !mIngoingDependencies.empty();
+            }
+            
+            size_t nrIngoingDependencies() const {
+                return mIngoingDependencies.size();
+            }
+            
+            DFTDependencyVector const& getIngoingDependencies() const {
+                return mIngoingDependencies;
+            }
         
             std::string toString() const override {
                 std::stringstream stream;

From 5da88d5d52ec6d3d54c6e194560effa6d690c2d5 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 18 Feb 2016 16:32:45 +0100
Subject: [PATCH 115/246] Small refactoring

Former-commit-id: 220d7408e7310d476f4af26bef94ce549fe71cbf
---
 src/CMakeLists.txt                    |  2 +-
 src/builder/ExplicitDFTModelBuilder.h |  2 +-
 src/storage/dft/DFT.cpp               | 22 ++++++++++------------
 src/storage/dft/DFT.h                 | 15 ++++++++++++---
 src/storage/dft/DFTState.cpp          |  3 +--
 5 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 48428d7cc..3aa121a0a 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -37,13 +37,13 @@ file(GLOB STORM_SOLVER_STATEELIMINATION_FILES ${PROJECT_SOURCE_DIR}/src/solver/s
 file(GLOB STORM_STORAGE_FILES ${PROJECT_SOURCE_DIR}/src/storage/*.h ${PROJECT_SOURCE_DIR}/src/storage/*.cpp)
 file(GLOB STORM_STORAGE_BISIMULATION_FILES ${PROJECT_SOURCE_DIR}/src/storage/bisimulation/*.h ${PROJECT_SOURCE_DIR}/src/storage/bisimulation/*.cpp)
 file(GLOB STORM_STORAGE_DD_FILES ${PROJECT_SOURCE_DIR}/src/storage/dd/*.h ${PROJECT_SOURCE_DIR}/src/storage/dd/*.cpp)
+file(GLOB STORM_STORAGE_DFT_FILES ${PROJECT_SOURCE_DIR}/src/storage/dft/*.h ${PROJECT_SOURCE_DIR}/src/storage/dft/*.cpp)
 file(GLOB_RECURSE STORM_STORAGE_DD_CUDD_FILES ${PROJECT_SOURCE_DIR}/src/storage/dd/cudd/*.h ${PROJECT_SOURCE_DIR}/src/storage/dd/cudd/*.cpp)
 file(GLOB_RECURSE STORM_STORAGE_DD_SYLVAN_FILES ${PROJECT_SOURCE_DIR}/src/storage/dd/sylvan/*.h ${PROJECT_SOURCE_DIR}/src/storage/dd/sylvan/*.cpp)
 file(GLOB_RECURSE STORM_STORAGE_EXPRESSIONS_FILES ${PROJECT_SOURCE_DIR}/src/storage/expressions/*.h ${PROJECT_SOURCE_DIR}/src/storage/expressions/*.cpp)
 file(GLOB_RECURSE STORM_STORAGE_PRISM_FILES ${PROJECT_SOURCE_DIR}/src/storage/prism/*.h ${PROJECT_SOURCE_DIR}/src/storage/prism/*.cpp)
 file(GLOB_RECURSE STORM_STORAGE_SPARSE_FILES ${PROJECT_SOURCE_DIR}/src/storage/sparse/*.h ${PROJECT_SOURCE_DIR}/src/storage/sparse/*.cpp)
 file(GLOB_RECURSE STORM_UTILITY_FILES ${PROJECT_SOURCE_DIR}/src/utility/*.h ${PROJECT_SOURCE_DIR}/src/utility/*.cpp)
-file(GLOB_RECURSE STORM_STORAGE_DFT_FILES ${PROJECT_SOURCE_DIR}/src/storage/dft/*.h ${PROJECT_SOURCE_DIR}/src/storage/sparse/*.cpp)
 
 
 # Additional include files like the storm-config.h
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 67dec3dc4..0b80608cf 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -49,7 +49,7 @@ namespace storm {
             size_t newIndex = 0;
 
         public:
-            ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const &dft) : mDft(dft), mStates(((mDft.stateSize() / 64) + 1) * 64, std::pow(2, mDft.nrBasicElements())) {
+            ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const &dft) : mDft(dft), mStates(((mDft.stateVectorSize() / 64) + 1) * 64, std::pow(2, mDft.nrBasicElements())) {
                 // stateSize is bound for size of bitvector
                 // 2^nrBE is upper bound for state space
             }
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 5735af2a7..9506b29a5 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -10,13 +10,12 @@ namespace storm {
     namespace storage {
 
         template<typename ValueType>
-        DFT<ValueType>::DFT(DFTElementVector const& elements, DFTElementPointer const& tle) : mElements(elements), mNrOfBEs(0), mNrOfSpares(0)
+        DFT<ValueType>::DFT(DFTElementVector const& elements, DFTElementPointer const& tle) : mElements(elements), mTopLevelIndex(tle->id()), mNrOfBEs(0), mNrOfSpares(0)
         {
             assert(elementIndicesCorrect());
-
-            size_t stateIndex = 0;
             mUsageInfoBits = storm::utility::math::uint64_log2(mElements.size()-1)+1;
-
+            size_t stateIndex = 0;
+            
             for (auto& elem : mElements) {
                 mIdToFailureIndex.push_back(stateIndex);
                 stateIndex += 2;
@@ -25,6 +24,7 @@ namespace storm {
                 }
                 else if (elem->isSpareGate()) {
                     ++mNrOfSpares;
+                    bool firstChild = true;
                     for(auto const& spareReprs : std::static_pointer_cast<DFTSpare<ValueType>>(elem)->children()) {
                         if(mActivationIndex.count(spareReprs->id()) == 0) {
                             mActivationIndex[spareReprs->id()] =  stateIndex++;
@@ -32,11 +32,9 @@ namespace storm {
                         std::set<size_t> module = {spareReprs->id()};
                         spareReprs->extendSpareModule(module);
                         std::vector<size_t> sparesAndBes;
-                        bool secondSpare = false;
-                        for(auto const& modelem : module) {
-                            if (mElements[modelem]->isSpareGate()) {
-                                STORM_LOG_THROW(!secondSpare, storm::exceptions::NotSupportedException, "Module for '" << spareReprs->name() << "' contains more than one spare.");
-                                secondSpare = true;
+                        for(size_t modelem : module) {
+                            if (spareReprs->id() != modelem && (isRepresentative(modelem) || (!firstChild && mTopLevelIndex == modelem))) {
+                                STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Module for '" << spareReprs->name() << "' contains more than one representative.");
                             }
                             if(mElements[modelem]->isSpareGate() || mElements[modelem]->isBasicElement()) {
                                 sparesAndBes.push_back(modelem);
@@ -44,7 +42,7 @@ namespace storm {
                             }
                         }
                         mSpareModules.insert(std::make_pair(spareReprs->id(), sparesAndBes));
-
+                        firstChild = false;
                     }
                     std::static_pointer_cast<DFTSpare<ValueType>>(elem)->setUseIndex(stateIndex);
                     mUsageIndex.insert(std::make_pair(elem->id(), stateIndex));
@@ -71,8 +69,8 @@ namespace storm {
             }
             mTopModule = std::vector<size_t>(topModuleSet.begin(), topModuleSet.end());
 
-            mStateSize = stateIndex;
-            mTopLevelIndex = tle->id();
+            mStateVectorSize = stateIndex;
+        }
 
         }
 
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index f2036e7d7..ca860d074 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -53,7 +53,7 @@ namespace storm {
             size_t mNrOfSpares;
             size_t mTopLevelIndex;
             size_t mUsageInfoBits;
-            size_t mStateSize;
+            size_t mStateVectorSize;
             std::map<size_t, size_t> mActivationIndex;
             std::map<size_t, std::vector<size_t>> mSpareModules;
             std::vector<size_t> mDependencies;
@@ -65,8 +65,8 @@ namespace storm {
         public:
             DFT(DFTElementVector const& elements, DFTElementPointer const& tle);
 
-            size_t stateSize() const {
-                return mStateSize;
+            size_t stateVectorSize() const {
+                return mStateVectorSize;
             }
             
             size_t nrElements() const {
@@ -198,6 +198,15 @@ namespace storm {
                 }
                 return elements;
             }
+            
+            bool isRepresentative(size_t id) const {
+                for (auto const& parent : getElement(id)->parents()) {
+                    if (parent->isSpareGate()) {
+                        return true;
+                    }
+                }
+                return false;
+            }
 
             bool hasRepresentant(size_t id) const {
                 return mRepresentants.find(id) != mRepresentants.end();
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 9916bbe0e..7e8429fdd 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -6,13 +6,12 @@ namespace storm {
     namespace storage {
 
         template<typename ValueType>
-        DFTState<ValueType>::DFTState(DFT<ValueType> const& dft, size_t id) : mStatus(dft.stateSize()), mId(id), mDft(dft)  {
+        DFTState<ValueType>::DFTState(DFT<ValueType> const& dft, size_t id) : mStatus(dft.stateVectorSize()), mId(id), mDft(dft)  {
             mInactiveSpares = dft.getSpareIndices();
             dft.initializeUses(*this);
             dft.initializeActivation(*this);
             std::vector<size_t> alwaysActiveBEs = dft.nonColdBEs();
             mIsCurrentlyFailableBE.insert(mIsCurrentlyFailableBE.end(), alwaysActiveBEs.begin(), alwaysActiveBEs.end());
-            
         }
 
         template<typename ValueType>

From cc92085a15de67a6c7a3bc942183429214088f71 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 16:40:44 +0100
Subject: [PATCH 116/246] bijection check for homomorphism

Former-commit-id: bf7f2f40662f11c6fbb1772bdc216eb17253ad12
---
 src/storage/dft/DFT.cpp          | 17 +++++++++++--
 src/storage/dft/DFTIsomorphism.h | 43 ++++++++++++++++++++++++++------
 2 files changed, 51 insertions(+), 9 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 5735af2a7..e231c7c8d 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -180,20 +180,29 @@ namespace storm {
         std::vector<std::vector<size_t>> DFT<ValueType>::findSymmetries(DFTColouring<ValueType> const& colouring) const {
             std::vector<size_t> vec;
             vec.reserve(nrElements());
-            storm::utility::iota_n(std::back_inserter(vec), 14, 0);
+            storm::utility::iota_n(std::back_inserter(vec), nrElements(), 0);
             BijectionCandidates<ValueType> completeCategories = colouring.colourSubdft(vec);
             std::vector<std::vector<size_t>> res;
+            
             for(auto const& colourClass : completeCategories.gateCandidates) {
                 if(colourClass.second.size() > 1) {
+                    std::vector<size_t> handledWithinClass;
                     for(auto it1 = colourClass.second.cbegin(); it1 != colourClass.second.cend(); ++it1) {
+                        if(!getGate(*it1)->hasOnlyStaticParents()) {
+                            continue;
+                        }
                         std::vector<size_t> sortedParent1Ids = getGate(*it1)->parentIds();
                         std::sort(sortedParent1Ids.begin(), sortedParent1Ids.end());
                         auto it2 = it1;
                         for(++it2; it2 != colourClass.second.cend(); ++it2) {
+                            if(!getGate(*it2)->hasOnlyStaticParents()) {
+                                continue;
+                            }
                             std::vector<size_t> sortedParent2Ids = getGate(*it2)->parentIds();
                             std::sort(sortedParent2Ids.begin(), sortedParent2Ids.end());
                             if(sortedParent1Ids == sortedParent2Ids) {
                                 std::cout << "Considering ids " << *it1 << ", " << *it2 << " for isomorphism." << std::endl;
+                                bool isSymmetry = false;
                                 std::vector<size_t> isubdft1 = getGate(*it1)->independentSubDft();
                                 std::vector<size_t> isubdft2 = getGate(*it2)->independentSubDft();
                                 if(!isubdft1.empty() && !isubdft2.empty() && isubdft1.size() == isubdft2.size()) {
@@ -201,7 +210,11 @@ namespace storm {
                                     auto LHS = colouring.colourSubdft(isubdft1);
                                     auto RHS = colouring.colourSubdft(isubdft2);
                                     auto IsoCheck = DFTIsomorphismCheck<ValueType>(LHS, RHS, *this);
-                                    IsoCheck.findIsomorphism();
+                                    isSymmetry = IsoCheck.findIsomorphism();
+                                }
+                                if(isSymmetry) {
+                                    std::cout << "subdfts are symmetric" << std::endl;
+                                    
                                 }
                             }
                         }
diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
index 6c4a44ad6..182a2b01c 100644
--- a/src/storage/dft/DFTIsomorphism.h
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -261,11 +261,42 @@ namespace storage {
          */
         bool check() {
             // We can skip BEs, as they are identified by they're homomorphic if they are in the same class
-            for(auto const& index : bijection) {
-                // As they are in the same group, the types are fine already. We just have to check the children.
-
+            for(auto const& indexpair : bijection) {
+                // Check type first. Colouring takes care of a lot, but not necesarily everything (e.g. voting thresholds)
+                equalType(*dft.getElement(indexpair.first), *dft.getElement(indexpair.second));
+                if(dft.isGate(indexpair.first)) {
+                    assert(dft.isGate(indexpair.second));
+                    auto const& lGate = dft.getGate(indexpair.first);
+                    std::set<size_t> childrenLeftMapped;
+                    for(auto const& child : lGate->children() ) {
+                        childrenLeftMapped.insert(bijection.at(child->id()));
+                    }
+                    auto const& rGate = dft.getGate(indexpair.second);
+                    std::set<size_t> childrenRight;
+                    for(auto const& child : rGate->children() ) {
+                        childrenRight.insert(child->id());
+                    }
+                    if(childrenLeftMapped != childrenRight) {
+                        return false;
+                    }
+                } else if(dft.isDependency(indexpair.first)) {
+                    assert(dft.isDependency(indexpair.second));
+                    auto const& lDep = dft.getDependency(indexpair.first);
+                    auto const& rDep = dft.getDependency(indexpair.second);
+                    if(bijection.at(lDep->triggerEvent()->id()) != rDep->triggerEvent()->id()) {
+                        return false;
+                    } 
+                    if(bijection.at(lDep->dependentEvent()->id()) != rDep->dependentEvent()->id()) {
+                        return false;
+                    }
+                }
+                else {
+                    assert(dft.isBasicElement(indexpair.first));
+                    assert(dft.isBasicElement(indexpair.second));
+                    // No operations required.
+                }
             }
-            return false;
+            return true;
         }
 
     private:
@@ -341,9 +372,7 @@ namespace storage {
         }
 
 
-        //std::vector<std::pair<size_t, size_t>> computeNextCandidate(){
-
-        //}
+        
     };
 
 

From 7bf6dbbaab21ac16a4d2333e45ab0ba25252a450 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 16:45:45 +0100
Subject: [PATCH 117/246] outgoingDependencies in c++ style :)

Former-commit-id: 51af1f47ba499719d5c22cb29b97a6da138a7533
---
 src/storage/dft/DFTElements.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 36075d005..d69b73f3b 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -168,7 +168,7 @@ namespace storm {
                 return mOutgoingDependencies.size();
             }
             
-            DFTDependencyVector const& getOutgoingDependencies() const {
+            DFTDependencyVector const& outgoingDependencies() const {
                 return mOutgoingDependencies;
             }
             

From ca77078a9c866cc0aee16908333ec37c138557de Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 18:03:57 +0100
Subject: [PATCH 118/246] Deterministic Building for DFTs

Former-commit-id: bb669a034e24494ae3c88a6a353931651c0c945a
---
 src/storage/dft/DFTBuilder.cpp | 4 ++--
 src/storage/dft/DFTBuilder.h   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index f0d1db5ac..1979aea3b 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -123,7 +123,7 @@ namespace storm {
         }
 
         template<typename ValueType>
-        void DFTBuilder<ValueType>::topoVisit(DFTElementPointer const& n, std::map<DFTElementPointer, topoSortColour>& visited, DFTElementVector& L) {
+        void DFTBuilder<ValueType>::topoVisit(DFTElementPointer const& n, std::map<DFTElementPointer, topoSortColour, OrderElementsById<ValueType>>& visited, DFTElementVector& L) {
             if(visited[n] == topoSortColour::GREY) {
                 throw storm::exceptions::WrongFormatException("DFT is cyclic");
             } else if(visited[n] == topoSortColour::WHITE) {
@@ -141,7 +141,7 @@ namespace storm {
         // TODO Matthias: use typedefs
         template<typename ValueType>
         std::vector<std::shared_ptr<DFTElement<ValueType>>> DFTBuilder<ValueType>::topoSort() {
-            std::map<DFTElementPointer, topoSortColour> visited;
+            std::map<DFTElementPointer, topoSortColour, OrderElementsById<ValueType>> visited;
             for(auto const& e : mElements) {
                 visited.insert(std::make_pair(e.second, topoSortColour::WHITE)); 
             }
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index 37c3c4eaa..17a16cb49 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -141,7 +141,7 @@ namespace storm {
             
             enum class topoSortColour {WHITE, BLACK, GREY}; 
             
-            void topoVisit(DFTElementPointer const& n, std::map<DFTElementPointer, topoSortColour>& visited, DFTElementVector& L);
+            void topoVisit(DFTElementPointer const& n, std::map<DFTElementPointer, topoSortColour, OrderElementsById<ValueType>>& visited, DFTElementVector& L);
 
             DFTElementVector topoSort();
             

From 7663c29c5d5a00fdde84ac892f7e3bca87958368 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 18:13:10 +0100
Subject: [PATCH 119/246] Fix in SubDFT computation.

Former-commit-id: aec3f5d0de949aa07c35222dfe1f8e320713bf81
---
 src/storage/dft/DFTElements.cpp | 26 ++++++++++++-----
 src/storage/dft/DFTElements.h   | 51 +++++++++++++++++++++++++++++----
 2 files changed, 65 insertions(+), 12 deletions(-)

diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index c7fc1d960..d59ec8f41 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -46,14 +46,20 @@ namespace storm {
 
         template<typename ValueType>
         std::vector<size_t> DFTElement<ValueType>::independentSubDft() const {
+            std::cout << "INDEPENDENT SUBTREE CALL " << this->id() << std::endl;
             std::vector<size_t> res;
             res.push_back(this->id());
-            // Extend for pdeps.
             return res;
         }
 
         template<typename ValueType>
-        void DFTElement<ValueType>::extendSubDft(std::set<size_t> elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const {
+        void DFTElement<ValueType>::extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const {
+            if(elemsInSubtree.count(this->id()) > 0) return;
+            std::cout << "ID " <<  this->id() <<  "PREL elems ";
+            for(auto const& i : elemsInSubtree) {
+                std::cout << i << " ";
+            }
+            std::cout << "in subtree." << std::endl;
             if(std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), mId) != parentsOfSubRoot.end()) {
                 // This is a parent of the suspected root, thus it is not a subdft.
                 elemsInSubtree.clear();
@@ -61,13 +67,19 @@ namespace storm {
             }
             elemsInSubtree.insert(mId);
             for(auto const& parent : mParents) {
-                if(elemsInSubtree.count(parent->id()) != 0) {
-                    parent->extendUnit(elemsInSubtree);
-                    if(elemsInSubtree.empty()) {
-                        return;
-                    }
+                
+                parent->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                if(elemsInSubtree.empty()) {
+                    return;
                 }
             }
+            for(auto const& dep : mOutgoingDependencies) {
+                dep->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                if(elemsInSubtree.empty()) {
+                    return;
+                }
+
+            }
         }
 
 
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index d69b73f3b..81b8ce303 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -202,7 +202,7 @@ namespace storm {
              * Helper to the independent subtree computation
              * @see independentSubDft
              */
-            virtual void extendSubDft(std::set<size_t> elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const;
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const;
 
             virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const {
                 return type() == other.type();
@@ -291,6 +291,11 @@ namespace storm {
                 std::vector<size_t> pids = this->parentIds();
                 for(auto const& child : mChildren) {
                     child->extendSubDft(unit, pids);
+                    std::cout << "int sub ";
+                    for(auto const& i : unit) {
+                        std::cout << i << " ";
+                    }
+                    std::cout << std::endl;
                     if(unit.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
                         break;
@@ -299,9 +304,10 @@ namespace storm {
                 return std::vector<size_t>(unit.begin(), unit.end());
             }
 
-            virtual void extendSubDft(std::set<size_t> elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
+                if(elemsInSubtree.count(this->id()) > 0) return;
                 DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
-                if(!elemsInSubtree.empty()) {
+                if(elemsInSubtree.empty()) {
                     // Parent in the subdft, ie it is *not* a subdft
                     return;
                 }
@@ -309,7 +315,7 @@ namespace storm {
                     child->extendSubDft(elemsInSubtree, parentsOfSubRoot);
                     if(elemsInSubtree.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
-                        break;
+                        return;
                     }
                 }
             }
@@ -437,7 +443,7 @@ namespace storm {
                 return mIngoingDependencies.size();
             }
             
-            DFTDependencyVector const& getIngoingDependencies() const {
+            DFTDependencyVector const& ingoingDependencies() const {
                 return mIngoingDependencies;
             }
         
@@ -455,6 +461,22 @@ namespace storm {
                 return storm::utility::isZero(mPassiveFailureRate);
             }
             
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
+                 if(elemsInSubtree.count(this->id())) return;
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                if(elemsInSubtree.empty()) {
+                    // Parent in the subdft, ie it is *not* a subdft
+                    return;
+                }
+                for(auto const& incDep : mIngoingDependencies) {
+                    incDep->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                    if(elemsInSubtree.empty()) {
+                        // Parent in the subdft, ie it is *not* a subdft
+                        return;
+                    }
+                }
+            }
+            
             bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
                 if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
                 DFTBE<ValueType> const&  otherBE = static_cast<DFTBE<ValueType> const&>(other);
@@ -502,6 +524,8 @@ namespace storm {
                 return 0;
             }
             
+            
+            
             bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
                 if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
                 DFTConst<ValueType> const& otherCNST = static_cast<DFTConst<ValueType> const&>(other);
@@ -589,6 +613,23 @@ namespace storm {
                 return std::vector<size_t>(unit.begin(), unit.end());
             }
 
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
+                 if(elemsInSubtree.count(this->id())) return;
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                if(elemsInSubtree.empty()) {
+                    // Parent in the subdft, ie it is *not* a subdft
+                    return;
+                }
+                mDependentEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                if(elemsInSubtree.empty()) {
+                    // Parent in the subdft, ie it is *not* a subdft
+                    return;
+                }
+                mTriggerEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                
+                
+            }
+            
             virtual std::string toString() const override {
                 std::stringstream stream;
                 bool fdep = storm::utility::isOne(mProbability);

From 30df7c0bda435a825d92b6a952009386c46a05f8 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 18:44:26 +0100
Subject: [PATCH 120/246] Convenience info about bijectioncandidates

Former-commit-id: c2af2c957ae465303b18e07dbc43b7a19a0c46ae
---
 src/storage/dft/DFTIsomorphism.h | 86 ++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)

diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
index 182a2b01c..6ce267e87 100644
--- a/src/storage/dft/DFTIsomorphism.h
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -63,6 +63,87 @@ namespace storage {
         std::unordered_map<size_t, std::vector<size_t>> gateCandidates;
         std::unordered_map<BEColourClass<ValueType>, std::vector<size_t>> beCandidates;
         std::unordered_map<std::pair<ValueType, ValueType>, std::vector<size_t>> pdepCandidates;
+        
+        size_t nrGroups() const {
+            return gateCandidates.size() + beCandidates.size() + pdepCandidates.size();
+        }
+        
+        size_t size() const {
+            return nrGates() + nrBEs() + nrDeps();
+        }
+        
+        size_t nrGates() const {
+            size_t res = 0;
+            for(auto const& x : gateCandidates) {
+                res += x.second.size();
+            }
+            return res;
+        }
+        
+        size_t nrBEs() const {
+            size_t res = 0;
+            for(auto const& x : beCandidates) {
+                res += x.second.size();
+            }
+            return res;
+        }
+        
+        size_t nrDeps() const {
+            size_t res = 0;
+            for(auto const& x : pdepCandidates) {
+                res += x.second.size();
+            }
+            return res;
+        }
+        
+        bool hasGate(size_t index) {
+            for(auto const& x : gateCandidates) {
+                for( auto const& ind : x.second) {
+                    if(index == ind) return true;
+                }
+            }
+            return false;
+        }
+        
+        bool hasBE(size_t index) {
+            for(auto const& x : beCandidates) {
+                for(auto const& ind : x.second) {
+                    if(index == ind) return true;
+                }
+            }
+            return false;
+        }
+        
+        bool hasDep(size_t index) {
+            for(auto const& x : pdepCandidates) {
+                for(auto const& ind : x.second) {
+                    if(index == ind) return true;
+                }
+            }
+            return false;
+        }
+        
+        bool has(size_t index) {
+            return hasGate(index) || hasBE(index) || hasDep(index);
+        }
+        
+        
+        
+        size_t trivialGateGroups() const {
+            size_t res = 0;
+            for(auto const& x : gateCandidates) {
+                if(x.second.size() == 1) ++res;
+            }
+            return res;
+        }
+        
+        size_t trivialBEGroups() const {
+            size_t res = 0;
+            for(auto const& x : beCandidates) {
+                if(x.second.size() == 1) ++res;
+            }
+            return res;
+        }
     };
 
     template<typename ValueType>
@@ -207,6 +288,9 @@ namespace storage {
             initializePermutationsAndTreatTrivialGroups(bleft.beCandidates, bright.beCandidates, currentPermutations.beCandidates);
             initializePermutationsAndTreatTrivialGroups(bleft.gateCandidates, bright.gateCandidates, currentPermutations.gateCandidates);
             initializePermutationsAndTreatTrivialGroups(bleft.pdepCandidates, bright.pdepCandidates, currentPermutations.pdepCandidates);
+            std::cout << bijection.size() << " vs. " << bleft.size() << " vs. " << bright.size() << std::endl;
+            assert(bijection.size() == bleft.size());
+            
         }
 
         /**
@@ -214,6 +298,7 @@ namespace storage {
          * @return true if a next bijection exists.
          */
         bool findNextBijection() {
+            assert(candidatesCompatible);
             bool foundNext = false;
             if(!currentPermutations.beCandidates.empty()) {
                 auto it = currentPermutations.beCandidates.begin();
@@ -260,6 +345,7 @@ namespace storage {
          *
          */
         bool check() {
+            assert(bijection.size() == bleft.size());
             // We can skip BEs, as they are identified by they're homomorphic if they are in the same class
             for(auto const& indexpair : bijection) {
                 // Check type first. Colouring takes care of a lot, but not necesarily everything (e.g. voting thresholds)

From aaec1fd3bd9b5ff0db8b474ad606100ce0b0837b Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 18:56:36 +0100
Subject: [PATCH 121/246] isomorphism runs through first tests :)

Former-commit-id: c83157ba7ad6da368062e7f13e626d0733a14949
---
 src/storage/dft/DFTIsomorphism.h | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
index 6ce267e87..5aec35714 100644
--- a/src/storage/dft/DFTIsomorphism.h
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -96,7 +96,7 @@ namespace storage {
             return res;
         }
         
-        bool hasGate(size_t index) {
+        bool hasGate(size_t index) const {
             for(auto const& x : gateCandidates) {
                 for( auto const& ind : x.second) {
                     if(index == ind) return true;
@@ -105,7 +105,7 @@ namespace storage {
             return false;
         }
         
-        bool hasBE(size_t index) {
+        bool hasBE(size_t index) const {
             for(auto const& x : beCandidates) {
                 for(auto const& ind : x.second) {
                     if(index == ind) return true;
@@ -114,7 +114,7 @@ namespace storage {
             return false;
         }
         
-        bool hasDep(size_t index) {
+        bool hasDep(size_t index) const {
             for(auto const& x : pdepCandidates) {
                 for(auto const& ind : x.second) {
                     if(index == ind) return true;
@@ -123,7 +123,7 @@ namespace storage {
             return false;
         }
         
-        bool has(size_t index) {
+        bool has(size_t index) const {
             return hasGate(index) || hasBE(index) || hasDep(index);
         }
         
@@ -355,11 +355,13 @@ namespace storage {
                     auto const& lGate = dft.getGate(indexpair.first);
                     std::set<size_t> childrenLeftMapped;
                     for(auto const& child : lGate->children() ) {
+                        assert(bleft.has(child->id()));
                         childrenLeftMapped.insert(bijection.at(child->id()));
                     }
                     auto const& rGate = dft.getGate(indexpair.second);
                     std::set<size_t> childrenRight;
                     for(auto const& child : rGate->children() ) {
+                        assert(bright.has(child->id()));
                         childrenRight.insert(child->id());
                     }
                     if(childrenLeftMapped != childrenRight) {
@@ -435,7 +437,7 @@ namespace storage {
                     auto it = permutations.insert(colour);
                     assert(it.second);
                     std::sort(it.first->second.begin(), it.first->second.end());
-                    zipVectorsIntoMap(colour.second, permutations.find(colour.first)->second, bijection);
+                    zipVectorsIntoMap(left.at(colour.first), it.first->second, bijection);
                 } else {
                     assert(colour.second.size() == 1);
                     assert(bijection.count(left.at(colour.first).front()) == 0);

From 2dbcd260e4127672119fb96474a36014e35fef88 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 19:00:37 +0100
Subject: [PATCH 122/246] symred is now an option

Former-commit-id: 572599165612efed2c499668622425b05902927a
---
 src/storm-dyftee.cpp | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index a8122f2bd..f0da80f0f 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -4,6 +4,7 @@
 #include "builder/ExplicitDFTModelBuilder.h"
 #include "modelchecker/results/CheckResult.h"
 #include "utility/storm.h"
+#include "storage/dft/DFTIsomorphism.h"
 
 /*!
  * Load DFT from filename, build corresponding Model and check against given property.
@@ -12,13 +13,19 @@
  * @param property PCTC formula capturing the property to check.
  */
 template <typename ValueType>
-void analyzeDFT(std::string filename, std::string property) {
+void analyzeDFT(std::string filename, std::string property, bool symred = false) {
     // Parsing DFT
     std::cout << "Parsing DFT file..." << std::endl;
     storm::parser::DFTGalileoParser<ValueType> parser;
     storm::storage::DFT<ValueType> dft = parser.parseDFT(filename);
     std::cout << "Built data structure" << std::endl;
-
+    
+    if(symred) {
+        std::cout << dft.getElementsString() << std::endl;
+        auto colouring = dft.colourDFT();
+        dft.findSymmetries(colouring);
+    }
+        
     // Building Markov Automaton
     std::cout << "Building Model..." << std::endl;
     storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft);
@@ -52,6 +59,7 @@ int main(int argc, char** argv) {
 
     // Parse cli arguments
     bool parametric = false;
+    bool symred = false;
     log4cplus::LogLevel level = log4cplus::WARN_LOG_LEVEL;
     std::string filename = argv[1];
     std::string pctlFormula = "";
@@ -74,6 +82,8 @@ int main(int argc, char** argv) {
             ++i;
             assert(i < argc);
             pctlFormula = argv[i];
+        } else if (option == "--symred") {
+            symred = true;
         } else {
             std::cout << "Option '" << option << "' not recognized." << std::endl;
             return 1;
@@ -88,8 +98,8 @@ int main(int argc, char** argv) {
     std::cout << "Running " << (parametric ? "parametric " : "") << "DFT analysis on file " << filename << " with property " << pctlFormula << std::endl;
 
     if (parametric) {
-        analyzeDFT<storm::RationalFunction>(filename, pctlFormula);
+        analyzeDFT<storm::RationalFunction>(filename, pctlFormula, symred);
     } else {
-        analyzeDFT<double>(filename, pctlFormula);
+        analyzeDFT<double>(filename, pctlFormula, symred);
     }
 }

From 11f01cdf5273136f0718a170b83ea4202c657431 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 21:09:12 +0100
Subject: [PATCH 123/246] towards using symred for counting abstr

Former-commit-id: 51bad8ba1e6b711cc45c82f69240c79dcf8b03cb
---
 src/storage/dft/DFT.cpp          | 36 +++++++++++++++++++++++++-------
 src/storage/dft/DFTElements.cpp  |  5 -----
 src/storage/dft/DFTElements.h    |  5 -----
 src/storage/dft/DFTIsomorphism.h |  4 ++--
 4 files changed, 31 insertions(+), 19 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index e231c7c8d..1ce4618cf 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -186,8 +186,12 @@ namespace storm {
             
             for(auto const& colourClass : completeCategories.gateCandidates) {
                 if(colourClass.second.size() > 1) {
-                    std::vector<size_t> handledWithinClass;
+                    std::set<size_t> foundEqClassFor;
                     for(auto it1 = colourClass.second.cbegin(); it1 != colourClass.second.cend(); ++it1) {
+                        std::vector<std::vector<size_t>> symClass;
+                        if(foundEqClassFor.count(*it1) > 0) {
+                            continue;
+                        }
                         if(!getGate(*it1)->hasOnlyStaticParents()) {
                             continue;
                         }
@@ -200,20 +204,38 @@ namespace storm {
                             }
                             std::vector<size_t> sortedParent2Ids = getGate(*it2)->parentIds();
                             std::sort(sortedParent2Ids.begin(), sortedParent2Ids.end());
+                            
                             if(sortedParent1Ids == sortedParent2Ids) {
                                 std::cout << "Considering ids " << *it1 << ", " << *it2 << " for isomorphism." << std::endl;
                                 bool isSymmetry = false;
                                 std::vector<size_t> isubdft1 = getGate(*it1)->independentSubDft();
                                 std::vector<size_t> isubdft2 = getGate(*it2)->independentSubDft();
-                                if(!isubdft1.empty() && !isubdft2.empty() && isubdft1.size() == isubdft2.size()) {
-                                    std::cout << "Checking subdfts from " << *it1 << ", " << *it2 << " for isomorphism." << std::endl;
-                                    auto LHS = colouring.colourSubdft(isubdft1);
-                                    auto RHS = colouring.colourSubdft(isubdft2);
-                                    auto IsoCheck = DFTIsomorphismCheck<ValueType>(LHS, RHS, *this);
-                                    isSymmetry = IsoCheck.findIsomorphism();
+                                if(isubdft1.empty() || isubdft2.empty() || isubdft1.size() != isubdft2.size()) {
+                                    continue;
                                 }
+                                std::cout << "Checking subdfts from " << *it1 << ", " << *it2 << " for isomorphism." << std::endl;
+                                auto LHS = colouring.colourSubdft(isubdft1);
+                                auto RHS = colouring.colourSubdft(isubdft2);
+                                auto IsoCheck = DFTIsomorphismCheck<ValueType>(LHS, RHS, *this);
+                                isSymmetry = IsoCheck.findIsomorphism();
                                 if(isSymmetry) {
                                     std::cout << "subdfts are symmetric" << std::endl;
+                                    foundEqClassFor.insert(*it2);
+                                    if(symClass.empty()) {
+                                        for(auto const& i : isubdft1) {
+                                            symClass.push_back(std::vector<size_t>({i}));
+                                        }
+                                    }
+                                    auto symClassIt = symClass.begin();
+                                    for(auto const& i : isubdft1) {
+                                        symClassIt->emplace_back(IsoCheck.getIsomorphism().at(i));
+                                        for(auto const& v : *symClassIt) {
+                                            std::cout << v << " ";
+                                        }
+                                        std::cout << std::endl;
+                                        ++symClassIt;
+                                        
+                                    }
                                     
                                 }
                             }
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index d59ec8f41..26f5f9cbe 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -55,11 +55,6 @@ namespace storm {
         template<typename ValueType>
         void DFTElement<ValueType>::extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const {
             if(elemsInSubtree.count(this->id()) > 0) return;
-            std::cout << "ID " <<  this->id() <<  "PREL elems ";
-            for(auto const& i : elemsInSubtree) {
-                std::cout << i << " ";
-            }
-            std::cout << "in subtree." << std::endl;
             if(std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), mId) != parentsOfSubRoot.end()) {
                 // This is a parent of the suspected root, thus it is not a subdft.
                 elemsInSubtree.clear();
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 81b8ce303..c352bd38e 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -291,11 +291,6 @@ namespace storm {
                 std::vector<size_t> pids = this->parentIds();
                 for(auto const& child : mChildren) {
                     child->extendSubDft(unit, pids);
-                    std::cout << "int sub ";
-                    for(auto const& i : unit) {
-                        std::cout << i << " ";
-                    }
-                    std::cout << std::endl;
                     if(unit.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
                         break;
diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
index 5aec35714..0d5590d3d 100644
--- a/src/storage/dft/DFTIsomorphism.h
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -256,8 +256,8 @@ namespace storage {
          * Can only be called after the findIsomorphism procedure returned that an isomorphism has found.
          * @see findIsomorphism
          */
-        std::vector<std::pair<size_t, size_t>> getIsomorphism() const {
-
+        std::map<size_t, size_t> const& getIsomorphism() const {
+            return bijection;
         }
 
         /**

From 130fa1328ab30f297c79122273c100273472767f Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 21:39:43 +0100
Subject: [PATCH 124/246] function returns independent symmetries

Former-commit-id: 674f0bcff263b0d52d928a37cfdac50d69066d47
---
 src/storage/dft/DFT.cpp          | 15 ++++++++-------
 src/storage/dft/DFT.h            |  4 ++--
 src/storage/dft/SymmetricUnits.h | 33 ++++++++++++++++++++++++++------
 src/storm-dyftee.cpp             |  3 ++-
 4 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 1ce4618cf..0a90f1513 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -1,5 +1,6 @@
 #include <boost/container/flat_set.hpp>
 
+#include <map>
 #include "DFT.h"
 #include "src/exceptions/NotSupportedException.h"
 
@@ -177,12 +178,12 @@ namespace storm {
         }
 
         template<typename ValueType>
-        std::vector<std::vector<size_t>> DFT<ValueType>::findSymmetries(DFTColouring<ValueType> const& colouring) const {
+        DFTIndependentSymmetries DFT<ValueType>::findSymmetries(DFTColouring<ValueType> const& colouring) const {
             std::vector<size_t> vec;
             vec.reserve(nrElements());
             storm::utility::iota_n(std::back_inserter(vec), nrElements(), 0);
             BijectionCandidates<ValueType> completeCategories = colouring.colourSubdft(vec);
-            std::vector<std::vector<size_t>> res;
+            std::map<size_t, std::vector<std::vector<size_t>>> res;
             
             for(auto const& colourClass : completeCategories.gateCandidates) {
                 if(colourClass.second.size() > 1) {
@@ -229,10 +230,6 @@ namespace storm {
                                     auto symClassIt = symClass.begin();
                                     for(auto const& i : isubdft1) {
                                         symClassIt->emplace_back(IsoCheck.getIsomorphism().at(i));
-                                        for(auto const& v : *symClassIt) {
-                                            std::cout << v << " ";
-                                        }
-                                        std::cout << std::endl;
                                         ++symClassIt;
                                         
                                     }
@@ -240,10 +237,14 @@ namespace storm {
                                 }
                             }
                         }
+                        if(!symClass.empty()) {
+                            res.emplace(*it1, symClass);
+                        }
                     }
+                    
                 }
             }
-            return res;
+            return DFTIndependentSymmetries(res);
         }
 
 
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index f2036e7d7..57bfee16d 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -11,7 +11,7 @@
 
 #include "DFTElements.h"
 #include "../BitVector.h"
-
+#include "SymmetricUnits.h"
 #include "../../utility/math.h"
 #include "src/utility/macros.h"
 
@@ -230,7 +230,7 @@ namespace storm {
 
             DFTColouring<ValueType> colourDFT() const;
 
-            std::vector<std::vector<size_t>> findSymmetries(DFTColouring<ValueType> const& colouring) const;
+            DFTIndependentSymmetries findSymmetries(DFTColouring<ValueType> const& colouring) const;
 
         private:
             bool elementIndicesCorrect() const {
diff --git a/src/storage/dft/SymmetricUnits.h b/src/storage/dft/SymmetricUnits.h
index 3959593a1..6521ee8d2 100644
--- a/src/storage/dft/SymmetricUnits.h
+++ b/src/storage/dft/SymmetricUnits.h
@@ -1,7 +1,28 @@
-#ifndef SYMMETRICUNITS_H
-#define	SYMMETRICUNITS_H
-
-
-
-#endif	/* SYMMETRICUNITS_H */
+#pragma once
 
+namespace storm {
+    namespace storage {
+        struct DFTIndependentSymmetries {
+            std::map<size_t, std::vector<std::vector<size_t>>> groups;
+            
+            DFTIndependentSymmetries(std::map<size_t, std::vector<std::vector<size_t>>> groups) : groups(groups) {
+                
+            }
+        };
+        
+        inline std::ostream& operator<<(std::ostream& os, DFTIndependentSymmetries const& s)  {
+            for(auto const& cl : s.groups) {
+                std::cout << "SYM GROUP FOR " << cl.first << std::endl;
+                for(auto const& eqClass : cl.second) {
+                    for(auto const& i : eqClass) {
+                        std::cout << i << " ";
+                    }
+                    std::cout << std::endl;
+                }
+            }
+            
+            
+            return os;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index f0da80f0f..49b573f33 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -23,7 +23,8 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     if(symred) {
         std::cout << dft.getElementsString() << std::endl;
         auto colouring = dft.colourDFT();
-        dft.findSymmetries(colouring);
+        auto res = dft.findSymmetries(colouring);
+        std::cout << res;
     }
         
     // Building Markov Automaton

From 2ab4417ed4ff6ad07fcfcc242c0075acd64e657f Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Thu, 18 Feb 2016 21:52:05 +0100
Subject: [PATCH 125/246] symmetry also check deps for roots now

Former-commit-id: a1141250c2dee120e442dc72e42417c19053b055
---
 src/storage/dft/DFT.cpp | 18 +++++++++++++++---
 src/storage/dft/DFT.h   |  2 ++
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 0a90f1513..d56166f60 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -196,8 +196,8 @@ namespace storm {
                         if(!getGate(*it1)->hasOnlyStaticParents()) {
                             continue;
                         }
-                        std::vector<size_t> sortedParent1Ids = getGate(*it1)->parentIds();
-                        std::sort(sortedParent1Ids.begin(), sortedParent1Ids.end());
+                        
+                        std::pair<std::vector<size_t>, std::vector<size_t>> influencedElem1Ids = getSortedParentAndOutDepIds(*it1);
                         auto it2 = it1;
                         for(++it2; it2 != colourClass.second.cend(); ++it2) {
                             if(!getGate(*it2)->hasOnlyStaticParents()) {
@@ -206,7 +206,7 @@ namespace storm {
                             std::vector<size_t> sortedParent2Ids = getGate(*it2)->parentIds();
                             std::sort(sortedParent2Ids.begin(), sortedParent2Ids.end());
                             
-                            if(sortedParent1Ids == sortedParent2Ids) {
+                            if(influencedElem1Ids == getSortedParentAndOutDepIds(*it2)) {
                                 std::cout << "Considering ids " << *it1 << ", " << *it2 << " for isomorphism." << std::endl;
                                 bool isSymmetry = false;
                                 std::vector<size_t> isubdft1 = getGate(*it1)->independentSubDft();
@@ -247,6 +247,18 @@ namespace storm {
             return DFTIndependentSymmetries(res);
         }
 
+        template<typename ValueType>
+        std::pair<std::vector<size_t>, std::vector<size_t>> DFT<ValueType>::getSortedParentAndOutDepIds(size_t index) const {
+            std::pair<std::vector<size_t>, std::vector<size_t>> res;
+            res.first = getElement(index)->parentIds();
+            std::sort(res.first.begin(), res.first.end());
+            for(auto const& dep : getElement(index)->outgoingDependencies()) {
+                res.second.push_back(dep->id());
+            }
+            std::sort(res.second.begin(), res.second.end());
+            return res;
+        }
+        
 
         // Explicitly instantiate the class.
         template class DFT<double>;
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 57bfee16d..1583cc8d5 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -233,6 +233,8 @@ namespace storm {
             DFTIndependentSymmetries findSymmetries(DFTColouring<ValueType> const& colouring) const;
 
         private:
+            std::pair<std::vector<size_t>, std::vector<size_t>> getSortedParentAndOutDepIds(size_t index) const;
+            
             bool elementIndicesCorrect() const {
                 for(size_t i = 0; i < mElements.size(); ++i) {
                     if(mElements[i]->id() != i) return false;

From 0d3687cf5e89d629431d2cb6ed3d530e1d86ef88 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 18 Feb 2016 23:23:00 +0100
Subject: [PATCH 126/246] Refactored and sorted bitvector

Former-commit-id: 28ca00af502f334cbb6a10c03277d3f39b592072
---
 src/builder/ExplicitDFTModelBuilder.cpp |  43 ++++++++-
 src/builder/ExplicitDFTModelBuilder.h   |   8 +-
 src/storage/dft/DFT.cpp                 | 100 ++++++++++++++++++---
 src/storage/dft/DFT.h                   | 115 ++++++++++++++----------
 src/storage/dft/DFTElements.h           |  23 +----
 src/storage/dft/DFTState.cpp            |  72 ++++++++++-----
 src/storage/dft/DFTState.h              |  16 ++--
 7 files changed, 261 insertions(+), 116 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 160535443..91a16f2d2 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -13,11 +13,52 @@ namespace storm {
         ExplicitDFTModelBuilder<ValueType>::ModelComponents::ModelComponents() : transitionMatrix(), stateLabeling(), markovianStates(), exitRates(), choiceLabeling() {
             // Intentionally left empty.
         }
+        
+        template <typename ValueType>
+        ExplicitDFTModelBuilder<ValueType>::ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft) : mDft(dft), mStates(((mDft.stateVectorSize() / 64) + 1) * 64, std::pow(2, mDft.nrBasicElements())) {
+            // stateSize is bound for size of bitvector
+            // 2^nrBE is upper bound for state space
+
+            // Find symmetries
+            // TODO activate
+            // Currently using hack to test
+            std::vector<std::vector<size_t>> symmetries;
+            std::vector<size_t> vecB;
+            std::vector<size_t> vecC;
+            std::vector<size_t> vecD;
+            if (false) {
+                for (size_t i = 0; i < mDft.nrElements(); ++i) {
+                    std::string name = mDft.getElement(i)->name();
+                    size_t id = mDft.getElement(i)->id();
+                    if (boost::starts_with(name, "B")) {
+                        vecB.push_back(id);
+                    } else if (boost::starts_with(name, "C")) {
+                        vecC.push_back(id);
+                    } else if (boost::starts_with(name, "D")) {
+                        vecD.push_back(id);
+                    }
+                }
+                symmetries.push_back(vecB);
+                symmetries.push_back(vecC);
+                symmetries.push_back(vecD);
+                std::cout << "Found the following symmetries:" << std::endl;
+                for (auto const& symmetry : symmetries) {
+                    for (auto const& elem : symmetry) {
+                        std::cout << elem << " -> ";
+                    }
+                    std::cout << std::endl;
+                }
+            } else {
+                vecB.push_back(mDft.getTopLevelIndex());
+            }
+            mStateGenerationInfo = std::make_shared<storm::storage::DFTStateGenerationInfo>(mDft.buildStateGenerationInfo(vecB, symmetries));
+        }
+
 
         template <typename ValueType>
         std::shared_ptr<storm::models::sparse::Model<ValueType>> ExplicitDFTModelBuilder<ValueType>::buildModel() {
             // Initialize
-            DFTStatePointer state = std::make_shared<storm::storage::DFTState<ValueType>>(mDft, newIndex++);
+            DFTStatePointer state = std::make_shared<storm::storage::DFTState<ValueType>>(mDft, *mStateGenerationInfo, newIndex++);
             mStates.findOrAdd(state->status(), state);
 
             std::queue<DFTStatePointer> stateQueue;
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 0b80608cf..eacf2568c 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -44,15 +44,13 @@ namespace storm {
                 boost::optional<std::vector<boost::container::flat_set<uint_fast64_t>>> choiceLabeling;
             };
 
-            storm::storage::DFT<ValueType> const &mDft;
+            storm::storage::DFT<ValueType> const& mDft;
+            std::shared_ptr<storm::storage::DFTStateGenerationInfo> mStateGenerationInfo;
             storm::storage::BitVectorHashMap<DFTStatePointer> mStates;
             size_t newIndex = 0;
 
         public:
-            ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const &dft) : mDft(dft), mStates(((mDft.stateVectorSize() / 64) + 1) * 64, std::pow(2, mDft.nrBasicElements())) {
-                // stateSize is bound for size of bitvector
-                // 2^nrBE is upper bound for state space
-            }
+            ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft);
 
             std::shared_ptr<storm::models::sparse::Model<ValueType>> buildModel();
 
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 9506b29a5..62f7fe704 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -10,15 +10,18 @@ namespace storm {
     namespace storage {
 
         template<typename ValueType>
-        DFT<ValueType>::DFT(DFTElementVector const& elements, DFTElementPointer const& tle) : mElements(elements), mTopLevelIndex(tle->id()), mNrOfBEs(0), mNrOfSpares(0)
-        {
+        DFT<ValueType>::DFT(DFTElementVector const& elements, DFTElementPointer const& tle) : mElements(elements), mNrOfBEs(0), mNrOfSpares(0), mTopLevelIndex(tle->id()) {
             assert(elementIndicesCorrect());
-            mUsageInfoBits = storm::utility::math::uint64_log2(mElements.size()-1)+1;
-            size_t stateIndex = 0;
+            size_t stateVectorIndex = 0;
+            std::set<size_t> tmpRepresentatives;
+            size_t usageInfoBits = storm::utility::math::uint64_log2(mElements.size()-1)+1;
+            size_t nrRepresentatives = 0;
             
             for (auto& elem : mElements) {
-                mIdToFailureIndex.push_back(stateIndex);
-                stateIndex += 2;
+                stateVectorIndex += 2;
+                if (isRepresentative(elem->id())) {
+                    ++nrRepresentatives;
+                }
                 if(elem->isBasicElement()) {
                     ++mNrOfBEs;
                 }
@@ -26,9 +29,7 @@ namespace storm {
                     ++mNrOfSpares;
                     bool firstChild = true;
                     for(auto const& spareReprs : std::static_pointer_cast<DFTSpare<ValueType>>(elem)->children()) {
-                        if(mActivationIndex.count(spareReprs->id()) == 0) {
-                            mActivationIndex[spareReprs->id()] =  stateIndex++;
-                        }
+                        tmpRepresentatives.insert(spareReprs->id());
                         std::set<size_t> module = {spareReprs->id()};
                         spareReprs->extendSpareModule(module);
                         std::vector<size_t> sparesAndBes;
@@ -44,14 +45,13 @@ namespace storm {
                         mSpareModules.insert(std::make_pair(spareReprs->id(), sparesAndBes));
                         firstChild = false;
                     }
-                    std::static_pointer_cast<DFTSpare<ValueType>>(elem)->setUseIndex(stateIndex);
-                    mUsageIndex.insert(std::make_pair(elem->id(), stateIndex));
-                    stateIndex += mUsageInfoBits;
+                    stateVectorIndex += usageInfoBits;
 
                 } else if (elem->isDependency()) {
                     mDependencies.push_back(elem->id());
                 }
             }
+            stateVectorIndex += tmpRepresentatives.size();
 
             // For the top module, we assume, contrary to [Jun15], that we have all spare gates and basic elements which are not in another module.
             std::set<size_t> topModuleSet;
@@ -68,12 +68,84 @@ namespace storm {
                 }
             }
             mTopModule = std::vector<size_t>(topModuleSet.begin(), topModuleSet.end());
-
-            mStateVectorSize = stateIndex;
+            
+            std::cout << tmpRepresentatives.size() << ", " << nrRepresentatives << std::endl;
+            std::cout << stateVectorIndex << ", " << (nrElements() * 2 + mNrOfSpares * usageInfoBits + tmpRepresentatives.size()) << std::endl;
+            assert(tmpRepresentatives.size() == nrRepresentatives);
+            assert(stateVectorIndex == nrElements() * 2 + mNrOfSpares * usageInfoBits + tmpRepresentatives.size());
+            mStateVectorSize = stateVectorIndex;
         }
 
+        template<typename ValueType>
+        DFTStateGenerationInfo DFT<ValueType>::buildStateGenerationInfo(std::vector<size_t> const& subTreeRoots, std::vector<std::vector<size_t>> const& symmetries) const {
+            // Use symmetry
+            // Collect all elements in the first subtree
+            // TODO make recursive to use for nested subtrees
+            
+            DFTStateGenerationInfo generationInfo(nrElements());
+
+            // Perform DFS and insert all elements of subtree sequentially
+            size_t stateIndex = 0;
+            std::queue<size_t> visitQueue;
+            std::set<size_t> visited;
+            visitQueue.push(subTreeRoots[0]);
+            bool consideredDependencies = false;
+            while (true) {
+                while (!visitQueue.empty()) {
+                    size_t id = visitQueue.front();
+                    visitQueue.pop();
+                    if (visited.count(id) == 1) {
+                        // Already visited
+                        continue;
+                    }
+                    visited.insert(id);
+                    DFTElementPointer element = mElements[id];
+                    
+                    // Insert children
+                    if (element->isGate()) {
+                        for (auto const& child : std::static_pointer_cast<DFTGate<ValueType>>(element)->children()) {
+                            visitQueue.push(child->id());
+                        }
+                    }
+                    
+                    // Reserve bits for element
+                    generationInfo.addStateIndex(id, stateIndex);
+                    stateIndex += 2;
+
+                    if (isRepresentative(id)) {
+                        generationInfo.addSpareActivationIndex(id, stateIndex);
+                        ++stateIndex;
+                    }
+
+                    if (element->isSpareGate()) {
+                        generationInfo.addSpareUsageIndex(id, stateIndex);
+                        stateIndex += generationInfo.usageInfoBits();
+                    }
+                    
+                }
+                
+                if (consideredDependencies) {
+                    break;
+                }
+                
+                // Consider dependencies
+                for (size_t idDependency : getDependencies()) {
+                    std::shared_ptr<DFTDependency<ValueType> const> dependency = getDependency(idDependency);
+                    visitQueue.push(dependency->id());
+                    visitQueue.push(dependency->triggerEvent()->id());
+                    visitQueue.push(dependency->dependentEvent()->id());
+                }
+                consideredDependencies = true;
+            }
+            assert(stateIndex = mStateVectorSize);
+
+            STORM_LOG_TRACE(generationInfo);
+            
+            return generationInfo;
         }
 
+
+
         template<typename ValueType>
         std::string DFT<ValueType>::getElementsString() const {
             std::stringstream stream;
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index ca860d074..015f26c7d 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -33,6 +33,69 @@ namespace storm {
         // Forward declarations
         template<typename T> class DFTColouring;
 
+        
+        class DFTStateGenerationInfo {
+        private:
+            const size_t mUsageInfoBits;
+            std::map<size_t, size_t> mSpareUsageIndex; // id spare -> index first bit in state
+            std::map<size_t, size_t> mSpareActivationIndex; // id spare representative -> index in state
+            std::vector<size_t> mIdToStateIndex; // id -> index first bit in state
+            
+        public:
+            
+            DFTStateGenerationInfo(size_t nrElements) : mUsageInfoBits(storm::utility::math::uint64_log2(nrElements-1)+1), mIdToStateIndex(nrElements) {
+            }
+
+            size_t usageInfoBits() const {
+                return mUsageInfoBits;
+            }
+            
+            void addStateIndex(size_t id, size_t index) {
+                assert(id < mIdToStateIndex.size());
+                mIdToStateIndex[id] = index;
+            }
+
+            void addSpareActivationIndex(size_t id, size_t index) {
+                mSpareActivationIndex[id] = index;
+            }
+
+            void addSpareUsageIndex(size_t id, size_t index) {
+                mSpareUsageIndex[id] = index;
+            }
+
+            size_t getStateIndex(size_t id) const {
+                assert(id < mIdToStateIndex.size());
+                return mIdToStateIndex[id];
+            }
+            
+            size_t getSpareUsageIndex(size_t id) const {
+                assert(mSpareUsageIndex.count(id) > 0);
+                return mSpareUsageIndex.at(id);
+            }
+            
+            size_t getSpareActivationIndex(size_t id) const {
+                assert(mSpareActivationIndex.count(id) > 0);
+                return mSpareActivationIndex.at(id);
+            }
+            
+            friend std::ostream& operator<<(std::ostream& os, DFTStateGenerationInfo const& info) {
+                os << "Id to state index:" << std::endl;
+                for (size_t id = 0; id < info.mIdToStateIndex.size(); ++id) {
+                    os << id << " -> " << info.getStateIndex(id) << std::endl;
+                }
+                os << "Spare usage index with usage InfoBits of size " << info.mUsageInfoBits << ":" << std::endl;
+                for (auto pair : info.mSpareUsageIndex) {
+                    os << pair.first << " -> " << pair.second << std::endl;
+                }
+                os << "Spare activation index:" << std::endl;
+                for (auto pair : info.mSpareActivationIndex) {
+                    os << pair.first << " -> " << pair.second << std::endl;
+                }
+                return os;
+            }
+            
+        };
+        
 
         /**
          * Represents a Dynamic Fault Tree
@@ -52,18 +115,17 @@ namespace storm {
             size_t mNrOfBEs;
             size_t mNrOfSpares;
             size_t mTopLevelIndex;
-            size_t mUsageInfoBits;
             size_t mStateVectorSize;
-            std::map<size_t, size_t> mActivationIndex;
             std::map<size_t, std::vector<size_t>> mSpareModules;
             std::vector<size_t> mDependencies;
             std::vector<size_t> mTopModule;
-            std::vector<size_t> mIdToFailureIndex;
-            std::map<size_t, size_t> mUsageIndex;
-            std::map<size_t, size_t> mRepresentants;
+            std::map<size_t, size_t> mRepresentants; // id element -> id representative
+            std::vector<std::vector<size_t>> mSymmetries;
             
         public:
             DFT(DFTElementVector const& elements, DFTElementPointer const& tle);
+            
+            DFTStateGenerationInfo buildStateGenerationInfo(std::vector<size_t> const& subTreeRoots, std::vector<std::vector<size_t>> const& symmetries) const;
 
             size_t stateVectorSize() const {
                 return mStateVectorSize;
@@ -77,34 +139,8 @@ namespace storm {
                 return mNrOfBEs;
             }
             
-            size_t usageInfoBits() const {
-                return mUsageInfoBits;
-            }
-            
-            size_t usageIndex(size_t id) const {
-                assert(mUsageIndex.find(id) != mUsageIndex.end());
-                return mUsageIndex.find(id)->second;
-            }
-            
-            size_t failureIndex(size_t id) const {
-                return mIdToFailureIndex[id];
-            }
-            
-            void initializeUses(DFTState<ValueType>& state) const {
-                for(auto const& elem : mElements) {
-                    if(elem->isSpareGate()) {
-                        std::static_pointer_cast<DFTSpare<ValueType>>(elem)->initializeUses(state);
-                    }
-                }
-            }
-            
-            void initializeActivation(DFTState<ValueType>& state) const {
-                state.activate(mTopLevelIndex);
-                for(auto const& elem : mTopModule) {
-                    if(mElements[elem]->isSpareGate()) {
-                        propagateActivation(state, state.uses(elem));
-                    }
-                }
+            size_t getTopLevelIndex() const {
+                return mTopLevelIndex;
             }
             
             std::vector<size_t> getSpareIndices() const {
@@ -130,15 +166,6 @@ namespace storm {
                 return mDependencies;
             }
 
-            void propagateActivation(DFTState<ValueType>& state, size_t representativeId) const {
-                state.activate(representativeId);
-                for(size_t id : module(representativeId)) {
-                    if(mElements[id]->isSpareGate()) {
-                        propagateActivation(state, state.uses(id));
-                    }
-                }
-            }
-            
             std::vector<size_t> nonColdBEs() const {
                 std::vector<size_t> result;
                 for(DFTElementPointer elem : mElements) {
@@ -170,10 +197,6 @@ namespace storm {
                 return getElement(index)->isDependency();
             }
 
-//            std::shared_ptr<DFTGate<ValueType> const> getGate(size_t index) const {
-//                return
-//            }
-
             std::shared_ptr<DFTBE<ValueType> const> getBasicElement(size_t index) const {
                 assert(isBasicElement(index));
                 return std::static_pointer_cast<DFTBE<ValueType> const>(mElements[index]);
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 36075d005..db407fb85 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -898,10 +898,6 @@ namespace storm {
         template<typename ValueType>
         class DFTSpare : public DFTGate<ValueType> {
 
-        private:
-            size_t mUseIndex;
-            size_t mActiveIndex;
-            
         public:
             DFTSpare(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
                     DFTGate<ValueType>(id, name, children)
@@ -919,24 +915,11 @@ namespace storm {
                 return true;
             }
             
-            void setUseIndex(size_t useIndex) {
-                mUseIndex = useIndex; 
-            }
-            
-            void setActiveIndex(size_t activeIndex) {
-                mActiveIndex = activeIndex;
-            }
-
-            void initializeUses(storm::storage::DFTState<ValueType>& state) {
-                assert(this->mChildren.size() > 0);
-                state.setUsesAtPosition(mUseIndex, this->mChildren[0]->id());
-            }
-
             void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 if(state.isOperational(this->mId)) {
-                    size_t uses = state.extractUses(mUseIndex);
+                    size_t uses = state.uses(this->mId);
                     if(!state.isOperational(uses)) {
-                        bool claimingSuccessful = state.claimNew(this->mId, mUseIndex, uses, this->mChildren);
+                        bool claimingSuccessful = state.claimNew(this->mId, uses, this->mChildren);
                         if(!claimingSuccessful) {
                             this->fail(state, queues);
                         }
@@ -946,7 +929,7 @@ namespace storm {
 
             void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 if(state.isOperational(this->mId)) {
-                    if(state.isFailsafe(state.extractUses((mUseIndex)))) {
+                    if(state.isFailsafe(state.uses(this->mId))) {
                         this->failsafe(state, queues);
                         this->childrenDontCare(state, queues);
                     }
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 7e8429fdd..c3f7c9f32 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -6,10 +6,25 @@ namespace storm {
     namespace storage {
 
         template<typename ValueType>
-        DFTState<ValueType>::DFTState(DFT<ValueType> const& dft, size_t id) : mStatus(dft.stateVectorSize()), mId(id), mDft(dft)  {
+        DFTState<ValueType>::DFTState(DFT<ValueType> const& dft, DFTStateGenerationInfo const& stateGenerationInfo, size_t id) : mStatus(dft.stateVectorSize()), mId(id), mDft(dft), mStateGenerationInfo(stateGenerationInfo)  {
             mInactiveSpares = dft.getSpareIndices();
-            dft.initializeUses(*this);
-            dft.initializeActivation(*this);
+            
+            // Initialize uses
+            for(size_t id  : mDft.getSpareIndices()) {
+                std::shared_ptr<DFTGate<ValueType> const> elem = mDft.getGate(id);
+                assert(elem->isSpareGate());
+                assert(elem->nrChildren() > 0);
+                this->setUses(id, elem->children()[0]->id());
+            }
+            
+            // Initialize activation
+            this->activate(mDft.getTopLevelIndex());
+            for(auto const& id : mDft.module(mDft.getTopLevelIndex())) {
+                if(mDft.getElement(id)->isSpareGate()) {
+                    propagateActivation(uses(id));
+                }
+            }
+
             std::vector<size_t> alwaysActiveBEs = dft.nonColdBEs();
             mIsCurrentlyFailableBE.insert(mIsCurrentlyFailableBE.end(), alwaysActiveBEs.begin(), alwaysActiveBEs.end());
         }
@@ -26,7 +41,7 @@ namespace storm {
 
         template<typename ValueType>
         int DFTState<ValueType>::getElementStateInt(size_t id) const {
-            return mStatus.getAsInt(mDft.failureIndex(id), 2);
+            return mStatus.getAsInt(mStateGenerationInfo.getStateIndex(id), 2);
         }
 
         template<typename ValueType>
@@ -46,12 +61,12 @@ namespace storm {
 
         template<typename ValueType>
         bool DFTState<ValueType>::hasFailed(size_t id) const {
-            return mStatus[mDft.failureIndex(id)];
+            return mStatus[mStateGenerationInfo.getStateIndex(id)];
         }
 
         template<typename ValueType>
         bool DFTState<ValueType>::isFailsafe(size_t id) const {
-            return mStatus[mDft.failureIndex(id)+1];
+            return mStatus[mStateGenerationInfo.getStateIndex(id)+1];
         }
 
         template<typename ValueType>
@@ -66,38 +81,38 @@ namespace storm {
         
         template<typename ValueType>
         bool DFTState<ValueType>::dependencySuccessful(size_t id) const {
-            return mStatus[mDft.failureIndex(id)];
+            return mStatus[mStateGenerationInfo.getStateIndex(id)];
         }
         template<typename ValueType>
         bool DFTState<ValueType>::dependencyUnsuccessful(size_t id) const {
-            return mStatus[mDft.failureIndex(id)+1];
+            return mStatus[mStateGenerationInfo.getStateIndex(id)+1];
         }
 
         template<typename ValueType>
         void DFTState<ValueType>::setFailed(size_t id) {
-            mStatus.set(mDft.failureIndex(id));
+            mStatus.set(mStateGenerationInfo.getStateIndex(id));
         }
 
         template<typename ValueType>
         void DFTState<ValueType>::setFailsafe(size_t id) {
-            mStatus.set(mDft.failureIndex(id)+1);
+            mStatus.set(mStateGenerationInfo.getStateIndex(id)+1);
         }
 
         template<typename ValueType>
         void DFTState<ValueType>::setDontCare(size_t id) {
-            mStatus.setFromInt(mDft.failureIndex(id), 2, static_cast<uint_fast64_t>(DFTElementState::DontCare) );
+            mStatus.setFromInt(mStateGenerationInfo.getStateIndex(id), 2, static_cast<uint_fast64_t>(DFTElementState::DontCare) );
         }
         
         template<typename ValueType>
         void DFTState<ValueType>::setDependencySuccessful(size_t id) {
             // No distinction between successful dependency and no dependency at all
-            // -> we do not set bit
-            //mStatus.set(mDft.failureIndex(id));
+            // => we do not set bit
+            //mStatus.set(mStateGenerationInfo.mIdToStateIndex(id));
         }
 
         template<typename ValueType>
         void DFTState<ValueType>::setDependencyUnsuccessful(size_t id) {
-            mStatus.set(mDft.failureIndex(id)+1);
+            mStatus.set(mStateGenerationInfo.getStateIndex(id)+1);
         }
 
         template<typename ValueType>
@@ -157,8 +172,7 @@ namespace storm {
 
         template<typename ValueType>
         void DFTState<ValueType>::activate(size_t repr) {
-            std::vector<size_t>  const& module = mDft.module(repr);
-            for(size_t elem : module) {
+            for(size_t elem : mDft.module(repr)) {
                 if(mDft.getElement(elem)->isColdBasicElement() && isOperational(elem)) {
                     mIsCurrentlyFailableBE.push_back(elem);
                 }
@@ -174,16 +188,26 @@ namespace storm {
             assert(mDft.getElement(id)->isSpareGate());
             return (std::find(mInactiveSpares.begin(), mInactiveSpares.end(), id) == mInactiveSpares.end());
         }
+            
+        template<typename ValueType>
+        void DFTState<ValueType>::propagateActivation(size_t representativeId) {
+            activate(representativeId);
+            for(size_t id : mDft.module(representativeId)) {
+                if(mDft.getElement(id)->isSpareGate()) {
+                    propagateActivation(uses(id));
+                }
+            }
+        }
 
         template<typename ValueType>
         uint_fast64_t DFTState<ValueType>::uses(size_t id) const {
-            return extractUses(mDft.usageIndex(id));
+            return extractUses(mStateGenerationInfo.getSpareUsageIndex(id));
         }
 
         template<typename ValueType>
         uint_fast64_t DFTState<ValueType>::extractUses(size_t from) const {
-            assert(mDft.usageInfoBits() < 64);
-            return mStatus.getAsInt(from, mDft.usageInfoBits());
+            assert(mStateGenerationInfo.usageInfoBits() < 64);
+            return mStatus.getAsInt(from, mStateGenerationInfo.usageInfoBits());
         }
 
         template<typename ValueType>
@@ -192,13 +216,13 @@ namespace storm {
         }
 
         template<typename ValueType>
-        void DFTState<ValueType>::setUsesAtPosition(size_t usageIndex, size_t child) {
-            mStatus.setFromInt(usageIndex, mDft.usageInfoBits(), child);
+        void DFTState<ValueType>::setUses(size_t spareId, size_t child) {
+            mStatus.setFromInt(mStateGenerationInfo.getSpareUsageIndex(spareId), mStateGenerationInfo.usageInfoBits(), child);
             mUsedRepresentants.push_back(child);
         }
 
         template<typename ValueType>
-        bool DFTState<ValueType>::claimNew(size_t spareId, size_t usageIndex, size_t currentlyUses, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children) {
+        bool DFTState<ValueType>::claimNew(size_t spareId, size_t currentlyUses, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children) {
             auto it = children.begin();
             while ((*it)->id() != currentlyUses) {
                 assert(it != children.end());
@@ -208,9 +232,9 @@ namespace storm {
             while(it != children.end()) {
                 size_t childId = (*it)->id();
                 if(!hasFailed(childId) && !isUsed(childId)) {
-                    setUsesAtPosition(usageIndex, childId);
+                    setUses(spareId, childId);
                     if(isActiveSpare(spareId)) {
-                        mDft.propagateActivation(*this, childId);
+                        propagateActivation(childId);
                     }
                     return true;
                 }
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 450953bd7..fcbcdc62d 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -17,6 +17,7 @@ namespace storm {
         class DFTBE;
         template<typename ValueType>
         class DFTElement;
+        class DFTStateGenerationInfo;
 
         template<typename ValueType>
         class DFTState {
@@ -31,9 +32,10 @@ namespace storm {
             std::vector<size_t> mUsedRepresentants;
             bool mValid = true;
             const DFT<ValueType>& mDft;
+            const DFTStateGenerationInfo& mStateGenerationInfo;
             
         public:
-            DFTState(DFT<ValueType> const& dft, size_t id);
+            DFTState(DFT<ValueType> const& dft, DFTStateGenerationInfo const& stateGenerationInfo, size_t id);
             
             DFTElementState getElementState(size_t id) const;
             
@@ -75,6 +77,8 @@ namespace storm {
             
             bool isActiveSpare(size_t id) const;
             
+            void propagateActivation(size_t representativeId);
+            
             void markAsInvalid() {
                 mValid = false;
             }
@@ -109,13 +113,13 @@ namespace storm {
             bool isUsed(size_t child) const;
             
             /**
-             * Sets to to the usageIndex which child is now used.
-             * @param usageIndex 
-             * @param child
+             * Sets for the spare which child is now used.
+             * @param spareId Id of the spare
+             * @param child Id of the child which is now used
              */
-            void setUsesAtPosition(size_t usageIndex, size_t child);
+            void setUses(size_t spareId, size_t child);
             
-            bool claimNew(size_t spareId, size_t usageIndex, size_t currentlyUses, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children);
+            bool claimNew(size_t spareId, size_t currentlyUses, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children);
             
             bool hasOutgoingEdges() const {
                 return !mIsCurrentlyFailableBE.empty();

From a89a728f6d41e7cea80e77301e53da901adffe8d Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 18 Feb 2016 23:28:35 +0100
Subject: [PATCH 127/246] Moved benchmark script to SVN

Former-commit-id: 92c39188e787522038ae542a6782c7d54762b657
---
 benchmark_dft.py | 136 -----------------------------------------------
 1 file changed, 136 deletions(-)
 delete mode 100644 benchmark_dft.py

diff --git a/benchmark_dft.py b/benchmark_dft.py
deleted file mode 100644
index 6f25e08ed..000000000
--- a/benchmark_dft.py
+++ /dev/null
@@ -1,136 +0,0 @@
-import os
-import os.path
-import sys
-import subprocess
-import re
-import time
-import argparse
-
-DIR=os.getcwd()
-STORM_PATH=os.path.join(DIR, "build/src/storm-dft")
-EXAMPLE_DIR=os.path.join(DIR, "examples/dft/")
-
-benchmarks = [ 
-    ("and", False, [3, 1]),
-    ("and_param", True, ["(4*x^2+2*x+1)/((x) * (2*x+1))", "1"]),
-    ("cardiac", False, [8597.360004, 1]),
-    ("cas", False, [0.859736, 1]),
-    ("cm2", False, [0.256272, 1]),
-    #("cm4", False, [0.338225, 1]), # big
-    ("cps", False, ["inf", 0.333333]),
-    #("deathegg", False, [24.642857, 1]), # contains fdep to gate
-    #("fdep", False, [0.666667, 1]), # contains fdep to two elements
-    ("fdep2", False, [2, 1]),
-    ("fdep3", False, [2.5, 1]),
-    #("ftpp_complex", False, [0, 1]), # Compute
-    #("ftpp_large", False, [0, 1]), # Compute
-    #("ftpp_standard", False, [0, 1]), # Compute
-    ("mdcs", False, [2.85414, 1]),
-    ("mdcs2", False, [2.85414, 1]),
-    ("mp", False, [1.66667, 1]),
-    ("or", False, [1, 1]),
-    ("pand", False, ["inf", 0.666667]),
-    ("pand_param", True, ["-1", "(x)/(y+x)"]),
-    ("pdep", False, [2.66667, 1]),
-    #("pdep2", False, [0, 1]), #Compute # contains pdep to two elements
-    ("pdep3", False, [2.79167, 1]),
-    ("spare", False, [3.53846, 1]),
-    ("spare2", False, [1.86957, 1]),
-    ("spare3", False, [1.27273, 1]),
-    ("spare4", False, [4.8459, 1]),
-    ("spare5", False, [2.66667, 1]),
-    ("spare6", False, [1.4, 1]),
-    ("spare7", False, [3.67333, 1]),
-    ("symmetry", False, [4.16667, 1]),
-    ("symmetry2", False, [3.06111, 1]),
-    ("tripple_and1", False, [4.16667, 1]),
-    ("tripple_and2", False, [3.66667, 1]),
-    ("tripple_and2_c", False, [3.6667, 1]),
-    ("tripple_and_c", False, [4.16667, 1]),
-    ("tripple_or", False, [0.5, 1]),
-    ("tripple_or2", False, [0.666667, 1]),
-    ("tripple_or2_c", False, [0.66667, 1]),
-    ("tripple_or_c", False, [0.5, 1]),
-    ("tripple_pand", False, ["inf", 0.0416667]),
-    ("tripple_pand2", False, ["inf", 0.166667]),
-    ("tripple_pand2_c", False, ["inf", 0.166667]),
-    ("tripple_pand_c", False, ["inf", 0.0416667]),
-    ("voting", False, [1.66667, 1]),
-    ("voting2", False, [0.588235, 1])
-]
-
-def run_storm_dft(filename, prop, parametric, quiet):
-    # Run storm-dft on filename and return result
-    dft_file = os.path.join(EXAMPLE_DIR, filename + ".dft")
-    args = [STORM_PATH,
-            dft_file,
-            prop]
-    if parametric:
-        args.append('--parametric')
-
-    output = run_tool(args, quiet)
-    # Get result
-    match = re.search(r'Result: \[(.*)\]', output)
-    if not match:
-        return None
-    
-    result = match.group(1)
-    return result
-
-def run_tool(args, quiet=False):
-    """
-    Executes a process,
-    :returns: the `stdout`
-    """
-    pipe = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-    result = "";
-    for line in iter(pipe.stdout.readline, ""):
-        if not line and pipe.poll() is not None:
-            break
-        output = line.decode(encoding='UTF-8').rstrip()
-        if output != "":
-            if  not quiet:
-                print("\t * " + output)
-            result = output
-    return result
-
-def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
-    if a == b:
-        return True
-    return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description='Benchmarking DFTs via Storm')
-    parser.add_argument('--debuglevel', type=int, default=0, help='the debug level (0=silent, 1=print benchmarks, 2=print output from storm')
-    args = parser.parse_args()
-    count = 0
-    correct = 0
-    properties = ['--expectedtime', '--probability']
-    start = time.time()
-    for index, prop in enumerate(properties):
-        for (benchmark, parametric, result_original) in benchmarks:
-            expected_result = result_original[index]
-            # Run benchmark and check result
-            count += 1;
-            if args.debuglevel > 0:
-                print("Running '{}' with property '{}'".format(benchmark, prop))
-            result = run_storm_dft(benchmark, prop, parametric, args.debuglevel<2)
-            if result is None:
-                print("Error occurred on example '{}' with property '{}'".format(benchmark, prop))
-                continue
-
-            if not parametric:
-                # Float
-                result = float(result)
-                if not isclose(result, float(expected_result), rel_tol=1e-05):
-                    print("Wrong result on example '{}' with property '{}': result: {}, Expected: {}".format(benchmark, prop, result, expected_result))
-                else:
-                    correct += 1
-            else:
-                # Parametric
-                if result != expected_result:
-                    print("Wrong result on example '{}' with property '{}': result: {}, Expected: {}".format(benchmark, prop, result, expected_result))
-                else:
-                    correct += 1
-    end = time.time()
-    print("Correct results for {} of {} DFT checks in {}s".format(correct, count, end-start))

From 689acfa28b80fcf9933d99ccc05931ace6b51412 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 19 Feb 2016 09:29:22 +0100
Subject: [PATCH 128/246] Removed debug assertions

Former-commit-id: a25b569e58427e70dd1054a9c4583850c998897e
---
 src/storage/dft/DFT.cpp | 16 +++-------------
 1 file changed, 3 insertions(+), 13 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 36733eb51..c53f711e4 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -13,13 +13,9 @@ namespace storm {
         template<typename ValueType>
         DFT<ValueType>::DFT(DFTElementVector const& elements, DFTElementPointer const& tle) : mElements(elements), mNrOfBEs(0), mNrOfSpares(0), mTopLevelIndex(tle->id()) {
             assert(elementIndicesCorrect());
-            size_t stateVectorIndex = 0;
-            std::set<size_t> tmpRepresentatives;
-            size_t usageInfoBits = storm::utility::math::uint64_log2(mElements.size()-1)+1;
             size_t nrRepresentatives = 0;
             
             for (auto& elem : mElements) {
-                stateVectorIndex += 2;
                 if (isRepresentative(elem->id())) {
                     ++nrRepresentatives;
                 }
@@ -30,7 +26,6 @@ namespace storm {
                     ++mNrOfSpares;
                     bool firstChild = true;
                     for(auto const& spareReprs : std::static_pointer_cast<DFTSpare<ValueType>>(elem)->children()) {
-                        tmpRepresentatives.insert(spareReprs->id());
                         std::set<size_t> module = {spareReprs->id()};
                         spareReprs->extendSpareModule(module);
                         std::vector<size_t> sparesAndBes;
@@ -46,14 +41,12 @@ namespace storm {
                         mSpareModules.insert(std::make_pair(spareReprs->id(), sparesAndBes));
                         firstChild = false;
                     }
-                    stateVectorIndex += usageInfoBits;
 
                 } else if (elem->isDependency()) {
                     mDependencies.push_back(elem->id());
                 }
             }
-            stateVectorIndex += tmpRepresentatives.size();
-
+          
             // For the top module, we assume, contrary to [Jun15], that we have all spare gates and basic elements which are not in another module.
             std::set<size_t> topModuleSet;
             // Initialize with all ids.
@@ -70,11 +63,8 @@ namespace storm {
             }
             mTopModule = std::vector<size_t>(topModuleSet.begin(), topModuleSet.end());
             
-            std::cout << tmpRepresentatives.size() << ", " << nrRepresentatives << std::endl;
-            std::cout << stateVectorIndex << ", " << (nrElements() * 2 + mNrOfSpares * usageInfoBits + tmpRepresentatives.size()) << std::endl;
-            assert(tmpRepresentatives.size() == nrRepresentatives);
-            assert(stateVectorIndex == nrElements() * 2 + mNrOfSpares * usageInfoBits + tmpRepresentatives.size());
-            mStateVectorSize = stateVectorIndex;
+            size_t usageInfoBits = storm::utility::math::uint64_log2(mElements.size()-1)+1;
+            mStateVectorSize = nrElements() * 2 + mNrOfSpares * usageInfoBits + nrRepresentatives;
         }
 
         template<typename ValueType>

From b8ff542b7b9ada840b2b9f55ee656cb5b218fcaf Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 19 Feb 2016 09:47:03 +0100
Subject: [PATCH 129/246] One conversion less for MA

Former-commit-id: d0b47adf9ba64252bb0c3418d7a4df84f5f9abf2
---
 src/builder/ExplicitDFTModelBuilder.cpp | 24 ++++++++++++------------
 src/models/sparse/MarkovAutomaton.cpp   | 13 +++++++++++++
 src/models/sparse/MarkovAutomaton.h     | 19 +++++++++++++++++++
 3 files changed, 44 insertions(+), 12 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 91a16f2d2..a7284cb9c 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -114,22 +114,22 @@ namespace storm {
             }
 
             std::shared_ptr<storm::models::sparse::Model<ValueType>> model;
-            // Turn the probabilities into rates by multiplying each row with the exit rate of the state.
-            // TODO Matthias: avoid transforming back and forth
-            storm::storage::SparseMatrix<ValueType> rateMatrix(modelComponents.transitionMatrix);
-            for (uint_fast64_t row = 0; row < rateMatrix.getRowCount(); ++row) {
-                assert(row < modelComponents.markovianStates.size());
-                if (modelComponents.markovianStates.get(row)) {
-                    for (auto& entry : rateMatrix.getRow(row)) {
-                        entry.setValue(entry.getValue() * modelComponents.exitRates[row]);
-                    }
-                }
-            }
             
             if (deterministic) {
+                // Turn the probabilities into rates by multiplying each row with the exit rate of the state.
+                // TODO Matthias: avoid transforming back and forth
+                storm::storage::SparseMatrix<ValueType> rateMatrix(modelComponents.transitionMatrix);
+                for (uint_fast64_t row = 0; row < rateMatrix.getRowCount(); ++row) {
+                    assert(row < modelComponents.markovianStates.size());
+                    if (modelComponents.markovianStates.get(row)) {
+                        for (auto& entry : rateMatrix.getRow(row)) {
+                            entry.setValue(entry.getValue() * modelComponents.exitRates[row]);
+                        }
+                    }
+                }
                 model = std::make_shared<storm::models::sparse::Ctmc<ValueType>>(std::move(rateMatrix), std::move(modelComponents.stateLabeling));
             } else {
-                model = std::make_shared<storm::models::sparse::MarkovAutomaton<ValueType>>(std::move(rateMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.markovianStates), std::move(modelComponents.exitRates));
+                model = std::make_shared<storm::models::sparse::MarkovAutomaton<ValueType>>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.markovianStates), std::move(modelComponents.exitRates), true);
             }
             
             model->printModelInformationToStream(std::cout);
diff --git a/src/models/sparse/MarkovAutomaton.cpp b/src/models/sparse/MarkovAutomaton.cpp
index c757af1a0..8276f519d 100644
--- a/src/models/sparse/MarkovAutomaton.cpp
+++ b/src/models/sparse/MarkovAutomaton.cpp
@@ -34,6 +34,19 @@ namespace storm {
                 this->turnRatesToProbabilities();
             }
             
+            template <typename ValueType, typename RewardModelType>
+            MarkovAutomaton<ValueType, RewardModelType>::MarkovAutomaton(storm::storage::SparseMatrix<ValueType>&& transitionMatrix,
+                                                                         storm::models::sparse::StateLabeling&& stateLabeling,
+                                                                         storm::storage::BitVector const& markovianStates,
+                                                                         std::vector<ValueType> const& exitRates,
+                                                                         bool probabilities,
+                                                                         std::unordered_map<std::string, RewardModelType>&& rewardModels,
+                                                                         boost::optional<std::vector<LabelSet>>&& optionalChoiceLabeling)
+            : NondeterministicModel<ValueType, RewardModelType>(storm::models::ModelType::MarkovAutomaton, std::move(transitionMatrix), std::move(stateLabeling), std::move(rewardModels), std::move(optionalChoiceLabeling)), markovianStates(markovianStates), exitRates(std::move(exitRates)), closed(false) {
+                assert(probabilities);
+                assert(this->getTransitionMatrix().isProbabilistic());
+            }
+            
             template <typename ValueType, typename RewardModelType>
             bool MarkovAutomaton<ValueType, RewardModelType>::isClosed() const {
                 return closed;
diff --git a/src/models/sparse/MarkovAutomaton.h b/src/models/sparse/MarkovAutomaton.h
index ed807ab84..e335f5050 100644
--- a/src/models/sparse/MarkovAutomaton.h
+++ b/src/models/sparse/MarkovAutomaton.h
@@ -49,6 +49,25 @@ namespace storm {
                                 std::unordered_map<std::string, RewardModelType>&& rewardModels = std::unordered_map<std::string, RewardModelType>(),
                                 boost::optional<std::vector<LabelSet>>&& optionalChoiceLabeling = boost::optional<std::vector<LabelSet>>());
                 
+                /*!
+                 * Constructs a model by moving the given data.
+                 *
+                 * @param transitionMatrix The matrix representing the transitions in the model in terms of rates.
+                 * @param stateLabeling The labeling of the states.
+                 * @param markovianStates A bit vector indicating the Markovian states of the automaton.
+                 * @param exitRates A vector storing the exit rates of the states.
+                 * @param rewardModels A mapping of reward model names to reward models.
+                 * @param optionalChoiceLabeling A vector that represents the labels associated with the choices of each state.
+                 * @param probabilities Flag if transitions matrix contains probabilities or rates
+                 */
+                MarkovAutomaton(storm::storage::SparseMatrix<ValueType>&& transitionMatrix,
+                                storm::models::sparse::StateLabeling&& stateLabeling,
+                                storm::storage::BitVector const& markovianStates,
+                                std::vector<ValueType> const& exitRates,
+                                bool probabilities,
+                                std::unordered_map<std::string, RewardModelType>&& rewardModels = std::unordered_map<std::string, RewardModelType>(),
+                                boost::optional<std::vector<LabelSet>>&& optionalChoiceLabeling = boost::optional<std::vector<LabelSet>>());
+                
                 MarkovAutomaton(MarkovAutomaton<ValueType, RewardModelType> const& other) = default;
                 MarkovAutomaton& operator=(MarkovAutomaton<ValueType, RewardModelType> const& other) = default;
                 

From 99c87182e4f2da4f1b341bc3628cc9a2ef70904f Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 19 Feb 2016 11:10:06 +0100
Subject: [PATCH 130/246] Fixed missing include for gcc

Former-commit-id: 3cf040d87ccef51985901d4f1104dc04ac944655
---
 src/solver/AbstractEquationSolver.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/solver/AbstractEquationSolver.h b/src/solver/AbstractEquationSolver.h
index 904e459bd..491570637 100644
--- a/src/solver/AbstractEquationSolver.h
+++ b/src/solver/AbstractEquationSolver.h
@@ -2,6 +2,7 @@
 #define STORM_SOLVER_ABSTRACTEQUATIONSOLVER_H_
 
 #include "src/solver/TerminationCondition.h"
+#include <memory>
 
 namespace storm {
     namespace solver {
@@ -50,4 +51,4 @@ namespace storm {
     }
 }
 
-#endif /* STORM_SOLVER_ABSTRACTEQUATIONSOLVER_H_ */
\ No newline at end of file
+#endif /* STORM_SOLVER_ABSTRACTEQUATIONSOLVER_H_ */

From 3f70a69d6e453f77094cb4ec0e00cdf6b8174a23 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 19 Feb 2016 11:15:17 +0100
Subject: [PATCH 131/246] Added argument for timebound

Former-commit-id: 22a83eae6eaf0630e87a483dbaf180a445687a7a
---
 src/storm-dyftee.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 49b573f33..fa4047dd6 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -6,6 +6,8 @@
 #include "utility/storm.h"
 #include "storage/dft/DFTIsomorphism.h"
 
+#include <boost/lexical_cast.hpp>
+
 /*!
  * Load DFT from filename, build corresponding Model and check against given property.
  *
@@ -74,6 +76,20 @@ int main(int argc, char** argv) {
         } else if (option == "--probability") {
             assert(pctlFormula.empty());
             pctlFormula = "P=? [F \"failed\"]";
+        } else if (option == "--timebound") {
+            assert(pctlFormula.empty());
+            ++i;
+            assert(i < argc);
+            double timeBound;
+            try {
+                timeBound = boost::lexical_cast<double>(argv[i]);
+            } catch (boost::bad_lexical_cast e) {
+                std::cerr << "The time bound '" << argv[i] << "' is not valid." << std::endl;
+                return 2;
+            }
+            std::stringstream stream;
+            stream << "P=? [F<=" << timeBound << " \"failed\"]";
+            pctlFormula = stream.str();
         } else if (option == "--trace") {
             level = log4cplus::TRACE_LOG_LEVEL;
         } else if (option == "--debug") {

From e12ac3624902fe969fd3b18bfc06bee02f665e7a Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 19 Feb 2016 11:41:34 +0100
Subject: [PATCH 132/246] Fixed problem with usageInfoBits for only one element

Former-commit-id: ac52fff2d7808a2e952252aee3c5f0da88086643
---
 src/storage/dft/DFT.cpp | 2 +-
 src/storage/dft/DFT.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index c53f711e4..654fb269e 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -63,7 +63,7 @@ namespace storm {
             }
             mTopModule = std::vector<size_t>(topModuleSet.begin(), topModuleSet.end());
             
-            size_t usageInfoBits = storm::utility::math::uint64_log2(mElements.size()-1)+1;
+            size_t usageInfoBits = mElements.size() > 1 ? storm::utility::math::uint64_log2(mElements.size()-1) + 1 : 1;
             mStateVectorSize = nrElements() * 2 + mNrOfSpares * usageInfoBits + nrRepresentatives;
         }
 
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 07403fd33..0cedfbfa7 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -43,7 +43,7 @@ namespace storm {
             
         public:
             
-            DFTStateGenerationInfo(size_t nrElements) : mUsageInfoBits(storm::utility::math::uint64_log2(nrElements-1)+1), mIdToStateIndex(nrElements) {
+            DFTStateGenerationInfo(size_t nrElements) : mUsageInfoBits(nrElements > 1 ? storm::utility::math::uint64_log2(nrElements-1) + 1 : 1), mIdToStateIndex(nrElements) {
             }
 
             size_t usageInfoBits() const {

From 20242e10e50e599da04e689e477628f1f10ce291 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 19 Feb 2016 13:08:37 +0100
Subject: [PATCH 133/246] Small fix

Former-commit-id: d702592ab208db0e618a599af680b27e1e71f556
---
 src/storm-dyftee.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index fa4047dd6..7b7cea029 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -25,8 +25,8 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     if(symred) {
         std::cout << dft.getElementsString() << std::endl;
         auto colouring = dft.colourDFT();
-        auto res = dft.findSymmetries(colouring);
-        std::cout << res;
+        storm::storage::DFTIndependentSymmetries symmetries = dft.findSymmetries(colouring);
+        std::cout << symmetries;
     }
         
     // Building Markov Automaton

From c25889bc3ee94876c329eafb26fcdcb0e61179ed Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 19 Feb 2016 13:57:38 +0100
Subject: [PATCH 134/246] minor

Former-commit-id: 1a746c86f203a21c3b613850c556af7a28f56cf6
---
 src/storage/dft/DFT.cpp       | 10 ++++++++++
 src/storage/dft/DFT.h         |  1 +
 src/storage/dft/DFTElements.h |  2 ++
 3 files changed, 13 insertions(+)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index d56166f60..a52cf8984 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -172,11 +172,21 @@ namespace storm {
             return ISD;
         }
 
+        template<typename ValueType>
+        std::vector<size_t> DFT<ValueType>::immediateFailureCauses(size_t index) const {
+            if(isGate(index)) {
+
+            } else {
+                return {index};
+            }
+        }
+
         template<typename ValueType>
         DFTColouring<ValueType> DFT<ValueType>::colourDFT() const {
             return DFTColouring<ValueType>(*this);
         }
 
+
         template<typename ValueType>
         DFTIndependentSymmetries DFT<ValueType>::findSymmetries(DFTColouring<ValueType> const& colouring) const {
             std::vector<size_t> vec;
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 1583cc8d5..61f286619 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -232,6 +232,7 @@ namespace storm {
 
             DFTIndependentSymmetries findSymmetries(DFTColouring<ValueType> const& colouring) const;
 
+            std::vector<size_t> immediateFailureCauses(size_t index) const;
         private:
             std::pair<std::vector<size_t>, std::vector<size_t>> getSortedParentAndOutDepIds(size_t index) const;
             
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index c352bd38e..1a3c5b512 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -173,6 +173,8 @@ namespace storm {
             }
             
             virtual void extendSpareModule(std::set<size_t>& elementsInModule) const;
+
+           // virtual void extendImmediateFailureCausePathEvents(std::set<size_t>& ) const;
             
             virtual size_t nrChildren() const = 0;
 

From 102602dea251e76a5247c367401717030718752e Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 19 Feb 2016 15:29:27 +0100
Subject: [PATCH 135/246] some refactoring

Former-commit-id: 90be99f04d7736718e19986a2d02d9815813e889
---
 src/builder/ExplicitDFTModelBuilder.cpp | 29 ++++++++++++++++++-------
 src/builder/ExplicitDFTModelBuilder.h   | 10 ++++++++-
 src/storm-dyftee.cpp                    |  3 ++-
 src/utility/storm.h                     | 21 ++++++++++--------
 4 files changed, 44 insertions(+), 19 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index a7284cb9c..08b6f4026 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -56,7 +56,7 @@ namespace storm {
 
 
         template <typename ValueType>
-        std::shared_ptr<storm::models::sparse::Model<ValueType>> ExplicitDFTModelBuilder<ValueType>::buildModel() {
+        std::shared_ptr<storm::models::sparse::Model<ValueType>> ExplicitDFTModelBuilder<ValueType>::buildModel(LabelOptions const& labelOpts) {
             // Initialize
             DFTStatePointer state = std::make_shared<storm::storage::DFTState<ValueType>>(mDft, *mStateGenerationInfo, newIndex++);
             mStates.findOrAdd(state->status(), state);
@@ -89,25 +89,32 @@ namespace storm {
             modelComponents.stateLabeling.addLabel("init");
             modelComponents.stateLabeling.addLabelToState("init", 0);
             // Label all states corresponding to their status (failed, failsafe, failed BE)
-            modelComponents.stateLabeling.addLabel("failed");
-            modelComponents.stateLabeling.addLabel("failsafe");
+            if(labelOpts.buildFailLabel) {
+                modelComponents.stateLabeling.addLabel("failed");
+            } 
+            if(labelOpts.buildFailSafeLabel) {
+                modelComponents.stateLabeling.addLabel("failsafe");
+            }
+            
             // Collect labels for all BE
             std::vector<std::shared_ptr<storage::DFTBE<ValueType>>> basicElements = mDft.getBasicElements();
             for (std::shared_ptr<storage::DFTBE<ValueType>> elem : basicElements) {
-                modelComponents.stateLabeling.addLabel(elem->name() + "_fail");
+                if(labelOpts.beLabels.count(elem->name()) > 0) {
+                    modelComponents.stateLabeling.addLabel(elem->name() + "_fail");
+                }
             }
 
             for (auto const& stateVectorPair : mStates) {
                 DFTStatePointer state = stateVectorPair.second;
-                if (mDft.hasFailed(state)) {
+                if (labelOpts.buildFailLabel && mDft.hasFailed(state)) {
                     modelComponents.stateLabeling.addLabelToState("failed", state->getId());
                 }
-                if (mDft.isFailsafe(state)) {
+                if (labelOpts.buildFailSafeLabel && mDft.isFailsafe(state)) {
                     modelComponents.stateLabeling.addLabelToState("failsafe", state->getId());
                 };
                 // Set fail status for each BE
                 for (std::shared_ptr<storage::DFTBE<ValueType>> elem : basicElements) {
-                    if (state->hasFailed(elem->id())) {
+                    if (labelOpts.beLabels.count(elem->name()) > 0 && state->hasFailed(elem->id()) ) {
                         modelComponents.stateLabeling.addLabelToState(elem->name() + "_fail", state->getId());
                     }
                 }
@@ -129,7 +136,13 @@ namespace storm {
                 }
                 model = std::make_shared<storm::models::sparse::Ctmc<ValueType>>(std::move(rateMatrix), std::move(modelComponents.stateLabeling));
             } else {
-                model = std::make_shared<storm::models::sparse::MarkovAutomaton<ValueType>>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.markovianStates), std::move(modelComponents.exitRates), true);
+                std::shared_ptr<storm::models::sparse::MarkovAutomaton<ValueType>> ma = std::make_shared<storm::models::sparse::MarkovAutomaton<ValueType>>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.markovianStates), std::move(modelComponents.exitRates), true);
+                if (ma->hasOnlyTrivialNondeterminism()) {
+                 // Markov automaton can be converted into CTMC
+                    model = ma->convertToCTMC();
+                } else {
+                    model = ma;
+                }
             }
             
             model->printModelInformationToStream(std::cout);
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index eacf2568c..40e0c2a8c 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -44,15 +44,23 @@ namespace storm {
                 boost::optional<std::vector<boost::container::flat_set<uint_fast64_t>>> choiceLabeling;
             };
 
+          
+            
             storm::storage::DFT<ValueType> const& mDft;
             std::shared_ptr<storm::storage::DFTStateGenerationInfo> mStateGenerationInfo;
             storm::storage::BitVectorHashMap<DFTStatePointer> mStates;
             size_t newIndex = 0;
 
         public:
+              struct LabelOptions {
+                bool buildFailLabel = true;
+                bool buildFailSafeLabel = false;
+                std::set<std::string> beLabels = {};
+            };
+            
             ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft);
 
-            std::shared_ptr<storm::models::sparse::Model<ValueType>> buildModel();
+            std::shared_ptr<storm::models::sparse::Model<ValueType>> buildModel(LabelOptions const& labelOpts);
 
         private:
             bool exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates);
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 7b7cea029..805ef7570 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -32,7 +32,8 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     // Building Markov Automaton
     std::cout << "Building Model..." << std::endl;
     storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft);
-    std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildModel();
+    typename storm::builder::ExplicitDFTModelBuilder<ValueType>::LabelOptions labeloptions; // TODO initialize this with the formula
+    std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildModel(labeloptions);
     std::cout << "Built Model" << std::endl;
 
     // Model checking
diff --git a/src/utility/storm.h b/src/utility/storm.h
index f737b318e..5d02405fa 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -196,6 +196,15 @@ namespace storm {
     
     template<typename ModelType>
     std::shared_ptr<storm::models::ModelBase> preprocessModel(std::shared_ptr<storm::models::ModelBase> model, std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas) {
+        if(model->getType() == storm::models::ModelType::MarkovAutomaton && model->isSparseModel()) {
+            std::shared_ptr<storm::models::sparse::MarkovAutomaton<typename ModelType::ValueType>> ma = model->template as<storm::models::sparse::MarkovAutomaton<typename ModelType::ValueType>>();
+            if (ma->hasOnlyTrivialNondeterminism()) {
+                // Markov automaton can be converted into CTMC
+                model = ma->convertToCTMC();
+                
+            } 
+        }
+        
         if (model->isSparseModel() && storm::settings::generalSettings().isBisimulationSet()) {
             storm::storage::BisimulationType bisimType = storm::storage::BisimulationType::Strong;
             if (storm::settings::bisimulationSettings().isWeakBisimulationSet()) {
@@ -205,6 +214,7 @@ namespace storm {
             STORM_LOG_THROW(model->isSparseModel(), storm::exceptions::InvalidSettingsException, "Bisimulation minimization is currently only available for sparse models.");
             return performBisimulationMinimization<ModelType>(model->template as<storm::models::sparse::Model<typename ModelType::ValueType>>(), formulas, bisimType);
         }
+        
         return model;
     }
     
@@ -302,15 +312,8 @@ namespace storm {
             result = modelchecker.check(task);
         } else if (model->getType() == storm::models::ModelType::MarkovAutomaton) {
             std::shared_ptr<storm::models::sparse::MarkovAutomaton<ValueType>> ma = model->template as<storm::models::sparse::MarkovAutomaton<ValueType>>();
-            if (ma->hasOnlyTrivialNondeterminism()) {
-                // Markov automaton can be converted into CTMC
-                std::shared_ptr<storm::models::sparse::Ctmc<ValueType>> ctmc = ma->convertToCTMC();
-                storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<ValueType>> modelchecker(*ctmc);
-                result = modelchecker.check(task);
-            } else {
-                storm::modelchecker::SparseMarkovAutomatonCslModelChecker<storm::models::sparse::MarkovAutomaton<ValueType>> modelchecker(*ma);
-                result = modelchecker.check(task);
-            }
+            storm::modelchecker::SparseMarkovAutomatonCslModelChecker<storm::models::sparse::MarkovAutomaton<ValueType>> modelchecker(*ma);
+            result = modelchecker.check(task);
         } else {
             STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The model type " << model->getType() << " is not supported.");
         }

From d160bb1b134784612d0d6a1508102c803a3bcff4 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 19 Feb 2016 15:47:16 +0100
Subject: [PATCH 136/246] Use only state ids instead of complete data structure

Former-commit-id: 0852cce6d7ba5e7c6b35630ffdb2631cecf64534
---
 src/builder/ExplicitDFTModelBuilder.cpp | 65 +++++++++++++------------
 src/builder/ExplicitDFTModelBuilder.h   |  4 +-
 src/storage/BitVectorHashMap.cpp        |  8 +--
 src/storage/dft/DFT.cpp                 |  1 +
 src/storage/dft/DFT.h                   |  8 +++
 src/storage/dft/DFTState.cpp            | 10 ++++
 src/storage/dft/DFTState.h              |  8 ++-
 7 files changed, 62 insertions(+), 42 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index a7284cb9c..2d466dec8 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -15,14 +15,13 @@ namespace storm {
         }
         
         template <typename ValueType>
-        ExplicitDFTModelBuilder<ValueType>::ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft) : mDft(dft), mStates(((mDft.stateVectorSize() / 64) + 1) * 64, std::pow(2, mDft.nrBasicElements())) {
-            // stateSize is bound for size of bitvector
-            // 2^nrBE is upper bound for state space
+        ExplicitDFTModelBuilder<ValueType>::ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft) : mDft(dft), mStates(((mDft.stateVectorSize() / 64) + 1) * 64, INITIAL_BUCKETSIZE) {
+            // stateVectorSize is bound for size of bitvector
 
             // Find symmetries
             // TODO activate
             // Currently using hack to test
-            std::vector<std::vector<size_t>> symmetries;
+            std::vector<std::vector<size_t>> symmetriesTmp;
             std::vector<size_t> vecB;
             std::vector<size_t> vecC;
             std::vector<size_t> vecD;
@@ -38,11 +37,11 @@ namespace storm {
                         vecD.push_back(id);
                     }
                 }
-                symmetries.push_back(vecB);
-                symmetries.push_back(vecC);
-                symmetries.push_back(vecD);
+                symmetriesTmp.push_back(vecB);
+                symmetriesTmp.push_back(vecC);
+                symmetriesTmp.push_back(vecD);
                 std::cout << "Found the following symmetries:" << std::endl;
-                for (auto const& symmetry : symmetries) {
+                for (auto const& symmetry : symmetriesTmp) {
                     for (auto const& elem : symmetry) {
                         std::cout << elem << " -> ";
                     }
@@ -51,7 +50,7 @@ namespace storm {
             } else {
                 vecB.push_back(mDft.getTopLevelIndex());
             }
-            mStateGenerationInfo = std::make_shared<storm::storage::DFTStateGenerationInfo>(mDft.buildStateGenerationInfo(vecB, symmetries));
+            mStateGenerationInfo = std::make_shared<storm::storage::DFTStateGenerationInfo>(mDft.buildStateGenerationInfo(vecB, symmetriesTmp));
         }
 
 
@@ -59,7 +58,7 @@ namespace storm {
         std::shared_ptr<storm::models::sparse::Model<ValueType>> ExplicitDFTModelBuilder<ValueType>::buildModel() {
             // Initialize
             DFTStatePointer state = std::make_shared<storm::storage::DFTState<ValueType>>(mDft, *mStateGenerationInfo, newIndex++);
-            mStates.findOrAdd(state->status(), state);
+            mStates.findOrAdd(state->status(), state->getId());
 
             std::queue<DFTStatePointer> stateQueue;
             stateQueue.push(state);
@@ -97,18 +96,19 @@ namespace storm {
                 modelComponents.stateLabeling.addLabel(elem->name() + "_fail");
             }
 
-            for (auto const& stateVectorPair : mStates) {
-                DFTStatePointer state = stateVectorPair.second;
-                if (mDft.hasFailed(state)) {
-                    modelComponents.stateLabeling.addLabelToState("failed", state->getId());
+            for (auto const& stateIdPair : mStates) {
+                storm::storage::BitVector state = stateIdPair.first;
+                size_t stateId = stateIdPair.second;
+                if (mDft.hasFailed(state, *mStateGenerationInfo)) {
+                    modelComponents.stateLabeling.addLabelToState("failed", stateId);
                 }
-                if (mDft.isFailsafe(state)) {
-                    modelComponents.stateLabeling.addLabelToState("failsafe", state->getId());
+                if (mDft.isFailsafe(state, *mStateGenerationInfo)) {
+                    modelComponents.stateLabeling.addLabelToState("failsafe", stateId);
                 };
                 // Set fail status for each BE
                 for (std::shared_ptr<storage::DFTBE<ValueType>> elem : basicElements) {
-                    if (state->hasFailed(elem->id())) {
-                        modelComponents.stateLabeling.addLabelToState(elem->name() + "_fail", state->getId());
+                    if (storm::storage::DFTState<ValueType>::hasFailed(state, mStateGenerationInfo->getStateIndex(elem->id()))) {
+                        modelComponents.stateLabeling.addLabelToState(elem->name() + "_fail", stateId);
                     }
                 }
             }
@@ -213,15 +213,16 @@ namespace storm {
                     
                     // Update failable dependencies
                     newState->updateFailableDependencies(nextBE->id());
-
+                    
+                    size_t newStateId;
                     if (mStates.contains(newState->status())) {
                         // State already exists
-                        newState = mStates.findOrAdd(newState->status(), newState);
+                        newStateId = mStates.getValue(newState->status());
                         STORM_LOG_TRACE("State " << mDft.getStateString(newState) << " already exists");
                     } else {
                         // New state
                         newState->setId(newIndex++);
-                        mStates.findOrAdd(newState->status(), newState);
+                        newStateId = mStates.findOrAdd(newState->status(), newState->getId());
                         STORM_LOG_TRACE("New state " << mDft.getStateString(newState));
 
                         // Add state to search queue
@@ -232,22 +233,22 @@ namespace storm {
                     if (hasDependencies) {
                         // Failure is due to dependency -> add non-deterministic choice
                         std::shared_ptr<storm::storage::DFTDependency<ValueType> const> dependency = mDft.getDependency(state->getDependencyId(smallest-1));
-                        transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, newState->getId(), dependency->probability());
-                        STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newState->getId() << " with probability " << dependency->probability());
+                        transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, newStateId, dependency->probability());
+                        STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newStateId << " with probability " << dependency->probability());
 
                         if (!storm::utility::isOne(dependency->probability())) {
                             // Add transition to state where dependency was unsuccessful
                             DFTStatePointer unsuccessfulState = std::make_shared<storm::storage::DFTState<ValueType>>(*state);
                             unsuccessfulState->letDependencyBeUnsuccessful(smallest-1);
-                            
+                            size_t unsuccessfulStateId;
                             if (mStates.contains(unsuccessfulState->status())) {
                                 // Unsuccessful state already exists
-                                unsuccessfulState = mStates.findOrAdd(unsuccessfulState->status(), unsuccessfulState);
+                                unsuccessfulStateId = mStates.getValue(unsuccessfulState->status());
                                 STORM_LOG_TRACE("State " << mDft.getStateString(unsuccessfulState) << " already exists");
                             } else {
                                 // New unsuccessful state
                                 unsuccessfulState->setId(newIndex++);
-                                mStates.findOrAdd(unsuccessfulState->status(), unsuccessfulState);
+                                unsuccessfulStateId = mStates.findOrAdd(unsuccessfulState->status(), unsuccessfulState->getId());
                                 STORM_LOG_TRACE("New state " << mDft.getStateString(unsuccessfulState));
                                 
                                 // Add unsuccessful state to search queue
@@ -255,11 +256,11 @@ namespace storm {
                             }
 
                             ValueType remainingProbability = storm::utility::one<ValueType>() - dependency->probability();
-                            transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, unsuccessfulState->getId(), remainingProbability);
-                            STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << unsuccessfulState->getId() << " with probability " << remainingProbability);
+                            transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, unsuccessfulStateId, remainingProbability);
+                            STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << unsuccessfulStateId << " with probability " << remainingProbability);
                         } else {
                             // Self-loop with probability one cannot be eliminated later one.
-                            assert(state->getId() != newState->getId());
+                            assert(state->getId() != newStateId);
                         }
                         ++rowOffset;
 
@@ -274,15 +275,15 @@ namespace storm {
                         }
                         STORM_LOG_TRACE("BE " << nextBE->name() << " is " << (isUsed ? "used" : "not used"));
                         ValueType rate = isUsed ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
-                        auto resultFind = outgoingTransitions.find(newState->getId());
+                        auto resultFind = outgoingTransitions.find(newStateId);
                         if (resultFind != outgoingTransitions.end()) {
                             // Add to existing transition
                             resultFind->second += rate;
                             STORM_LOG_TRACE("Updated transition from " << state->getId() << " to " << resultFind->first << " with rate " << rate << " to new rate " << resultFind->second);
                         } else {
                             // Insert new transition
-                            outgoingTransitions.insert(std::make_pair(newState->getId(), rate));
-                            STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newState->getId() << " with rate " << rate);
+                            outgoingTransitions.insert(std::make_pair(newStateId, rate));
+                            STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newStateId << " with rate " << rate);
                         }
                         exitRate += rate;
                     }
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index eacf2568c..322790aa4 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -43,10 +43,12 @@ namespace storm {
                 // A vector that stores a labeling for each choice.
                 boost::optional<std::vector<boost::container::flat_set<uint_fast64_t>>> choiceLabeling;
             };
+            
+            const size_t INITIAL_BUCKETSIZE = 20000;
 
             storm::storage::DFT<ValueType> const& mDft;
             std::shared_ptr<storm::storage::DFTStateGenerationInfo> mStateGenerationInfo;
-            storm::storage::BitVectorHashMap<DFTStatePointer> mStates;
+            storm::storage::BitVectorHashMap<size_t> mStates;
             size_t newIndex = 0;
 
         public:
diff --git a/src/storage/BitVectorHashMap.cpp b/src/storage/BitVectorHashMap.cpp
index be0e32325..4d6238350 100644
--- a/src/storage/BitVectorHashMap.cpp
+++ b/src/storage/BitVectorHashMap.cpp
@@ -4,9 +4,6 @@
 
 #include "src/utility/macros.h"
 
-#include "src/storage/dft/DFTState.h"
-#include "src/adapters/CarlAdapter.h"
-
 namespace storm {
     namespace storage {
         template<class ValueType, class Hash1, class Hash2>
@@ -243,9 +240,6 @@ namespace storm {
         
         template class BitVectorHashMap<uint_fast64_t>;
         template class BitVectorHashMap<uint32_t>;
-        template class BitVectorHashMap<std::shared_ptr<DFTState<double>>>;
-#ifdef STORM_HAVE_CARL
-        template class BitVectorHashMap<std::shared_ptr<DFTState<storm::RationalFunction>>>;
-#endif
+        template class BitVectorHashMap<size_t>;
     }
 }
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 654fb269e..522173d81 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -204,6 +204,7 @@ namespace storm {
             return stream.str();
         }
 
+        // TODO rewrite to only use bitvector and id
         template<typename ValueType>
         std::string DFT<ValueType>::getStateString(DFTStatePointer const& state) const{
             std::stringstream stream;
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 0cedfbfa7..2ee1a2edf 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -244,10 +244,18 @@ namespace storm {
                 return state->hasFailed(mTopLevelIndex);
             }
             
+            bool hasFailed(storm::storage::BitVector const& state, DFTStateGenerationInfo const& stateGenerationInfo) const {
+                return storm::storage::DFTState<ValueType>::hasFailed(state, stateGenerationInfo.getStateIndex(mTopLevelIndex));
+            }
+            
             bool isFailsafe(DFTStatePointer const& state) const {
                 return state->isFailsafe(mTopLevelIndex);
             }
             
+            bool isFailsafe(storm::storage::BitVector const& state, DFTStateGenerationInfo const& stateGenerationInfo) const {
+                return storm::storage::DFTState<ValueType>::isFailsafe(state, stateGenerationInfo.getStateIndex(mTopLevelIndex));
+            }
+            
             std::string getElementsString() const;
 
             std::string getInfoString() const;
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index c3f7c9f32..0bad03f78 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -63,11 +63,21 @@ namespace storm {
         bool DFTState<ValueType>::hasFailed(size_t id) const {
             return mStatus[mStateGenerationInfo.getStateIndex(id)];
         }
+        
+        template<typename ValueType>
+        bool DFTState<ValueType>::hasFailed(storm::storage::BitVector const& state, size_t indexId) {
+            return state[indexId];
+        }
 
         template<typename ValueType>
         bool DFTState<ValueType>::isFailsafe(size_t id) const {
             return mStatus[mStateGenerationInfo.getStateIndex(id)+1];
         }
+        
+        template<typename ValueType>
+        bool DFTState<ValueType>::isFailsafe(storm::storage::BitVector const& state, size_t indexId) {
+            return state[indexId+1];
+        }
 
         template<typename ValueType>
         bool DFTState<ValueType>::dontCare(size_t id) const {
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index fcbcdc62d..821aa2fcb 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -51,10 +51,14 @@ namespace storm {
             
             bool hasFailed(size_t id) const;
             
-            bool isFailsafe(size_t id) const ;
+            static bool hasFailed(storm::storage::BitVector const& state, size_t indexId);
             
+            bool isFailsafe(size_t id) const;
+
+            static bool isFailsafe(storm::storage::BitVector const& state, size_t indexId);
+
             bool dontCare(size_t id) const;
-            
+
             bool dependencyTriggered(size_t id) const;
 
             bool dependencySuccessful(size_t id) const;

From 2754450f91d26079332baed8d89d1d98cc0b3e90 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 19 Feb 2016 15:47:57 +0100
Subject: [PATCH 137/246] Refactored DFS search into own method

Former-commit-id: 3efbcf062f6928f318d91347f3d2eb1eb9946049
---
 src/storage/dft/DFT.cpp | 74 ++++++++++++++++++++++-------------------
 src/storage/dft/DFT.h   |  2 ++
 2 files changed, 41 insertions(+), 35 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 522173d81..c75d96a6c 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -82,43 +82,12 @@ namespace storm {
             visitQueue.push(subTreeRoots[0]);
             bool consideredDependencies = false;
             while (true) {
-                while (!visitQueue.empty()) {
-                    size_t id = visitQueue.front();
-                    visitQueue.pop();
-                    if (visited.count(id) == 1) {
-                        // Already visited
-                        continue;
-                    }
-                    visited.insert(id);
-                    DFTElementPointer element = mElements[id];
-                    
-                    // Insert children
-                    if (element->isGate()) {
-                        for (auto const& child : std::static_pointer_cast<DFTGate<ValueType>>(element)->children()) {
-                            visitQueue.push(child->id());
-                        }
-                    }
-                    
-                    // Reserve bits for element
-                    generationInfo.addStateIndex(id, stateIndex);
-                    stateIndex += 2;
-
-                    if (isRepresentative(id)) {
-                        generationInfo.addSpareActivationIndex(id, stateIndex);
-                        ++stateIndex;
-                    }
-
-                    if (element->isSpareGate()) {
-                        generationInfo.addSpareUsageIndex(id, stateIndex);
-                        stateIndex += generationInfo.usageInfoBits();
-                    }
-                    
-                }
-                
                 if (consideredDependencies) {
                     break;
                 }
                 
+                stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
+                
                 // Consider dependencies
                 for (size_t idDependency : getDependencies()) {
                     std::shared_ptr<DFTDependency<ValueType> const> dependency = getDependency(idDependency);
@@ -134,8 +103,43 @@ namespace storm {
             
             return generationInfo;
         }
-
-
+        
+        template<typename ValueType>
+        size_t DFT<ValueType>::performStateGenerationInfoDFS(DFTStateGenerationInfo& generationInfo, std::queue<size_t>& visitQueue, std::set<size_t>& visited, size_t stateIndex) const {
+            while (!visitQueue.empty()) {
+                size_t id = visitQueue.front();
+                visitQueue.pop();
+                if (visited.count(id) == 1) {
+                    // Already visited
+                    continue;
+                }
+                visited.insert(id);
+                DFTElementPointer element = mElements[id];
+                
+                // Insert children
+                if (element->isGate()) {
+                    for (auto const& child : std::static_pointer_cast<DFTGate<ValueType>>(element)->children()) {
+                        visitQueue.push(child->id());
+                    }
+                }
+                
+                // Reserve bits for element
+                generationInfo.addStateIndex(id, stateIndex);
+                stateIndex += 2;
+                
+                if (isRepresentative(id)) {
+                    generationInfo.addSpareActivationIndex(id, stateIndex);
+                    ++stateIndex;
+                }
+                
+                if (element->isSpareGate()) {
+                    generationInfo.addSpareUsageIndex(id, stateIndex);
+                    stateIndex += generationInfo.usageInfoBits();
+                }
+                
+            }
+            return stateIndex;
+        }
 
         template<typename ValueType>
         std::string DFT<ValueType>::getElementsString() const {
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 2ee1a2edf..3beacf8d9 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -127,6 +127,8 @@ namespace storm {
             
             DFTStateGenerationInfo buildStateGenerationInfo(std::vector<size_t> const& subTreeRoots, std::vector<std::vector<size_t>> const& symmetries) const;
 
+            size_t performStateGenerationInfoDFS(DFTStateGenerationInfo& generationInfo, std::queue<size_t>& visitQueue, std::set<size_t>& visited, size_t stateIndex) const;
+            
             size_t stateVectorSize() const {
                 return mStateVectorSize;
             }

From b93f5c2f624ebb87316d191b7104badcd65dc23f Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 19 Feb 2016 16:19:36 +0100
Subject: [PATCH 138/246] refactored a bit, plus bisimulation is now done

Former-commit-id: 42877cdb29c91063c626f4efd711fc8f2d1460d0
---
 src/builder/ExplicitDFTModelBuilder.cpp |  1 -
 src/storm-dyftee.cpp                    | 23 ++++++++++++++++++++---
 2 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index c6d59d6cb..cbb9b69d0 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -145,7 +145,6 @@ namespace storm {
                 }
             }
             
-            model->printModelInformationToStream(std::cout);
             return model;
         }
 
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 805ef7570..2160ed210 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -16,12 +16,19 @@
  */
 template <typename ValueType>
 void analyzeDFT(std::string filename, std::string property, bool symred = false) {
+    storm::settings::SettingsManager& manager = storm::settings::mutableManager();
+    manager.setFromString("");
+
     // Parsing DFT
     std::cout << "Parsing DFT file..." << std::endl;
     storm::parser::DFTGalileoParser<ValueType> parser;
     storm::storage::DFT<ValueType> dft = parser.parseDFT(filename);
     std::cout << "Built data structure" << std::endl;
-    
+    std::cout << "Parse formula..." << std::endl;
+    std::vector<std::shared_ptr<storm::logic::Formula>> parsedFormulas = storm::parseFormulasForExplicit(property);
+    std::vector<std::shared_ptr<const storm::logic::Formula>> formulas(parsedFormulas.begin(), parsedFormulas.end());
+    assert(formulas.size() == 1);
+    std::cout << "parsed formula." << std::endl;
     if(symred) {
         std::cout << dft.getElementsString() << std::endl;
         auto colouring = dft.colourDFT();
@@ -36,10 +43,20 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildModel(labeloptions);
     std::cout << "Built Model" << std::endl;
 
+    
+    model->printModelInformationToStream(std::cout);
+    
+    std::cout << "Bisimulation..." << std::endl;
+    
+    if (model->isOfType(storm::models::ModelType::Ctmc)) {
+            model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), formulas, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
+    }
+    
+    
+    model->printModelInformationToStream(std::cout);
+    
     // Model checking
     std::cout << "Model checking..." << std::endl;
-    std::vector<std::shared_ptr<storm::logic::Formula>> formulas = storm::parseFormulasForExplicit(property);
-    assert(formulas.size() == 1);
     std::unique_ptr<storm::modelchecker::CheckResult> result(storm::verifySparseModel(model, formulas[0]));
     assert(result);
     std::cout << "Result: ";

From 0156b1276485e7acf60a74c25cc89a070b2ab6a3 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 19 Feb 2016 17:36:35 +0100
Subject: [PATCH 139/246] Fixed compile problem under gcc

Former-commit-id: f5d40795e99f9d40698b8787f2409f6735a1c2f8
---
 src/builder/ExplicitDFTModelBuilder.h | 4 ++--
 src/storage/BitVectorHashMap.cpp      | 1 -
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 522f2375c..a64efaddd 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -50,7 +50,7 @@ namespace storm {
             
             storm::storage::DFT<ValueType> const& mDft;
             std::shared_ptr<storm::storage::DFTStateGenerationInfo> mStateGenerationInfo;
-            storm::storage::BitVectorHashMap<size_t> mStates;
+            storm::storage::BitVectorHashMap<uint32_t> mStates;
             size_t newIndex = 0;
 
         public:
@@ -71,4 +71,4 @@ namespace storm {
     }
 }
 
-#endif	/* EXPLICITDFTMODELBUILDER_H */
\ No newline at end of file
+#endif	/* EXPLICITDFTMODELBUILDER_H */
diff --git a/src/storage/BitVectorHashMap.cpp b/src/storage/BitVectorHashMap.cpp
index 4d6238350..9237dfde3 100644
--- a/src/storage/BitVectorHashMap.cpp
+++ b/src/storage/BitVectorHashMap.cpp
@@ -240,6 +240,5 @@ namespace storm {
         
         template class BitVectorHashMap<uint_fast64_t>;
         template class BitVectorHashMap<uint32_t>;
-        template class BitVectorHashMap<size_t>;
     }
 }

From 8755e75a60f12bc9e9cf91fd9ccbfe2367bc623c Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 19 Feb 2016 18:13:05 +0100
Subject: [PATCH 140/246] towards a new element (and actually added a folder)

Former-commit-id: 0bca77dfa7b9800ef60225ca2fcc3e01d5e1e157
---
 src/CMakeLists.txt                        |  2 +
 src/storage/dft/DFTElementType.h          |  7 ++-
 src/storage/dft/DFTElements.h             | 54 -----------------------
 src/storage/dft/elements/DFTRestriction.h | 13 ++++++
 4 files changed, 18 insertions(+), 58 deletions(-)
 create mode 100644 src/storage/dft/elements/DFTRestriction.h

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 3aa121a0a..60fbadab9 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -38,6 +38,7 @@ file(GLOB STORM_STORAGE_FILES ${PROJECT_SOURCE_DIR}/src/storage/*.h ${PROJECT_SO
 file(GLOB STORM_STORAGE_BISIMULATION_FILES ${PROJECT_SOURCE_DIR}/src/storage/bisimulation/*.h ${PROJECT_SOURCE_DIR}/src/storage/bisimulation/*.cpp)
 file(GLOB STORM_STORAGE_DD_FILES ${PROJECT_SOURCE_DIR}/src/storage/dd/*.h ${PROJECT_SOURCE_DIR}/src/storage/dd/*.cpp)
 file(GLOB STORM_STORAGE_DFT_FILES ${PROJECT_SOURCE_DIR}/src/storage/dft/*.h ${PROJECT_SOURCE_DIR}/src/storage/dft/*.cpp)
+file(GLOB STORM_STORAGE_DFT_ELEMENTS_FILES ${PROJECT_SOURCE_DIR}/src/storage/dft/elements/*.h ${PROJECT_SOURCE_DIR}/src/storage/dft/elements/*.cpp)
 file(GLOB_RECURSE STORM_STORAGE_DD_CUDD_FILES ${PROJECT_SOURCE_DIR}/src/storage/dd/cudd/*.h ${PROJECT_SOURCE_DIR}/src/storage/dd/cudd/*.cpp)
 file(GLOB_RECURSE STORM_STORAGE_DD_SYLVAN_FILES ${PROJECT_SOURCE_DIR}/src/storage/dd/sylvan/*.h ${PROJECT_SOURCE_DIR}/src/storage/dd/sylvan/*.cpp)
 file(GLOB_RECURSE STORM_STORAGE_EXPRESSIONS_FILES ${PROJECT_SOURCE_DIR}/src/storage/expressions/*.h ${PROJECT_SOURCE_DIR}/src/storage/expressions/*.cpp)
@@ -94,6 +95,7 @@ source_group(storage\\expressions FILES ${STORM_STORAGE_EXPRESSIONS_FILES})
 source_group(storage\\prism FILES ${STORM_STORAGE_PRISM_FILES})
 source_group(storage\\sparse FILES ${STORM_STORAGE_SPARSE_FILES})
 source_group(storage\\dft FILES ${STORM_STORAGE_DFT_FILES})
+source_group(storage\\dft\\elements FILES ${STORM_STORAGE_DFT_ELEMENTS_FILES})
 source_group(utility FILES ${STORM_UTILITY_FILES})
 
 # Add custom additional include or link directories
diff --git a/src/storage/dft/DFTElementType.h b/src/storage/dft/DFTElementType.h
index a32745cdf..d4bf3bfc2 100644
--- a/src/storage/dft/DFTElementType.h
+++ b/src/storage/dft/DFTElementType.h
@@ -4,20 +4,20 @@
 namespace storm {
     namespace storage {
 
-        enum class DFTElementType : int {AND = 0, COUNTING = 1, OR = 2, VOT = 3, BE = 4, CONSTF = 5, CONSTS = 6, PAND = 7, SPARE = 8, POR = 9, PDEP = 10, SEQAND = 11};
+        enum class DFTElementType : int {AND = 0, OR = 2, VOT = 3, BE = 4, CONSTF = 5, CONSTS = 6, PAND = 7, SPARE = 8, POR = 9, PDEP = 10, SEQ = 11, MUTEX=12};
 
         
         inline bool isGateType(DFTElementType const& tp) {
             switch(tp) {
                 case DFTElementType::AND:
-                case DFTElementType::COUNTING:
                 case DFTElementType::OR:
                 case DFTElementType::VOT:
                 case DFTElementType::PAND:
                 case DFTElementType::SPARE:
                 case DFTElementType::POR:
-                case DFTElementType::SEQAND:
                     return true;
+                case DFTElementType::SEQ:
+                case DFTElementType::MUTEX:
                 case DFTElementType::BE:
                 case DFTElementType::CONSTF:
                 case DFTElementType::CONSTS:
@@ -40,7 +40,6 @@ namespace storm {
                 case DFTElementType::POR:
                 case DFTElementType::SPARE:
                 case DFTElementType::PAND:
-                case DFTElementType::SEQAND:
                     return false;
                 default:
                     assert(false);
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 11fc31948..c51e180c7 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -726,60 +726,6 @@ namespace storm {
 
 
 
-        template<typename ValueType>
-        class DFTSeqAnd : public DFTGate<ValueType> {
-
-        public:
-            DFTSeqAnd(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
-                    DFTGate<ValueType>(id, name, children)
-            {}
-
-            void checkFails(storm::storage::DFTState<ValueType>& state,  DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-                if(!state.hasFailed(this->mId)) {
-                    bool childOperationalBefore = false;
-                    for(auto const& child : this->mChildren)
-                    {
-                        if(!state.hasFailed(child->id())) {
-                            childOperationalBefore = true;
-                        }
-                        else {
-                            if(childOperationalBefore) {
-                                state.markAsInvalid();
-                                return;
-                            }
-                        }
-                    }
-                    if(!childOperationalBefore) {
-                       fail(state, queues);
-                    }
-                  
-                } 
-            }
-
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const{
-                assert(hasFailsafeChild(state));
-                if(state.isOperational(this->mId)) {
-                    failsafe(state, queues);
-                    //return true;
-                }
-                //return false;
-            }
-
-            virtual DFTElementType type() const override {
-                return DFTElementType::SEQAND;
-            }
-
-            std::string  typestring() const override {
-                return "SEQAND";
-            }
-        };
-
-        template<typename ValueType>
-        inline std::ostream& operator<<(std::ostream& os, DFTSeqAnd<ValueType> const& gate) {
-             return os << gate.toString();
-        }
-
-
 
         template<typename ValueType>
         class DFTPand : public DFTGate<ValueType> {
diff --git a/src/storage/dft/elements/DFTRestriction.h b/src/storage/dft/elements/DFTRestriction.h
new file mode 100644
index 000000000..8bd586deb
--- /dev/null
+++ b/src/storage/dft/elements/DFTRestriction.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "../DFTElements.h"
+
+namespace storm {
+    namespace storage {
+        template<typename ValueType>
+        class DFTRestriction : public DFTElement<ValueType> {
+            
+        };
+        
+    }
+}
\ No newline at end of file

From 7bcbbe75faf5ea592b3253cad345517b1b3b8bc8 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sun, 21 Feb 2016 15:53:14 +0100
Subject: [PATCH 141/246] Set dont care for children if parent gate fails

Former-commit-id: c70852b7e85804cea30d6a27090baaa8457e4cb8
---
 src/storage/dft/DFTElements.cpp | 26 ++++++++++++++++----------
 src/storage/dft/DFTElements.h   |  2 ++
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index 26f5f9cbe..e06b3fe7d 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -7,18 +7,24 @@ namespace storm {
 
         template<typename ValueType>
         bool DFTElement<ValueType>::checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-            if(!state.dontCare(mId) && !hasOutgoingDependencies())
-            {
-                for(DFTGatePointer const& parent : mParents) {
-                    if(state.isOperational(parent->id())) {
-                        return false;
-                    }
+            if (state.dontCare(mId)) {
+                return false;
+            }
+            // Check that no outgoing dependencies can be triggered anymore
+            for (DFTDependencyPointer dependency : mOutgoingDependencies) {
+                if (state.isOperational(dependency->dependentEvent()->id()) && state.isOperational(dependency->triggerEvent()->id())) {
+                    return false;
                 }
-                state.setDontCare(mId);
-                return true;
-
             }
-            return false;
+            // Check that no parent can fail anymore
+            for(DFTGatePointer const& parent : mParents) {
+                if(state.isOperational(parent->id())) {
+                    return false;
+                }
+            }
+
+            state.setDontCare(mId);
+            return true;
         }
 
         template<typename ValueType>
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 11fc31948..d5620717f 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -350,6 +350,7 @@ namespace storm {
                     }
                 }
                 state.setFailed(this->mId);
+                this->childrenDontCare(state, queues);
             }
 
             void failsafe(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
@@ -359,6 +360,7 @@ namespace storm {
                     }
                 }
                 state.setFailsafe(this->mId);
+                this->childrenDontCare(state, queues);
             }
 
             void childrenDontCare(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {

From 74b512a76ef62c727a453a50590c12eded00c234 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sun, 21 Feb 2016 16:05:03 +0100
Subject: [PATCH 142/246] Consider dependencies in DFS for state generation
 info

Former-commit-id: c61210cbd548a265778bc636caedab123107d355
---
 src/storage/dft/DFT.cpp | 26 ++++++++++----------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 519036fff..92e780872 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -80,23 +80,17 @@ namespace storm {
             std::queue<size_t> visitQueue;
             std::set<size_t> visited;
             visitQueue.push(subTreeRoots[0]);
-            bool consideredDependencies = false;
-            while (true) {
-                if (consideredDependencies) {
-                    break;
-                }
-                
-                stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
-                
-                // Consider dependencies
-                for (size_t idDependency : getDependencies()) {
-                    std::shared_ptr<DFTDependency<ValueType> const> dependency = getDependency(idDependency);
-                    visitQueue.push(dependency->id());
-                    visitQueue.push(dependency->triggerEvent()->id());
-                    visitQueue.push(dependency->dependentEvent()->id());
-                }
-                consideredDependencies = true;
+            stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
+            
+            // Consider dependencies
+            for (size_t idDependency : getDependencies()) {
+                std::shared_ptr<DFTDependency<ValueType> const> dependency = getDependency(idDependency);
+                visitQueue.push(dependency->id());
+                visitQueue.push(dependency->triggerEvent()->id());
+                visitQueue.push(dependency->dependentEvent()->id());
             }
+            stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
+            
             assert(stateIndex = mStateVectorSize);
 
             STORM_LOG_TRACE(generationInfo);

From 2a2eefa95645e13f2254497c3a58d332dae06076 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Sun, 21 Feb 2016 19:25:38 +0100
Subject: [PATCH 143/246] towards restrictions

Former-commit-id: e3baec90ea5ea4bf82e91892fd722cc2583a94e0
---
 src/storage/dft/DFTBuilder.cpp            |  52 +++++-
 src/storage/dft/DFTBuilder.h              |  19 ++-
 src/storage/dft/DFTElements.h             |  20 +++
 src/storage/dft/elements/DFTRestriction.h | 195 +++++++++++++++++++++-
 4 files changed, 281 insertions(+), 5 deletions(-)

diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index 1979aea3b..62b022635 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -27,6 +27,7 @@ namespace storm {
                         childElement->addParent(gate);
                     } else {
                         // Child not found -> find first dependent event to assure that child is dependency
+                        // TODO: Not sure whether this is the intended behaviour?
                         auto itFind = mElements.find(child + "_1");
                         assert(itFind != mElements.end());
                         assert(itFind->second->isDependency());
@@ -34,6 +35,17 @@ namespace storm {
                     }
                 }
             }
+            
+            for(auto& elem : mRestrictionChildNames) {
+                for(auto const& childName : elem.second) {
+                    auto itFind = mElements.find(childName);
+                    assert(itFind != mElements.end());
+                    DFTElementPointer childElement = itFind->second;
+                    assert(!childElement->isDependency() && !childElement->isRestriction());
+                    elem.first->pushBackChild(childElement);
+                    childElement->addRestriction(elem.first);
+                }
+            }
 
             // Initialize dependencies
             for (auto& dependency : mDependencies) {
@@ -45,6 +57,17 @@ namespace storm {
                 dependentEvent->addIngoingDependency(dependency);
             }
 
+//            for (auto& restriction : mRestrictions) {
+//                std::set<DFTGatePointer> parentsOfRestrictedElements;
+//                for (auto& child : restriction->children()) {
+//                    for(DFTGatePointer& parent : child->parents()) {
+//                        parentsOfRestrictedElements.insert(parent);
+//                    }
+//                }
+//
+//
+//            }
+
             // Sort elements topologically
             // compute rank
             for (auto& elem : mElements) {
@@ -82,6 +105,33 @@ namespace storm {
             return elem->rank();
         }
 
+        template<typename ValueType>
+        bool DFTBuilder<ValueType>::addRestriction(std::string const& name, std::vector<std::string> const& children, DFTElementType tp) {
+            if (children.size() <= 1) {
+                STORM_LOG_ERROR("Sequence enforcers require at least two children");
+            }
+            if (mElements.count(name) != 0) {
+                return false;
+            }
+            DFTRestrictionPointer restr;
+            switch (tp) {
+                case DFTElementType::SEQ:
+                    restr = std::make_shared<DFTSeq < ValueType>>
+                    (mNextId++, name);
+                    break;
+                case DFTElementType::MUTEX:
+                    STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type not supported.");
+                    break;
+                default:
+                    STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type not known.");
+                    break;
+            }
+
+            mElements[name] = restr;
+            mRestrictionChildNames[restr] = children;
+            mRestrictions.push_back(restr);
+        }
+
         template<typename ValueType>
         bool DFTBuilder<ValueType>::addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementType tp) {
             assert(children.size() > 0);
@@ -108,11 +158,11 @@ namespace storm {
                    break;
                 case DFTElementType::BE:
                 case DFTElementType::VOT:
+                case DFTElementType::PDEP:
                     // Handled separately
                     STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type handled separately.");
                 case DFTElementType::CONSTF:
                 case DFTElementType::CONSTS:
-                case DFTElementType::PDEP:
                     STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type not supported.");
                 default:
                     STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type not known.");
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index 17a16cb49..8ef0d6cf1 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -3,6 +3,7 @@
 #define	DFTBUILDER_H
 
 #include "DFTElements.h"
+#include "elements/DFTRestriction.h"
 #include <iostream>
 #include <unordered_map>
 #include <map>
@@ -21,13 +22,16 @@ namespace storm {
             using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
             using DFTGateVector = std::vector<DFTGatePointer>;
             using DFTDependencyPointer = std::shared_ptr<DFTDependency<ValueType>>;
+            using DFTRestrictionPointer = std::shared_ptr<DFTRestriction<ValueType>>;
 
         private:
             std::size_t mNextId = 0;
             std::string topLevelIdentifier;
             std::unordered_map<std::string, DFTElementPointer> mElements;
             std::unordered_map<DFTElementPointer, std::vector<std::string>> mChildNames;
+            std::unordered_map<DFTRestrictionPointer, std::vector<std::string>> mRestrictionChildNames;
             std::vector<DFTDependencyPointer> mDependencies;
+            std::vector<DFTRestrictionPointer> mRestrictions;
             
         public:
             DFTBuilder() {
@@ -53,9 +57,19 @@ namespace storm {
             bool addSpareElement(std::string const& name, std::vector<std::string> const& children) {
                 return addStandardGate(name, children, DFTElementType::SPARE);
             }
+
+            bool addSequenceEnforcer(std::string const& name, std::vector<std::string> const& children) {
+                return addRestriction(name, children, DFTElementType::SEQ);
+            }
+
+            bool addMutex(std::string const& name, std::vector<std::string> const& children) {
+                return addRestriction(name, children, DFTElementType::MUTEX);
+            }
             
             bool addDepElement(std::string const& name, std::vector<std::string> const& children, ValueType probability) {
-                assert(children.size() > 1);
+                if(children.size() <= 1) {
+                    STORM_LOG_ERROR("Dependencies require at least two children");
+                }
                 if(mElements.count(name) != 0) {
                     // Element with that name already exists.
                     return false;
@@ -138,7 +152,8 @@ namespace storm {
             unsigned computeRank(DFTElementPointer const& elem);
             
             bool addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementType tp);
-            
+            bool addRestriction(std::string const& name, std::vector<std::string> const& children, DFTElementType tp);
+
             enum class topoSortColour {WHITE, BLACK, GREY}; 
             
             void topoVisit(DFTElementPointer const& n, std::map<DFTElementPointer, topoSortColour, OrderElementsById<ValueType>>& visited, DFTElementVector& L);
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index c51e180c7..66e8b3e8a 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -26,6 +26,8 @@ namespace storm {
         
         template<typename ValueType>
         class DFTDependency;
+        template<typename ValueType>
+        class DFTRestriction;
 
         template<typename ValueType>
         class DFTElement {
@@ -34,6 +36,9 @@ namespace storm {
             using DFTGateVector = std::vector<DFTGatePointer>;
             using DFTDependencyPointer = std::shared_ptr<DFTDependency<ValueType>>;
             using DFTDependencyVector = std::vector<DFTDependencyPointer>;
+            using DFTRestrictionPointer = std::shared_ptr<DFTRestriction<ValueType>>;
+            using DFTRestrictionVector = std::vector<DFTRestrictionPointer>;
+
 
         protected:
             size_t mId;
@@ -41,6 +46,8 @@ namespace storm {
             size_t mRank = -1;
             DFTGateVector mParents;
             DFTDependencyVector mOutgoingDependencies;
+            DFTRestrictionVector mRestrictions;
+
 
         public:
             DFTElement(size_t id, std::string const& name) :
@@ -95,6 +102,10 @@ namespace storm {
             virtual bool isDependency() const {
                 return false;
             }
+            
+            virtual bool isRestriction() const {
+                return false;
+            }
 
             virtual void setId(size_t newId) {
                 mId = newId;
@@ -118,6 +129,15 @@ namespace storm {
                 }
             }
 
+            bool addRestriction(DFTRestrictionPointer const& e) {
+                if (std::find(mRestrictions.begin(), mRestrictions.end(), e) != mRestrictions.end()) {
+                    return false;
+                } else {
+                    mRestrictions.push_back(e);
+                    return true;
+                }
+            }
+
              bool hasOnlyStaticParents() const {
                 for(auto const& parent : mParents) {
                     if(!isStaticGateType(parent->type())) {
diff --git a/src/storage/dft/elements/DFTRestriction.h b/src/storage/dft/elements/DFTRestriction.h
index 8bd586deb..464c49db2 100644
--- a/src/storage/dft/elements/DFTRestriction.h
+++ b/src/storage/dft/elements/DFTRestriction.h
@@ -6,8 +6,199 @@ namespace storm {
     namespace storage {
         template<typename ValueType>
         class DFTRestriction : public DFTElement<ValueType> {
-            
+            using DFTElementPointer = std::shared_ptr<DFTElement<ValueType>>;
+            using DFTElementVector = std::vector<DFTElementPointer>;
+        protected:
+            DFTElementVector mChildren;
+
+        public:
+            DFTRestriction(size_t id, std::string const& name, DFTElementVector const& children) :
+            DFTElement<ValueType>(id, name), mChildren(children)
+                    {}
+
+            virtual ~DFTRestriction() {}
+
+            void pushBackChild(DFTElementPointer elem) {
+                return mChildren.push_back(elem);
+            }
+
+            size_t nrChildren() const override {
+                return mChildren.size();
+            }
+
+            DFTElementVector const& children() const {
+                return mChildren;
+            }
+
+            virtual bool isRestriction() const override {
+                return true;
+            }
+
+
+            virtual std::string typestring() const = 0;
+
+            virtual void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const = 0;
+
+            virtual void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const = 0;
+
+            virtual void extendSpareModule(std::set<size_t>& elementsInSpareModule) const override {
+                DFTElement<ValueType>::extendSpareModule(elementsInSpareModule);
+                for(auto const& child : mChildren) {
+                    if(elementsInSpareModule.count(child->id()) == 0) {
+                        elementsInSpareModule.insert(child->id());
+                        child->extendSpareModule(elementsInSpareModule);
+                    }
+                }
+            }
+
+            virtual std::vector<size_t> independentUnit() const override {
+                std::set<size_t> unit = {this->mId};
+                for(auto const& child : mChildren) {
+                    child->extendUnit(unit);
+                }
+                return std::vector<size_t>(unit.begin(), unit.end());
+            }
+
+            virtual void extendUnit(std::set<size_t>& unit) const override {
+                DFTElement<ValueType>::extendUnit(unit);
+                for(auto const& child : mChildren) {
+                    child->extendUnit(unit);
+                }
+            }
+
+            virtual std::vector<size_t> independentSubDft() const override {
+                auto prelRes = DFTElement<ValueType>::independentSubDft();
+                if(prelRes.empty()) {
+                    // No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft.
+                    return prelRes;
+                }
+                std::set<size_t> unit(prelRes.begin(), prelRes.end());
+                std::vector<size_t> pids = this->parentIds();
+                for(auto const& child : mChildren) {
+                    child->extendSubDft(unit, pids);
+                    if(unit.empty()) {
+                        // Parent in the subdft, ie it is *not* a subdft
+                        break;
+                    }
+                }
+                return std::vector<size_t>(unit.begin(), unit.end());
+            }
+
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
+                if(elemsInSubtree.count(this->id()) > 0) return;
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                if(elemsInSubtree.empty()) {
+                    // Parent in the subdft, ie it is *not* a subdft
+                    return;
+                }
+                for(auto const& child : mChildren) {
+                    child->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                    if(elemsInSubtree.empty()) {
+                        // Parent in the subdft, ie it is *not* a subdft
+                        return;
+                    }
+                }
+            }
+
+
+            virtual std::string toString() const override {
+                std::stringstream stream;
+                stream << "{" << this->name() << "} " << typestring() << "( ";
+                typename DFTElementVector::const_iterator it = mChildren.begin();
+                stream << (*it)->name();
+                ++it;
+                while(it != mChildren.end()) {
+                    stream <<  ", " << (*it)->name();
+                    ++it;
+                }
+                stream << ")";
+                return stream.str();
+            }
+
+            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                if(DFTElement<ValueType>::checkDontCareAnymore(state, queues)) {
+                    childrenDontCare(state, queues);
+                    return true;
+                }
+                return false;
+            }
+
+
+        protected:
+
+            void fail(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                //state.restrictionViolated(this->mId);
+            }
+
+            void failsafe(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+
+            }
+
+            void childrenDontCare(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                queues.propagateDontCare(mChildren);
+            }
+
+            bool hasFailsafeChild(DFTState<ValueType>& state) const {
+                for(auto const& child : mChildren) {
+                    if(state.isFailsafe(child->id()))
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            bool hasFailedChild(DFTState<ValueType>& state) const {
+                for(auto const& child : mChildren) {
+                    if(state.hasFailed(child->id())) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+
+
+
         };
-        
+
+        template<typename ValueType>
+        class DFTSeq : public DFTRestriction<ValueType> {
+
+
+        public:
+            DFTSeq(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTRestriction<ValueType>(id, name, children)
+            {}
+
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                assert(queues.failurePropagationDone());
+                bool childOperationalBefore = false;
+                for(auto const& child : this->mChildren)
+                {
+                    if(!state.hasFailed(child->id())) {
+                        childOperationalBefore = true;
+                    } else if(childOperationalBefore && state.hasFailed(child->id())){
+                        this->fail(state, queues);
+                        return;
+                    }
+                }
+
+            }
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                assert(this->hasFailsafeChild(state));
+
+            }
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::SEQ;
+            }
+
+            std::string typestring() const override {
+                return "SEQ";
+            }
+        };
+
     }
 }
\ No newline at end of file

From 371ba87f1c08223f0708e8ceee015d1b5d843466 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sun, 21 Feb 2016 19:35:20 +0100
Subject: [PATCH 144/246] Fixed activation of spares

Former-commit-id: f62ccdc79a984cad432d00d8c06a855e52debdb1
---
 examples/dft/spare8.dft                 |  7 +++++
 src/builder/ExplicitDFTModelBuilder.cpp | 15 +++++-----
 src/storage/dft/DFT.cpp                 | 14 +++++----
 src/storage/dft/DFTElements.h           | 32 ++++++++++++++++----
 src/storage/dft/DFTState.cpp            | 40 ++++++++++---------------
 src/storage/dft/DFTState.h              |  9 +++---
 6 files changed, 69 insertions(+), 48 deletions(-)
 create mode 100644 examples/dft/spare8.dft

diff --git a/examples/dft/spare8.dft b/examples/dft/spare8.dft
new file mode 100644
index 000000000..c67eaf022
--- /dev/null
+++ b/examples/dft/spare8.dft
@@ -0,0 +1,7 @@
+toplevel "A";
+"A" wsp "I" "B";
+"B" wsp "J" "K";
+"I" lambda=0.5 dorm=0.3;
+"J" lambda=0.5 dorm=0.3;
+"K" lambda=0.5 dorm=0.3;
+
diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index cbb9b69d0..4900845a5 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -256,7 +256,7 @@ namespace storm {
                             if (mStates.contains(unsuccessfulState->status())) {
                                 // Unsuccessful state already exists
                                 unsuccessfulStateId = mStates.getValue(unsuccessfulState->status());
-                                STORM_LOG_TRACE("State " << mDft.getStateString(unsuccessfulState) << " already exists");
+                                STORM_LOG_TRACE("State " << mDft.getStateString(unsuccessfulState) << " with id " << unsuccessfulStateId << " already exists");
                             } else {
                                 // New unsuccessful state
                                 unsuccessfulState->setId(newIndex++);
@@ -277,16 +277,15 @@ namespace storm {
                         ++rowOffset;
 
                     } else {
-                        // Set failure rate according to usage
-                        bool isUsed = true;
+                        // Set failure rate according to activation
+                        bool isActive = true;
                         if (mDft.hasRepresentant(nextBE->id())) {
-                            DFTElementCPointer representant = mDft.getRepresentant(nextBE->id());
-                            // Used must be checked for the state we are coming from as this state is responsible for the
+                            // Active must be checked for the state we are coming from as this state is responsible for the
                             // rate and not the new state we are going to
-                            isUsed = state->isUsed(representant->id());
+                            isActive = state->isActive(mDft.getRepresentant(nextBE->id())->id());
                         }
-                        STORM_LOG_TRACE("BE " << nextBE->name() << " is " << (isUsed ? "used" : "not used"));
-                        ValueType rate = isUsed ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
+                        STORM_LOG_TRACE("BE " << nextBE->name() << " is " << (isActive ? "active" : "not active"));
+                        ValueType rate = isActive ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
                         auto resultFind = outgoingTransitions.find(newStateId);
                         if (resultFind != outgoingTransitions.end()) {
                             // Add to existing transition
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 92e780872..3fbcd5ee1 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -191,10 +191,11 @@ namespace storm {
                 } else {
                     stream << "\t** " << storm::storage::toChar(state->getElementState(elem->id()));
                     if(elem->isSpareGate()) {
-                        if(state->isActiveSpare(elem->id())) {
-                            stream << " actively";
+                        size_t useId = state->uses(elem->id());
+                        if(state->isActive(useId)) {
+                            stream << " actively ";
                         }
-                        stream << " using " << state->uses(elem->id());
+                        stream << " using " << useId;
                     }
                 }
                 stream << std::endl;
@@ -214,10 +215,11 @@ namespace storm {
                     stream << storm::storage::toChar(state->getElementState(elem->id()));
                     if(elem->isSpareGate()) {
                         stream << "[";
-                        if(state->isActiveSpare(elem->id())) {
-                            stream << "actively ";
+                        size_t useId = state->uses(elem->id());
+                        if(state->isActive(useId)) {
+                            stream << " actively ";
                         }
-                        stream << "using " << state->uses(elem->id()) << "]";
+                        stream << "using " << useId << "]";
                     }
                 }
             }
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index eaee1d54a..22c819f84 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -259,11 +259,13 @@ namespace storm {
             virtual void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const = 0;
             
             virtual void extendSpareModule(std::set<size_t>& elementsInSpareModule) const override {
-                DFTElement<ValueType>::extendSpareModule(elementsInSpareModule);
-                for(auto const& child : mChildren) {
-                    if(elementsInSpareModule.count(child->id()) == 0) {
-                        elementsInSpareModule.insert(child->id());
-                        child->extendSpareModule(elementsInSpareModule);
+                if (!this->isSpareGate()) {
+                    DFTElement<ValueType>::extendSpareModule(elementsInSpareModule);
+                    for( auto const& child : mChildren) {
+                        if(elementsInSpareModule.count(child->id()) == 0) {
+                            elementsInSpareModule.insert(child->id());
+                            child->extendSpareModule(elementsInSpareModule);
+                        }
                     }
                 }
             }
@@ -350,6 +352,9 @@ namespace storm {
                     }
                 }
                 state.setFailed(this->mId);
+                if (this->isSpareGate()) {
+                    this->finalizeSpare(state);
+                }
                 this->childrenDontCare(state, queues);
             }
 
@@ -360,6 +365,9 @@ namespace storm {
                     }
                 }
                 state.setFailsafe(this->mId);
+                if (this->isSpareGate()) {
+                    this->finalizeSpare(state);
+                }
                 this->childrenDontCare(state, queues);
             }
 
@@ -367,6 +375,20 @@ namespace storm {
                 queues.propagateDontCare(mChildren);
             }
 
+            /**
+             * Finish failed/failsafe spare gate by activating the children and setting the useIndex to zero.
+             * This prevents multiple fail states with different usages or activations.
+             * @param state The current state.
+             */
+            void finalizeSpare(DFTState<ValueType>& state) const {
+                state.setUses(this->mId, 0);
+                for (auto child : this->children()) {
+                    if (!state.isActive(child->id())) {
+                        state.activate(child->id());
+                    }
+                }
+            }
+
             bool hasFailsafeChild(DFTState<ValueType>& state) const {
                 for(auto const& child : mChildren) {
                     if(state.isFailsafe(child->id()))
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 0bad03f78..7f34e03ef 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -7,7 +7,6 @@ namespace storm {
 
         template<typename ValueType>
         DFTState<ValueType>::DFTState(DFT<ValueType> const& dft, DFTStateGenerationInfo const& stateGenerationInfo, size_t id) : mStatus(dft.stateVectorSize()), mId(id), mDft(dft), mStateGenerationInfo(stateGenerationInfo)  {
-            mInactiveSpares = dft.getSpareIndices();
             
             // Initialize uses
             for(size_t id  : mDft.getSpareIndices()) {
@@ -18,12 +17,7 @@ namespace storm {
             }
             
             // Initialize activation
-            this->activate(mDft.getTopLevelIndex());
-            for(auto const& id : mDft.module(mDft.getTopLevelIndex())) {
-                if(mDft.getElement(id)->isSpareGate()) {
-                    propagateActivation(uses(id));
-                }
-            }
+            propagateActivation(mDft.getTopLevelIndex());
 
             std::vector<size_t> alwaysActiveBEs = dft.nonColdBEs();
             mIsCurrentlyFailableBE.insert(mIsCurrentlyFailableBE.end(), alwaysActiveBEs.begin(), alwaysActiveBEs.end());
@@ -182,29 +176,25 @@ namespace storm {
 
         template<typename ValueType>
         void DFTState<ValueType>::activate(size_t repr) {
-            for(size_t elem : mDft.module(repr)) {
-                if(mDft.getElement(elem)->isColdBasicElement() && isOperational(elem)) {
-                    mIsCurrentlyFailableBE.push_back(elem);
-                }
-                else if(mDft.getElement(elem)->isSpareGate()) {
-                    assert(std::find(mInactiveSpares.begin(), mInactiveSpares.end(), elem) != mInactiveSpares.end());
-                    mInactiveSpares.erase(std::find(mInactiveSpares.begin(), mInactiveSpares.end(), elem));
-                }
-            }
+            size_t activationIndex = mStateGenerationInfo.getSpareActivationIndex(repr);
+            assert(!mStatus[activationIndex]);
+            mStatus.set(activationIndex);
+            propagateActivation(repr);
         }
 
         template<typename ValueType>
-        bool DFTState<ValueType>::isActiveSpare(size_t id) const {
-            assert(mDft.getElement(id)->isSpareGate());
-            return (std::find(mInactiveSpares.begin(), mInactiveSpares.end(), id) == mInactiveSpares.end());
+        bool DFTState<ValueType>::isActive(size_t id) const {
+            assert(mDft.isRepresentative(id));
+            return mStatus[mStateGenerationInfo.getSpareActivationIndex(id)];
         }
             
         template<typename ValueType>
         void DFTState<ValueType>::propagateActivation(size_t representativeId) {
-            activate(representativeId);
-            for(size_t id : mDft.module(representativeId)) {
-                if(mDft.getElement(id)->isSpareGate()) {
-                    propagateActivation(uses(id));
+            for(size_t elem : mDft.module(representativeId)) {
+                if(mDft.getElement(elem)->isColdBasicElement() && isOperational(elem)) {
+                    mIsCurrentlyFailableBE.push_back(elem);
+                } else if (mDft.getElement(elem)->isSpareGate() && !isActive(uses(elem))) {
+                    activate(uses(elem));
                 }
             }
         }
@@ -243,8 +233,8 @@ namespace storm {
                 size_t childId = (*it)->id();
                 if(!hasFailed(childId) && !isUsed(childId)) {
                     setUses(spareId, childId);
-                    if(isActiveSpare(spareId)) {
-                        propagateActivation(childId);
+                    if(isActive(currentlyUses)) {
+                        activate(childId);
                     }
                     return true;
                 }
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 821aa2fcb..7a26e10ab 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -26,7 +26,6 @@ namespace storm {
             // Status is bitvector where each element has two bits with the meaning according to DFTElementState
             storm::storage::BitVector mStatus;
             size_t mId;
-            std::vector<size_t> mInactiveSpares;
             std::vector<size_t> mIsCurrentlyFailableBE;
             std::vector<size_t> mFailableDependencies;
             std::vector<size_t> mUsedRepresentants;
@@ -79,9 +78,7 @@ namespace storm {
             
             void activate(size_t repr);
             
-            bool isActiveSpare(size_t id) const;
-            
-            void propagateActivation(size_t representativeId);
+            bool isActive(size_t id) const;
             
             void markAsInvalid() {
                 mValid = false;
@@ -200,6 +197,10 @@ namespace storm {
             friend bool operator==(DFTState const& a, DFTState const& b) {
                 return a.mStatus == b.mStatus;
             }
+            
+        private:
+            void propagateActivation(size_t representativeId);
+
         };
 
     }

From a6f389fce2ed993a29a1adf3c6ab165a71e85e1e Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Sun, 21 Feb 2016 20:59:08 +0100
Subject: [PATCH 145/246] SEQ in the parser

Former-commit-id: 8163e7149ccd512ddbb109ca907c040836711079
---
 src/parser/DFTGalileoParser.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index d11f5ae3b..65ad82437 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -102,6 +102,8 @@ namespace storm {
                         success = builder.addPandElement(name, childNames);
                     } else if (tokens[1] == "wsp" || tokens[1] == "csp") {
                         success = builder.addSpareElement(name, childNames);
+                    } else if (tokens[1] == "seq") {
+                        success = builder.addSequenceEnforcer(name, childNames);
                     } else if (tokens[1] == "fdep") {
                         success = builder.addDepElement(name, childNames, storm::utility::one<ValueType>());
                     } else if (boost::starts_with(tokens[1], "pdep=")) {

From 9dd2a71f2f78808892bc26b7b8d69c3c4c8b05fb Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Sun, 21 Feb 2016 20:59:45 +0100
Subject: [PATCH 146/246] towards state space construction for SEQs

Former-commit-id: 890ce8bd85d0e7660653f2370e8ec764b8233caf
---
 src/storage/dft/DFT.h                         |  1 +
 src/storage/dft/DFTElements.cpp               |  2 +-
 src/storage/dft/DFTElements.h                 | 16 +++++++++++++++
 .../dft/DFTStateSpaceGenerationQueues.h       | 20 +++++++++++++++++++
 src/storage/dft/elements/DFTRestriction.h     |  4 ++--
 5 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index a0059d81b..1f3e8cceb 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -10,6 +10,7 @@
 #include <boost/iterator/counting_iterator.hpp>
 
 #include "DFTElements.h"
+#include "elements/DFTRestriction.h"
 #include "../BitVector.h"
 #include "SymmetricUnits.h"
 #include "../../utility/math.h"
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index e06b3fe7d..9d21e5dd4 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -52,7 +52,7 @@ namespace storm {
 
         template<typename ValueType>
         std::vector<size_t> DFTElement<ValueType>::independentSubDft() const {
-            std::cout << "INDEPENDENT SUBTREE CALL " << this->id() << std::endl;
+            //std::cout << "INDEPENDENT SUBTREE CALL " << this->id() << std::endl;
             std::vector<size_t> res;
             res.push_back(this->id());
             return res;
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index db1f0f6cf..bb4be80a7 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -159,6 +159,18 @@ namespace storm {
             DFTGateVector const& parents() const {
                 return mParents;
             }
+            
+            bool hasRestrictions() const {
+                return !mRestrictions.empty();
+            }
+            
+            size_t nrRestrictions() const {
+                return mRestrictions.size();
+            }
+            
+            DFTRestrictionVector const& restrictions() const {
+                return mRestrictions;
+            }
 
             std::vector<size_t> parentIds() const {
                 std::vector<size_t> res;
@@ -371,7 +383,11 @@ namespace storm {
                         queues.propagateFailure(parent);
                     }
                 }
+                for(std::shared_ptr<DFTRestriction<ValueType>> restr : this->mRestrictions) {
+                    queues.checkRestrictionLater(restr);
+                }
                 state.setFailed(this->mId);
+                // TODO can this be moved towards DFTSpare?
                 if (this->isSpareGate()) {
                     this->finalizeSpare(state);
                 }
diff --git a/src/storage/dft/DFTStateSpaceGenerationQueues.h b/src/storage/dft/DFTStateSpaceGenerationQueues.h
index b881a220b..6ded7cb38 100644
--- a/src/storage/dft/DFTStateSpaceGenerationQueues.h
+++ b/src/storage/dft/DFTStateSpaceGenerationQueues.h
@@ -15,6 +15,8 @@ namespace storm {
         class DFTGate;
         template<typename ValueType>
         class DFTElement;
+        template<typename ValueType>
+        class DFTRestriction;
 
 
         template<typename ValueType>
@@ -24,11 +26,14 @@ namespace storm {
             using DFTElementVector = std::vector<DFTElementPointer>;
             using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
             using DFTGateVector = std::vector<DFTGatePointer>;
+            using DFTRestrictionPointer = std::shared_ptr<DFTRestriction<ValueType>>;
+            using DFTRestrictionVector = std::vector<DFTRestrictionPointer>;
 
             std::priority_queue<DFTGatePointer, DFTGateVector, OrderElementsByRank<ValueType>> failurePropagation;
             DFTGateVector failsafePropagation;
             DFTElementVector dontcarePropagation;
             DFTElementVector activatePropagation;
+            DFTRestrictionVector restrictionChecks;
 
         public:
             void propagateFailure(DFTGatePointer const& elem) {
@@ -45,6 +50,21 @@ namespace storm {
                 return next;
             }
             
+            bool restrictionChecksDone() const {
+                return restrictionChecks.empty();
+            }
+            
+            DFTRestrictionPointer nextRestrictionCheck() {
+                assert(!restrictionChecksDone());
+                DFTRestrictionPointer next = restrictionChecks.back();
+                restrictionChecks.pop_back();
+                return next;
+            }
+            
+            void checkRestrictionLater(DFTRestrictionPointer const& restr) {
+                restrictionChecks.push_back(restr);
+            }
+            
             bool failsafePropagationDone() const {
                 return failsafePropagation.empty();
             }
diff --git a/src/storage/dft/elements/DFTRestriction.h b/src/storage/dft/elements/DFTRestriction.h
index 464c49db2..0d8651e50 100644
--- a/src/storage/dft/elements/DFTRestriction.h
+++ b/src/storage/dft/elements/DFTRestriction.h
@@ -127,7 +127,7 @@ namespace storm {
         protected:
 
             void fail(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-                //state.restrictionViolated(this->mId);
+                state.markAsInvalid();
             }
 
             void failsafe(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
@@ -187,7 +187,7 @@ namespace storm {
             }
 
             void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                assert(this->hasFailsafeChild(state));
+                
 
             }
 

From dde9af6c44959254518f5d684a4a73c35184f049 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Mon, 22 Feb 2016 00:05:05 +0100
Subject: [PATCH 147/246] mergeFailedStates and some updates for SEQs

Former-commit-id: 128a7e0da53e11d8853a07d799c15720724dca34
---
 src/builder/ExplicitDFTModelBuilder.cpp   | 87 +++++++++++++++--------
 src/builder/ExplicitDFTModelBuilder.h     |  5 ++
 src/storage/dft/DFTBuilder.cpp            |  1 +
 src/storage/dft/DFTElements.cpp           |  4 ++
 src/storage/dft/elements/DFTRestriction.h | 12 ++--
 src/storm-dyftee.cpp                      |  2 +-
 6 files changed, 74 insertions(+), 37 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 4900845a5..1840ba40a 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -57,36 +57,47 @@ namespace storm {
         template <typename ValueType>
         std::shared_ptr<storm::models::sparse::Model<ValueType>> ExplicitDFTModelBuilder<ValueType>::buildModel(LabelOptions const& labelOpts) {
             // Initialize
-            DFTStatePointer state = std::make_shared<storm::storage::DFTState<ValueType>>(mDft, *mStateGenerationInfo, newIndex++);
-            mStates.findOrAdd(state->status(), state->getId());
-
-            std::queue<DFTStatePointer> stateQueue;
-            stateQueue.push(state);
-
             bool deterministicModel = false;
             ModelComponents modelComponents;
             std::vector<uint_fast64_t> tmpMarkovianStates;
             storm::storage::SparseMatrixBuilder<ValueType> transitionMatrixBuilder(0, 0, 0, false, !deterministicModel, 0);
+            
 
+            if(mergeFailedStates) {
+                newIndex++;
+                
+                transitionMatrixBuilder.newRowGroup(failedIndex);
+                transitionMatrixBuilder.addNextValue(failedIndex, failedIndex, storm::utility::one<ValueType>());
+                STORM_LOG_TRACE("Added self loop for " << failedIndex);
+                modelComponents.exitRates.push_back(storm::utility::one<ValueType>());
+                tmpMarkovianStates.push_back(failedIndex);        
+            }
+            
+            DFTStatePointer state = std::make_shared<storm::storage::DFTState<ValueType>>(mDft, *mStateGenerationInfo, newIndex++);
+            mStates.findOrAdd(state->status(), state->getId());
+            initialStateIndex = state->getId();
+            std::queue<DFTStatePointer> stateQueue;
+            stateQueue.push(state);
+            
             // Begin model generation
             bool deterministic = exploreStates(stateQueue, transitionMatrixBuilder, tmpMarkovianStates, modelComponents.exitRates);
-            STORM_LOG_DEBUG("Generated " << mStates.size() << " states");
+            STORM_LOG_DEBUG("Generated " << mStates.size() + (mergeFailedStates ? 1 : 0) << " states");
             STORM_LOG_DEBUG("Model is " << (deterministic ? "deterministic" : "non-deterministic"));
 
+            size_t stateSize = mStates.size() + (mergeFailedStates ? 1 : 0);
             // Build Markov Automaton
-            modelComponents.markovianStates = storm::storage::BitVector(mStates.size(), tmpMarkovianStates);
+            modelComponents.markovianStates = storm::storage::BitVector(stateSize, tmpMarkovianStates);
             // Build transition matrix
-            modelComponents.transitionMatrix = transitionMatrixBuilder.build();
+            modelComponents.transitionMatrix = transitionMatrixBuilder.build(stateSize, stateSize);
             STORM_LOG_DEBUG("Transition matrix: " << std::endl << modelComponents.transitionMatrix);
             STORM_LOG_DEBUG("Exit rates: " << modelComponents.exitRates);
             STORM_LOG_DEBUG("Markovian states: " << modelComponents.markovianStates);
-            assert(!deterministic || modelComponents.transitionMatrix.getRowCount() == modelComponents.transitionMatrix.getColumnCount());
-
+            
             // Build state labeling
-            modelComponents.stateLabeling = storm::models::sparse::StateLabeling(mStates.size());
+            modelComponents.stateLabeling = storm::models::sparse::StateLabeling(mStates.size() + (mergeFailedStates ? 1 : 0));
             // Initial state is always first state without any failure
             modelComponents.stateLabeling.addLabel("init");
-            modelComponents.stateLabeling.addLabelToState("init", 0);
+            modelComponents.stateLabeling.addLabelToState("init", initialStateIndex);
             // Label all states corresponding to their status (failed, failsafe, failed BE)
             if(labelOpts.buildFailLabel) {
                 modelComponents.stateLabeling.addLabel("failed");
@@ -103,10 +114,13 @@ namespace storm {
                 }
             }
 
+            if(mergeFailedStates) {
+                modelComponents.stateLabeling.addLabelToState("failed", failedIndex);
+            }
             for (auto const& stateIdPair : mStates) {
                 storm::storage::BitVector state = stateIdPair.first;
                 size_t stateId = stateIdPair.second;
-                if (labelOpts.buildFailLabel && mDft.hasFailed(state, *mStateGenerationInfo)) {
+                if (!mergeFailedStates && labelOpts.buildFailLabel && mDft.hasFailed(state, *mStateGenerationInfo)) {
                     modelComponents.stateLabeling.addLabelToState("failed", stateId);
                 }
                 if (labelOpts.buildFailSafeLabel && mDft.isFailsafe(state, *mStateGenerationInfo)) {
@@ -151,13 +165,12 @@ namespace storm {
         template <typename ValueType>
         bool ExplicitDFTModelBuilder<ValueType>::exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates) {
 
-            assert(exitRates.empty());
-            assert(markovianStates.empty());
             // TODO Matthias: set Markovian states directly as bitvector?
             std::map<size_t, ValueType> outgoingTransitions;
             size_t rowOffset = 0; // Captures number of non-deterministic choices
             bool deterministic = true;
-
+            
+            
             while (!stateQueue.empty()) {
                 // Initialization
                 outgoingTransitions.clear();
@@ -189,6 +202,7 @@ namespace storm {
 
                 // Let BE fail
                 while (smallest < failableCount) {
+                    assert(!mDft.hasFailed(state));
                     STORM_LOG_TRACE("exploring from: " << mDft.getStateString(state));
 
                     // Construct new state as copy from original one
@@ -207,11 +221,23 @@ namespace storm {
                             queues.propagateFailure(parent);
                         }
                     }
+                    for (DFTRestrictionPointer restr : nextBE->restrictions()) {
+                        queues.checkRestrictionLater(restr);
+                    }
 
                     while (!queues.failurePropagationDone()) {
                         DFTGatePointer next = queues.nextFailurePropagation();
                         next->checkFails(*newState, queues);
                     }
+                    
+                    while(!queues.restrictionChecksDone()) {
+                        DFTRestrictionPointer next = queues.nextRestrictionCheck();
+                        next->checkFails(*newState, queues);
+                    } 
+                    
+                    if(newState->isInvalid()) {
+                        continue;
+                    }
 
                     while (!queues.failsafePropagationDone()) {
                         DFTGatePointer next = queues.nextFailsafePropagation();
@@ -226,19 +252,24 @@ namespace storm {
                     // Update failable dependencies
                     newState->updateFailableDependencies(nextBE->id());
                     
+                    bool dftFailed = newState->hasFailed(mDft.getTopLevelIndex());
                     size_t newStateId;
-                    if (mStates.contains(newState->status())) {
-                        // State already exists
-                        newStateId = mStates.getValue(newState->status());
-                        STORM_LOG_TRACE("State " << mDft.getStateString(newState) << " already exists");
+                    if(dftFailed && mergeFailedStates) {
+                        newStateId = failedIndex;
                     } else {
-                        // New state
-                        newState->setId(newIndex++);
-                        newStateId = mStates.findOrAdd(newState->status(), newState->getId());
-                        STORM_LOG_TRACE("New state " << mDft.getStateString(newState));
-
-                        // Add state to search queue
-                        stateQueue.push(newState);
+                       if (mStates.contains(newState->status())) {
+                            // State already exists
+                            newStateId = mStates.getValue(newState->status());
+                            STORM_LOG_TRACE("State " << mDft.getStateString(newState) << " already exists");
+                        } else {
+                            // New state
+                            newState->setId(newIndex++);
+                            newStateId = mStates.findOrAdd(newState->status(), newState->getId());
+                            STORM_LOG_TRACE("New state " << mDft.getStateString(newState));
+
+                            // Add state to search queue
+                            stateQueue.push(newState);
+                        } 
                     }
 
                     // Set transitions
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 522f2375c..42ca2755d 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -23,6 +23,8 @@ namespace storm {
             using DFTElementCPointer = std::shared_ptr<storm::storage::DFTElement<ValueType> const>;
             using DFTGatePointer = std::shared_ptr<storm::storage::DFTGate<ValueType>>;
             using DFTStatePointer = std::shared_ptr<storm::storage::DFTState<ValueType>>;
+            using DFTRestrictionPointer = std::shared_ptr<storm::storage::DFTRestriction<ValueType>>;
+
 
             // A structure holding the individual components of a model.
             struct ModelComponents {
@@ -52,6 +54,9 @@ namespace storm {
             std::shared_ptr<storm::storage::DFTStateGenerationInfo> mStateGenerationInfo;
             storm::storage::BitVectorHashMap<size_t> mStates;
             size_t newIndex = 0;
+            bool mergeFailedStates = true;
+            size_t failedIndex = 0;
+            size_t initialStateIndex = 0;
 
         public:
               struct LabelOptions {
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index 62b022635..213fce0df 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -130,6 +130,7 @@ namespace storm {
             mElements[name] = restr;
             mRestrictionChildNames[restr] = children;
             mRestrictions.push_back(restr);
+            return true;
         }
 
         template<typename ValueType>
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index 9d21e5dd4..7bb8c2cf5 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -10,6 +10,7 @@ namespace storm {
             if (state.dontCare(mId)) {
                 return false;
             }
+            
             // Check that no outgoing dependencies can be triggered anymore
             for (DFTDependencyPointer dependency : mOutgoingDependencies) {
                 if (state.isOperational(dependency->dependentEvent()->id()) && state.isOperational(dependency->triggerEvent()->id())) {
@@ -22,6 +23,9 @@ namespace storm {
                     return false;
                 }
             }
+            
+            
+        
 
             state.setDontCare(mId);
             return true;
diff --git a/src/storage/dft/elements/DFTRestriction.h b/src/storage/dft/elements/DFTRestriction.h
index 0d8651e50..46b6e23cc 100644
--- a/src/storage/dft/elements/DFTRestriction.h
+++ b/src/storage/dft/elements/DFTRestriction.h
@@ -116,10 +116,6 @@ namespace storm {
             }
 
             virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                if(DFTElement<ValueType>::checkDontCareAnymore(state, queues)) {
-                    childrenDontCare(state, queues);
-                    return true;
-                }
                 return false;
             }
 
@@ -134,10 +130,6 @@ namespace storm {
 
             }
 
-            void childrenDontCare(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-                queues.propagateDontCare(mChildren);
-            }
-
             bool hasFailsafeChild(DFTState<ValueType>& state) const {
                 for(auto const& child : mChildren) {
                     if(state.isFailsafe(child->id()))
@@ -189,6 +181,10 @@ namespace storm {
             void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 
 
+            }
+            
+            bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) {
+                
             }
 
             virtual DFTElementType type() const override {
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 2160ed210..aa2e0879f 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -48,7 +48,7 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     
     std::cout << "Bisimulation..." << std::endl;
     
-    if (model->isOfType(storm::models::ModelType::Ctmc)) {
+    if (model->getNumberOfStates() > 500 && model->isOfType(storm::models::ModelType::Ctmc)) {
             model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), formulas, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
     }
     

From f89cc46576e1fb07cb3981fd37f042e609aabea8 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Mon, 22 Feb 2016 00:05:27 +0100
Subject: [PATCH 148/246] two more small examples

Former-commit-id: 9d420a62b21d0e41270a5419071061c0687464cb
---
 examples/dft/seq1.dft       | 5 +++++
 examples/dft/spare_cold.dft | 5 +++++
 2 files changed, 10 insertions(+)
 create mode 100644 examples/dft/seq1.dft
 create mode 100644 examples/dft/spare_cold.dft

diff --git a/examples/dft/seq1.dft b/examples/dft/seq1.dft
new file mode 100644
index 000000000..8f5459fd2
--- /dev/null
+++ b/examples/dft/seq1.dft
@@ -0,0 +1,5 @@
+toplevel "A";
+"A" and "B" "C";
+"X" seq "B" "C";
+"B" lambda=0.5 dorm=0.3;
+"C" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/spare_cold.dft b/examples/dft/spare_cold.dft
new file mode 100644
index 000000000..d01174bd5
--- /dev/null
+++ b/examples/dft/spare_cold.dft
@@ -0,0 +1,5 @@
+toplevel "A";
+"A" wsp "I" "M";
+"I" lambda=0.5 dorm=0.0;
+"M" lambda=0.5 dorm=0.0;
+

From fa4a1aa68f24517cfd38d06daec991ebcb2a6903 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 22 Feb 2016 15:44:37 +0100
Subject: [PATCH 149/246] Fixed bug with filtering reward vector

Former-commit-id: ad709ad0dd3da3c062480f1cd23e910e46064dab
---
 .../SparseDtmcEliminationModelChecker.cpp     | 23 +++++++++++++++----
 .../SparseDtmcEliminationModelChecker.h       |  2 ++
 2 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
index 2ea8fa459..5425044b2 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
@@ -584,11 +584,13 @@ namespace storm {
             
             // Do some sanity checks to establish some required properties.
             RewardModelType const& rewardModel = this->getModel().getRewardModel(checkTask.isRewardModelSet() ? checkTask.getRewardModel() : "");
-            // TODO use maybeStates instead of all states
-            std::vector<ValueType> stateRewardValues = rewardModel.getTotalRewardVector(trueStates.getNumberOfSetBits(), this->getModel().getTransitionMatrix(), trueStates);
 
             STORM_LOG_THROW(!rewardModel.empty(), storm::exceptions::IllegalArgumentException, "Input model does not have a reward model.");
-            std::vector<ValueType> result = computeReachabilityRewards(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), this->getModel().getInitialStates(), targetStates, stateRewardValues, checkTask.isOnlyInitialStatesRelevantSet());
+            std::vector<ValueType> result = computeReachabilityRewards(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), this->getModel().getInitialStates(), targetStates,
+                                                                       [&] (uint_fast64_t numberOfRows, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::BitVector const& maybeStates) {
+                                                                           return rewardModel.getTotalRewardVector(numberOfRows, transitionMatrix, maybeStates);
+                                                                       },
+                                                                       checkTask.isOnlyInitialStatesRelevantSet());
 
             // Construct check result.
             std::unique_ptr<CheckResult> checkResult(new ExplicitQuantitativeCheckResult<ValueType>(result));
@@ -597,6 +599,17 @@ namespace storm {
 
         template<typename SparseDtmcModelType>
         std::vector<typename SparseDtmcModelType::ValueType> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::computeReachabilityRewards(storm::storage::SparseMatrix<ValueType> const& probabilityMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, std::vector<ValueType>& stateRewardValues, bool computeForInitialStatesOnly) {
+            return computeReachabilityRewards(probabilityMatrix, backwardTransitions, initialStates, targetStates,
+                                              [&] (uint_fast64_t numberOfRows, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::BitVector const& maybeStates) {
+                                                  std::vector<ValueType> result(numberOfRows);
+                                                  storm::utility::vector::selectVectorValues(result, maybeStates, stateRewardValues);
+                                                  return result;
+                                              },
+                                              computeForInitialStatesOnly);
+        }
+
+        template<typename SparseDtmcModelType>
+        std::vector<typename SparseDtmcModelType::ValueType> SparseDtmcEliminationModelChecker<SparseDtmcModelType>::computeReachabilityRewards(storm::storage::SparseMatrix<ValueType> const& probabilityMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, std::function<std::vector<ValueType>(uint_fast64_t, storm::storage::SparseMatrix<ValueType> const&, storm::storage::BitVector const&)> const& totalStateRewardVectorGetter, bool computeForInitialStatesOnly) {
 
             uint_fast64_t numberOfStates = probabilityMatrix.getRowCount();
             
@@ -639,9 +652,9 @@ namespace storm {
                 storm::storage::SparseMatrix<ValueType> submatrixTransposed = submatrix.transpose();
                 
                 // Project the state reward vector to all maybe-states.
-                storm::storage::BitVector phiStates(numberOfStates, true);
+                std::vector<ValueType> stateRewardValues = totalStateRewardVectorGetter(submatrix.getRowCount(), probabilityMatrix, maybeStates);
 
-                std::vector<ValueType> subresult = computeReachabilityValues(submatrix, stateRewardValues, submatrixTransposed, newInitialStates, computeForInitialStatesOnly, phiStates, targetStates, probabilityMatrix.getConstrainedRowSumVector(maybeStates, targetStates));
+                std::vector<ValueType> subresult = computeReachabilityValues(submatrix, stateRewardValues, submatrixTransposed, newInitialStates, computeForInitialStatesOnly, trueStates, targetStates, probabilityMatrix.getConstrainedRowSumVector(maybeStates, targetStates));
                 storm::utility::vector::setVectorValues<ValueType>(result, maybeStates, subresult);
             }
             
diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
index 76e939d66..33b61a2c4 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h
@@ -91,6 +91,8 @@ namespace storm {
             
             static std::vector<ValueType> computeLongRunValues(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& maybeStates, bool computeResultsForInitialStatesOnly, std::vector<ValueType>& stateValues);
             
+            static std::vector<ValueType> computeReachabilityRewards(storm::storage::SparseMatrix<ValueType> const& probabilityMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, std::function<std::vector<ValueType>(uint_fast64_t, storm::storage::SparseMatrix<ValueType> const&, storm::storage::BitVector const&)> const& totalStateRewardVectorGetter, bool computeForInitialStatesOnly);
+
             static std::vector<ValueType> computeReachabilityValues(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, std::vector<ValueType>& values, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& initialStates, bool computeResultsForInitialStatesOnly, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, std::vector<ValueType> const& oneStepProbabilitiesToTarget);
             
             static std::shared_ptr<StatePriorityQueue<ValueType>> createStatePriorityQueue(boost::optional<std::vector<uint_fast64_t>> const& stateDistances, storm::storage::FlexibleSparseMatrix<ValueType> const& transitionMatrix, storm::storage::FlexibleSparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType>& oneStepProbabilities, storm::storage::BitVector const& states);

From a44d38e0bfe47637a083ac292be31446c33376bf Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 22 Feb 2016 15:48:50 +0100
Subject: [PATCH 150/246] Symmetries are given to StateGenerationInfo

Former-commit-id: b91cce3a81815032bcb95b80ea9b37aa8c076aa3
---
 src/builder/ExplicitDFTModelBuilder.cpp | 36 ++-----------------------
 src/builder/ExplicitDFTModelBuilder.h   |  6 ++---
 src/storage/dft/DFT.cpp                 | 10 +++++--
 src/storage/dft/DFT.h                   |  2 +-
 src/storm-dyftee.cpp                    | 11 ++++----
 5 files changed, 20 insertions(+), 45 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 1840ba40a..a1973d519 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -15,42 +15,10 @@ namespace storm {
         }
         
         template <typename ValueType>
-        ExplicitDFTModelBuilder<ValueType>::ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft) : mDft(dft), mStates(((mDft.stateVectorSize() / 64) + 1) * 64, INITIAL_BUCKETSIZE) {
+        ExplicitDFTModelBuilder<ValueType>::ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft, storm::storage::DFTIndependentSymmetries const& symmetries) : mDft(dft), mStates(((mDft.stateVectorSize() / 64) + 1) * 64, INITIAL_BUCKETSIZE) {
             // stateVectorSize is bound for size of bitvector
 
-            // Find symmetries
-            // TODO activate
-            // Currently using hack to test
-            std::vector<std::vector<size_t>> symmetriesTmp;
-            std::vector<size_t> vecB;
-            std::vector<size_t> vecC;
-            std::vector<size_t> vecD;
-            if (false) {
-                for (size_t i = 0; i < mDft.nrElements(); ++i) {
-                    std::string name = mDft.getElement(i)->name();
-                    size_t id = mDft.getElement(i)->id();
-                    if (boost::starts_with(name, "B")) {
-                        vecB.push_back(id);
-                    } else if (boost::starts_with(name, "C")) {
-                        vecC.push_back(id);
-                    } else if (boost::starts_with(name, "D")) {
-                        vecD.push_back(id);
-                    }
-                }
-                symmetriesTmp.push_back(vecB);
-                symmetriesTmp.push_back(vecC);
-                symmetriesTmp.push_back(vecD);
-                std::cout << "Found the following symmetries:" << std::endl;
-                for (auto const& symmetry : symmetriesTmp) {
-                    for (auto const& elem : symmetry) {
-                        std::cout << elem << " -> ";
-                    }
-                    std::cout << std::endl;
-                }
-            } else {
-                vecB.push_back(mDft.getTopLevelIndex());
-            }
-            mStateGenerationInfo = std::make_shared<storm::storage::DFTStateGenerationInfo>(mDft.buildStateGenerationInfo(vecB, symmetriesTmp));
+            mStateGenerationInfo = std::make_shared<storm::storage::DFTStateGenerationInfo>(mDft.buildStateGenerationInfo(symmetries));
         }
 
 
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 42ca2755d..6d17375b2 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -1,13 +1,13 @@
 #ifndef EXPLICITDFTMODELBUILDER_H
 #define	EXPLICITDFTMODELBUILDER_H
 
-#include "../storage/dft/DFT.h"
-
 #include <src/models/sparse/StateLabeling.h>
 #include <src/models/sparse/StandardRewardModel.h>
 #include <src/models/sparse/Model.h>
 #include <src/storage/SparseMatrix.h>
 #include <src/storage/BitVectorHashMap.h>
+#include <src/storage/dft/DFT.h>
+#include <src/storage/dft/SymmetricUnits.h>
 #include <boost/container/flat_set.hpp>
 #include <boost/optional/optional.hpp>
 #include <stack>
@@ -65,7 +65,7 @@ namespace storm {
                 std::set<std::string> beLabels = {};
             };
             
-            ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft);
+            ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft, storm::storage::DFTIndependentSymmetries const& symmetries);
 
             std::shared_ptr<storm::models::sparse::Model<ValueType>> buildModel(LabelOptions const& labelOpts);
 
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 3fbcd5ee1..c88fbee1c 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -68,7 +68,7 @@ namespace storm {
         }
 
         template<typename ValueType>
-        DFTStateGenerationInfo DFT<ValueType>::buildStateGenerationInfo(std::vector<size_t> const& subTreeRoots, std::vector<std::vector<size_t>> const& symmetries) const {
+        DFTStateGenerationInfo DFT<ValueType>::buildStateGenerationInfo(storm::storage::DFTIndependentSymmetries const& symmetries) const {
             // Use symmetry
             // Collect all elements in the first subtree
             // TODO make recursive to use for nested subtrees
@@ -79,7 +79,13 @@ namespace storm {
             size_t stateIndex = 0;
             std::queue<size_t> visitQueue;
             std::set<size_t> visited;
-            visitQueue.push(subTreeRoots[0]);
+            size_t firstRoot;
+            if (symmetries.groups.empty()) {
+                firstRoot = mTopLevelIndex;
+            } else {
+                firstRoot = symmetries.groups.begin()->first;
+            }
+            visitQueue.push(firstRoot);
             stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
             
             // Consider dependencies
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 1f3e8cceb..d8d6aa9bc 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -126,7 +126,7 @@ namespace storm {
         public:
             DFT(DFTElementVector const& elements, DFTElementPointer const& tle);
             
-            DFTStateGenerationInfo buildStateGenerationInfo(std::vector<size_t> const& subTreeRoots, std::vector<std::vector<size_t>> const& symmetries) const;
+            DFTStateGenerationInfo buildStateGenerationInfo(storm::storage::DFTIndependentSymmetries const& symmetries) const;
 
             size_t performStateGenerationInfoDFS(DFTStateGenerationInfo& generationInfo, std::queue<size_t>& visitQueue, std::set<size_t>& visited, size_t stateIndex) const;
             
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index aa2e0879f..ba50d90f3 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -28,17 +28,19 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     std::vector<std::shared_ptr<storm::logic::Formula>> parsedFormulas = storm::parseFormulasForExplicit(property);
     std::vector<std::shared_ptr<const storm::logic::Formula>> formulas(parsedFormulas.begin(), parsedFormulas.end());
     assert(formulas.size() == 1);
-    std::cout << "parsed formula." << std::endl;
+    std::cout << "Parsed formula." << std::endl;
+    std::map<size_t, std::vector<std::vector<size_t>>> emptySymmetry;
+    storm::storage::DFTIndependentSymmetries symmetries(emptySymmetry);
     if(symred) {
         std::cout << dft.getElementsString() << std::endl;
         auto colouring = dft.colourDFT();
-        storm::storage::DFTIndependentSymmetries symmetries = dft.findSymmetries(colouring);
-        std::cout << symmetries;
+        symmetries = dft.findSymmetries(colouring);
+        std::cout << "Symmetries: " << symmetries << std::endl;
     }
         
     // Building Markov Automaton
     std::cout << "Building Model..." << std::endl;
-    storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft);
+    storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft, symmetries);
     typename storm::builder::ExplicitDFTModelBuilder<ValueType>::LabelOptions labeloptions; // TODO initialize this with the formula
     std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildModel(labeloptions);
     std::cout << "Built Model" << std::endl;
@@ -52,7 +54,6 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
             model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), formulas, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
     }
     
-    
     model->printModelInformationToStream(std::cout);
     
     // Model checking

From 6685b358f07df97ae43890d90493e14fb76f7f7e Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 22 Feb 2016 18:31:52 +0100
Subject: [PATCH 151/246] Symmetry mirrored in state vector

Former-commit-id: 7e5a578c44d7c47637f5575621a648edeb13282f
---
 examples/dft/symmetry3.dft | 12 +++++++
 examples/dft/symmetry4.dft | 12 +++++++
 src/storage/dft/DFT.cpp    | 73 ++++++++++++++++++++++++++++++--------
 src/storage/dft/DFT.h      |  2 +-
 4 files changed, 84 insertions(+), 15 deletions(-)
 create mode 100644 examples/dft/symmetry3.dft
 create mode 100644 examples/dft/symmetry4.dft

diff --git a/examples/dft/symmetry3.dft b/examples/dft/symmetry3.dft
new file mode 100644
index 000000000..edda963f9
--- /dev/null
+++ b/examples/dft/symmetry3.dft
@@ -0,0 +1,12 @@
+toplevel "A";
+"A" and "B" "B'" "B''";
+"B" and "C" "D";
+"B'" and "C'" "D'";
+"B''" and "C''" "D''";
+"C" lambda=0.5 dorm=0;
+"D" lambda=0.5 dorm=0;
+"C'" lambda=0.5 dorm=0;
+"D'" lambda=0.5 dorm=0;
+"C''" lambda=0.5 dorm=0;
+"D''" lambda=0.5 dorm=0;
+
diff --git a/examples/dft/symmetry4.dft b/examples/dft/symmetry4.dft
new file mode 100644
index 000000000..f401fc241
--- /dev/null
+++ b/examples/dft/symmetry4.dft
@@ -0,0 +1,12 @@
+toplevel "A";
+"A" and "B" "B'" "C" "C'";
+"B" and "D" "E";
+"B'" and "D'" "E'";
+"C" or "F";
+"C'" or "F'";
+"D" lambda=0.5 dorm=0;
+"E" lambda=0.5 dorm=0;
+"D'" lambda=0.5 dorm=0;
+"E'" lambda=0.5 dorm=0;
+"F" lambda=0.5 dorm=0;
+"F'" lambda=0.5 dorm=0;
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index c88fbee1c..03812c937 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -72,22 +72,60 @@ namespace storm {
             // Use symmetry
             // Collect all elements in the first subtree
             // TODO make recursive to use for nested subtrees
-            
+
             DFTStateGenerationInfo generationInfo(nrElements());
 
             // Perform DFS and insert all elements of subtree sequentially
             size_t stateIndex = 0;
             std::queue<size_t> visitQueue;
-            std::set<size_t> visited;
-            size_t firstRoot;
+            storm::storage::BitVector visited(nrElements(), false);
+
             if (symmetries.groups.empty()) {
-                firstRoot = mTopLevelIndex;
+                // Perform DFS for whole tree
+                visitQueue.push(mTopLevelIndex);
+                stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
             } else {
-                firstRoot = symmetries.groups.begin()->first;
+                // Perform DFS for first subtree of each symmetry
+                for (auto const& symmetryGroup : symmetries.groups) {
+                    visitQueue.push(symmetryGroup.first);
+                    size_t stateIndexBefore = stateIndex;
+                    stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
+                    size_t offset = stateIndex - stateIndexBefore;
+
+                    // Mirror symmetries
+                    assert(!symmetryGroup.second.empty());
+                    for (std::vector<size_t> symmetricElements : symmetryGroup.second) {
+                        assert(symmetricElements.size() > 1);
+                        size_t originalElement = symmetricElements[0];
+                        size_t index = generationInfo.getStateIndex(originalElement);
+                        size_t activationIndex = isRepresentative(originalElement) ? generationInfo.getSpareActivationIndex(originalElement) : 0;
+                        size_t usageIndex = mElements[originalElement]->isSpareGate() ? generationInfo.getSpareUsageIndex(originalElement) : 0;
+
+                        // Mirror symmetry for each element
+                        for (size_t i = 1; i < symmetricElements.size(); ++i) {
+                            size_t symmetricElement = symmetricElements[i];
+                            visited.set(symmetricElement);
+
+                            generationInfo.addStateIndex(symmetricElement, index + offset * i);
+                            stateIndex += 2;
+
+                            assert((activationIndex > 0) == isRepresentative(symmetricElement));
+                            if (activationIndex > 0) {
+                                generationInfo.addSpareActivationIndex(symmetricElement, activationIndex + offset * i);
+                                ++stateIndex;
+                            }
+
+                            assert((usageIndex > 0) == mElements[symmetricElement]->isSpareGate());
+                            if (usageIndex > 0) {
+                                generationInfo.addSpareUsageIndex(symmetricElement, usageIndex + offset * i);
+                                stateIndex += generationInfo.usageInfoBits();
+                            }
+                        }
+                    }
+                }
             }
-            visitQueue.push(firstRoot);
-            stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
-            
+
+            // TODO symmetries in dependencies?
             // Consider dependencies
             for (size_t idDependency : getDependencies()) {
                 std::shared_ptr<DFTDependency<ValueType> const> dependency = getDependency(idDependency);
@@ -96,24 +134,31 @@ namespace storm {
                 visitQueue.push(dependency->dependentEvent()->id());
             }
             stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
-            
-            assert(stateIndex = mStateVectorSize);
+
+            // Visit all remaining states
+            for (size_t i = 0; i < visited.size(); ++i) {
+                if (!visited[i]) {
+                    visitQueue.push(i);
+                    stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
+                }
+            }
 
             STORM_LOG_TRACE(generationInfo);
-            
+            assert(stateIndex == mStateVectorSize);
+            assert(visited.full());
             return generationInfo;
         }
         
         template<typename ValueType>
-        size_t DFT<ValueType>::performStateGenerationInfoDFS(DFTStateGenerationInfo& generationInfo, std::queue<size_t>& visitQueue, std::set<size_t>& visited, size_t stateIndex) const {
+        size_t DFT<ValueType>::performStateGenerationInfoDFS(DFTStateGenerationInfo& generationInfo, std::queue<size_t>& visitQueue, storm::storage::BitVector& visited, size_t stateIndex) const {
             while (!visitQueue.empty()) {
                 size_t id = visitQueue.front();
                 visitQueue.pop();
-                if (visited.count(id) == 1) {
+                if (visited[id]) {
                     // Already visited
                     continue;
                 }
-                visited.insert(id);
+                visited.set(id);
                 DFTElementPointer element = mElements[id];
                 
                 // Insert children
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index d8d6aa9bc..d3da06776 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -128,7 +128,7 @@ namespace storm {
             
             DFTStateGenerationInfo buildStateGenerationInfo(storm::storage::DFTIndependentSymmetries const& symmetries) const;
 
-            size_t performStateGenerationInfoDFS(DFTStateGenerationInfo& generationInfo, std::queue<size_t>& visitQueue, std::set<size_t>& visited, size_t stateIndex) const;
+            size_t performStateGenerationInfoDFS(DFTStateGenerationInfo& generationInfo, std::queue<size_t>& visitQueue, storm::storage::BitVector& visited, size_t stateIndex) const;
             
             size_t stateVectorSize() const {
                 return mStateVectorSize;

From 1e4dbb1e582820109a98bc2cb54878f3b59342d6 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 23 Feb 2016 13:52:06 +0100
Subject: [PATCH 152/246] More preparations for counting abstraction

Former-commit-id: b283b28fdd41a254f82d5c8ece22286a77b4eeac
---
 src/storage/dft/DFT.cpp | 72 ++++++++++++++++++++++++++---------------
 src/storage/dft/DFT.h   | 29 +++++++++++++++++
 2 files changed, 75 insertions(+), 26 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 03812c937..b61425953 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -85,22 +85,28 @@ namespace storm {
                 visitQueue.push(mTopLevelIndex);
                 stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
             } else {
-                // Perform DFS for first subtree of each symmetry
                 for (auto const& symmetryGroup : symmetries.groups) {
+                    assert(!symmetryGroup.second.empty());
+
+                    // Perform DFS for first subtree of each symmetry
                     visitQueue.push(symmetryGroup.first);
-                    size_t stateIndexBefore = stateIndex;
+                    size_t groupIndex = stateIndex;
                     stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
-                    size_t offset = stateIndex - stateIndexBefore;
-
+                    size_t offset = stateIndex - groupIndex;
+                    
                     // Mirror symmetries
-                    assert(!symmetryGroup.second.empty());
+                    size_t noSymmetricElements = symmetryGroup.second.front().size();
+                    assert(noSymmetricElements > 1);
+
                     for (std::vector<size_t> symmetricElements : symmetryGroup.second) {
-                        assert(symmetricElements.size() > 1);
+                        assert(symmetricElements.size() == noSymmetricElements);
+
+                        // Initialize for original element
                         size_t originalElement = symmetricElements[0];
                         size_t index = generationInfo.getStateIndex(originalElement);
                         size_t activationIndex = isRepresentative(originalElement) ? generationInfo.getSpareActivationIndex(originalElement) : 0;
                         size_t usageIndex = mElements[originalElement]->isSpareGate() ? generationInfo.getSpareUsageIndex(originalElement) : 0;
-
+                        
                         // Mirror symmetry for each element
                         for (size_t i = 1; i < symmetricElements.size(); ++i) {
                             size_t symmetricElement = symmetricElements[i];
@@ -122,6 +128,13 @@ namespace storm {
                             }
                         }
                     }
+
+                    // Store starting indices of symmetry groups
+                    std::vector<size_t> symmetryIndices;
+                    for (size_t i = 0; i < noSymmetricElements; ++i) {
+                        symmetryIndices.push_back(groupIndex + i * offset);
+                    }
+                    generationInfo.addSymmetry(offset, symmetryIndices);
                 }
             }
 
@@ -146,9 +159,32 @@ namespace storm {
             STORM_LOG_TRACE(generationInfo);
             assert(stateIndex == mStateVectorSize);
             assert(visited.full());
+            
             return generationInfo;
         }
         
+        template<typename ValueType>
+        size_t DFT<ValueType>::generateStateInfo(DFTStateGenerationInfo& generationInfo, size_t id, storm::storage::BitVector& visited, size_t stateIndex) const {
+            assert(!visited[id]);
+            visited.set(id);
+            
+            // Reserve bits for element
+            generationInfo.addStateIndex(id, stateIndex);
+            stateIndex += 2;
+            
+            if (isRepresentative(id)) {
+                generationInfo.addSpareActivationIndex(id, stateIndex);
+                ++stateIndex;
+            }
+            
+            if (mElements[id]->isSpareGate()) {
+                generationInfo.addSpareUsageIndex(id, stateIndex);
+                stateIndex += generationInfo.usageInfoBits();
+            }
+            
+            return stateIndex;
+        }
+        
         template<typename ValueType>
         size_t DFT<ValueType>::performStateGenerationInfoDFS(DFTStateGenerationInfo& generationInfo, std::queue<size_t>& visitQueue, storm::storage::BitVector& visited, size_t stateIndex) const {
             while (!visitQueue.empty()) {
@@ -158,30 +194,14 @@ namespace storm {
                     // Already visited
                     continue;
                 }
-                visited.set(id);
-                DFTElementPointer element = mElements[id];
+                stateIndex = generateStateInfo(generationInfo, id, visited, stateIndex);
                 
                 // Insert children
-                if (element->isGate()) {
-                    for (auto const& child : std::static_pointer_cast<DFTGate<ValueType>>(element)->children()) {
+                if (mElements[id]->isGate()) {
+                    for (auto const& child : std::static_pointer_cast<DFTGate<ValueType>>(mElements[id])->children()) {
                         visitQueue.push(child->id());
                     }
                 }
-                
-                // Reserve bits for element
-                generationInfo.addStateIndex(id, stateIndex);
-                stateIndex += 2;
-                
-                if (isRepresentative(id)) {
-                    generationInfo.addSpareActivationIndex(id, stateIndex);
-                    ++stateIndex;
-                }
-                
-                if (element->isSpareGate()) {
-                    generationInfo.addSpareUsageIndex(id, stateIndex);
-                    stateIndex += generationInfo.usageInfoBits();
-                }
-                
             }
             return stateIndex;
         }
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index d3da06776..22d001aaf 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -41,6 +41,7 @@ namespace storm {
             std::map<size_t, size_t> mSpareUsageIndex; // id spare -> index first bit in state
             std::map<size_t, size_t> mSpareActivationIndex; // id spare representative -> index in state
             std::vector<size_t> mIdToStateIndex; // id -> index first bit in state
+            std::vector<std::pair<size_t, std::vector<size_t>>> mSymmetries; // pair (lenght of symmetry group, vector indicating the starting points of the symmetry groups)
             
         public:
             
@@ -79,6 +80,24 @@ namespace storm {
                 return mSpareActivationIndex.at(id);
             }
             
+            size_t addSymmetry(size_t lenght, std::vector<size_t>& startingIndices) {
+                mSymmetries.push_back(std::make_pair(lenght, startingIndices));
+            }
+            
+            size_t getSymmetrySize() {
+                return mSymmetries.size();
+            }
+            
+            size_t getSymmetryLength(size_t pos) {
+                assert(pos < mSymmetries.size());
+                return mSymmetries[pos].first;
+            }
+            
+            std::vector<size_t> const& getSymmetryIndices(size_t pos) {
+                assert(pos < mSymmetries.size());
+                return mSymmetries[pos].second;
+            }
+            
             friend std::ostream& operator<<(std::ostream& os, DFTStateGenerationInfo const& info) {
                 os << "Id to state index:" << std::endl;
                 for (size_t id = 0; id < info.mIdToStateIndex.size(); ++id) {
@@ -92,6 +111,14 @@ namespace storm {
                 for (auto pair : info.mSpareActivationIndex) {
                     os << pair.first << " -> " << pair.second << std::endl;
                 }
+                os << "Symmetries:" << std::endl;
+                for (auto pair : info.mSymmetries) {
+                    os << "Length: " << pair.first << ", starting indices: ";
+                    for (size_t index : pair.second) {
+                        os << index << ", ";
+                    }
+                    os << std::endl;
+                }
                 return os;
             }
             
@@ -127,6 +154,8 @@ namespace storm {
             DFT(DFTElementVector const& elements, DFTElementPointer const& tle);
             
             DFTStateGenerationInfo buildStateGenerationInfo(storm::storage::DFTIndependentSymmetries const& symmetries) const;
+            
+            size_t generateStateInfo(DFTStateGenerationInfo& generationInfo, size_t id, storm::storage::BitVector& visited, size_t stateIndex) const;
 
             size_t performStateGenerationInfoDFS(DFTStateGenerationInfo& generationInfo, std::queue<size_t>& visitQueue, storm::storage::BitVector& visited, size_t stateIndex) const;
             

From 2e8460548b9110a439a519b4e0facbdeb520a5d6 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 23 Feb 2016 13:52:48 +0100
Subject: [PATCH 153/246] Failed spares set use index to own id

Former-commit-id: e4da5bd5d8d0400fed1531b2891422a918dc090c
---
 src/storage/dft/DFT.cpp       | 10 +++++-----
 src/storage/dft/DFTElements.h |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index b61425953..eef83928d 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -263,10 +263,10 @@ namespace storm {
                     stream << "\t** " << storm::storage::toChar(state->getElementState(elem->id()));
                     if(elem->isSpareGate()) {
                         size_t useId = state->uses(elem->id());
-                        if(state->isActive(useId)) {
-                            stream << " actively ";
+                        if(useId == elem->id() || state->isActive(useId)) {
+                            stream << "actively ";
                         }
-                        stream << " using " << useId;
+                        stream << "using " << useId;
                     }
                 }
                 stream << std::endl;
@@ -287,8 +287,8 @@ namespace storm {
                     if(elem->isSpareGate()) {
                         stream << "[";
                         size_t useId = state->uses(elem->id());
-                        if(state->isActive(useId)) {
-                            stream << " actively ";
+                        if(useId == elem->id() || state->isActive(useId)) {
+                            stream << "actively ";
                         }
                         stream << "using " << useId << "]";
                     }
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index bb4be80a7..3236a5551 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -412,12 +412,12 @@ namespace storm {
             }
 
             /**
-             * Finish failed/failsafe spare gate by activating the children and setting the useIndex to zero.
+             * Finish failed/failsafe spare gate by activating the children and setting the useIndex to the spare id.
              * This prevents multiple fail states with different usages or activations.
              * @param state The current state.
              */
             void finalizeSpare(DFTState<ValueType>& state) const {
-                state.setUses(this->mId, 0);
+                state.setUses(this->mId, this->mId);
                 for (auto child : this->children()) {
                     if (!state.isActive(child->id())) {
                         state.activate(child->id());

From d1482723869c7571b6a53878d8b6a7dc5519d3f0 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 23 Feb 2016 14:24:44 +0100
Subject: [PATCH 154/246] Forgot const

Former-commit-id: 5a748fadf912a65cc3cf332d43bf6ae8a16d3960
---
 src/storage/dft/DFT.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 22d001aaf..453db1443 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -84,16 +84,16 @@ namespace storm {
                 mSymmetries.push_back(std::make_pair(lenght, startingIndices));
             }
             
-            size_t getSymmetrySize() {
+            size_t getSymmetrySize() const {
                 return mSymmetries.size();
             }
             
-            size_t getSymmetryLength(size_t pos) {
+            size_t getSymmetryLength(size_t pos) const {
                 assert(pos < mSymmetries.size());
                 return mSymmetries[pos].first;
             }
             
-            std::vector<size_t> const& getSymmetryIndices(size_t pos) {
+            std::vector<size_t> const& getSymmetryIndices(size_t pos) const {
                 assert(pos < mSymmetries.size());
                 return mSymmetries[pos].second;
             }

From cce39fbd5dc7eeaff21090f850e83b0522c91573 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 23 Feb 2016 18:57:41 +0100
Subject: [PATCH 155/246] Helper function for symmetry ordering on bitvector

Former-commit-id: e98b004de6f93c4287e4a869483c0dce892f29c5
---
 src/storage/dft/DFTState.cpp | 31 +++++++++++++++++++++++++++++++
 src/storage/dft/DFTState.h   |  6 ++++++
 2 files changed, 37 insertions(+)

diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 7f34e03ef..591f6f9da 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -242,6 +242,37 @@ namespace storm {
             }
             return false;
         }
+        
+        template<typename ValueType>
+        bool DFTState<ValueType>::orderBySymmetry() {
+            bool changed = false;
+            for (size_t pos = 0; pos < mStateGenerationInfo.getSymmetrySize(); ++pos) {
+                // Check each symmetry
+                size_t length = mStateGenerationInfo.getSymmetryLength(pos);
+                std::vector<size_t> symmetryIndices = mStateGenerationInfo.getSymmetryIndices(pos);
+                // Sort symmetry group in decreasing order by bubble sort
+                // TODO use better algorithm?
+                size_t tmp, elem1, elem2;
+                size_t n = symmetryIndices.size();
+                do {
+                    tmp = 0;
+                    for (size_t i = 1; i < n; ++i) {
+                        elem1 = mStatus.getAsInt(symmetryIndices[i-1], length);
+                        elem2 = mStatus.getAsInt(symmetryIndices[i], length);
+                        if (elem1 > elem2) {
+                            // Swap elements
+                            mStatus.setFromInt(symmetryIndices[i-1], length, elem2);
+                            mStatus.setFromInt(symmetryIndices[i], length, elem1);
+                            tmp = i;
+                            changed = true;
+                        }
+                    }
+                    n = tmp;
+                } while (n > 0);
+            }
+            return changed;
+        }
+
 
         // Explicitly instantiate the class.
         template class DFTState<double>;
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 7a26e10ab..eccf7f01d 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -164,6 +164,12 @@ namespace storm {
              */
             void letDependencyBeUnsuccessful(size_t index = 0);
             
+            /**
+             * Order the state in decreasing order using the symmetries.
+             * @return True, if elements were swapped, false if nothing changed.
+             */
+            bool orderBySymmetry();
+            
             std::string getCurrentlyFailableString() const {
                 std::stringstream stream;
                 if (nrFailableDependencies() > 0) {

From d340ea74253b17dae0c5cb790aa01aa4db05b0f8 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 24 Feb 2016 13:09:21 +0100
Subject: [PATCH 156/246] Helper function for replacing columns in SpareMatrix

Former-commit-id: aa37022b7c3831988fe70e331860960685954f05
---
 src/storage/SparseMatrix.cpp | 67 ++++++++++++++++++++++++++++++++++++
 src/storage/SparseMatrix.h   | 16 +++++++++
 2 files changed, 83 insertions(+)

diff --git a/src/storage/SparseMatrix.cpp b/src/storage/SparseMatrix.cpp
index d41e2ef2c..fa95f3930 100644
--- a/src/storage/SparseMatrix.cpp
+++ b/src/storage/SparseMatrix.cpp
@@ -220,6 +220,73 @@ namespace storm {
             return lastColumn;
         }
         
+        // Debug method for printing the current matrix
+        template<typename ValueType>
+        void print(std::vector<typename SparseMatrix<ValueType>::index_type> const& rowGroupIndices, std::vector<MatrixEntry<typename SparseMatrix<ValueType>::index_type, typename SparseMatrix<ValueType>::value_type>> const& columnsAndValues, std::vector<typename SparseMatrix<ValueType>::index_type> const& rowIndications) {
+            typename SparseMatrix<ValueType>::index_type endGroups;
+            typename SparseMatrix<ValueType>::index_type endRows;
+            // Iterate over all row groups.
+            for (typename SparseMatrix<ValueType>::index_type group = 0; group < rowGroupIndices.size(); ++group) {
+                std::cout << "\t---- group " << group << "/" << (rowGroupIndices.size() - 1) << " ---- " << std::endl;
+                endGroups = group < rowGroupIndices.size()-1 ? rowGroupIndices[group+1] : rowIndications.size();
+                // Iterate over all rows in a row group
+                for (typename SparseMatrix<ValueType>::index_type i = rowGroupIndices[group]; i < endGroups; ++i) {
+                    endRows = i < rowIndications.size()-1 ? rowIndications[i+1] : columnsAndValues.size();
+                    // Print the actual row.
+                    std::cout << "Row " << i << " (" << rowIndications[i] << " - " << endRows << ")" << ": ";
+                    for (typename SparseMatrix<ValueType>::index_type pos = rowIndications[i]; pos < endRows; ++pos) {
+                        std::cout << "(" << columnsAndValues[pos].getColumn() << ": " << columnsAndValues[pos].getValue() << ") ";
+                    }
+                    std::cout << std::endl;
+                }
+            }
+        }
+        
+        template<typename ValueType>
+        bool SparseMatrixBuilder<ValueType>::replaceColumns(std::vector<index_type> const& replacements, index_type offset) {
+            bool changed = false;
+            index_type maxColumn = 0;
+            for (auto& elem : columnsAndValues) {
+                if (elem.getColumn() >= offset) {
+                    elem.setColumn(replacements[elem.getColumn() - offset]);
+                    changed = true;
+                }
+                maxColumn = std::max(maxColumn, elem.getColumn());
+            }
+            assert(changed || highestColumn == maxColumn);
+            highestColumn = maxColumn;
+            assert(changed || lastColumn == columnsAndValues[columnsAndValues.size() - 1].getColumn());
+            lastColumn = columnsAndValues[columnsAndValues.size() - 1].getColumn();
+            
+            if (changed) {
+                fixColumns();
+            }
+            return changed;
+        }
+
+        template<typename ValueType>
+        void SparseMatrixBuilder<ValueType>::fixColumns() {
+            // Sort columns per row
+            typename SparseMatrix<ValueType>::index_type endGroups;
+            typename SparseMatrix<ValueType>::index_type endRows;
+            for (index_type group = 0; group < rowGroupIndices.size(); ++group) {
+                endGroups = group < rowGroupIndices.size()-1 ? rowGroupIndices[group+1] : rowIndications.size();
+                for (index_type i = rowGroupIndices[group]; i < endGroups; ++i) {
+                    endRows = i < rowIndications.size()-1 ? rowIndications[i+1] : columnsAndValues.size();
+                    // Sort the row
+                    std::sort(columnsAndValues.begin() + rowIndications[i], columnsAndValues.begin() + endRows,
+                              [](MatrixEntry<index_type, value_type> const& a, MatrixEntry<index_type, value_type> const& b) {
+                                  return a.getColumn() < b.getColumn();
+                              });
+                    // Assert no equal elements
+                    assert(std::is_sorted(columnsAndValues.begin() + rowIndications[i], columnsAndValues.begin() + endRows,
+                                          [](MatrixEntry<index_type, value_type> const& a, MatrixEntry<index_type, value_type> const& b) {
+                                              return a.getColumn() <= b.getColumn();
+                                          }));
+                }
+            }
+        }
+        
         template<typename ValueType>
         SparseMatrix<ValueType>::rows::rows(iterator begin, index_type entryCount) : beginIterator(begin), entryCount(entryCount) {
             // Intentionally left empty.
diff --git a/src/storage/SparseMatrix.h b/src/storage/SparseMatrix.h
index f9d9916c4..4892dbe32 100644
--- a/src/storage/SparseMatrix.h
+++ b/src/storage/SparseMatrix.h
@@ -217,6 +217,17 @@ namespace storm {
              */
             index_type getLastColumn() const;
             
+            /*!
+             * Replaces all columns with id > offset according to replacements.
+             * Every state  with id offset+i is replaced by the id in replacements[i].
+             * Afterwards the columns are sorted.
+             *
+             * @param replacements Mapping indicating the replacements from offset+i -> value of i.
+             * @param offset Offset to add to each id in vector index.
+             * @return True if replacement took place, False if nothing changed.
+             */
+            bool replaceColumns(std::vector<index_type> const& replacements, index_type offset);
+            
         private:
             // A flag indicating whether a row count was set upon construction.
             bool initialRowCountSet;
@@ -277,6 +288,11 @@ namespace storm {
             // Stores the currently active row group. This is used for correctly constructing the row grouping of the
             // matrix.
             index_type currentRowGroup;
+            
+            /*!
+             * Fixes the matrix by sorting the columns to gain increasing order again.
+             */
+            void fixColumns();
         };
         
         /*!

From 8a77228e32dcf4930d31629e15a28f07145f41d5 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 24 Feb 2016 13:28:13 +0100
Subject: [PATCH 157/246] Set value in BitVectorHashMap

Former-commit-id: 2083df9c4abfa5484a694b59bc5e63be41361146
---
 src/storage/BitVectorHashMap.cpp | 24 ++++++++++++++++++++++++
 src/storage/BitVectorHashMap.h   | 19 +++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/src/storage/BitVectorHashMap.cpp b/src/storage/BitVectorHashMap.cpp
index 4d6238350..08875af3b 100644
--- a/src/storage/BitVectorHashMap.cpp
+++ b/src/storage/BitVectorHashMap.cpp
@@ -140,6 +140,11 @@ namespace storm {
             return findOrAddAndGetBucket(key, value).first;
         }
         
+        template<class ValueType, class Hash1, class Hash2>
+        void BitVectorHashMap<ValueType, Hash1, Hash2>::setOrAdd(storm::storage::BitVector const& key, ValueType const& value) {
+            setOrAddAndGetBucket(key, value);
+        }
+        
         template<class ValueType, class Hash1, class Hash2>
         std::pair<ValueType, std::size_t> BitVectorHashMap<ValueType, Hash1, Hash2>::findOrAddAndGetBucket(storm::storage::BitVector const& key, ValueType const& value) {
             // If the load of the map is too high, we increase the size.
@@ -161,6 +166,25 @@ namespace storm {
             }
         }
         
+        template<class ValueType, class Hash1, class Hash2>
+        std::size_t BitVectorHashMap<ValueType, Hash1, Hash2>::setOrAddAndGetBucket(storm::storage::BitVector const& key, ValueType const& value) {
+            // If the load of the map is too high, we increase the size.
+            if (numberOfElements >= loadFactor * *currentSizeIterator) {
+                this->increaseSize();
+            }
+            
+            std::tuple<bool, std::size_t, bool> flagBucketTuple = this->findBucketToInsert<true>(key);
+            STORM_LOG_ASSERT(!std::get<2>(flagBucketTuple), "Failed to find bucket for insertion.");
+            if (!std::get<0>(flagBucketTuple)) {
+                // Insert the new bits into the bucket.
+                buckets.set(std::get<1>(flagBucketTuple) * bucketSize, key);
+                occupied.set(std::get<1>(flagBucketTuple));
+                ++numberOfElements;
+            }
+            values[std::get<1>(flagBucketTuple)] = value;
+            return std::get<1>(flagBucketTuple);
+        }
+        
         template<class ValueType, class Hash1, class Hash2>
         ValueType BitVectorHashMap<ValueType, Hash1, Hash2>::getValue(storm::storage::BitVector const& key) const {
             std::pair<bool, std::size_t> flagBucketPair = this->findBucket(key);
diff --git a/src/storage/BitVectorHashMap.h b/src/storage/BitVectorHashMap.h
index d50dac59e..18ca52186 100644
--- a/src/storage/BitVectorHashMap.h
+++ b/src/storage/BitVectorHashMap.h
@@ -66,6 +66,15 @@ namespace storm {
              * @return The found value if the key is already contained in the map and the provided new value otherwise.
              */
             ValueType findOrAdd(storm::storage::BitVector const& key, ValueType const& value);
+            
+            /*!
+             * Sets the given key value pain in the map. If the key is found in the map, the corresponding value is
+             * overwritten with the given value. Otherwise, the key is inserted with the given value.
+             *
+             * @param key The key to search or insert.
+             * @param value The value to set.
+             */
+            void setOrAdd(storm::storage::BitVector const& key, ValueType const& value);
 
             /*!
              * Searches for the given key in the map. If it is found, the mapped-to value is returned. Otherwise, the
@@ -79,6 +88,16 @@ namespace storm {
              */
             std::pair<ValueType, std::size_t> findOrAddAndGetBucket(storm::storage::BitVector const& key, ValueType const& value);
             
+            /*!
+             * Sets the given key value pain in the map. If the key is found in the map, the corresponding value is
+             * overwritten with the given value. Otherwise, the key is inserted with the given value.
+             *
+             * @param key The key to search or insert.
+             * @param value The value to set.
+             * @return The index of the bucket into which the key was inserted.
+             */
+            std::size_t setOrAddAndGetBucket(storm::storage::BitVector const& key, ValueType const& value);
+            
             /*!
              * Retrieves the key stored in the given bucket (if any) and the value it is mapped to.
              *

From ea2fe4a19a8da9af321f455eeb8694e0d6d8b000 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 24 Feb 2016 13:39:28 +0100
Subject: [PATCH 158/246] First working version of symmetry reduction

Former-commit-id: e3641940d42b15b0c6177201960ffd052e165351
---
 src/builder/ExplicitDFTModelBuilder.cpp | 90 +++++++++++++++++++++----
 src/builder/ExplicitDFTModelBuilder.h   |  6 +-
 2 files changed, 81 insertions(+), 15 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index a1973d519..f14408190 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -134,7 +134,7 @@ namespace storm {
         bool ExplicitDFTModelBuilder<ValueType>::exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates) {
 
             // TODO Matthias: set Markovian states directly as bitvector?
-            std::map<size_t, ValueType> outgoingTransitions;
+            std::map<uint_fast64_t, ValueType> outgoingTransitions;
             size_t rowOffset = 0; // Captures number of non-deterministic choices
             bool deterministic = true;
             
@@ -221,23 +221,51 @@ namespace storm {
                     newState->updateFailableDependencies(nextBE->id());
                     
                     bool dftFailed = newState->hasFailed(mDft.getTopLevelIndex());
-                    size_t newStateId;
+                    uint_fast64_t newStateId;
                     if(dftFailed && mergeFailedStates) {
                         newStateId = failedIndex;
                     } else {
-                       if (mStates.contains(newState->status())) {
+                        // Order state by symmetry
+                        STORM_LOG_TRACE("Check for symmetry: " << mDft.getStateString(newState));
+                        bool changed = newState->orderBySymmetry();
+                        STORM_LOG_TRACE("State " << (changed ? "changed to " : "did not change") << (changed ? mDft.getStateString(newState) : ""));
+                        
+                        // Check if state already exists
+                        if (mStates.contains(newState->status())) {
                             // State already exists
                             newStateId = mStates.getValue(newState->status());
-                            STORM_LOG_TRACE("State " << mDft.getStateString(newState) << " already exists");
+                            STORM_LOG_TRACE("State " << mDft.getStateString(newState) << " with id " << newStateId << " already exists");
+                            
+                            // Check if possible pseudo state can be created now
+                            if (!changed && newStateId >= OFFSET_PSEUDO_STATE) {
+                                newStateId = newStateId - OFFSET_PSEUDO_STATE;
+                                assert(newStateId < mPseudoStatesMapping.size());
+                                if (mPseudoStatesMapping[newStateId] == 0) {
+                                    // Create pseudo state now
+                                    newState->setId(newIndex++);
+                                    mPseudoStatesMapping[newStateId] = newState->getId();
+                                    newStateId = newState->getId();
+                                    mStates.setOrAdd(newState->status(), newStateId);
+                                    stateQueue.push(newState);
+                                    STORM_LOG_TRACE("Now create state " << mDft.getStateString(newState) << " with id " << newStateId);
+                                }
+                            }
                         } else {
                             // New state
-                            newState->setId(newIndex++);
-                            newStateId = mStates.findOrAdd(newState->status(), newState->getId());
-                            STORM_LOG_TRACE("New state " << mDft.getStateString(newState));
-
-                            // Add state to search queue
-                            stateQueue.push(newState);
-                        } 
+                            if (changed) {
+                                // Remember to create state later on
+                                newState->setId(mPseudoStatesMapping.size() + OFFSET_PSEUDO_STATE);
+                                mPseudoStatesMapping.push_back(0);
+                                newStateId = mStates.findOrAdd(newState->status(), newState->getId());
+                                STORM_LOG_TRACE("New state for later creation: " << mDft.getStateString(newState));
+                            } else {
+                                // Create new state
+                                newState->setId(newIndex++);
+                                newStateId = mStates.findOrAdd(newState->status(), newState->getId());
+                                STORM_LOG_TRACE("New state: " << mDft.getStateString(newState));
+                                stateQueue.push(newState);
+                            }
+                        }
                     }
 
                     // Set transitions
@@ -248,10 +276,11 @@ namespace storm {
                         STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newStateId << " with probability " << dependency->probability());
 
                         if (!storm::utility::isOne(dependency->probability())) {
+                            // TODO Matthias: use symmetry as well
                             // Add transition to state where dependency was unsuccessful
                             DFTStatePointer unsuccessfulState = std::make_shared<storm::storage::DFTState<ValueType>>(*state);
                             unsuccessfulState->letDependencyBeUnsuccessful(smallest-1);
-                            size_t unsuccessfulStateId;
+                            uint_fast64_t unsuccessfulStateId;
                             if (mStates.contains(unsuccessfulState->status())) {
                                 // Unsuccessful state already exists
                                 unsuccessfulStateId = mStates.getValue(unsuccessfulState->status());
@@ -303,6 +332,38 @@ namespace storm {
                 if (hasDependencies) {
                     rowOffset--; // One increment to many
                 } else {
+                    // Try to merge pseudo states with their instantiation
+                    // TODO Matthias: improve?
+                    auto it = outgoingTransitions.begin();
+                    while (it != outgoingTransitions.end()) {
+                        if (it->first >= OFFSET_PSEUDO_STATE) {
+                            uint_fast64_t newId = it->first - OFFSET_PSEUDO_STATE;
+                            assert(newId < mPseudoStatesMapping.size());
+                            if (mPseudoStatesMapping[newId] > 0) {
+                                // State exists already
+                                newId = mPseudoStatesMapping[newId];
+                                auto itFind = outgoingTransitions.find(newId);
+                                if (itFind != outgoingTransitions.end()) {
+                                    // Add probability from pseudo state to instantiation
+                                    itFind->second += it->second;
+                                    STORM_LOG_TRACE("Merged pseudo state " << newId << " adding rate " << it->second << " to total rate of " << itFind->second);
+                                } else {
+                                    // Only change id
+                                    outgoingTransitions.emplace(newId, it->second);
+                                    STORM_LOG_TRACE("Instantiated pseudo state " << newId << " with rate " << it->second);
+                                }
+                                // Remove pseudo state
+                                auto itErase = it;
+                                ++it;
+                                outgoingTransitions.erase(itErase);
+                            } else {
+                                ++it;
+                            }
+                        } else {
+                            ++it;
+                        }
+                    }
+                    
                     // Add all probability transitions
                     for (auto it = outgoingTransitions.begin(); it != outgoingTransitions.end(); ++it)
                     {
@@ -316,6 +377,11 @@ namespace storm {
                 assert(exitRates.size()-1 == state->getId());
 
             } // end while queue
+            assert(std::find(mPseudoStatesMapping.begin(), mPseudoStatesMapping.end(), 0) == mPseudoStatesMapping.end());
+            
+            // Replace pseudo states in matrix
+            transitionMatrixBuilder.replaceColumns(mPseudoStatesMapping, OFFSET_PSEUDO_STATE);
+            
             assert(!deterministic || rowOffset == 0);
             return deterministic;
         }
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 6d17375b2..b9008f91e 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -47,12 +47,12 @@ namespace storm {
             };
             
             const size_t INITIAL_BUCKETSIZE = 20000;
-
-          
+            const uint_fast64_t OFFSET_PSEUDO_STATE = UINT_FAST64_MAX / 2;
             
             storm::storage::DFT<ValueType> const& mDft;
             std::shared_ptr<storm::storage::DFTStateGenerationInfo> mStateGenerationInfo;
-            storm::storage::BitVectorHashMap<size_t> mStates;
+            storm::storage::BitVectorHashMap<uint_fast64_t> mStates;
+            std::vector<uint_fast64_t> mPseudoStatesMapping;
             size_t newIndex = 0;
             bool mergeFailedStates = true;
             size_t failedIndex = 0;

From 1e9fedb7ba4f18b383b86fb3700591dd57840848 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 24 Feb 2016 13:55:24 +0100
Subject: [PATCH 159/246] Order symmetries in decreasing order

Former-commit-id: 7ba21b0b9e20ae04998040350c66a7963276dba0
---
 examples/dft/symmetry5.dft   | 21 +++++++++++++++++++++
 src/storage/dft/DFTState.cpp |  2 +-
 2 files changed, 22 insertions(+), 1 deletion(-)
 create mode 100644 examples/dft/symmetry5.dft

diff --git a/examples/dft/symmetry5.dft b/examples/dft/symmetry5.dft
new file mode 100644
index 000000000..18f700bb2
--- /dev/null
+++ b/examples/dft/symmetry5.dft
@@ -0,0 +1,21 @@
+toplevel "A";
+"A" and "BA" "BB" "BC" "BD" "BE" "BF";
+"BA" and "CA" "DA";
+"BB" and "CB" "DB";
+"BC" and "CC" "DC";
+"BD" and "CD" "DD";
+"BE" and "CE" "DE";
+"BF" and "CF" "DF";
+"CA" lambda=0.5 dorm=0;
+"DA" lambda=0.5 dorm=0;
+"CB" lambda=0.5 dorm=0;
+"DB" lambda=0.5 dorm=0;
+"CC" lambda=0.5 dorm=0;
+"DC" lambda=0.5 dorm=0;
+"CD" lambda=0.5 dorm=0;
+"DD" lambda=0.5 dorm=0;
+"CE" lambda=0.5 dorm=0;
+"DE" lambda=0.5 dorm=0;
+"CF" lambda=0.5 dorm=0;
+"DF" lambda=0.5 dorm=0;
+
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 591f6f9da..be5c33060 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -259,7 +259,7 @@ namespace storm {
                     for (size_t i = 1; i < n; ++i) {
                         elem1 = mStatus.getAsInt(symmetryIndices[i-1], length);
                         elem2 = mStatus.getAsInt(symmetryIndices[i], length);
-                        if (elem1 > elem2) {
+                        if (elem1 < elem2) {
                             // Swap elements
                             mStatus.setFromInt(symmetryIndices[i-1], length, elem2);
                             mStatus.setFromInt(symmetryIndices[i], length, elem1);

From 490f232d7ab36fb17ea1d08ecd6f7781668688fb Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 24 Feb 2016 14:28:24 +0100
Subject: [PATCH 160/246] Example for possible pdep symmetry

Former-commit-id: 1ea07bd19666aa9ce5060e98d8ec397a8ca3ea3e
---
 examples/dft/pdep_symmetry.dft | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 examples/dft/pdep_symmetry.dft

diff --git a/examples/dft/pdep_symmetry.dft b/examples/dft/pdep_symmetry.dft
new file mode 100644
index 000000000..43224d790
--- /dev/null
+++ b/examples/dft/pdep_symmetry.dft
@@ -0,0 +1,11 @@
+toplevel "A";
+"A" and "B" "B'";
+"B" and "C" "D" "PDEP";
+"B'" and "C'" "D'" "PDEP'";
+"PDEP" pdep=0.6 "B" "C";
+"PDEP'" pdep=0.6 "B'" "C'";
+"C" lambda=0.5 dorm=0;
+"D" lambda=0.5 dorm=0;
+"C'" lambda=0.5 dorm=0;
+"D'" lambda=0.5 dorm=0;
+

From 91970cea72d118db128c79dc89669c89ea2c3216 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 24 Feb 2016 15:28:58 +0100
Subject: [PATCH 161/246] intermediate commit

Former-commit-id: 2de6f9106211db3f5f04ac76cf101c9142a33a65
---
 src/storage/dft/DFT.h           |  2 +-
 src/storage/dft/DFTElements.cpp | 11 +++++++---
 src/storage/dft/DFTElements.h   | 37 ++++++++++++++++++++++++++++++---
 3 files changed, 43 insertions(+), 7 deletions(-)

diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 1f3e8cceb..f0e08b31a 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -41,7 +41,7 @@ namespace storm {
             std::map<size_t, size_t> mSpareUsageIndex; // id spare -> index first bit in state
             std::map<size_t, size_t> mSpareActivationIndex; // id spare representative -> index in state
             std::vector<size_t> mIdToStateIndex; // id -> index first bit in state
-            
+            std::map<size_t, size_t> mRestrictedItems;
         public:
             
             DFTStateGenerationInfo(size_t nrElements) : mUsageInfoBits(nrElements > 1 ? storm::utility::math::uint64_log2(nrElements-1) + 1 : 1), mIdToStateIndex(nrElements) {
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index 7bb8c2cf5..81c78ccc6 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -24,9 +24,6 @@ namespace storm {
                 }
             }
             
-            
-        
-
             state.setDontCare(mId);
             return true;
         }
@@ -85,6 +82,14 @@ namespace storm {
                 }
 
             }
+            
+            for(auto const& restr : mRestrictions) {
+                restr->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                if(elemsInSubtree.empty()) {
+                    return;
+                }
+            }
+            
         }
 
 
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index bb4be80a7..00688f36e 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -200,6 +200,40 @@ namespace storm {
                 return mOutgoingDependencies.size();
             }
             
+            std::set<DFTElement<ValueType>> restrictedItems() const {
+                std::set<DFTElement<ValueType>> result;
+                for(auto const& restr : mRestrictions) {
+                    bool foundThis = false;
+                    for(auto const& child : restr->children()) {
+                        if(!foundThis) {
+                            if(child->id() == mId) {
+                                foundThis = true;
+                            }
+                        } else if(result.count(child) == 0) {
+                            result.insert(child);
+                        }
+                    }
+                }
+            }
+            
+            std::set<DFTElement<ValueType>> restrictedItemsTC() const {
+                std::set<DFTElement<ValueType>> result;
+                for(auto const& restr : mRestrictions) {
+                    bool foundThis = false;
+                    for(auto const& child : restr->children()) {
+                        if(!foundThis) {
+                            if(child->id() == mId) {
+                                foundThis = true;
+                            }
+                        } else if(result.count(child) == 0) {
+                            result.insert(child);
+                            std::set<DFTElement<ValueType>> tmpRes = child->restrictedItemsTC();
+                            result.insert(tmpRes.begin(), tmpRes.end());
+                        }
+                    }
+                }
+            }
+            
             DFTDependencyVector const& outgoingDependencies() const {
                 return mOutgoingDependencies;
             }
@@ -784,9 +818,6 @@ namespace storm {
             return os << gate.toString();
         }
 
-
-
-
         template<typename ValueType>
         class DFTPand : public DFTGate<ValueType> {
 

From 6b166952e88bf60c23f13913dbe918c4145d76df Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 24 Feb 2016 16:33:20 +0100
Subject: [PATCH 162/246] output operators for element type

Former-commit-id: 8298f03f5e0c260394d1eeb542289e100d053ba9
---
 src/storage/dft/DFTElementType.h | 36 +++++++++++++++++++++++++++++---
 1 file changed, 33 insertions(+), 3 deletions(-)

diff --git a/src/storage/dft/DFTElementType.h b/src/storage/dft/DFTElementType.h
index d4bf3bfc2..8b8035d45 100644
--- a/src/storage/dft/DFTElementType.h
+++ b/src/storage/dft/DFTElementType.h
@@ -6,7 +6,6 @@ namespace storm {
 
         enum class DFTElementType : int {AND = 0, OR = 2, VOT = 3, BE = 4, CONSTF = 5, CONSTS = 6, PAND = 7, SPARE = 8, POR = 9, PDEP = 10, SEQ = 11, MUTEX=12};
 
-        
         inline bool isGateType(DFTElementType const& tp) {
             switch(tp) {
                 case DFTElementType::AND:
@@ -29,7 +28,6 @@ namespace storm {
             }
         }
 
-        
         inline bool isStaticGateType(DFTElementType const& tp) {
             if(!isGateType(tp)) return false;
             switch(tp) {
@@ -46,7 +44,39 @@ namespace storm {
                     return false;
             }
         }
-        
+
+        inline std::string toString(DFTElementType const& tp) {
+            switch(tp) {
+                case DFTElementType::BE:
+                    return "BE";
+                case DFTElementType::OR:
+                    return "OR";
+                case DFTElementType::AND:
+                    return "AND";
+                case DFTElementType::VOT:
+                    return "VOT";
+                case DFTElementType::POR:
+                    return "POR";
+                case DFTElementType::PAND:
+                    return "PAND";
+                case DFTElementType::SPARE:
+                    return "SPARE";
+                case DFTElementType::SEQ:
+                    return "SEQ";
+                case DFTElementType::MUTEX:
+                    return "MUTEX";
+                case DFTElementType::PDEP:
+                    return "PDEP";
+                default:
+                    assert(false);
+            }
+        }
+
+        inline std::ostream& operator<<(std::ostream& os, DFTElementType const& tp) {
+            return os << toString(tp) << std::endl;
+        }
+
+
         
     }
 }

From 084bc26a5f93315a77506cb6f4a1dd6e0e9e5239 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 24 Feb 2016 16:34:44 +0100
Subject: [PATCH 163/246] fixed some things with respect to SEQs

Former-commit-id: 8460c4b5a59f86f4e195248704f1a08384744c63
---
 src/storage/dft/DFT.cpp          | 1 +
 src/storage/dft/DFTBuilder.cpp   | 3 +--
 src/storage/dft/DFTElements.cpp  | 1 +
 src/storage/dft/DFTIsomorphism.h | 1 +
 4 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index eef83928d..3d2b09088 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -333,6 +333,7 @@ namespace storm {
                     for(auto it1 = colourClass.second.cbegin(); it1 != colourClass.second.cend(); ++it1) {
                         std::vector<std::vector<size_t>> symClass;
                         if(foundEqClassFor.count(*it1) > 0) {
+                            // This item is already in a class.
                             continue;
                         }
                         if(!getGate(*it1)->hasOnlyStaticParents()) {
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index 213fce0df..5e5c3da84 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -116,8 +116,7 @@ namespace storm {
             DFTRestrictionPointer restr;
             switch (tp) {
                 case DFTElementType::SEQ:
-                    restr = std::make_shared<DFTSeq < ValueType>>
-                    (mNextId++, name);
+                    restr = std::make_shared<DFTSeq<ValueType>>(mNextId++, name);
                     break;
                 case DFTElementType::MUTEX:
                     STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type not supported.");
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index 81c78ccc6..f11f0b99f 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -1,6 +1,7 @@
 #include <src/exceptions/NotImplementedException.h>
 #include <src/utility/macros.h>
 #include "DFTElements.h"
+#include "elements/DFTRestriction.h"
 
 namespace storm {
     namespace storage {
diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
index 0d5590d3d..498170368 100644
--- a/src/storage/dft/DFTIsomorphism.h
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -207,6 +207,7 @@ namespace storage {
         }
 
         void colourize(std::shared_ptr<const DFTGate<ValueType>> const& gate) {
+             std::cout <<  "Colour " << gate->id() << ": "  << gate->type() << " " << gate->nrChildren() << " " << gate->rank() << "." << std::endl;
              gateColour[gate->id()] = gateColourizer(gate->type(), gate->nrChildren(), gate->nrParents(), 0, gate->rank());
         }
         

From 5b6dcd0eed4fb795c810ab41f947ccb2fb57af92 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 24 Feb 2016 18:14:18 +0100
Subject: [PATCH 164/246] UsageIndex is number of used child now

Former-commit-id: 629aeae3182982c94900a8b890f4a1b81ac8021c
---
 examples/dft/spare_symmetry.dft |  9 +++++++++
 src/storage/dft/DFT.cpp         | 29 +++++++++++++++++++++++++----
 src/storage/dft/DFT.h           | 12 +++++++++++-
 src/storage/dft/DFTElements.h   |  4 ++--
 src/storage/dft/DFTState.cpp    | 15 +++++++++++++--
 src/storage/dft/DFTState.h      | 11 +++++++++--
 6 files changed, 69 insertions(+), 11 deletions(-)
 create mode 100644 examples/dft/spare_symmetry.dft

diff --git a/examples/dft/spare_symmetry.dft b/examples/dft/spare_symmetry.dft
new file mode 100644
index 000000000..04b5c253b
--- /dev/null
+++ b/examples/dft/spare_symmetry.dft
@@ -0,0 +1,9 @@
+toplevel "A";
+"A" and "B" "C";
+"B" wsp "I" "J";
+"C" wsp "K" "L";
+"I" lambda=0.5 dorm=0.3;
+"J" lambda=0.5 dorm=0.3;
+"K" lambda=0.5 dorm=0.3;
+"L" lambda=0.5 dorm=0.3;
+
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index eef83928d..2924789fd 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -11,7 +11,7 @@ namespace storm {
     namespace storage {
 
         template<typename ValueType>
-        DFT<ValueType>::DFT(DFTElementVector const& elements, DFTElementPointer const& tle) : mElements(elements), mNrOfBEs(0), mNrOfSpares(0), mTopLevelIndex(tle->id()) {
+        DFT<ValueType>::DFT(DFTElementVector const& elements, DFTElementPointer const& tle) : mElements(elements), mNrOfBEs(0), mNrOfSpares(0), mTopLevelIndex(tle->id()), mMaxSpareChildCount(0) {
             assert(elementIndicesCorrect());
             size_t nrRepresentatives = 0;
             
@@ -25,6 +25,7 @@ namespace storm {
                 else if (elem->isSpareGate()) {
                     ++mNrOfSpares;
                     bool firstChild = true;
+                    mMaxSpareChildCount = std::max(mMaxSpareChildCount, std::static_pointer_cast<DFTSpare<ValueType>>(elem)->children().size());
                     for(auto const& spareReprs : std::static_pointer_cast<DFTSpare<ValueType>>(elem)->children()) {
                         std::set<size_t> module = {spareReprs->id()};
                         spareReprs->extendSpareModule(module);
@@ -63,7 +64,9 @@ namespace storm {
             }
             mTopModule = std::vector<size_t>(topModuleSet.begin(), topModuleSet.end());
             
-            size_t usageInfoBits = mElements.size() > 1 ? storm::utility::math::uint64_log2(mElements.size()-1) + 1 : 1;
+            //Reserve space for failed spares
+            ++mMaxSpareChildCount;
+            size_t usageInfoBits = storm::utility::math::uint64_log2(mMaxSpareChildCount) + 1;
             mStateVectorSize = nrElements() * 2 + mNrOfSpares * usageInfoBits + nrRepresentatives;
         }
 
@@ -73,7 +76,7 @@ namespace storm {
             // Collect all elements in the first subtree
             // TODO make recursive to use for nested subtrees
 
-            DFTStateGenerationInfo generationInfo(nrElements());
+            DFTStateGenerationInfo generationInfo(nrElements(), mMaxSpareChildCount);
 
             // Perform DFS and insert all elements of subtree sequentially
             size_t stateIndex = 0;
@@ -296,7 +299,25 @@ namespace storm {
             }
             return stream.str();
         }
-
+        
+        template<typename ValueType>
+        size_t DFT<ValueType>::getChild(size_t spareId, size_t nrUsedChild) const {
+            assert(mElements[spareId]->isSpareGate());
+            return getGate(spareId)->children()[nrUsedChild]->id();
+        }
+        
+        template<typename ValueType>
+        size_t DFT<ValueType>::getNrChild(size_t spareId, size_t childId) const {
+            assert(mElements[spareId]->isSpareGate());
+            DFTElementVector children = getGate(spareId)->children();
+            for (size_t nrChild = 0; nrChild < children.size(); ++nrChild) {
+                if (children[nrChild]->id() == childId) {
+                    return nrChild;
+                }
+            }
+            assert(false);
+        }
+        
         template <typename ValueType>
         std::vector<size_t> DFT<ValueType>::getIndependentSubDftRoots(size_t index) const {
             auto elem = getElement(index);
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 453db1443..48bb60f68 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -45,7 +45,8 @@ namespace storm {
             
         public:
             
-            DFTStateGenerationInfo(size_t nrElements) : mUsageInfoBits(nrElements > 1 ? storm::utility::math::uint64_log2(nrElements-1) + 1 : 1), mIdToStateIndex(nrElements) {
+            DFTStateGenerationInfo(size_t nrElements, size_t maxSpareChildCount) : mUsageInfoBits(storm::utility::math::uint64_log2(maxSpareChildCount) + 1), mIdToStateIndex(nrElements) {
+                assert(maxSpareChildCount < pow(2, mUsageInfoBits));
             }
 
             size_t usageInfoBits() const {
@@ -144,6 +145,7 @@ namespace storm {
             size_t mNrOfSpares;
             size_t mTopLevelIndex;
             size_t mStateVectorSize;
+            size_t mMaxSpareChildCount;
             std::map<size_t, std::vector<size_t>> mSpareModules;
             std::vector<size_t> mDependencies;
             std::vector<size_t> mTopModule;
@@ -175,6 +177,10 @@ namespace storm {
                 return mTopLevelIndex;
             }
             
+            size_t getMaxSpareChildCount() const {
+                return mMaxSpareChildCount;
+            }
+            
             std::vector<size_t> getSpareIndices() const {
                 std::vector<size_t> indices;
                 for(auto const& elem : mElements) {
@@ -288,6 +294,10 @@ namespace storm {
                 return storm::storage::DFTState<ValueType>::isFailsafe(state, stateGenerationInfo.getStateIndex(mTopLevelIndex));
             }
             
+            size_t getChild(size_t spareId, size_t nrUsedChild) const;
+            
+            size_t getNrChild(size_t spareId, size_t childId) const;
+            
             std::string getElementsString() const;
 
             std::string getInfoString() const;
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 3236a5551..48318d0ae 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -412,12 +412,12 @@ namespace storm {
             }
 
             /**
-             * Finish failed/failsafe spare gate by activating the children and setting the useIndex to the spare id.
+             * Finish failed/failsafe spare gate by activating the children and setting the useIndex to the maximum value.
              * This prevents multiple fail states with different usages or activations.
              * @param state The current state.
              */
             void finalizeSpare(DFTState<ValueType>& state) const {
-                state.setUses(this->mId, this->mId);
+                state.finalizeUses(this->mId);
                 for (auto child : this->children()) {
                     if (!state.isActive(child->id())) {
                         state.activate(child->id());
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index be5c33060..8af84255c 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -201,7 +201,12 @@ namespace storm {
 
         template<typename ValueType>
         uint_fast64_t DFTState<ValueType>::uses(size_t id) const {
-            return extractUses(mStateGenerationInfo.getSpareUsageIndex(id));
+            size_t nrUsedChild = extractUses(mStateGenerationInfo.getSpareUsageIndex(id));
+            if (nrUsedChild == mDft.getMaxSpareChildCount()) {
+                return id;
+            } else {
+                return mDft.getChild(id, nrUsedChild);
+            }
         }
 
         template<typename ValueType>
@@ -217,9 +222,15 @@ namespace storm {
 
         template<typename ValueType>
         void DFTState<ValueType>::setUses(size_t spareId, size_t child) {
-            mStatus.setFromInt(mStateGenerationInfo.getSpareUsageIndex(spareId), mStateGenerationInfo.usageInfoBits(), child);
+            mStatus.setFromInt(mStateGenerationInfo.getSpareUsageIndex(spareId), mStateGenerationInfo.usageInfoBits(), mDft.getNrChild(spareId, child));
             mUsedRepresentants.push_back(child);
         }
+        
+        template<typename ValueType>
+        void DFTState<ValueType>::finalizeUses(size_t spareId) {
+            assert(hasFailed(spareId));
+            mStatus.setFromInt(mStateGenerationInfo.getSpareUsageIndex(spareId), mStateGenerationInfo.usageInfoBits(), mDft.getMaxSpareChildCount());
+        }
 
         template<typename ValueType>
         bool DFTState<ValueType>::claimNew(size_t spareId, size_t currentlyUses, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children) {
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index eccf7f01d..ea874cf1b 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -93,9 +93,10 @@ namespace storm {
             }
            
             /**
-             * This method gets the usage information for a spare
+             * This method returns the id of the used child for a spare. If no element is used, it returns the given id.
              * @param id Id of the spare
-             * @return The child that currently is used.
+             * @return The id of the currently used child or if non is used (because of spare failure) the id of
+             * the spare.
              */
             uint_fast64_t uses(size_t id) const;
             
@@ -120,6 +121,12 @@ namespace storm {
              */
             void setUses(size_t spareId, size_t child);
             
+            /**
+             * Sets the use for the spare to a default value to gain consistent states after failures.
+             * @param spareId Id of the spare
+             */
+            void finalizeUses(size_t spareId);
+            
             bool claimNew(size_t spareId, size_t currentlyUses, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children);
             
             bool hasOutgoingEdges() const {

From d32d90de5b7f5a75062ecd1146077b99d4c0489c Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 24 Feb 2016 18:18:19 +0100
Subject: [PATCH 165/246] Fixed some compile warnings

Former-commit-id: 91055b14cff62f8a06b7cbfad79f504a83f44563
---
 src/storage/dft/DFT.h                     | 4 ++--
 src/storage/dft/elements/DFTRestriction.h | 2 +-
 src/storm-dyftee.cpp                      | 1 -
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 48bb60f68..7d10b2ee1 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -81,8 +81,8 @@ namespace storm {
                 return mSpareActivationIndex.at(id);
             }
             
-            size_t addSymmetry(size_t lenght, std::vector<size_t>& startingIndices) {
-                mSymmetries.push_back(std::make_pair(lenght, startingIndices));
+            void addSymmetry(size_t length, std::vector<size_t>& startingIndices) {
+                mSymmetries.push_back(std::make_pair(length, startingIndices));
             }
             
             size_t getSymmetrySize() const {
diff --git a/src/storage/dft/elements/DFTRestriction.h b/src/storage/dft/elements/DFTRestriction.h
index 46b6e23cc..d0482e4a7 100644
--- a/src/storage/dft/elements/DFTRestriction.h
+++ b/src/storage/dft/elements/DFTRestriction.h
@@ -183,7 +183,7 @@ namespace storm {
 
             }
             
-            bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) {
+            bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 
             }
 
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index ba50d90f3..07bff5732 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -32,7 +32,6 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     std::map<size_t, std::vector<std::vector<size_t>>> emptySymmetry;
     storm::storage::DFTIndependentSymmetries symmetries(emptySymmetry);
     if(symred) {
-        std::cout << dft.getElementsString() << std::endl;
         auto colouring = dft.colourDFT();
         symmetries = dft.findSymmetries(colouring);
         std::cout << "Symmetries: " << symmetries << std::endl;

From 9c30394b33ce72e4a7b467743910061ae8c49d09 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 25 Feb 2016 14:59:27 +0100
Subject: [PATCH 166/246] Finalize sparse for failed, failsafe, dontcare

Former-commit-id: 722285c8d5e4c4d350ae56150bb287f1c8c5d298
---
 src/storage/dft/DFTElements.cpp | 13 +++++++---
 src/storage/dft/DFTElements.h   | 42 ++++++++++++++++-----------------
 src/storage/dft/DFTState.cpp    |  8 ++++---
 3 files changed, 35 insertions(+), 28 deletions(-)

diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index 7bb8c2cf5..3f1d30017 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -17,17 +17,24 @@ namespace storm {
                     return false;
                 }
             }
+            
+            bool hasParentSpare = false;
+
             // Check that no parent can fail anymore
             for(DFTGatePointer const& parent : mParents) {
                 if(state.isOperational(parent->id())) {
                     return false;
                 }
+                if (parent->isSpareGate()) {
+                    hasParentSpare = true;
+                }
             }
             
-            
-        
-
             state.setDontCare(mId);
+            if (hasParentSpare && !state.isActive(mId)) {
+                // Activate child for consistency in failed spares
+                state.activate(mId);
+            }
             return true;
         }
 
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 48318d0ae..0b970355f 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -387,10 +387,6 @@ namespace storm {
                     queues.checkRestrictionLater(restr);
                 }
                 state.setFailed(this->mId);
-                // TODO can this be moved towards DFTSpare?
-                if (this->isSpareGate()) {
-                    this->finalizeSpare(state);
-                }
                 this->childrenDontCare(state, queues);
             }
 
@@ -401,30 +397,13 @@ namespace storm {
                     }
                 }
                 state.setFailsafe(this->mId);
-                if (this->isSpareGate()) {
-                    this->finalizeSpare(state);
-                }
                 this->childrenDontCare(state, queues);
             }
-
+            
             void childrenDontCare(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
                 queues.propagateDontCare(mChildren);
             }
 
-            /**
-             * Finish failed/failsafe spare gate by activating the children and setting the useIndex to the maximum value.
-             * This prevents multiple fail states with different usages or activations.
-             * @param state The current state.
-             */
-            void finalizeSpare(DFTState<ValueType>& state) const {
-                state.finalizeUses(this->mId);
-                for (auto child : this->children()) {
-                    if (!state.isActive(child->id())) {
-                        state.activate(child->id());
-                    }
-                }
-            }
-
             bool hasFailsafeChild(DFTState<ValueType>& state) const {
                 for(auto const& child : mChildren) {
                     if(state.isFailsafe(child->id()))
@@ -959,6 +938,24 @@ namespace storm {
                 return true;
             }
             
+            void fail(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                DFTGate<ValueType>::fail(state, queues);
+                state.finalizeUses(this->mId);
+            }
+            
+            void failsafe(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                DFTGate<ValueType>::failsafe(state, queues);
+                state.finalizeUses(this->mId);
+            }
+            
+            bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                if (DFTGate<ValueType>::checkDontCareAnymore(state, queues)) {
+                    state.finalizeUses(this->mId);
+                    return true;
+                }
+                return false;
+            }
+            
             void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 if(state.isOperational(this->mId)) {
                     size_t uses = state.uses(this->mId);
@@ -979,6 +976,7 @@ namespace storm {
                     }
                 }
             }
+
         };
         
         template<typename ValueType>
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 8af84255c..7d3b25c8a 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -179,7 +179,6 @@ namespace storm {
             size_t activationIndex = mStateGenerationInfo.getSpareActivationIndex(repr);
             assert(!mStatus[activationIndex]);
             mStatus.set(activationIndex);
-            propagateActivation(repr);
         }
 
         template<typename ValueType>
@@ -190,11 +189,14 @@ namespace storm {
             
         template<typename ValueType>
         void DFTState<ValueType>::propagateActivation(size_t representativeId) {
+            if (representativeId != mDft.getTopLevelIndex()) {
+                activate(representativeId);
+            }
             for(size_t elem : mDft.module(representativeId)) {
                 if(mDft.getElement(elem)->isColdBasicElement() && isOperational(elem)) {
                     mIsCurrentlyFailableBE.push_back(elem);
                 } else if (mDft.getElement(elem)->isSpareGate() && !isActive(uses(elem))) {
-                    activate(uses(elem));
+                    propagateActivation(uses(elem));
                 }
             }
         }
@@ -245,7 +247,7 @@ namespace storm {
                 if(!hasFailed(childId) && !isUsed(childId)) {
                     setUses(spareId, childId);
                     if(isActive(currentlyUses)) {
-                        activate(childId);
+                        propagateActivation(childId);
                     }
                     return true;
                 }

From f6374c60f8bb562661b625440d3a73f4c380cf0f Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 26 Feb 2016 11:25:50 +0100
Subject: [PATCH 167/246] Bitte ein Bit

Former-commit-id: ff11916b9a2d5a37074404e6025d8ebfe769ac03
---
 src/storage/BitVector.cpp    | 124 +++++++++++++++++++++++++++++++++++
 src/storage/BitVector.h      |  36 ++++++++++
 src/storage/dft/DFTState.cpp |   9 +--
 3 files changed, 162 insertions(+), 7 deletions(-)

diff --git a/src/storage/BitVector.cpp b/src/storage/BitVector.cpp
index dff4b2f5f..02e40aa59 100644
--- a/src/storage/BitVector.cpp
+++ b/src/storage/BitVector.cpp
@@ -10,6 +10,12 @@
 #include "src/utility/Hash.h"
 #include "src/utility/macros.h"
 
+#include <bitset>
+
+#ifndef NDEBUG
+//#define ASSERT_BITVECTOR
+#endif
+
 namespace storm {
     namespace storage {
 
@@ -413,6 +419,7 @@ namespace storm {
         }
 
         uint_fast64_t BitVector::getAsInt(uint_fast64_t bitIndex, uint_fast64_t numberOfBits) const {
+            assert(numberOfBits <= 64);
             uint64_t bucket = bitIndex >> 6;
             uint64_t bitIndexInBucket = bitIndex & mod64mask;
 
@@ -662,6 +669,103 @@ namespace storm {
             }
             return endIndex;
         }
+        
+        BitVector BitVector::getAsBitVector(uint_fast64_t start, uint_fast64_t length) {
+            BitVector result(length);
+            
+            uint_fast64_t index = 0;
+            for ( ; index + 63 <= length; index += 63) {
+                result.setFromInt(index, 63, getAsInt(start + index, 63));
+            }
+            // Insert remaining bits
+            result.setFromInt(index, length-index, getAsInt(start+index, length-index));
+            
+#ifdef ASSERT_BITVECTOR
+            // Check correctness of getter
+            for (uint_fast64_t i = 0; i < length; ++i) {
+                STORM_LOG_ASSERT(result.get(i) == get(start + i), "Getting of bits not correct for index " << i);
+            }
+#endif
+            return result;
+        }
+        
+        void BitVector::setFromBitVector(uint_fast64_t start, BitVector const& other) {
+            uint_fast64_t index = 0;
+            for ( ; index + 63 <= other.bitCount; index += 63) {
+                setFromInt(start+index, 63, other.getAsInt(index, 63));
+            }
+            // Insert remaining bits
+            setFromInt(start+index, other.bitCount-index, other.getAsInt(index, other.bitCount-index));
+            
+#ifdef ASSERT_BITVECTOR
+            // Check correctness of setter
+            for (uint_fast64_t i = 0; i < other.bitCount; ++i) {
+                STORM_LOG_ASSERT(other.get(i) == get(start + i), "Setting of bits not correct for index " << i);
+            }
+#endif
+        }
+        
+        bool BitVector::compareAndSwap(uint_fast64_t start1, uint_fast64_t start2, uint_fast64_t length) {
+            if (length < 64) {
+                uint_fast64_t elem1 = getAsInt(start1, length);
+                uint_fast64_t elem2 = getAsInt(start2, length);
+                if (elem1 < elem2) {
+                    // Swap elements
+                    setFromInt(start1, length, elem2);
+                    setFromInt(start2, length, elem1);
+                    return true;
+                }
+                return false;
+            } else {
+                //TODO improve performance
+                BitVector elem1 = getAsBitVector(start1, length);
+                BitVector elem2 = getAsBitVector(start2, length);
+                
+                if (!(elem1 < elem2)) {
+                    // Elements already sorted
+#ifdef ASSERT_BITVECTOR
+                    // Check that sorted
+                    for (uint_fast64_t i = 0; i < length; ++i) {
+                        if (get(start1 + i) > get(start2 + i)) {
+                            break;
+                        }
+                        STORM_LOG_ASSERT(get(start1 + i) >= get(start2 + i), "Bit vector not sorted for indices " << start1+i << " and " << start2+i);
+                    }
+#endif
+                    return false;
+                }
+                
+#ifdef ASSERT_BITVECTOR
+                BitVector check(*this);
+#endif
+                
+                // Swap elements
+                setFromBitVector(start1, elem2);
+                setFromBitVector(start2, elem1);
+                
+#ifdef ASSERT_BITVECTOR
+                // Check correctness of swapping
+                bool tmp;
+                for (uint_fast64_t i = 0; i < length; ++i) {
+                    tmp = check.get(i + start1);
+                    check.set(i + start1, check.get(i + start2));
+                    check.set(i + start2, tmp);
+                }
+                STORM_LOG_ASSERT(*this == check, "Swapping not correct");
+                
+                // Check that sorted
+                for (uint_fast64_t i = 0; i < length; ++i) {
+                    if (get(start1 + i) > get(start2 + i)) {
+                        break;
+                    }
+                    STORM_LOG_ASSERT(get(start1 + i) >= get(start2 + i), "Bit vector not sorted for indices " << start1+i << " and " << start2+i);
+                }
+#endif
+
+                return true;
+            }
+        }
+
 
         void BitVector::truncateLastBucket() {
             if ((bitCount & mod64mask) != 0) {
@@ -682,6 +786,26 @@ namespace storm {
 
             return out;
         }
+        
+        void BitVector::printBits(std::ostream& out) {
+            out << "bit vector(" << getNumberOfSetBits() << "/" << bitCount << ") ";
+            uint_fast64_t index = 0;
+            for ( ; index * 64 <= bitCount; ++index) {
+                std::bitset<64> tmp(bucketVector[index]);
+                out << tmp << "|";
+            }
+            
+            --index;
+            // Print last bits
+            if (index * 64 < bitCount) {
+                assert(index == bucketVector.size() - 1);
+                std::bitset<64> tmp(bucketVector[index]);
+                for (size_t i = 0; i + index * 64 < bitCount; ++i) {
+                    out << tmp[i];
+                }
+            }
+            out << std::endl;
+        }
 
         std::size_t NonZeroBitVectorHash::operator()(storm::storage::BitVector const& bv) const {
             STORM_LOG_ASSERT(bv.size() > 0, "Cannot hash bit vector of zero size.");
diff --git a/src/storage/BitVector.h b/src/storage/BitVector.h
index 695bdcb82..e3f81ebc9 100644
--- a/src/storage/BitVector.h
+++ b/src/storage/BitVector.h
@@ -461,6 +461,17 @@ namespace storm {
              */
             uint_fast64_t getNextSetIndex(uint_fast64_t startingIndex) const;
             
+            /*
+             * Compare two intervals [start1, start1+length] and [start2, start2+length] and swap them if the second
+             * one is larger than the first one. After the method the intervals are sorted in decreasing order.
+             *
+             * @param start1 Starting index of first interval.
+             * @param start2 Starting index of second interval.
+             * @param length Length of both intervals.
+             * @return True, if the intervals were swapped, false if nothing changed.
+             */
+            bool compareAndSwap(uint_fast64_t start1, uint_fast64_t start2, uint_fast64_t length);
+            
             friend std::ostream& operator<<(std::ostream& out, BitVector const& bitVector);
             friend struct std::hash<storm::storage::BitVector>;
             friend struct NonZeroBitVectorHash;
@@ -490,6 +501,31 @@ namespace storm {
              */
             void truncateLastBucket();
             
+            /*! Retrieves the content of the current bit vector at the given index for the given number of bits as a new
+             * bit vector.
+             *
+             * @param start The index of the first bit to get.
+             * @param length The number of bits to get.
+             * @return A new bit vector holding the selected bits.
+             */
+            BitVector getAsBitVector(uint_fast64_t start, uint_fast64_t length);
+            
+            /*!
+             * Sets the exact bit pattern of the given bit vector starting at the given bit index. Note: the given bit
+             * vector must be shorter than the current one minus the given index.
+             *
+             * @param start The index of the first bit that is supposed to be set.
+             * @param other The bit vector whose pattern to set.
+             */
+            void setFromBitVector(uint_fast64_t start, BitVector const& other);
+            
+            /*!
+             * Print bit vector and display all bits.
+             *
+             * @param out Stream to print to.
+             */
+            void printBits(std::ostream& out);
+            
             /*!
              * Retrieves the number of buckets of the underlying storage.
              *
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 7d3b25c8a..547fdd169 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -265,17 +265,12 @@ namespace storm {
                 std::vector<size_t> symmetryIndices = mStateGenerationInfo.getSymmetryIndices(pos);
                 // Sort symmetry group in decreasing order by bubble sort
                 // TODO use better algorithm?
-                size_t tmp, elem1, elem2;
+                size_t tmp;
                 size_t n = symmetryIndices.size();
                 do {
                     tmp = 0;
                     for (size_t i = 1; i < n; ++i) {
-                        elem1 = mStatus.getAsInt(symmetryIndices[i-1], length);
-                        elem2 = mStatus.getAsInt(symmetryIndices[i], length);
-                        if (elem1 < elem2) {
-                            // Swap elements
-                            mStatus.setFromInt(symmetryIndices[i-1], length, elem2);
-                            mStatus.setFromInt(symmetryIndices[i], length, elem1);
+                        if (mStatus.compareAndSwap(symmetryIndices[i-1], symmetryIndices[i], length)) {
                             tmp = i;
                             changed = true;
                         }

From 73c88a4faf02b85dc9e68208b9281618e1be2bd0 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 26 Feb 2016 13:37:27 +0100
Subject: [PATCH 168/246] update on restrictions

Former-commit-id: 5b14895f07bd6c5be922bcda2b0db0ff320b02ce
---
 src/storage/dft/DFT.cpp                   |  6 ++---
 src/storage/dft/DFTBuilder.cpp            | 11 +-------
 src/storage/dft/DFTElements.cpp           | 14 +++++-----
 src/storage/dft/DFTElements.h             | 32 +++++++++++------------
 src/storage/dft/elements/DFTRestriction.h | 14 +++++-----
 5 files changed, 35 insertions(+), 42 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index c46b9d84c..2aa557d8c 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -321,7 +321,7 @@ namespace storm {
         template <typename ValueType>
         std::vector<size_t> DFT<ValueType>::getIndependentSubDftRoots(size_t index) const {
             auto elem = getElement(index);
-            auto ISD = elem->independentSubDft();
+            auto ISD = elem->independentSubDft(false);
             return ISD;
         }
 
@@ -373,8 +373,8 @@ namespace storm {
                             if(influencedElem1Ids == getSortedParentAndOutDepIds(*it2)) {
                                 std::cout << "Considering ids " << *it1 << ", " << *it2 << " for isomorphism." << std::endl;
                                 bool isSymmetry = false;
-                                std::vector<size_t> isubdft1 = getGate(*it1)->independentSubDft();
-                                std::vector<size_t> isubdft2 = getGate(*it2)->independentSubDft();
+                                std::vector<size_t> isubdft1 = getGate(*it1)->independentSubDft(false);
+                                std::vector<size_t> isubdft2 = getGate(*it2)->independentSubDft(false);
                                 if(isubdft1.empty() || isubdft2.empty() || isubdft1.size() != isubdft2.size()) {
                                     continue;
                                 }
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index 5e5c3da84..e3889bf4d 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -57,16 +57,7 @@ namespace storm {
                 dependentEvent->addIngoingDependency(dependency);
             }
 
-//            for (auto& restriction : mRestrictions) {
-//                std::set<DFTGatePointer> parentsOfRestrictedElements;
-//                for (auto& child : restriction->children()) {
-//                    for(DFTGatePointer& parent : child->parents()) {
-//                        parentsOfRestrictedElements.insert(parent);
-//                    }
-//                }
-//
-//
-//            }
+
 
             // Sort elements topologically
             // compute rank
diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
index ecb6c049c..4cf49e0b0 100644
--- a/src/storage/dft/DFTElements.cpp
+++ b/src/storage/dft/DFTElements.cpp
@@ -63,7 +63,7 @@ namespace storm {
         }
 
         template<typename ValueType>
-        std::vector<size_t> DFTElement<ValueType>::independentSubDft() const {
+        std::vector<size_t> DFTElement<ValueType>::independentSubDft(bool blockParents) const {
             //std::cout << "INDEPENDENT SUBTREE CALL " << this->id() << std::endl;
             std::vector<size_t> res;
             res.push_back(this->id());
@@ -71,7 +71,7 @@ namespace storm {
         }
 
         template<typename ValueType>
-        void DFTElement<ValueType>::extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const {
+        void DFTElement<ValueType>::extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const {
             if(elemsInSubtree.count(this->id()) > 0) return;
             if(std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), mId) != parentsOfSubRoot.end()) {
                 // This is a parent of the suspected root, thus it is not a subdft.
@@ -80,14 +80,16 @@ namespace storm {
             }
             elemsInSubtree.insert(mId);
             for(auto const& parent : mParents) {
-                
-                parent->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                if(blockParents && std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), parent->id()) != parentsOfSubRoot.end()) {
+                    continue;
+                }
+                parent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
                 if(elemsInSubtree.empty()) {
                     return;
                 }
             }
             for(auto const& dep : mOutgoingDependencies) {
-                dep->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                dep->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
                 if(elemsInSubtree.empty()) {
                     return;
                 }
@@ -95,7 +97,7 @@ namespace storm {
             }
             
             for(auto const& restr : mRestrictions) {
-                restr->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                restr->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
                 if(elemsInSubtree.empty()) {
                     return;
                 }
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index 43db2c46e..dc07505bd 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -262,15 +262,15 @@ namespace storm {
             /**
              *  Computes independent subtrees starting with this element (this), that is, all elements (x) which are connected to either
              *  - one of the children of the element,
-             *  - a propabilisistic dependency
+             *  - a probabilistic dependency
              *  such that there exists a  path from x to a child of this does not go through this.
              */
-            virtual std::vector<size_t> independentSubDft() const;
+            virtual std::vector<size_t> independentSubDft(bool blockParents) const;
             /**
              * Helper to the independent subtree computation
              * @see independentSubDft
              */
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const;
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const;
 
             virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const {
                 return type() == other.type();
@@ -351,8 +351,8 @@ namespace storm {
                 }
             }
 
-            virtual std::vector<size_t> independentSubDft() const override {
-                auto prelRes = DFTElement<ValueType>::independentSubDft();
+            virtual std::vector<size_t> independentSubDft(bool blockParents) const override {
+                auto prelRes = DFTElement<ValueType>::independentSubDft(blockParents);
                 if(prelRes.empty()) {
                     // No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft.
                     return prelRes;
@@ -360,7 +360,7 @@ namespace storm {
                 std::set<size_t> unit(prelRes.begin(), prelRes.end());
                 std::vector<size_t> pids = this->parentIds();
                 for(auto const& child : mChildren) {
-                    child->extendSubDft(unit, pids);
+                    child->extendSubDft(unit, pids, blockParents);
                     if(unit.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
                         break;
@@ -369,15 +369,15 @@ namespace storm {
                 return std::vector<size_t>(unit.begin(), unit.end());
             }
 
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
                 if(elemsInSubtree.count(this->id()) > 0) return;
-                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
                 if(elemsInSubtree.empty()) {
                     // Parent in the subdft, ie it is *not* a subdft
                     return;
                 }
                 for(auto const& child : mChildren) {
-                    child->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                    child->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
                     if(elemsInSubtree.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
                         return;
@@ -531,15 +531,15 @@ namespace storm {
                 return storm::utility::isZero(mPassiveFailureRate);
             }
             
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
                  if(elemsInSubtree.count(this->id())) return;
-                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
                 if(elemsInSubtree.empty()) {
                     // Parent in the subdft, ie it is *not* a subdft
                     return;
                 }
                 for(auto const& incDep : mIngoingDependencies) {
-                    incDep->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                    incDep->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
                     if(elemsInSubtree.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
                         return;
@@ -683,19 +683,19 @@ namespace storm {
                 return std::vector<size_t>(unit.begin(), unit.end());
             }
 
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
                  if(elemsInSubtree.count(this->id())) return;
-                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
                 if(elemsInSubtree.empty()) {
                     // Parent in the subdft, ie it is *not* a subdft
                     return;
                 }
-                mDependentEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                mDependentEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
                 if(elemsInSubtree.empty()) {
                     // Parent in the subdft, ie it is *not* a subdft
                     return;
                 }
-                mTriggerEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                mTriggerEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
                 
                 
             }
diff --git a/src/storage/dft/elements/DFTRestriction.h b/src/storage/dft/elements/DFTRestriction.h
index d0482e4a7..70163a6e6 100644
--- a/src/storage/dft/elements/DFTRestriction.h
+++ b/src/storage/dft/elements/DFTRestriction.h
@@ -66,8 +66,8 @@ namespace storm {
                 }
             }
 
-            virtual std::vector<size_t> independentSubDft() const override {
-                auto prelRes = DFTElement<ValueType>::independentSubDft();
+            virtual std::vector<size_t> independentSubDft(bool blockParents) const override {
+                auto prelRes = DFTElement<ValueType>::independentSubDft(blockParents);
                 if(prelRes.empty()) {
                     // No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft.
                     return prelRes;
@@ -75,7 +75,7 @@ namespace storm {
                 std::set<size_t> unit(prelRes.begin(), prelRes.end());
                 std::vector<size_t> pids = this->parentIds();
                 for(auto const& child : mChildren) {
-                    child->extendSubDft(unit, pids);
+                    child->extendSubDft(unit, pids, blockParents);
                     if(unit.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
                         break;
@@ -84,15 +84,15 @@ namespace storm {
                 return std::vector<size_t>(unit.begin(), unit.end());
             }
 
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot) const override {
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
                 if(elemsInSubtree.count(this->id()) > 0) return;
-                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
                 if(elemsInSubtree.empty()) {
                     // Parent in the subdft, ie it is *not* a subdft
                     return;
                 }
                 for(auto const& child : mChildren) {
-                    child->extendSubDft(elemsInSubtree, parentsOfSubRoot);
+                    child->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
                     if(elemsInSubtree.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
                         return;
@@ -183,7 +183,7 @@ namespace storm {
 
             }
             
-            bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 
             }
 

From 11b29cfd87c6f311ff1f6844d2720c9950802e2e Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 26 Feb 2016 14:33:23 +0100
Subject: [PATCH 169/246] splitted elements into single headers

Former-commit-id: 6d0774478dc789f2b1f7a392e7aed726bdfecdf8
---
 src/storage/dft/DFT.h                     |   91 +-
 src/storage/dft/DFTElements.h             | 1036 +--------------------
 src/storage/dft/DFTStateGenerationInfo.h  |   96 ++
 src/storage/dft/elements/DFTAnd.h         |   50 +
 src/storage/dft/elements/DFTBE.h          |  104 +++
 src/storage/dft/elements/DFTConst.h       |   47 +
 src/storage/dft/elements/DFTDependency.h  |  118 +++
 src/storage/dft/elements/DFTElement.h     |  297 ++++++
 src/storage/dft/elements/DFTGate.h        |  180 ++++
 src/storage/dft/elements/DFTOr.h          |   45 +
 src/storage/dft/elements/DFTPand.h        |   56 ++
 src/storage/dft/elements/DFTPor.h         |   36 +
 src/storage/dft/elements/DFTRestriction.h |    3 +-
 src/storage/dft/elements/DFTSpare.h       |   70 ++
 src/storage/dft/elements/DFTVot.h         |   75 ++
 15 files changed, 1188 insertions(+), 1116 deletions(-)
 create mode 100644 src/storage/dft/DFTStateGenerationInfo.h
 create mode 100644 src/storage/dft/elements/DFTAnd.h
 create mode 100644 src/storage/dft/elements/DFTBE.h
 create mode 100644 src/storage/dft/elements/DFTConst.h
 create mode 100644 src/storage/dft/elements/DFTDependency.h
 create mode 100644 src/storage/dft/elements/DFTElement.h
 create mode 100644 src/storage/dft/elements/DFTGate.h
 create mode 100644 src/storage/dft/elements/DFTOr.h
 create mode 100644 src/storage/dft/elements/DFTPand.h
 create mode 100644 src/storage/dft/elements/DFTPor.h
 create mode 100644 src/storage/dft/elements/DFTSpare.h
 create mode 100644 src/storage/dft/elements/DFTVot.h

diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 408a7a535..9762def61 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -15,6 +15,7 @@
 #include "SymmetricUnits.h"
 #include "../../utility/math.h"
 #include "src/utility/macros.h"
+#include "DFTStateGenerationInfo.h"
 
 namespace storm {
     namespace storage {
@@ -35,96 +36,6 @@ namespace storm {
         template<typename T> class DFTColouring;
 
         
-        class DFTStateGenerationInfo {
-        private:
-            const size_t mUsageInfoBits;
-            std::map<size_t, size_t> mSpareUsageIndex; // id spare -> index first bit in state
-            std::map<size_t, size_t> mSpareActivationIndex; // id spare representative -> index in state
-            std::vector<size_t> mIdToStateIndex; // id -> index first bit in state
-            std::map<size_t, size_t> mRestrictedItems;
-            std::vector<std::pair<size_t, std::vector<size_t>>> mSymmetries; // pair (lenght of symmetry group, vector indicating the starting points of the symmetry groups)
-
-        public:
-            
-            DFTStateGenerationInfo(size_t nrElements, size_t maxSpareChildCount) : mUsageInfoBits(storm::utility::math::uint64_log2(maxSpareChildCount) + 1), mIdToStateIndex(nrElements) {
-                assert(maxSpareChildCount < pow(2, mUsageInfoBits));
-            }
-
-            size_t usageInfoBits() const {
-                return mUsageInfoBits;
-            }
-            
-            void addStateIndex(size_t id, size_t index) {
-                assert(id < mIdToStateIndex.size());
-                mIdToStateIndex[id] = index;
-            }
-
-            void addSpareActivationIndex(size_t id, size_t index) {
-                mSpareActivationIndex[id] = index;
-            }
-
-            void addSpareUsageIndex(size_t id, size_t index) {
-                mSpareUsageIndex[id] = index;
-            }
-
-            size_t getStateIndex(size_t id) const {
-                assert(id < mIdToStateIndex.size());
-                return mIdToStateIndex[id];
-            }
-            
-            size_t getSpareUsageIndex(size_t id) const {
-                assert(mSpareUsageIndex.count(id) > 0);
-                return mSpareUsageIndex.at(id);
-            }
-            
-            size_t getSpareActivationIndex(size_t id) const {
-                assert(mSpareActivationIndex.count(id) > 0);
-                return mSpareActivationIndex.at(id);
-            }
-            
-            void addSymmetry(size_t length, std::vector<size_t>& startingIndices) {
-                mSymmetries.push_back(std::make_pair(length, startingIndices));
-            }
-            
-            size_t getSymmetrySize() const {
-                return mSymmetries.size();
-            }
-            
-            size_t getSymmetryLength(size_t pos) const {
-                assert(pos < mSymmetries.size());
-                return mSymmetries[pos].first;
-            }
-            
-            std::vector<size_t> const& getSymmetryIndices(size_t pos) const {
-                assert(pos < mSymmetries.size());
-                return mSymmetries[pos].second;
-            }
-            
-            friend std::ostream& operator<<(std::ostream& os, DFTStateGenerationInfo const& info) {
-                os << "Id to state index:" << std::endl;
-                for (size_t id = 0; id < info.mIdToStateIndex.size(); ++id) {
-                    os << id << " -> " << info.getStateIndex(id) << std::endl;
-                }
-                os << "Spare usage index with usage InfoBits of size " << info.mUsageInfoBits << ":" << std::endl;
-                for (auto pair : info.mSpareUsageIndex) {
-                    os << pair.first << " -> " << pair.second << std::endl;
-                }
-                os << "Spare activation index:" << std::endl;
-                for (auto pair : info.mSpareActivationIndex) {
-                    os << pair.first << " -> " << pair.second << std::endl;
-                }
-                os << "Symmetries:" << std::endl;
-                for (auto pair : info.mSymmetries) {
-                    os << "Length: " << pair.first << ", starting indices: ";
-                    for (size_t index : pair.second) {
-                        os << index << ", ";
-                    }
-                    os << std::endl;
-                }
-                return os;
-            }
-            
-        };
         
 
         /**
diff --git a/src/storage/dft/DFTElements.h b/src/storage/dft/DFTElements.h
index dc07505bd..49bc5cc53 100644
--- a/src/storage/dft/DFTElements.h
+++ b/src/storage/dft/DFTElements.h
@@ -1,1024 +1,12 @@
-#ifndef DFTELEMENTS_H
-#define	DFTELEMENTS_H
-
-#include <set>
-#include <vector>
-#include <memory>
-#include <string>
-#include <cassert>
-#include <cstdlib>
-#include <iostream>
-#include <functional>
-
-#include "DFTElementType.h"
-#include "DFTState.h"
-#include "DFTStateSpaceGenerationQueues.h"
-#include "src/utility/constants.h"
-#include "src/adapters/CarlAdapter.h"
-
-using std::size_t;
-
-namespace storm {
-    namespace storage {
-
-        template<typename ValueType>
-        class DFTGate;
-        
-        template<typename ValueType>
-        class DFTDependency;
-        template<typename ValueType>
-        class DFTRestriction;
-
-        template<typename ValueType>
-        class DFTElement {
-
-            using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
-            using DFTGateVector = std::vector<DFTGatePointer>;
-            using DFTDependencyPointer = std::shared_ptr<DFTDependency<ValueType>>;
-            using DFTDependencyVector = std::vector<DFTDependencyPointer>;
-            using DFTRestrictionPointer = std::shared_ptr<DFTRestriction<ValueType>>;
-            using DFTRestrictionVector = std::vector<DFTRestrictionPointer>;
-
-
-        protected:
-            size_t mId;
-            std::string mName;
-            size_t mRank = -1;
-            DFTGateVector mParents;
-            DFTDependencyVector mOutgoingDependencies;
-            DFTRestrictionVector mRestrictions;
-
-
-        public:
-            DFTElement(size_t id, std::string const& name) :
-                    mId(id), mName(name)
-            {}
-
-            virtual ~DFTElement() {}
-
-            /**
-             * Returns the id
-             */
-            virtual size_t id() const {
-                return mId;
-            }
-
-            virtual DFTElementType type() const = 0;
-
-            virtual void setRank(size_t rank) {
-                mRank = rank;
-            }
-            
-            virtual size_t rank() const {
-                return mRank;
-            }
-            
-            virtual bool isConstant() const {
-                return false;
-            }
-            
-            virtual bool isGate() const {
-                return false;
-            }
-
-            /**
-             *  Returns true if the element is a BE
-             */
-            virtual bool isBasicElement() const {
-                return false;
-            }
-            
-            virtual bool isColdBasicElement() const {
-                return false;
-            }
-
-            /**
-             * Returns true if the element is a spare gate
-             */
-            virtual bool isSpareGate() const {
-                return false;
-            }
-
-            virtual bool isDependency() const {
-                return false;
-            }
-            
-            virtual bool isRestriction() const {
-                return false;
-            }
-
-            virtual void setId(size_t newId) {
-                mId = newId;
-            }
-
-            /**
-             * Returns the name
-             */
-            virtual std::string const& name() const {
-                return mName;
-            }
-            
-            bool addParent(DFTGatePointer const& e) {
-                if(std::find(mParents.begin(), mParents.end(), e) != mParents.end()) {
-                    return false;
-                }
-                else 
-                {
-                    mParents.push_back(e);
-                    return true;
-                }
-            }
-
-            bool addRestriction(DFTRestrictionPointer const& e) {
-                if (std::find(mRestrictions.begin(), mRestrictions.end(), e) != mRestrictions.end()) {
-                    return false;
-                } else {
-                    mRestrictions.push_back(e);
-                    return true;
-                }
-            }
-
-             bool hasOnlyStaticParents() const {
-                for(auto const& parent : mParents) {
-                    if(!isStaticGateType(parent->type())) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-
-            
-            bool hasParents() const {
-                return !mParents.empty();
-            }
-            
-            size_t nrParents() const {
-                return mParents.size();
-            }
-
-            DFTGateVector const& parents() const {
-                return mParents;
-            }
-            
-            bool hasRestrictions() const {
-                return !mRestrictions.empty();
-            }
-            
-            size_t nrRestrictions() const {
-                return mRestrictions.size();
-            }
-            
-            DFTRestrictionVector const& restrictions() const {
-                return mRestrictions;
-            }
-
-            std::vector<size_t> parentIds() const {
-                std::vector<size_t> res;
-                for(auto parent : parents()) {
-                    res.push_back(parent->id());
-                }
-                return res;
-            }
-            
-            bool addOutgoingDependency(DFTDependencyPointer const& e) {
-                assert(e->triggerEvent()->id() == this->id());
-                if(std::find(mOutgoingDependencies.begin(), mOutgoingDependencies.end(), e) != mOutgoingDependencies.end()) {
-                    return false;
-                }
-                else
-                {
-                    mOutgoingDependencies.push_back(e);
-                    return true;
-                }
-            }
-            
-            bool hasOutgoingDependencies() const {
-                return !mOutgoingDependencies.empty();
-            }
-            
-            size_t nrOutgoingDependencies() const {
-                return mOutgoingDependencies.size();
-            }
-            
-            std::set<DFTElement<ValueType>> restrictedItems() const {
-                std::set<DFTElement<ValueType>> result;
-                for(auto const& restr : mRestrictions) {
-                    bool foundThis = false;
-                    for(auto const& child : restr->children()) {
-                        if(!foundThis) {
-                            if(child->id() == mId) {
-                                foundThis = true;
-                            }
-                        } else if(result.count(child) == 0) {
-                            result.insert(child);
-                        }
-                    }
-                }
-            }
-            
-            std::set<DFTElement<ValueType>> restrictedItemsTC() const {
-                std::set<DFTElement<ValueType>> result;
-                for(auto const& restr : mRestrictions) {
-                    bool foundThis = false;
-                    for(auto const& child : restr->children()) {
-                        if(!foundThis) {
-                            if(child->id() == mId) {
-                                foundThis = true;
-                            }
-                        } else if(result.count(child) == 0) {
-                            result.insert(child);
-                            std::set<DFTElement<ValueType>> tmpRes = child->restrictedItemsTC();
-                            result.insert(tmpRes.begin(), tmpRes.end());
-                        }
-                    }
-                }
-            }
-            
-            DFTDependencyVector const& outgoingDependencies() const {
-                return mOutgoingDependencies;
-            }
-            
-            virtual void extendSpareModule(std::set<size_t>& elementsInModule) const;
-
-           // virtual void extendImmediateFailureCausePathEvents(std::set<size_t>& ) const;
-            
-            virtual size_t nrChildren() const = 0;
-
-            virtual std::string toString() const = 0;
-
-            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const;
-
-            /**
-             *  Computes the independent unit of this element, that is, all elements which are direct or indirect successors of an element.
-             */
-            virtual std::vector<size_t> independentUnit() const;
-
-            /**
-             *  Helper to independent unit computation
-             *  @see independentUnit
-             */
-            virtual void extendUnit(std::set<size_t>& unit) const;
-
-            /**
-             *  Computes independent subtrees starting with this element (this), that is, all elements (x) which are connected to either
-             *  - one of the children of the element,
-             *  - a probabilistic dependency
-             *  such that there exists a  path from x to a child of this does not go through this.
-             */
-            virtual std::vector<size_t> independentSubDft(bool blockParents) const;
-            /**
-             * Helper to the independent subtree computation
-             * @see independentSubDft
-             */
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const;
-
-            virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const {
-                return type() == other.type();
-            }
-
-
-        protected:
-           // virtual bool checkIsomorphicSubDftHelper(DFTElement const& otherElem, std::vector<std::pair<DFTElement const&, DFTElement const&>>& mapping, std::vector<DFTElement const&> const& order ) const = 0;
-
-        };
-
-
-
-
-        template<typename ValueType>
-        class DFTGate : public DFTElement<ValueType> {
-
-            using DFTElementPointer = std::shared_ptr<DFTElement<ValueType>>;
-            using DFTElementVector = std::vector<DFTElementPointer>;
-
-        protected:
-            DFTElementVector mChildren;
-
-        public:
-            DFTGate(size_t id, std::string const& name, DFTElementVector const& children) :
-                    DFTElement<ValueType>(id, name), mChildren(children)
-            {}
-            
-            virtual ~DFTGate() {}
-            
-            void pushBackChild(DFTElementPointer elem) {
-                return mChildren.push_back(elem);
-            }
-
-            size_t nrChildren() const override {
-                return mChildren.size();
-            }
-
-            DFTElementVector const& children() const {
-                return mChildren;
-            }
-            
-            virtual bool isGate() const override {
-                return true;
-            }
-            
-            
-            virtual std::string typestring() const = 0;
-
-            virtual void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const = 0;
-
-            virtual void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const = 0;
-            
-            virtual void extendSpareModule(std::set<size_t>& elementsInSpareModule) const override {
-                if (!this->isSpareGate()) {
-                    DFTElement<ValueType>::extendSpareModule(elementsInSpareModule);
-                    for( auto const& child : mChildren) {
-                        if(elementsInSpareModule.count(child->id()) == 0) {
-                            elementsInSpareModule.insert(child->id());
-                            child->extendSpareModule(elementsInSpareModule);
-                        }
-                    }
-                }
-            }
-            
-            virtual std::vector<size_t> independentUnit() const override {
-                std::set<size_t> unit = {this->mId};
-                for(auto const& child : mChildren) {
-                    child->extendUnit(unit);
-                }
-                return std::vector<size_t>(unit.begin(), unit.end());
-            }
-
-            virtual void extendUnit(std::set<size_t>& unit) const override {
-                DFTElement<ValueType>::extendUnit(unit);
-                for(auto const& child : mChildren) {
-                    child->extendUnit(unit);
-                }
-            }
-
-            virtual std::vector<size_t> independentSubDft(bool blockParents) const override {
-                auto prelRes = DFTElement<ValueType>::independentSubDft(blockParents);
-                if(prelRes.empty()) {
-                    // No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft.
-                    return prelRes;
-                }
-                std::set<size_t> unit(prelRes.begin(), prelRes.end());
-                std::vector<size_t> pids = this->parentIds();
-                for(auto const& child : mChildren) {
-                    child->extendSubDft(unit, pids, blockParents);
-                    if(unit.empty()) {
-                        // Parent in the subdft, ie it is *not* a subdft
-                        break;
-                    }
-                }
-                return std::vector<size_t>(unit.begin(), unit.end());
-            }
-
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
-                if(elemsInSubtree.count(this->id()) > 0) return;
-                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
-                if(elemsInSubtree.empty()) {
-                    // Parent in the subdft, ie it is *not* a subdft
-                    return;
-                }
-                for(auto const& child : mChildren) {
-                    child->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
-                    if(elemsInSubtree.empty()) {
-                        // Parent in the subdft, ie it is *not* a subdft
-                        return;
-                    }
-                }
-            }
-
-
-            virtual std::string toString() const override {
-                std::stringstream stream;
-                stream << "{" << this->name() << "} " << typestring() << "( ";
-                typename DFTElementVector::const_iterator it = mChildren.begin();
-                stream << (*it)->name();
-                ++it;
-                while(it != mChildren.end()) {
-                    stream <<  ", " << (*it)->name();
-                    ++it;
-                }
-                stream << ")";
-                return stream.str();
-            }
-
-            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                if(DFTElement<ValueType>::checkDontCareAnymore(state, queues)) {
-                    childrenDontCare(state, queues);
-                    return true;
-                }
-                return false;
-            }
-
-
-        protected:
-
-            void fail(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-                for(std::shared_ptr<DFTGate> parent : this->mParents) {
-                    if(state.isOperational(parent->id())) {
-                        queues.propagateFailure(parent);
-                    }
-                }
-                for(std::shared_ptr<DFTRestriction<ValueType>> restr : this->mRestrictions) {
-                    queues.checkRestrictionLater(restr);
-                }
-                state.setFailed(this->mId);
-                this->childrenDontCare(state, queues);
-            }
-
-            void failsafe(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-                for(std::shared_ptr<DFTGate> parent : this->mParents) {
-                    if(state.isOperational(parent->id())) {
-                        queues.propagateFailsafe(parent);
-                    }
-                }
-                state.setFailsafe(this->mId);
-                this->childrenDontCare(state, queues);
-            }
-            
-            void childrenDontCare(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-                queues.propagateDontCare(mChildren);
-            }
-
-            bool hasFailsafeChild(DFTState<ValueType>& state) const {
-                for(auto const& child : mChildren) {
-                    if(state.isFailsafe(child->id()))
-                    {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            bool hasFailedChild(DFTState<ValueType>& state) const {
-                for(auto const& child : mChildren) {
-                    if(state.hasFailed(child->id())) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-            
-        };
-        
-       
-
-        template<typename ValueType>
-        class DFTBE : public DFTElement<ValueType> {
-            
-            using DFTDependencyPointer = std::shared_ptr<DFTDependency<ValueType>>;
-            using DFTDependencyVector = std::vector<DFTDependencyPointer>;
-
-        protected:
-            ValueType mActiveFailureRate;
-            ValueType mPassiveFailureRate;
-            DFTDependencyVector mIngoingDependencies;
-
-        public:
-            DFTBE(size_t id, std::string const& name, ValueType failureRate, ValueType dormancyFactor) :
-                    DFTElement<ValueType>(id, name), mActiveFailureRate(failureRate), mPassiveFailureRate(dormancyFactor * failureRate)
-            {}
-
-            DFTElementType type() const override {
-                return DFTElementType::BE;
-            }
-
-            virtual size_t nrChildren() const override {
-                return 0;
-            }
-
-            ValueType const& activeFailureRate() const {
-                return mActiveFailureRate;
-            }
-
-            ValueType const& passiveFailureRate() const {
-                return mPassiveFailureRate;
-            }
-            
-            bool addIngoingDependency(DFTDependencyPointer const& e) {
-                assert(e->dependentEvent()->id() == this->id());
-                if(std::find(mIngoingDependencies.begin(), mIngoingDependencies.end(), e) != mIngoingDependencies.end()) {
-                    return false;
-                }
-                else
-                {
-                    mIngoingDependencies.push_back(e);
-                    return true;
-                }
-            }
-            
-            bool hasIngoingDependencies() const {
-                return !mIngoingDependencies.empty();
-            }
-            
-            size_t nrIngoingDependencies() const {
-                return mIngoingDependencies.size();
-            }
-            
-            DFTDependencyVector const& ingoingDependencies() const {
-                return mIngoingDependencies;
-            }
-        
-            std::string toString() const override {
-                std::stringstream stream;
-                stream << *this;
-                return stream.str();
-            }
-            
-            bool isBasicElement() const override{
-                return true;
-            }
-            
-            bool isColdBasicElement() const override{
-                return storm::utility::isZero(mPassiveFailureRate);
-            }
-            
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
-                 if(elemsInSubtree.count(this->id())) return;
-                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
-                if(elemsInSubtree.empty()) {
-                    // Parent in the subdft, ie it is *not* a subdft
-                    return;
-                }
-                for(auto const& incDep : mIngoingDependencies) {
-                    incDep->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
-                    if(elemsInSubtree.empty()) {
-                        // Parent in the subdft, ie it is *not* a subdft
-                        return;
-                    }
-                }
-            }
-            
-            bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
-                if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
-                DFTBE<ValueType> const&  otherBE = static_cast<DFTBE<ValueType> const&>(other);
-                return (mActiveFailureRate == otherBE.mActiveFailureRate) && (mPassiveFailureRate == otherBE.mPassiveFailureRate);
-            }
-            
-            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override;
-        };
-
-        template<typename ValueType>
-        inline std::ostream& operator<<(std::ostream& os, DFTBE<ValueType> const& be) {
-            return os << "{" << be.name() << "} BE(" << be.activeFailureRate() << ", " << be.passiveFailureRate() << ")";
-        }
-
-
-
-        template<typename ValueType>
-        class DFTConst : public DFTElement<ValueType> {
-
-            bool mFailed;
-
-        public:
-            DFTConst(size_t id, std::string const& name, bool failed) :
-                    DFTElement<ValueType>(id, name), mFailed(failed)
-            {}
-
-            DFTElementType type() const override {
-                if(mFailed) {
-                    return DFTElementType::CONSTF;
-                } else {
-                    return DFTElementType::CONSTS;
-                }
-            }
-
-
-            bool failed() const {
-                return mFailed;
-            }
-            
-            virtual bool isConstant() const {
-                return true;
-            }
-            
-            virtual size_t nrChildren() const override {
-                return 0;
-            }
-            
-            
-            
-            bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
-                if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
-                DFTConst<ValueType> const& otherCNST = static_cast<DFTConst<ValueType> const&>(other);
-                return (mFailed == otherCNST.mFailed);
-            }
-            
-        };
-
-
-        template<typename ValueType>
-        class DFTDependency : public DFTElement<ValueType> {
-
-            using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
-            using DFTBEPointer = std::shared_ptr<DFTBE<ValueType>>;
-            
-        protected:
-            std::string mNameTrigger;
-            std::string mNameDependent;
-            ValueType mProbability;
-            DFTGatePointer mTriggerEvent;
-            DFTBEPointer mDependentEvent;
-
-        public:
-            DFTDependency(size_t id, std::string const& name, std::string const& trigger, std::string const& dependent, ValueType probability) :
-                DFTElement<ValueType>(id, name), mNameTrigger(trigger), mNameDependent(dependent), mProbability(probability)
-            {
-            }
-
-            virtual ~DFTDependency() {}
-
-            void initialize(DFTGatePointer triggerEvent, DFTBEPointer dependentEvent) {
-                assert(triggerEvent->name() == mNameTrigger);
-                assert(dependentEvent->name() == mNameDependent);
-                mTriggerEvent = triggerEvent;
-                mDependentEvent = dependentEvent;
-            }
-
-            std::string nameTrigger() const {
-                return mNameTrigger;
-            }
-
-            std::string nameDependent() const {
-                return mNameDependent;
-            }
-
-            ValueType const& probability() const {
-                return mProbability;
-            }
-
-            DFTGatePointer const& triggerEvent() const {
-                assert(mTriggerEvent);
-                return mTriggerEvent;
-            }
-
-            DFTBEPointer const& dependentEvent() const {
-                assert(mDependentEvent);
-                return mDependentEvent;
-            }
-
-            DFTElementType type() const override {
-                return DFTElementType::PDEP;
-            }
-
-            virtual size_t nrChildren() const override {
-                return 1;
-            }
-
-            virtual bool isDependency() const override {
-                return true;
-            }
-            
-            virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
-                if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
-                DFTDependency<ValueType> const& otherDEP= static_cast<DFTDependency<ValueType> const&>(other);
-                return (mProbability == otherDEP.mProbability);
-            }
-            
-
-            virtual std::vector<size_t> independentUnit() const override {
-                std::set<size_t> unit = {this->mId};
-                mDependentEvent->extendUnit(unit);
-                if(unit.count(mTriggerEvent->id()) != 0) {
-                    return {};
-                }
-                return std::vector<size_t>(unit.begin(), unit.end());
-            }
-
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
-                 if(elemsInSubtree.count(this->id())) return;
-                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
-                if(elemsInSubtree.empty()) {
-                    // Parent in the subdft, ie it is *not* a subdft
-                    return;
-                }
-                mDependentEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
-                if(elemsInSubtree.empty()) {
-                    // Parent in the subdft, ie it is *not* a subdft
-                    return;
-                }
-                mTriggerEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
-                
-                
-            }
-            
-            virtual std::string toString() const override {
-                std::stringstream stream;
-                bool fdep = storm::utility::isOne(mProbability);
-                stream << "{" << this->name() << "} " << (fdep ? "FDEP" : "PDEP") << "(" << mTriggerEvent->name() << " => " << mDependentEvent->name() << ")";
-                if (!fdep) {
-                    stream << " with probability " << mProbability;
-                }
-                return stream.str();
-            }
-
-        protected:
-
-        };
-
-
-        template<typename ValueType>
-        class DFTAnd : public DFTGate<ValueType> {
-            
-        public:
-            DFTAnd(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
-                    DFTGate<ValueType>(id, name, children)
-            {}
-
-            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                if(state.isOperational(this->mId)) {
-                    for(auto const& child : this->mChildren)
-                    {
-                        if(!state.hasFailed(child->id())) {
-                            return;
-                        }
-                    }
-                    this->fail(state, queues);
-                }
-            }
-
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                assert(this->hasFailsafeChild(state));
-                if(state.isOperational(this->mId)) {
-                    this->failsafe(state, queues);
-                    this->childrenDontCare(state, queues);
-                }
-            }
-
-            virtual DFTElementType type() const override {
-                return DFTElementType::AND;
-            }
-            
-            std::string typestring() const override {
-                return "AND";
-            }
-        };
-
-        template<typename ValueType>
-        inline std::ostream& operator<<(std::ostream& os, DFTAnd<ValueType> const& gate) {
-            return os << gate.toString();
-        }
-
-        
-
-        template<typename ValueType>
-        class DFTOr : public DFTGate<ValueType> {
-
-        public:
-            DFTOr(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
-                    DFTGate<ValueType>(id, name, children)
-            {}
-
-            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                assert(this->hasFailedChild(state));
-                if(state.isOperational(this->mId)) {
-                    this->fail(state, queues);
-                }
-            }
-
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                 for(auto const& child : this->mChildren) {
-                     if(!state.isFailsafe(child->id())) {
-                         return;
-                     }
-                 }
-                 this->failsafe(state, queues);
-            }
-
-            virtual DFTElementType type() const override {
-                return DFTElementType::OR;
-            }
-            
-            std::string typestring() const override {
-                return "OR";
-            }
-        };
-
-        template<typename ValueType>
-        inline std::ostream& operator<<(std::ostream& os, DFTOr<ValueType> const& gate) {
-            return os << gate.toString();
-        }
-
-        template<typename ValueType>
-        class DFTPand : public DFTGate<ValueType> {
-
-        public:
-            DFTPand(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
-                    DFTGate<ValueType>(id, name, children)
-            {}
-
-            void checkFails(storm::storage::DFTState<ValueType>& state,  DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                if(state.isOperational(this->mId)) {
-                    bool childOperationalBefore = false;
-                    for(auto const& child : this->mChildren)
-                    {
-                        if(!state.hasFailed(child->id())) {
-                            childOperationalBefore = true;
-                        } else if(childOperationalBefore && state.hasFailed(child->id())){
-                            this->failsafe(state, queues);
-                            this->childrenDontCare(state, queues);
-                            return;
-                        }
-                    }
-                    if(!childOperationalBefore) {
-                        this->fail(state, queues);
-                    }
-                }
-            }
-
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                assert(this->hasFailsafeChild(state));
-                if(state.isOperational(this->mId)) {
-                    this->failsafe(state, queues);
-                    this->childrenDontCare(state, queues);
-                }
-            }
-
-            virtual DFTElementType type() const override {
-                return DFTElementType::PAND;
-            }
-            
-            std::string typestring() const override {
-                return "PAND";
-            }
-        };
-        
-        template<typename ValueType>
-        inline std::ostream& operator<<(std::ostream& os, DFTPand<ValueType> const& gate) {
-             return os << gate.toString();
-        }
-
-
-
-        template<typename ValueType>
-        class DFTPor : public DFTGate<ValueType> {
-        public:
-            DFTPor(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
-                    DFTGate<ValueType>(id, name, children)
-            {}
-
-            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                 assert(false);
-            }
-
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                assert(false);
-            }
-
-            virtual DFTElementType type() const override {
-                return DFTElementType::POR;
-            }
-            
-            std::string  typestring() const override {
-                return "POR";
-            }
-        };
-
-        template<typename ValueType>
-        inline std::ostream& operator<<(std::ostream& os, DFTPor<ValueType> const& gate) {
-             return os << gate.toString();
-        }
-
-
-
-        template<typename ValueType>
-        class DFTVot : public DFTGate<ValueType> {
-
-        private:
-            unsigned mThreshold;
-
-        public:
-            DFTVot(size_t id, std::string const& name, unsigned threshold, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
-                    DFTGate<ValueType>(id, name, children), mThreshold(threshold)
-            {}
-
-            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                if(state.isOperational(this->mId)) {
-                    unsigned nrFailedChildren = 0;
-                    for(auto const& child : this->mChildren)
-                    {
-                        if(state.hasFailed(child->id())) {
-                            ++nrFailedChildren;
-                            if(nrFailedChildren >= mThreshold) 
-                            {
-                                this->fail(state, queues);
-                                return;
-                            }
-                        }
-                    }
-                  
-                } 
-            }
-
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                assert(this->hasFailsafeChild(state));
-                if(state.isOperational(this->mId)) {
-                    unsigned nrFailsafeChildren = 0;
-                    for(auto const& child : this->mChildren)
-                    {
-                        if(state.isFailsafe(child->id())) {
-                            ++nrFailsafeChildren;
-                            if(nrFailsafeChildren > this->nrChildren() - mThreshold)
-                            {
-                                this->failsafe(state, queues);
-                                this->childrenDontCare(state, queues);
-                                return;
-                            }
-                        }
-                    }
-                }
-            }
-
-            virtual DFTElementType type() const override {
-                return DFTElementType::VOT;
-            }
-            
-            std::string typestring() const override{
-                return "VOT (" + std::to_string(mThreshold) + ")";
-            }
-            
-            virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
-                if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
-                DFTVot<ValueType> const& otherVOT = static_cast<DFTVot<ValueType> const&>(other);
-                return (mThreshold == otherVOT.mThreshold);
-            }
-        };
-
-        template<typename ValueType>
-        inline std::ostream& operator<<(std::ostream& os, DFTVot<ValueType> const& gate) {
-            return os << gate.toString();
-        }
-
-
-
-        template<typename ValueType>
-        class DFTSpare : public DFTGate<ValueType> {
-
-        public:
-            DFTSpare(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
-                    DFTGate<ValueType>(id, name, children)
-            {}
-            
-            std::string typestring() const override {
-                return "SPARE";
-            }
-
-            virtual DFTElementType type() const override {
-                return DFTElementType::SPARE;
-            }
-
-            bool isSpareGate() const override {
-                return true;
-            }
-            
-            void fail(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-                DFTGate<ValueType>::fail(state, queues);
-                state.finalizeUses(this->mId);
-            }
-            
-            void failsafe(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-                DFTGate<ValueType>::failsafe(state, queues);
-                state.finalizeUses(this->mId);
-            }
-            
-            bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                if (DFTGate<ValueType>::checkDontCareAnymore(state, queues)) {
-                    state.finalizeUses(this->mId);
-                    return true;
-                }
-                return false;
-            }
-            
-            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                if(state.isOperational(this->mId)) {
-                    size_t uses = state.uses(this->mId);
-                    if(!state.isOperational(uses)) {
-                        bool claimingSuccessful = state.claimNew(this->mId, uses, this->mChildren);
-                        if(!claimingSuccessful) {
-                            this->fail(state, queues);
-                        }
-                    }                  
-                } 
-            }
-
-            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                if(state.isOperational(this->mId)) {
-                    if(state.isFailsafe(state.uses(this->mId))) {
-                        this->failsafe(state, queues);
-                        this->childrenDontCare(state, queues);
-                    }
-                }
-            }
-
-        };
-        
-        template<typename ValueType>
-        bool equalType(DFTElement<ValueType> const& e1, DFTElement<ValueType> const& e2) {
-            return e1.isTypeEqualTo(e2);
-        }
-        
-    }
-}
-
-
-
-#endif	/* DFTELEMENTS_H */
-
+#pragma once
+
+#include "elements/DFTAnd.h"
+#include "elements/DFTBE.h"
+#include "elements/DFTConst.h"
+#include "elements/DFTDependency.h"
+#include "elements/DFTOr.h"
+#include "elements/DFTPand.h"
+#include "elements/DFTPor.h"
+#include "elements/DFTRestriction.h"
+#include "elements/DFTSpare.h"
+#include "elements/DFTVot.h"
\ No newline at end of file
diff --git a/src/storage/dft/DFTStateGenerationInfo.h b/src/storage/dft/DFTStateGenerationInfo.h
new file mode 100644
index 000000000..f82d4e8af
--- /dev/null
+++ b/src/storage/dft/DFTStateGenerationInfo.h
@@ -0,0 +1,96 @@
+#pragma once
+
+namespace storm {
+    namespace storage {
+        class DFTStateGenerationInfo {
+        private:
+            const size_t mUsageInfoBits;
+            std::map<size_t, size_t> mSpareUsageIndex; // id spare -> index first bit in state
+            std::map<size_t, size_t> mSpareActivationIndex; // id spare representative -> index in state
+            std::vector<size_t> mIdToStateIndex; // id -> index first bit in state
+            std::map<size_t, size_t> mRestrictedItems;
+            std::vector<std::pair<size_t, std::vector<size_t>>> mSymmetries; // pair (lenght of symmetry group, vector indicating the starting points of the symmetry groups)
+
+        public:
+
+            DFTStateGenerationInfo(size_t nrElements, size_t maxSpareChildCount) : mUsageInfoBits(storm::utility::math::uint64_log2(maxSpareChildCount) + 1), mIdToStateIndex(nrElements) {
+                assert(maxSpareChildCount < pow(2, mUsageInfoBits));
+            }
+
+            size_t usageInfoBits() const {
+                return mUsageInfoBits;
+            }
+
+            void addStateIndex(size_t id, size_t index) {
+                assert(id < mIdToStateIndex.size());
+                mIdToStateIndex[id] = index;
+            }
+
+            void addSpareActivationIndex(size_t id, size_t index) {
+                mSpareActivationIndex[id] = index;
+            }
+
+            void addSpareUsageIndex(size_t id, size_t index) {
+                mSpareUsageIndex[id] = index;
+            }
+
+            size_t getStateIndex(size_t id) const {
+                assert(id < mIdToStateIndex.size());
+                return mIdToStateIndex[id];
+            }
+
+            size_t getSpareUsageIndex(size_t id) const {
+                assert(mSpareUsageIndex.count(id) > 0);
+                return mSpareUsageIndex.at(id);
+            }
+
+            size_t getSpareActivationIndex(size_t id) const {
+                assert(mSpareActivationIndex.count(id) > 0);
+                return mSpareActivationIndex.at(id);
+            }
+
+            void addSymmetry(size_t length, std::vector<size_t>& startingIndices) {
+                mSymmetries.push_back(std::make_pair(length, startingIndices));
+            }
+
+            size_t getSymmetrySize() const {
+                return mSymmetries.size();
+            }
+
+            size_t getSymmetryLength(size_t pos) const {
+                assert(pos < mSymmetries.size());
+                return mSymmetries[pos].first;
+            }
+
+            std::vector<size_t> const& getSymmetryIndices(size_t pos) const {
+                assert(pos < mSymmetries.size());
+                return mSymmetries[pos].second;
+            }
+
+            friend std::ostream& operator<<(std::ostream& os, DFTStateGenerationInfo const& info) {
+                os << "Id to state index:" << std::endl;
+                for (size_t id = 0; id < info.mIdToStateIndex.size(); ++id) {
+                    os << id << " -> " << info.getStateIndex(id) << std::endl;
+                }
+                os << "Spare usage index with usage InfoBits of size " << info.mUsageInfoBits << ":" << std::endl;
+                for (auto pair : info.mSpareUsageIndex) {
+                    os << pair.first << " -> " << pair.second << std::endl;
+                }
+                os << "Spare activation index:" << std::endl;
+                for (auto pair : info.mSpareActivationIndex) {
+                    os << pair.first << " -> " << pair.second << std::endl;
+                }
+                os << "Symmetries:" << std::endl;
+                for (auto pair : info.mSymmetries) {
+                    os << "Length: " << pair.first << ", starting indices: ";
+                    for (size_t index : pair.second) {
+                        os << index << ", ";
+                    }
+                    os << std::endl;
+                }
+                return os;
+            }
+
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/storage/dft/elements/DFTAnd.h b/src/storage/dft/elements/DFTAnd.h
new file mode 100644
index 000000000..5a5763166
--- /dev/null
+++ b/src/storage/dft/elements/DFTAnd.h
@@ -0,0 +1,50 @@
+#pragma once 
+#include "DFTGate.h"
+
+namespace storm {
+    namespace storage {
+        template<typename ValueType>
+        class DFTAnd : public DFTGate<ValueType> {
+            
+        public:
+            DFTAnd(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children)
+            {}
+
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                if(state.isOperational(this->mId)) {
+                    for(auto const& child : this->mChildren)
+                    {
+                        if(!state.hasFailed(child->id())) {
+                            return;
+                        }
+                    }
+                    this->fail(state, queues);
+                }
+            }
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                assert(this->hasFailsafeChild(state));
+                if(state.isOperational(this->mId)) {
+                    this->failsafe(state, queues);
+                    this->childrenDontCare(state, queues);
+                }
+            }
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::AND;
+            }
+            
+            std::string typestring() const override {
+                return "AND";
+            }
+        };
+
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTAnd<ValueType> const& gate) {
+            return os << gate.toString();
+        }
+
+              
+    }
+}
diff --git a/src/storage/dft/elements/DFTBE.h b/src/storage/dft/elements/DFTBE.h
new file mode 100644
index 000000000..5e09e965e
--- /dev/null
+++ b/src/storage/dft/elements/DFTBE.h
@@ -0,0 +1,104 @@
+#pragma once
+namespace storm {
+    namespace storage {
+        template<typename ValueType>
+        class DFTBE : public DFTElement<ValueType> {
+            
+            using DFTDependencyPointer = std::shared_ptr<DFTDependency<ValueType>>;
+            using DFTDependencyVector = std::vector<DFTDependencyPointer>;
+
+        protected:
+            ValueType mActiveFailureRate;
+            ValueType mPassiveFailureRate;
+            DFTDependencyVector mIngoingDependencies;
+
+        public:
+            DFTBE(size_t id, std::string const& name, ValueType failureRate, ValueType dormancyFactor) :
+                    DFTElement<ValueType>(id, name), mActiveFailureRate(failureRate), mPassiveFailureRate(dormancyFactor * failureRate)
+            {}
+
+            DFTElementType type() const override {
+                return DFTElementType::BE;
+            }
+
+            virtual size_t nrChildren() const override {
+                return 0;
+            }
+
+            ValueType const& activeFailureRate() const {
+                return mActiveFailureRate;
+            }
+
+            ValueType const& passiveFailureRate() const {
+                return mPassiveFailureRate;
+            }
+            
+            bool addIngoingDependency(DFTDependencyPointer const& e) {
+                assert(e->dependentEvent()->id() == this->id());
+                if(std::find(mIngoingDependencies.begin(), mIngoingDependencies.end(), e) != mIngoingDependencies.end()) {
+                    return false;
+                }
+                else
+                {
+                    mIngoingDependencies.push_back(e);
+                    return true;
+                }
+            }
+            
+            bool hasIngoingDependencies() const {
+                return !mIngoingDependencies.empty();
+            }
+            
+            size_t nrIngoingDependencies() const {
+                return mIngoingDependencies.size();
+            }
+            
+            DFTDependencyVector const& ingoingDependencies() const {
+                return mIngoingDependencies;
+            }
+        
+            std::string toString() const override {
+                std::stringstream stream;
+                stream << *this;
+                return stream.str();
+            }
+            
+            bool isBasicElement() const override{
+                return true;
+            }
+            
+            bool isColdBasicElement() const override{
+                return storm::utility::isZero(mPassiveFailureRate);
+            }
+            
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
+                 if(elemsInSubtree.count(this->id())) return;
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                if(elemsInSubtree.empty()) {
+                    // Parent in the subdft, ie it is *not* a subdft
+                    return;
+                }
+                for(auto const& incDep : mIngoingDependencies) {
+                    incDep->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                    if(elemsInSubtree.empty()) {
+                        // Parent in the subdft, ie it is *not* a subdft
+                        return;
+                    }
+                }
+            }
+            
+            bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
+                if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
+                DFTBE<ValueType> const&  otherBE = static_cast<DFTBE<ValueType> const&>(other);
+                return (mActiveFailureRate == otherBE.mActiveFailureRate) && (mPassiveFailureRate == otherBE.mPassiveFailureRate);
+            }
+            
+            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override;
+        };
+
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTBE<ValueType> const& be) {
+            return os << "{" << be.name() << "} BE(" << be.activeFailureRate() << ", " << be.passiveFailureRate() << ")";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/storage/dft/elements/DFTConst.h b/src/storage/dft/elements/DFTConst.h
new file mode 100644
index 000000000..e827e173c
--- /dev/null
+++ b/src/storage/dft/elements/DFTConst.h
@@ -0,0 +1,47 @@
+#pragma once
+
+
+#include "DFTElement.h"
+namespace storm {
+    namespace storage {
+        template<typename ValueType>
+        class DFTConst : public DFTElement<ValueType> {
+
+            bool mFailed;
+
+        public:
+            DFTConst(size_t id, std::string const& name, bool failed) :
+                    DFTElement<ValueType>(id, name), mFailed(failed)
+            {}
+
+            DFTElementType type() const override {
+                if(mFailed) {
+                    return DFTElementType::CONSTF;
+                } else {
+                    return DFTElementType::CONSTS;
+                }
+            }
+
+
+            bool failed() const {
+                return mFailed;
+            }
+            
+            virtual bool isConstant() const {
+                return true;
+            }
+            
+            virtual size_t nrChildren() const override {
+                return 0;
+            }
+            
+            
+            bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
+                if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
+                DFTConst<ValueType> const& otherCNST = static_cast<DFTConst<ValueType> const&>(other);
+                return (mFailed == otherCNST.mFailed);
+            }
+
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/storage/dft/elements/DFTDependency.h b/src/storage/dft/elements/DFTDependency.h
new file mode 100644
index 000000000..c7f3f6bfd
--- /dev/null
+++ b/src/storage/dft/elements/DFTDependency.h
@@ -0,0 +1,118 @@
+#pragma once
+
+
+#include "DFTElement.h"
+namespace storm {
+    namespace storage {
+        
+        template<typename ValueType>
+        class DFTDependency : public DFTElement<ValueType> {
+
+            using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
+            using DFTBEPointer = std::shared_ptr<DFTBE<ValueType>>;
+            
+        protected:
+            std::string mNameTrigger;
+            std::string mNameDependent;
+            ValueType mProbability;
+            DFTGatePointer mTriggerEvent;
+            DFTBEPointer mDependentEvent;
+
+        public:
+            DFTDependency(size_t id, std::string const& name, std::string const& trigger, std::string const& dependent, ValueType probability) :
+                DFTElement<ValueType>(id, name), mNameTrigger(trigger), mNameDependent(dependent), mProbability(probability)
+            {
+            }
+
+            virtual ~DFTDependency() {}
+
+            void initialize(DFTGatePointer triggerEvent, DFTBEPointer dependentEvent) {
+                assert(triggerEvent->name() == mNameTrigger);
+                assert(dependentEvent->name() == mNameDependent);
+                mTriggerEvent = triggerEvent;
+                mDependentEvent = dependentEvent;
+            }
+
+            std::string nameTrigger() const {
+                return mNameTrigger;
+            }
+
+            std::string nameDependent() const {
+                return mNameDependent;
+            }
+
+            ValueType const& probability() const {
+                return mProbability;
+            }
+
+            DFTGatePointer const& triggerEvent() const {
+                assert(mTriggerEvent);
+                return mTriggerEvent;
+            }
+
+            DFTBEPointer const& dependentEvent() const {
+                assert(mDependentEvent);
+                return mDependentEvent;
+            }
+
+            DFTElementType type() const override {
+                return DFTElementType::PDEP;
+            }
+
+            virtual size_t nrChildren() const override {
+                return 1;
+            }
+
+            virtual bool isDependency() const override {
+                return true;
+            }
+            
+            virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
+                if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
+                DFTDependency<ValueType> const& otherDEP= static_cast<DFTDependency<ValueType> const&>(other);
+                return (mProbability == otherDEP.mProbability);
+            }
+            
+
+            virtual std::vector<size_t> independentUnit() const override {
+                std::set<size_t> unit = {this->mId};
+                mDependentEvent->extendUnit(unit);
+                if(unit.count(mTriggerEvent->id()) != 0) {
+                    return {};
+                }
+                return std::vector<size_t>(unit.begin(), unit.end());
+            }
+
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
+                 if(elemsInSubtree.count(this->id())) return;
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                if(elemsInSubtree.empty()) {
+                    // Parent in the subdft, ie it is *not* a subdft
+                    return;
+                }
+                mDependentEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                if(elemsInSubtree.empty()) {
+                    // Parent in the subdft, ie it is *not* a subdft
+                    return;
+                }
+                mTriggerEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                
+                
+            }
+            
+            virtual std::string toString() const override {
+                std::stringstream stream;
+                bool fdep = storm::utility::isOne(mProbability);
+                stream << "{" << this->name() << "} " << (fdep ? "FDEP" : "PDEP") << "(" << mTriggerEvent->name() << " => " << mDependentEvent->name() << ")";
+                if (!fdep) {
+                    stream << " with probability " << mProbability;
+                }
+                return stream.str();
+            }
+
+        protected:
+
+        };
+
+    }
+}
\ No newline at end of file
diff --git a/src/storage/dft/elements/DFTElement.h b/src/storage/dft/elements/DFTElement.h
new file mode 100644
index 000000000..d6840132a
--- /dev/null
+++ b/src/storage/dft/elements/DFTElement.h
@@ -0,0 +1,297 @@
+#pragma once 
+
+#include <string>
+#include <cassert>
+#include <cstdlib>
+#include <iostream>
+#include <functional>
+#include <set>
+#include <vector>
+#include <memory>
+
+
+
+#include "../DFTElementType.h"
+#include "../DFTState.h"
+#include "../DFTStateSpaceGenerationQueues.h"
+#include "src/utility/constants.h"
+#include "src/adapters/CarlAdapter.h"
+
+
+
+
+namespace storm {
+    namespace storage {
+        
+        using std::size_t;
+        template<typename ValueType>
+        class DFTGate;
+        
+        template<typename ValueType>
+        class DFTDependency;
+        template<typename ValueType>
+        class DFTRestriction;
+
+        
+        template<typename ValueType>
+        class DFTElement {
+
+            using DFTGatePointer = std::shared_ptr<DFTGate<ValueType>>;
+            using DFTGateVector = std::vector<DFTGatePointer>;
+            using DFTDependencyPointer = std::shared_ptr<DFTDependency<ValueType>>;
+            using DFTDependencyVector = std::vector<DFTDependencyPointer>;
+            using DFTRestrictionPointer = std::shared_ptr<DFTRestriction<ValueType>>;
+            using DFTRestrictionVector = std::vector<DFTRestrictionPointer>;
+
+
+        protected:
+            std::size_t mId;
+            std::string mName;
+            std::size_t mRank = -1;
+            DFTGateVector mParents;
+            DFTDependencyVector mOutgoingDependencies;
+            DFTRestrictionVector mRestrictions;
+
+
+        public:
+            DFTElement(size_t id, std::string const& name) :
+                    mId(id), mName(name)
+            {}
+
+            virtual ~DFTElement() {}
+
+            /**
+             * Returns the id
+             */
+            virtual size_t id() const {
+                return mId;
+            }
+
+            virtual DFTElementType type() const = 0;
+
+            virtual void setRank(size_t rank) {
+                mRank = rank;
+            }
+            
+            virtual size_t rank() const {
+                return mRank;
+            }
+            
+            virtual bool isConstant() const {
+                return false;
+            }
+            
+            virtual bool isGate() const {
+                return false;
+            }
+
+            /**
+             *  Returns true if the element is a BE
+             */
+            virtual bool isBasicElement() const {
+                return false;
+            }
+            
+            virtual bool isColdBasicElement() const {
+                return false;
+            }
+
+            /**
+             * Returns true if the element is a spare gate
+             */
+            virtual bool isSpareGate() const {
+                return false;
+            }
+
+            virtual bool isDependency() const {
+                return false;
+            }
+            
+            virtual bool isRestriction() const {
+                return false;
+            }
+
+            virtual void setId(size_t newId) {
+                mId = newId;
+            }
+
+            /**
+             * Returns the name
+             */
+            virtual std::string const& name() const {
+                return mName;
+            }
+            
+            bool addParent(DFTGatePointer const& e) {
+                if(std::find(mParents.begin(), mParents.end(), e) != mParents.end()) {
+                    return false;
+                }
+                else 
+                {
+                    mParents.push_back(e);
+                    return true;
+                }
+            }
+
+            bool addRestriction(DFTRestrictionPointer const& e) {
+                if (std::find(mRestrictions.begin(), mRestrictions.end(), e) != mRestrictions.end()) {
+                    return false;
+                } else {
+                    mRestrictions.push_back(e);
+                    return true;
+                }
+            }
+
+             bool hasOnlyStaticParents() const {
+                for(auto const& parent : mParents) {
+                    if(!isStaticGateType(parent->type())) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            
+            bool hasParents() const {
+                return !mParents.empty();
+            }
+            
+            size_t nrParents() const {
+                return mParents.size();
+            }
+
+            DFTGateVector const& parents() const {
+                return mParents;
+            }
+            
+            bool hasRestrictions() const {
+                return !mRestrictions.empty();
+            }
+            
+            size_t nrRestrictions() const {
+                return mRestrictions.size();
+            }
+            
+            DFTRestrictionVector const& restrictions() const {
+                return mRestrictions;
+            }
+
+            std::vector<size_t> parentIds() const {
+                std::vector<size_t> res;
+                for(auto parent : parents()) {
+                    res.push_back(parent->id());
+                }
+                return res;
+            }
+            
+            bool addOutgoingDependency(DFTDependencyPointer const& e) {
+                assert(e->triggerEvent()->id() == this->id());
+                if(std::find(mOutgoingDependencies.begin(), mOutgoingDependencies.end(), e) != mOutgoingDependencies.end()) {
+                    return false;
+                }
+                else
+                {
+                    mOutgoingDependencies.push_back(e);
+                    return true;
+                }
+            }
+            
+            bool hasOutgoingDependencies() const {
+                return !mOutgoingDependencies.empty();
+            }
+            
+            size_t nrOutgoingDependencies() const {
+                return mOutgoingDependencies.size();
+            }
+            
+            std::set<DFTElement<ValueType>> restrictedItems() const {
+                std::set<DFTElement<ValueType>> result;
+                for(auto const& restr : mRestrictions) {
+                    bool foundThis = false;
+                    for(auto const& child : restr->children()) {
+                        if(!foundThis) {
+                            if(child->id() == mId) {
+                                foundThis = true;
+                            }
+                        } else if(result.count(child) == 0) {
+                            result.insert(child);
+                        }
+                    }
+                }
+            }
+            
+            std::set<DFTElement<ValueType>> restrictedItemsTC() const {
+                std::set<DFTElement<ValueType>> result;
+                for(auto const& restr : mRestrictions) {
+                    bool foundThis = false;
+                    for(auto const& child : restr->children()) {
+                        if(!foundThis) {
+                            if(child->id() == mId) {
+                                foundThis = true;
+                            }
+                        } else if(result.count(child) == 0) {
+                            result.insert(child);
+                            std::set<DFTElement<ValueType>> tmpRes = child->restrictedItemsTC();
+                            result.insert(tmpRes.begin(), tmpRes.end());
+                        }
+                    }
+                }
+            }
+            
+            DFTDependencyVector const& outgoingDependencies() const {
+                return mOutgoingDependencies;
+            }
+            
+            virtual void extendSpareModule(std::set<size_t>& elementsInModule) const;
+
+           // virtual void extendImmediateFailureCausePathEvents(std::set<size_t>& ) const;
+            
+            virtual std::size_t nrChildren() const = 0;
+
+            virtual std::string toString() const = 0;
+
+            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const;
+
+            /**
+             *  Computes the independent unit of this element, that is, all elements which are direct or indirect successors of an element.
+             */
+            virtual std::vector<size_t> independentUnit() const;
+
+            /**
+             *  Helper to independent unit computation
+             *  @see independentUnit
+             */
+            virtual void extendUnit(std::set<size_t>& unit) const;
+
+            /**
+             *  Computes independent subtrees starting with this element (this), that is, all elements (x) which are connected to either
+             *  - one of the children of the element,
+             *  - a probabilistic dependency
+             *  such that there exists a  path from x to a child of this does not go through this.
+             */
+            virtual std::vector<size_t> independentSubDft(bool blockParents) const;
+            /**
+             * Helper to the independent subtree computation
+             * @see independentSubDft
+             */
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const;
+
+            virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const {
+                return type() == other.type();
+            }
+
+
+        protected:
+           // virtual bool checkIsomorphicSubDftHelper(DFTElement const& otherElem, std::vector<std::pair<DFTElement const&, DFTElement const&>>& mapping, std::vector<DFTElement const&> const& order ) const = 0;
+
+        };
+        
+        
+       
+          
+        template<typename ValueType>
+        bool equalType(DFTElement<ValueType> const& e1, DFTElement<ValueType> const& e2) {
+            return e1.isTypeEqualTo(e2);
+        }
+    }
+}
diff --git a/src/storage/dft/elements/DFTGate.h b/src/storage/dft/elements/DFTGate.h
new file mode 100644
index 000000000..52f9bcd43
--- /dev/null
+++ b/src/storage/dft/elements/DFTGate.h
@@ -0,0 +1,180 @@
+#pragma once
+
+#include "DFTElement.h"
+namespace storm {
+    namespace storage {
+    template<typename ValueType>
+        class DFTGate : public DFTElement<ValueType> {
+
+            using DFTElementPointer = std::shared_ptr<DFTElement<ValueType>>;
+            using DFTElementVector = std::vector<DFTElementPointer>;
+
+        protected:
+            DFTElementVector mChildren;
+
+        public:
+            DFTGate(size_t id, std::string const& name, DFTElementVector const& children) :
+                    DFTElement<ValueType>(id, name), mChildren(children)
+            {}
+            
+            virtual ~DFTGate() {}
+            
+            void pushBackChild(DFTElementPointer elem) {
+                return mChildren.push_back(elem);
+            }
+
+            size_t nrChildren() const override {
+                return mChildren.size();
+            }
+
+            DFTElementVector const& children() const {
+                return mChildren;
+            }
+            
+            virtual bool isGate() const override {
+                return true;
+            }
+            
+            
+            virtual std::string typestring() const = 0;
+
+            virtual void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const = 0;
+
+            virtual void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const = 0;
+            
+            virtual void extendSpareModule(std::set<size_t>& elementsInSpareModule) const override {
+                if (!this->isSpareGate()) {
+                    DFTElement<ValueType>::extendSpareModule(elementsInSpareModule);
+                    for( auto const& child : mChildren) {
+                        if(elementsInSpareModule.count(child->id()) == 0) {
+                            elementsInSpareModule.insert(child->id());
+                            child->extendSpareModule(elementsInSpareModule);
+                        }
+                    }
+                }
+            }
+            
+            virtual std::vector<size_t> independentUnit() const override {
+                std::set<size_t> unit = {this->mId};
+                for(auto const& child : mChildren) {
+                    child->extendUnit(unit);
+                }
+                return std::vector<size_t>(unit.begin(), unit.end());
+            }
+
+            virtual void extendUnit(std::set<size_t>& unit) const override {
+                DFTElement<ValueType>::extendUnit(unit);
+                for(auto const& child : mChildren) {
+                    child->extendUnit(unit);
+                }
+            }
+
+            virtual std::vector<size_t> independentSubDft(bool blockParents) const override {
+                auto prelRes = DFTElement<ValueType>::independentSubDft(blockParents);
+                if(prelRes.empty()) {
+                    // No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft.
+                    return prelRes;
+                }
+                std::set<size_t> unit(prelRes.begin(), prelRes.end());
+                std::vector<size_t> pids = this->parentIds();
+                for(auto const& child : mChildren) {
+                    child->extendSubDft(unit, pids, blockParents);
+                    if(unit.empty()) {
+                        // Parent in the subdft, ie it is *not* a subdft
+                        break;
+                    }
+                }
+                return std::vector<size_t>(unit.begin(), unit.end());
+            }
+
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
+                if(elemsInSubtree.count(this->id()) > 0) return;
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                if(elemsInSubtree.empty()) {
+                    // Parent in the subdft, ie it is *not* a subdft
+                    return;
+                }
+                for(auto const& child : mChildren) {
+                    child->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                    if(elemsInSubtree.empty()) {
+                        // Parent in the subdft, ie it is *not* a subdft
+                        return;
+                    }
+                }
+            }
+
+
+            virtual std::string toString() const override {
+                std::stringstream stream;
+                stream << "{" << this->name() << "} " << typestring() << "( ";
+                typename DFTElementVector::const_iterator it = mChildren.begin();
+                stream << (*it)->name();
+                ++it;
+                while(it != mChildren.end()) {
+                    stream <<  ", " << (*it)->name();
+                    ++it;
+                }
+                stream << ")";
+                return stream.str();
+            }
+
+            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                if(DFTElement<ValueType>::checkDontCareAnymore(state, queues)) {
+                    childrenDontCare(state, queues);
+                    return true;
+                }
+                return false;
+            }
+
+
+        protected:
+
+            void fail(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                for(std::shared_ptr<DFTGate> parent : this->mParents) {
+                    if(state.isOperational(parent->id())) {
+                        queues.propagateFailure(parent);
+                    }
+                }
+                for(std::shared_ptr<DFTRestriction<ValueType>> restr : this->mRestrictions) {
+                    queues.checkRestrictionLater(restr);
+                }
+                state.setFailed(this->mId);
+                this->childrenDontCare(state, queues);
+            }
+
+            void failsafe(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                for(std::shared_ptr<DFTGate> parent : this->mParents) {
+                    if(state.isOperational(parent->id())) {
+                        queues.propagateFailsafe(parent);
+                    }
+                }
+                state.setFailsafe(this->mId);
+                this->childrenDontCare(state, queues);
+            }
+            
+            void childrenDontCare(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                queues.propagateDontCare(mChildren);
+            }
+
+            bool hasFailsafeChild(DFTState<ValueType>& state) const {
+                for(auto const& child : mChildren) {
+                    if(state.isFailsafe(child->id()))
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            bool hasFailedChild(DFTState<ValueType>& state) const {
+                for(auto const& child : mChildren) {
+                    if(state.hasFailed(child->id())) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/storage/dft/elements/DFTOr.h b/src/storage/dft/elements/DFTOr.h
new file mode 100644
index 000000000..93e481d35
--- /dev/null
+++ b/src/storage/dft/elements/DFTOr.h
@@ -0,0 +1,45 @@
+#pragma once 
+
+#include "DFTGate.h"
+namespace storm {
+    namespace storage {
+        template<typename ValueType>
+        class DFTOr : public DFTGate<ValueType> {
+
+        public:
+            DFTOr(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children)
+            {}
+
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                assert(this->hasFailedChild(state));
+                if(state.isOperational(this->mId)) {
+                    this->fail(state, queues);
+                }
+            }
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                 for(auto const& child : this->mChildren) {
+                     if(!state.isFailsafe(child->id())) {
+                         return;
+                     }
+                 }
+                 this->failsafe(state, queues);
+            }
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::OR;
+            }
+            
+            std::string typestring() const override {
+                return "OR";
+            }
+        };
+
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTOr<ValueType> const& gate) {
+            return os << gate.toString();
+        }
+    }
+}
+       
\ No newline at end of file
diff --git a/src/storage/dft/elements/DFTPand.h b/src/storage/dft/elements/DFTPand.h
new file mode 100644
index 000000000..86472d76f
--- /dev/null
+++ b/src/storage/dft/elements/DFTPand.h
@@ -0,0 +1,56 @@
+#pragma once 
+
+#include "DFTGate.h"
+namespace storm {
+    namespace storage {
+          template<typename ValueType>
+        class DFTPand : public DFTGate<ValueType> {
+
+        public:
+            DFTPand(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children)
+            {}
+
+            void checkFails(storm::storage::DFTState<ValueType>& state,  DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                if(state.isOperational(this->mId)) {
+                    bool childOperationalBefore = false;
+                    for(auto const& child : this->mChildren)
+                    {
+                        if(!state.hasFailed(child->id())) {
+                            childOperationalBefore = true;
+                        } else if(childOperationalBefore && state.hasFailed(child->id())){
+                            this->failsafe(state, queues);
+                            this->childrenDontCare(state, queues);
+                            return;
+                        }
+                    }
+                    if(!childOperationalBefore) {
+                        this->fail(state, queues);
+                    }
+                }
+            }
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                assert(this->hasFailsafeChild(state));
+                if(state.isOperational(this->mId)) {
+                    this->failsafe(state, queues);
+                    this->childrenDontCare(state, queues);
+                }
+            }
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::PAND;
+            }
+            
+            std::string typestring() const override {
+                return "PAND";
+            }
+        };
+        
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTPand<ValueType> const& gate) {
+             return os << gate.toString();
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/src/storage/dft/elements/DFTPor.h b/src/storage/dft/elements/DFTPor.h
new file mode 100644
index 000000000..1aaa943b0
--- /dev/null
+++ b/src/storage/dft/elements/DFTPor.h
@@ -0,0 +1,36 @@
+#pragma once 
+
+#include "DFTGate.h"
+namespace storm {
+    namespace storage {
+        template<typename ValueType>
+        class DFTPor : public DFTGate<ValueType> {
+        public:
+            DFTPor(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children)
+            {}
+
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                 assert(false);
+            }
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                assert(false);
+            }
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::POR;
+            }
+            
+            std::string  typestring() const override {
+                return "POR";
+            }
+        };
+
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTPor<ValueType> const& gate) {
+             return os << gate.toString();
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/src/storage/dft/elements/DFTRestriction.h b/src/storage/dft/elements/DFTRestriction.h
index 70163a6e6..f0fef5845 100644
--- a/src/storage/dft/elements/DFTRestriction.h
+++ b/src/storage/dft/elements/DFTRestriction.h
@@ -1,7 +1,6 @@
 #pragma once
 
-#include "../DFTElements.h"
-
+#include "DFTElement.h"
 namespace storm {
     namespace storage {
         template<typename ValueType>
diff --git a/src/storage/dft/elements/DFTSpare.h b/src/storage/dft/elements/DFTSpare.h
new file mode 100644
index 000000000..dd3689311
--- /dev/null
+++ b/src/storage/dft/elements/DFTSpare.h
@@ -0,0 +1,70 @@
+#pragma once 
+
+
+#include "DFTGate.h"
+namespace storm {
+    namespace storage {
+        
+
+        template<typename ValueType>
+        class DFTSpare : public DFTGate<ValueType> {
+
+        public:
+            DFTSpare(size_t id, std::string const& name, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children)
+            {}
+            
+            std::string typestring() const override {
+                return "SPARE";
+            }
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::SPARE;
+            }
+
+            bool isSpareGate() const override {
+                return true;
+            }
+            
+            void fail(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                DFTGate<ValueType>::fail(state, queues);
+                state.finalizeUses(this->mId);
+            }
+            
+            void failsafe(DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+                DFTGate<ValueType>::failsafe(state, queues);
+                state.finalizeUses(this->mId);
+            }
+            
+            bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                if (DFTGate<ValueType>::checkDontCareAnymore(state, queues)) {
+                    state.finalizeUses(this->mId);
+                    return true;
+                }
+                return false;
+            }
+            
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                if(state.isOperational(this->mId)) {
+                    size_t uses = state.uses(this->mId);
+                    if(!state.isOperational(uses)) {
+                        bool claimingSuccessful = state.claimNew(this->mId, uses, this->mChildren);
+                        if(!claimingSuccessful) {
+                            this->fail(state, queues);
+                        }
+                    }                  
+                } 
+            }
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                if(state.isOperational(this->mId)) {
+                    if(state.isFailsafe(state.uses(this->mId))) {
+                        this->failsafe(state, queues);
+                        this->childrenDontCare(state, queues);
+                    }
+                }
+            }
+
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/storage/dft/elements/DFTVot.h b/src/storage/dft/elements/DFTVot.h
new file mode 100644
index 000000000..3a3e818d2
--- /dev/null
+++ b/src/storage/dft/elements/DFTVot.h
@@ -0,0 +1,75 @@
+#pragma once 
+namespace storm {
+    namespace storage {
+        
+
+        template<typename ValueType>
+        class DFTVot : public DFTGate<ValueType> {
+
+        private:
+            unsigned mThreshold;
+
+        public:
+            DFTVot(size_t id, std::string const& name, unsigned threshold, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children = {}) :
+                    DFTGate<ValueType>(id, name, children), mThreshold(threshold)
+            {}
+
+            void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                if(state.isOperational(this->mId)) {
+                    unsigned nrFailedChildren = 0;
+                    for(auto const& child : this->mChildren)
+                    {
+                        if(state.hasFailed(child->id())) {
+                            ++nrFailedChildren;
+                            if(nrFailedChildren >= mThreshold) 
+                            {
+                                this->fail(state, queues);
+                                return;
+                            }
+                        }
+                    }
+                  
+                } 
+            }
+
+            void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                assert(this->hasFailsafeChild(state));
+                if(state.isOperational(this->mId)) {
+                    unsigned nrFailsafeChildren = 0;
+                    for(auto const& child : this->mChildren)
+                    {
+                        if(state.isFailsafe(child->id())) {
+                            ++nrFailsafeChildren;
+                            if(nrFailsafeChildren > this->nrChildren() - mThreshold)
+                            {
+                                this->failsafe(state, queues);
+                                this->childrenDontCare(state, queues);
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+
+            virtual DFTElementType type() const override {
+                return DFTElementType::VOT;
+            }
+            
+            std::string typestring() const override{
+                return "VOT (" + std::to_string(mThreshold) + ")";
+            }
+            
+            virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const override {
+                if(!DFTElement<ValueType>::isTypeEqualTo(other)) return false;
+                DFTVot<ValueType> const& otherVOT = static_cast<DFTVot<ValueType> const&>(other);
+                return (mThreshold == otherVOT.mThreshold);
+            }
+        };
+
+        template<typename ValueType>
+        inline std::ostream& operator<<(std::ostream& os, DFTVot<ValueType> const& gate) {
+            return os << gate.toString();
+        }
+
+    }
+}
\ No newline at end of file

From 2a4157947691e91caa1ebb0cc6fceecda013e376 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 26 Feb 2016 14:50:46 +0100
Subject: [PATCH 170/246] refactored source file for elements

Former-commit-id: 0315e8a8cb685ef5969664e951593fa372db0918
---
 src/storage/dft/DFTElements.cpp       | 127 --------------------------
 src/storage/dft/elements/DFTBE.h      |   8 +-
 src/storage/dft/elements/DFTElement.h |   5 +-
 src/storage/dft/elements/DFTVot.h     |   1 +
 4 files changed, 11 insertions(+), 130 deletions(-)
 delete mode 100644 src/storage/dft/DFTElements.cpp

diff --git a/src/storage/dft/DFTElements.cpp b/src/storage/dft/DFTElements.cpp
deleted file mode 100644
index 4cf49e0b0..000000000
--- a/src/storage/dft/DFTElements.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#include <src/exceptions/NotImplementedException.h>
-#include <src/utility/macros.h>
-#include "DFTElements.h"
-#include "elements/DFTRestriction.h"
-
-namespace storm {
-    namespace storage {
-
-        template<typename ValueType>
-        bool DFTElement<ValueType>::checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-            if (state.dontCare(mId)) {
-                return false;
-            }
-            
-            // Check that no outgoing dependencies can be triggered anymore
-            for (DFTDependencyPointer dependency : mOutgoingDependencies) {
-                if (state.isOperational(dependency->dependentEvent()->id()) && state.isOperational(dependency->triggerEvent()->id())) {
-                    return false;
-                }
-            }
-            
-            bool hasParentSpare = false;
-
-            // Check that no parent can fail anymore
-            for(DFTGatePointer const& parent : mParents) {
-                if(state.isOperational(parent->id())) {
-                    return false;
-                }
-                if (parent->isSpareGate()) {
-                    hasParentSpare = true;
-                }
-            }
-            
-            state.setDontCare(mId);
-            if (hasParentSpare && !state.isActive(mId)) {
-                // Activate child for consistency in failed spares
-                state.activate(mId);
-            }
-            return true;
-        }
-
-        template<typename ValueType>
-        void DFTElement<ValueType>::extendSpareModule(std::set<size_t>& elementsInModule) const {
-            for(auto const& parent : mParents) {
-                if(elementsInModule.count(parent->id()) == 0 && !parent->isSpareGate()) {
-                    elementsInModule.insert(parent->id());
-                    parent->extendSpareModule(elementsInModule);
-                }
-            }
-        }
-
-        template<typename ValueType>
-        std::vector<size_t> DFTElement<ValueType>::independentUnit() const {
-            std::vector<size_t> res;
-            res.push_back(this->id());
-            // Extend for pdeps.
-            return res;
-        }
-
-        template<typename ValueType>
-        void DFTElement<ValueType>::extendUnit(std::set<size_t>& unit) const {
-            unit.insert(mId);
-        }
-
-        template<typename ValueType>
-        std::vector<size_t> DFTElement<ValueType>::independentSubDft(bool blockParents) const {
-            //std::cout << "INDEPENDENT SUBTREE CALL " << this->id() << std::endl;
-            std::vector<size_t> res;
-            res.push_back(this->id());
-            return res;
-        }
-
-        template<typename ValueType>
-        void DFTElement<ValueType>::extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const {
-            if(elemsInSubtree.count(this->id()) > 0) return;
-            if(std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), mId) != parentsOfSubRoot.end()) {
-                // This is a parent of the suspected root, thus it is not a subdft.
-                elemsInSubtree.clear();
-                return;
-            }
-            elemsInSubtree.insert(mId);
-            for(auto const& parent : mParents) {
-                if(blockParents && std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), parent->id()) != parentsOfSubRoot.end()) {
-                    continue;
-                }
-                parent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
-                if(elemsInSubtree.empty()) {
-                    return;
-                }
-            }
-            for(auto const& dep : mOutgoingDependencies) {
-                dep->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
-                if(elemsInSubtree.empty()) {
-                    return;
-                }
-
-            }
-            
-            for(auto const& restr : mRestrictions) {
-                restr->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
-                if(elemsInSubtree.empty()) {
-                    return;
-                }
-            }
-            
-        }
-
-
-        template<typename ValueType>
-        bool DFTBE<ValueType>::checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
-            if(DFTElement<ValueType>::checkDontCareAnymore(state, queues)) {
-                state.beNoLongerFailable(this->mId);
-                return true;
-            }
-            return false;
-        }
-
-
-        // Explicitly instantiate the class.
-        template class DFTBE<double>;
-
-#ifdef STORM_HAVE_CARL
-        template class DFTBE<RationalFunction>;
-#endif
-        
-    }
-}
diff --git a/src/storage/dft/elements/DFTBE.h b/src/storage/dft/elements/DFTBE.h
index 5e09e965e..a9c5b030d 100644
--- a/src/storage/dft/elements/DFTBE.h
+++ b/src/storage/dft/elements/DFTBE.h
@@ -93,7 +93,13 @@ namespace storm {
                 return (mActiveFailureRate == otherBE.mActiveFailureRate) && (mPassiveFailureRate == otherBE.mPassiveFailureRate);
             }
             
-            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override;
+            virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
+                if(DFTElement<ValueType>::checkDontCareAnymore(state, queues)) {
+                    state.beNoLongerFailable(this->mId);
+                    return true;
+                }
+                return false;
+            }
         };
 
         template<typename ValueType>
diff --git a/src/storage/dft/elements/DFTElement.h b/src/storage/dft/elements/DFTElement.h
index d6840132a..11223f3fa 100644
--- a/src/storage/dft/elements/DFTElement.h
+++ b/src/storage/dft/elements/DFTElement.h
@@ -8,6 +8,7 @@
 #include <set>
 #include <vector>
 #include <memory>
+#include <map>
 
 
 
@@ -204,7 +205,7 @@ namespace storm {
                 return mOutgoingDependencies.size();
             }
             
-            std::set<DFTElement<ValueType>> restrictedItems() const {
+            /*std::set<DFTElement<ValueType>> restrictedItems() const {
                 std::set<DFTElement<ValueType>> result;
                 for(auto const& restr : mRestrictions) {
                     bool foundThis = false;
@@ -236,7 +237,7 @@ namespace storm {
                         }
                     }
                 }
-            }
+            }*/
             
             DFTDependencyVector const& outgoingDependencies() const {
                 return mOutgoingDependencies;
diff --git a/src/storage/dft/elements/DFTVot.h b/src/storage/dft/elements/DFTVot.h
index 3a3e818d2..0233d979d 100644
--- a/src/storage/dft/elements/DFTVot.h
+++ b/src/storage/dft/elements/DFTVot.h
@@ -1,4 +1,5 @@
 #pragma once 
+#include "DFTGate.h"
 namespace storm {
     namespace storage {
         

From 6e777e88d1ad0eba0c56c255cdbc9e4f0b17685c Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 26 Feb 2016 14:51:03 +0100
Subject: [PATCH 171/246] fixed warning for restriction

Former-commit-id: ac2addb5318e7a8862e64d36551d1442725889b1
---
 src/storage/dft/elements/DFTRestriction.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/storage/dft/elements/DFTRestriction.h b/src/storage/dft/elements/DFTRestriction.h
index f0fef5845..78036528e 100644
--- a/src/storage/dft/elements/DFTRestriction.h
+++ b/src/storage/dft/elements/DFTRestriction.h
@@ -183,7 +183,8 @@ namespace storm {
             }
             
             virtual bool checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                
+                // Actually, it doesnt matter what we return here..
+                return false;
             }
 
             virtual DFTElementType type() const override {

From a204ac3a66409700fada898b22b722328d37fdda Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 26 Feb 2016 16:31:00 +0100
Subject: [PATCH 172/246] added a comment

Former-commit-id: 19a026c3f913d0bac6ce24ec886b2518e57d8d4f
---
 src/storage/dft/DFTBuilder.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index e3889bf4d..08d85d879 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -110,6 +110,7 @@ namespace storm {
                     restr = std::make_shared<DFTSeq<ValueType>>(mNextId++, name);
                     break;
                 case DFTElementType::MUTEX:
+                    // TODO notice that mutex state generation support is lacking anyway, as DONT CARE propagation would be broken for this.
                     STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Gate type not supported.");
                     break;
                 default:

From ed651409114127ed2db67307857e442a15999561 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 26 Feb 2016 16:49:18 +0100
Subject: [PATCH 173/246] add missing file

Former-commit-id: af1ea74d659e3fa9a99c46a7d621c346b5f97cfa
---
 src/storage/dft/elements/DFTElement.cpp | 120 ++++++++++++++++++++++++
 1 file changed, 120 insertions(+)
 create mode 100644 src/storage/dft/elements/DFTElement.cpp

diff --git a/src/storage/dft/elements/DFTElement.cpp b/src/storage/dft/elements/DFTElement.cpp
new file mode 100644
index 000000000..b71e0672b
--- /dev/null
+++ b/src/storage/dft/elements/DFTElement.cpp
@@ -0,0 +1,120 @@
+#include <set>
+#include <src/exceptions/NotImplementedException.h>
+#include <src/utility/macros.h>
+#include "DFTElement.h"
+#include "../DFTElements.h"
+
+namespace storm {
+    namespace storage {
+        
+        template<typename ValueType>
+        bool DFTElement<ValueType>::checkDontCareAnymore(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const {
+            if (state.dontCare(mId)) {
+                return false;
+            }
+            
+            // Check that no outgoing dependencies can be triggered anymore
+            for (DFTDependencyPointer dependency : mOutgoingDependencies) {
+                if (state.isOperational(dependency->dependentEvent()->id()) && state.isOperational(dependency->triggerEvent()->id())) {
+                    return false;
+                }
+            }
+            
+            bool hasParentSpare = false;
+
+            // Check that no parent can fail anymore
+            for(DFTGatePointer const& parent : mParents) {
+                if(state.isOperational(parent->id())) {
+                    return false;
+                }
+                if (parent->isSpareGate()) {
+                    hasParentSpare = true;
+                }
+            }
+            
+            state.setDontCare(mId);
+            if (hasParentSpare && !state.isActive(mId)) {
+                // Activate child for consistency in failed spares
+                state.activate(mId);
+            }
+            return true;
+        }
+
+        template<typename ValueType>
+        void DFTElement<ValueType>::extendSpareModule(std::set<size_t>& elementsInModule) const {
+            for(auto const& parent : mParents) {
+                if(elementsInModule.count(parent->id()) == 0 && !parent->isSpareGate()) {
+                    elementsInModule.insert(parent->id());
+                    parent->extendSpareModule(elementsInModule);
+                }
+            }
+        }
+
+        template<typename ValueType>
+        std::vector<size_t> DFTElement<ValueType>::independentUnit() const {
+            std::vector<size_t> res;
+            res.push_back(this->id());
+            // Extend for pdeps.
+            return res;
+        }
+
+        template<typename ValueType>
+        void DFTElement<ValueType>::extendUnit(std::set<size_t>& unit) const {
+            unit.insert(mId);
+        }
+
+        template<typename ValueType>
+        std::vector<size_t> DFTElement<ValueType>::independentSubDft(bool blockParents) const {
+            //std::cout << "INDEPENDENT SUBTREE CALL " << this->id() << std::endl;
+            std::vector<size_t> res;
+            res.push_back(this->id());
+            return res;
+        }
+
+        template<typename ValueType>
+        void DFTElement<ValueType>::extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const {
+            if(elemsInSubtree.count(this->id()) > 0) return;
+            if(std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), mId) != parentsOfSubRoot.end()) {
+                // This is a parent of the suspected root, thus it is not a subdft.
+                elemsInSubtree.clear();
+                return;
+            }
+            elemsInSubtree.insert(mId);
+            for(auto const& parent : mParents) {
+                if(blockParents && std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), parent->id()) != parentsOfSubRoot.end()) {
+                    continue;
+                }
+                parent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                if(elemsInSubtree.empty()) {
+                    return;
+                }
+            }
+            for(auto const& dep : mOutgoingDependencies) {
+                dep->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                if(elemsInSubtree.empty()) {
+                    return;
+                }
+
+            }
+            
+            for(auto const& restr : mRestrictions) {
+                restr->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                if(elemsInSubtree.empty()) {
+                    return;
+                }
+            }
+            
+        }
+        
+        
+
+        // Explicitly instantiate the class.
+        template class DFTElement<double>;
+
+#ifdef STORM_HAVE_CARL
+        template class DFTElement<RationalFunction>;
+#endif
+        
+
+    }
+}

From c6098e6a6a8a749c7d78baf88223096c2454908b Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 26 Feb 2016 16:49:44 +0100
Subject: [PATCH 174/246] post and pre SEQ elements for state space generation

Former-commit-id: 03e44081890d546b9d3033f7e1f85864c7d1ac06
---
 src/storage/dft/DFT.cpp                   | 10 ++++
 src/storage/dft/DFTStateGenerationInfo.h  | 16 +++++-
 src/storage/dft/elements/DFTElement.h     | 66 ++++++++++++++---------
 src/storage/dft/elements/DFTRestriction.h | 10 ++++
 4 files changed, 75 insertions(+), 27 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 2aa557d8c..9a12fe2f6 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -77,12 +77,22 @@ namespace storm {
             // TODO make recursive to use for nested subtrees
 
             DFTStateGenerationInfo generationInfo(nrElements(), mMaxSpareChildCount);
+            
+            // Generate Pre and Post info for restrictions
+            for(auto const& elem : mElements) {
+                if(!elem->isDependency() && !elem->isRestriction()) {
+                    generationInfo.setRestrictionPreElements(elem->id(), elem->seqRestrictionPres());
+                    generationInfo.setRestrictionPostElements(elem->id(), elem->seqRestrictionPosts());
+                }
+            }
+            
 
             // Perform DFS and insert all elements of subtree sequentially
             size_t stateIndex = 0;
             std::queue<size_t> visitQueue;
             storm::storage::BitVector visited(nrElements(), false);
 
+            // TODO make subfunction for this?
             if (symmetries.groups.empty()) {
                 // Perform DFS for whole tree
                 visitQueue.push(mTopLevelIndex);
diff --git a/src/storage/dft/DFTStateGenerationInfo.h b/src/storage/dft/DFTStateGenerationInfo.h
index f82d4e8af..a89add9bf 100644
--- a/src/storage/dft/DFTStateGenerationInfo.h
+++ b/src/storage/dft/DFTStateGenerationInfo.h
@@ -8,12 +8,16 @@ namespace storm {
             std::map<size_t, size_t> mSpareUsageIndex; // id spare -> index first bit in state
             std::map<size_t, size_t> mSpareActivationIndex; // id spare representative -> index in state
             std::vector<size_t> mIdToStateIndex; // id -> index first bit in state
-            std::map<size_t, size_t> mRestrictedItems;
+            std::map<size_t, std::vector<size_t>> mSeqRestrictionPreElements; // id -> list of restriction pre elements;
+            std::map<size_t, std::vector<size_t>> mSeqRestrictionPostElements; // id -> list of restriction post elements;
             std::vector<std::pair<size_t, std::vector<size_t>>> mSymmetries; // pair (lenght of symmetry group, vector indicating the starting points of the symmetry groups)
 
         public:
 
-            DFTStateGenerationInfo(size_t nrElements, size_t maxSpareChildCount) : mUsageInfoBits(storm::utility::math::uint64_log2(maxSpareChildCount) + 1), mIdToStateIndex(nrElements) {
+            DFTStateGenerationInfo(size_t nrElements, size_t maxSpareChildCount) :
+                mUsageInfoBits(storm::utility::math::uint64_log2(maxSpareChildCount) + 1), 
+                mIdToStateIndex(nrElements)
+            {
                 assert(maxSpareChildCount < pow(2, mUsageInfoBits));
             }
 
@@ -26,6 +30,14 @@ namespace storm {
                 mIdToStateIndex[id] = index;
             }
 
+            void setRestrictionPreElements(size_t id, std::vector<size_t> const& elems) {
+                mSeqRestrictionPreElements[id] = elems;
+            }
+            
+            void setRestrictionPostElements(size_t id, std::vector<size_t> const& elems) {
+                mSeqRestrictionPostElements[id] = elems;
+            }
+            
             void addSpareActivationIndex(size_t id, size_t index) {
                 mSpareActivationIndex[id] = index;
             }
diff --git a/src/storage/dft/elements/DFTElement.h b/src/storage/dft/elements/DFTElement.h
index 11223f3fa..2d57567e9 100644
--- a/src/storage/dft/elements/DFTElement.h
+++ b/src/storage/dft/elements/DFTElement.h
@@ -205,39 +205,55 @@ namespace storm {
                 return mOutgoingDependencies.size();
             }
             
-            /*std::set<DFTElement<ValueType>> restrictedItems() const {
-                std::set<DFTElement<ValueType>> result;
-                for(auto const& restr : mRestrictions) {
-                    bool foundThis = false;
-                    for(auto const& child : restr->children()) {
-                        if(!foundThis) {
-                            if(child->id() == mId) {
-                                foundThis = true;
-                            }
-                        } else if(result.count(child) == 0) {
-                            result.insert(child);
+            /**
+             * Obtains ids of elements which are the direct successor in the list of children of a restriction
+             * @return A vector of ids
+             */
+            std::vector<size_t> seqRestrictionPosts() const {
+                std::vector<size_t> res;
+                for (auto const& restr : mRestrictions) {
+                    if(!restr->isSeqEnforcer()) {
+                        continue;
+                    }
+                    auto it = restr->children().cbegin();
+                    for(; it != restr->children().cend(); ++it) {
+                        if((*it)->id() == mId) {
+                            break;
                         }
                     }
+                    assert(it != restr->children().cend());
+                    ++it;
+                    if(it != restr->children().cend()) {
+                        res.push_back((*it)->id());
+                    }
                 }
+                return res;
             }
             
-            std::set<DFTElement<ValueType>> restrictedItemsTC() const {
-                std::set<DFTElement<ValueType>> result;
-                for(auto const& restr : mRestrictions) {
-                    bool foundThis = false;
-                    for(auto const& child : restr->children()) {
-                        if(!foundThis) {
-                            if(child->id() == mId) {
-                                foundThis = true;
-                            }
-                        } else if(result.count(child) == 0) {
-                            result.insert(child);
-                            std::set<DFTElement<ValueType>> tmpRes = child->restrictedItemsTC();
-                            result.insert(tmpRes.begin(), tmpRes.end());
+            /**
+             * Obtains ids of elements which are the direct predecessor in the list of children of a restriction
+             * @return A vector of ids
+             */
+            std::vector<size_t> seqRestrictionPres() const {
+                std::vector<size_t> res;
+                for (auto const& restr : mRestrictions) {
+                    if(!restr->isSeqEnforcer()) {
+                        continue;
+                    }
+                    auto it = restr->children().cbegin();
+                    for(++it; it != restr->children().cend(); ++it) {
+                        if((*it)->id() == mId) {
+                            break;
                         }
                     }
+                    assert(it != restr->children().cend());
+                    if(it != restr->children().cbegin()) {
+                        --it;
+                        res.push_back((*it)->id());
+                    }
                 }
-            }*/
+                return res;
+            }
             
             DFTDependencyVector const& outgoingDependencies() const {
                 return mOutgoingDependencies;
diff --git a/src/storage/dft/elements/DFTRestriction.h b/src/storage/dft/elements/DFTRestriction.h
index 78036528e..dc2e6116e 100644
--- a/src/storage/dft/elements/DFTRestriction.h
+++ b/src/storage/dft/elements/DFTRestriction.h
@@ -32,6 +32,10 @@ namespace storm {
             virtual bool isRestriction() const override {
                 return true;
             }
+            
+            virtual bool isSeqEnforcer() const {
+                return false;
+            }
 
 
             virtual std::string typestring() const = 0;
@@ -162,6 +166,12 @@ namespace storm {
                     DFTRestriction<ValueType>(id, name, children)
             {}
 
+            virtual bool isSeqEnforcer() const override {
+                return true;
+            }
+
+
+            
             void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
                 assert(queues.failurePropagationDone());
                 bool childOperationalBefore = false;

From a6c087f4610a818183146b6f624d3e95dd93de15 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 26 Feb 2016 17:50:51 +0100
Subject: [PATCH 175/246] Dont Care Propagation and SEQ are now sound (but more
 DCs can be propagated with some care)

Former-commit-id: 96288dd8d951caf24325caef0d7eff00cd3e23db
---
 src/storage/dft/DFT.h                    |  4 ++++
 src/storage/dft/DFTState.cpp             | 13 +++++++++++++
 src/storage/dft/DFTState.h               |  7 +++++++
 src/storage/dft/DFTStateGenerationInfo.h |  6 ++++++
 src/storage/dft/elements/DFTElement.cpp  |  5 ++++-
 src/storage/dft/elements/DFTElement.h    |  2 +-
 6 files changed, 35 insertions(+), 2 deletions(-)

diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 9762def61..22041da85 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -146,6 +146,10 @@ namespace storm {
             bool isDependency(size_t index) const {
                 return getElement(index)->isDependency();
             }
+            
+            bool isRestriction(size_t index) const {
+                return getElement(index)->isRestriction();
+            }
 
             std::shared_ptr<DFTBE<ValueType> const> getBasicElement(size_t index) const {
                 assert(isBasicElement(index));
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 547fdd169..419403d55 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -233,6 +233,19 @@ namespace storm {
             assert(hasFailed(spareId));
             mStatus.setFromInt(mStateGenerationInfo.getSpareUsageIndex(spareId), mStateGenerationInfo.usageInfoBits(), mDft.getMaxSpareChildCount());
         }
+        
+        template<typename ValueType>
+        bool DFTState<ValueType>::hasOperationalPostSeqElements(size_t id) const {
+            assert(!mDft.isDependency(id));
+            assert(!mDft.isRestriction(id));
+            auto const& postIds =  mStateGenerationInfo.seqRestrictionPostElements(id);
+            for(size_t id : postIds) {
+                if(isOperational(id)) {
+                    return true;
+                }
+            }
+            return false;
+        }
 
         template<typename ValueType>
         bool DFTState<ValueType>::claimNew(size_t spareId, size_t currentlyUses, std::vector<std::shared_ptr<DFTElement<ValueType>>> const& children) {
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index ea874cf1b..826e510d5 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -177,6 +177,13 @@ namespace storm {
              */
             bool orderBySymmetry();
             
+            /**
+             * Checks whether operational post seq elements are present
+             * @param id
+             * @return 
+             */
+            bool hasOperationalPostSeqElements(size_t id) const;
+            
             std::string getCurrentlyFailableString() const {
                 std::stringstream stream;
                 if (nrFailableDependencies() > 0) {
diff --git a/src/storage/dft/DFTStateGenerationInfo.h b/src/storage/dft/DFTStateGenerationInfo.h
index a89add9bf..4b3ef92c9 100644
--- a/src/storage/dft/DFTStateGenerationInfo.h
+++ b/src/storage/dft/DFTStateGenerationInfo.h
@@ -38,6 +38,12 @@ namespace storm {
                 mSeqRestrictionPostElements[id] = elems;
             }
             
+            std::vector<size_t> const& seqRestrictionPostElements(size_t index) const {
+                assert(mSeqRestrictionPostElements.count(index) > 0);
+                return mSeqRestrictionPostElements.at(index);
+            }
+            
+            
             void addSpareActivationIndex(size_t id, size_t index) {
                 mSpareActivationIndex[id] = index;
             }
diff --git a/src/storage/dft/elements/DFTElement.cpp b/src/storage/dft/elements/DFTElement.cpp
index b71e0672b..0ee8a3cd2 100644
--- a/src/storage/dft/elements/DFTElement.cpp
+++ b/src/storage/dft/elements/DFTElement.cpp
@@ -32,6 +32,10 @@ namespace storm {
                 }
             }
             
+            if(!mRestrictions.empty() && state.hasOperationalPostSeqElements(mId)) {
+                return false;
+            }
+            
             state.setDontCare(mId);
             if (hasParentSpare && !state.isActive(mId)) {
                 // Activate child for consistency in failed spares
@@ -65,7 +69,6 @@ namespace storm {
 
         template<typename ValueType>
         std::vector<size_t> DFTElement<ValueType>::independentSubDft(bool blockParents) const {
-            //std::cout << "INDEPENDENT SUBTREE CALL " << this->id() << std::endl;
             std::vector<size_t> res;
             res.push_back(this->id());
             return res;
diff --git a/src/storage/dft/elements/DFTElement.h b/src/storage/dft/elements/DFTElement.h
index 2d57567e9..2b3b05c98 100644
--- a/src/storage/dft/elements/DFTElement.h
+++ b/src/storage/dft/elements/DFTElement.h
@@ -241,7 +241,7 @@ namespace storm {
                         continue;
                     }
                     auto it = restr->children().cbegin();
-                    for(++it; it != restr->children().cend(); ++it) {
+                    for(; it != restr->children().cend(); ++it) {
                         if((*it)->id() == mId) {
                             break;
                         }

From f562a84316eaf408df7ed633437cdf8cfce21711 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 26 Feb 2016 18:54:20 +0100
Subject: [PATCH 176/246] getRestriction added to DFT interface

Former-commit-id: ba114e4478f80c73353310368a0d2c13838a39a7
---
 src/storage/dft/DFT.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 22041da85..32e807197 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -165,6 +165,11 @@ namespace storm {
                 assert(isDependency(index));
                 return std::static_pointer_cast<DFTDependency<ValueType> const>(mElements[index]);
             }
+            
+            std::shared_ptr<DFTRestriction<ValueType> const> getRestriction(size_t index) const {
+                assert(isRestriction(index));
+                return std::static_pointer_cast<DFTRestriction<ValueType> const>(mElements[index]);
+            }
 
             std::vector<std::shared_ptr<DFTBE<ValueType>>> getBasicElements() const {
                 std::vector<std::shared_ptr<DFTBE<ValueType>>> elements;

From 63d2faf1edeee6398fa751dfd78cfcc7820129da Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Fri, 26 Feb 2016 18:54:48 +0100
Subject: [PATCH 177/246] DFTIsomorphism now runs in the presence of SEQs

Former-commit-id: 2666490663774164c43df8eb05a4a3f3a6d35b49
---
 src/storage/dft/DFTIsomorphism.h | 111 ++++++++++++++++++++++++++++---
 1 file changed, 100 insertions(+), 11 deletions(-)

diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
index 498170368..e487e92bf 100644
--- a/src/storage/dft/DFTIsomorphism.h
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -14,7 +14,7 @@ namespace storage {
 
     struct GateGroupToHash {
         static constexpr uint_fast64_t fivebitmask = (1 << 6) - 1;
-        static constexpr uint_fast64_t eightbitmaks = (1 << 8) - 1;
+        static constexpr uint_fast64_t eightbitmask = (1 << 8) - 1;
 
         /**
          * Hash function, which ensures that the colours are sorted according to their rank.
@@ -25,7 +25,7 @@ namespace storage {
             //Assumes 5 bits for the rank,
             groupHash |= (static_cast<uint_fast64_t>(rank) & fivebitmask) << (62 - 5);
             // 8 bits for the nrChildren,
-            groupHash |= (static_cast<uint_fast64_t>(nrChildren) & eightbitmaks) << (62 - 5 - 8);
+            groupHash |= (static_cast<uint_fast64_t>(nrChildren) & eightbitmask) << (62 - 5 - 8);
             // 5 bits for nrParents,
             groupHash |= (static_cast<uint_fast64_t>(nrParents) & fivebitmask) << (62 - 5 - 8 - 5);
             // 5 bits for nrPDEPs,
@@ -36,6 +36,20 @@ namespace storage {
         }
 
     };
+    
+    struct RestrictionGroupToHash {
+        static constexpr uint_fast64_t fivebitmask = (1 << 6) - 1;
+        
+        static constexpr uint_fast64_t eightbitmask = (1 << 8) - 1;
+        
+        uint_fast64_t operator()(DFTElementType type, size_t nrChildren, size_t rank) const {
+            uint_fast64_t groupHash = static_cast<uint_fast64_t>(0);
+            groupHash |= (static_cast<uint_fast64_t>(rank) & fivebitmask) << (62 - 5);
+            groupHash |= (static_cast<uint_fast64_t>(nrChildren) & eightbitmask) << (62 - 5 - 8);
+            groupHash |= (static_cast<uint_fast64_t>(type) & fivebitmask) << (62 - 5 - 8 - 5);
+            return groupHash;
+        }
+    };
 
 
     template<typename ValueType>
@@ -53,8 +67,6 @@ namespace storage {
         return lhs.hash == rhs.hash && lhs.aRate == rhs.aRate && lhs.pRate == rhs.pRate;
     }
 
-
-
     /**
      *
      */
@@ -63,13 +75,14 @@ namespace storage {
         std::unordered_map<size_t, std::vector<size_t>> gateCandidates;
         std::unordered_map<BEColourClass<ValueType>, std::vector<size_t>> beCandidates;
         std::unordered_map<std::pair<ValueType, ValueType>, std::vector<size_t>> pdepCandidates;
+        std::unordered_map<size_t, std::vector<size_t>> restrictionCandidates;
         
         size_t nrGroups() const {
-            return gateCandidates.size() + beCandidates.size() + pdepCandidates.size();
+            return gateCandidates.size() + beCandidates.size() + pdepCandidates.size() + restrictionCandidates.size();
         }
         
         size_t size() const {
-            return nrGates() + nrBEs() + nrDeps();
+            return nrGates() + nrBEs() + nrDeps() + nrRestrictions();
         }
         
         size_t nrGates() const {
@@ -96,6 +109,14 @@ namespace storage {
             return res;
         }
         
+        size_t nrRestrictions() const {
+            size_t res = 0;
+            for(auto const& x : restrictionCandidates) {
+                res += x.second.size();
+            }
+            return res;
+        }
+        
         bool hasGate(size_t index) const {
             for(auto const& x : gateCandidates) {
                 for( auto const& ind : x.second) {
@@ -123,8 +144,18 @@ namespace storage {
             return false;
         }
         
+        bool hasRestriction(size_t index) const {
+            for(auto const& x : restrictionCandidates) {
+                for(auto const& ind : x.second) {
+                    if(index == ind) return true;
+                }
+            }
+            return false;
+        }
+        
+        
         bool has(size_t index) const {
-            return hasGate(index) || hasBE(index) || hasDep(index);
+            return hasGate(index) || hasBE(index) || hasDep(index) || hasRestriction(index);
         }
         
         
@@ -152,7 +183,9 @@ namespace storage {
         std::unordered_map<size_t, size_t> gateColour;
         std::unordered_map<size_t, BEColourClass<ValueType>> beColour;
         std::unordered_map<size_t, std::pair<ValueType, ValueType>> depColour;
+        std::unordered_map<size_t, size_t> restrictionColour;
         GateGroupToHash gateColourizer;
+        RestrictionGroupToHash restrColourizer;
 
     public:
         DFTColouring(DFT<ValueType> const& ft) : dft(ft) {
@@ -161,9 +194,11 @@ namespace storage {
                     colourize(dft.getBasicElement(id));
                 } else if(dft.isGate(id)) {
                     colourize(dft.getGate(id));
-                } else {
-                    assert(dft.isDependency(id));
+                } else if(dft.isDependency(id)) {
                     colourize(dft.getDependency(id));
+                } else {
+                    assert(dft.isRestriction(id));
+                    colourize(dft.getRestriction(id));
                 }
             }
         }
@@ -186,14 +221,21 @@ namespace storage {
                     } else {
                         res.gateCandidates[gateColour.at(index)] = std::vector<size_t>({index});
                     }
-                } else {
-                    assert(dft.isDependency(index));
+                } else if(dft.isDependency(index)) {
                     auto it = res.pdepCandidates.find(depColour.at(index));
                     if(it != res.pdepCandidates.end()) {
                         it->second.push_back(index);
                     } else {
                         res.pdepCandidates[depColour.at(index)] = std::vector<size_t>({index});
                     }
+                } else {
+                    assert(dft.isRestriction(index));
+                    auto it = res.restrictionCandidates.find(restrictionColour.at(index));
+                    if(it != res.restrictionCandidates.end()) {
+                        it->second.push_back(index);
+                    } else {
+                        res.restrictionCandidates[restrictionColour.at(index)] = std::vector<size_t>({index});
+                    }
                 }
 
             }
@@ -214,6 +256,10 @@ namespace storage {
         void colourize(std::shared_ptr<const DFTDependency<ValueType>> const& dep) {
             depColour[dep->id()] = std::pair<ValueType, ValueType>(dep->probability(), dep->dependentEvent()->activeFailureRate());
         }
+        
+        void colourize(std::shared_ptr<const DFTRestriction<ValueType>> const& restr) {
+            restrictionColour[restr->id()] = restrColourizer(restr->type(), restr->nrChildren(), restr->rank());
+        }
     };
 
 
@@ -289,6 +335,7 @@ namespace storage {
             initializePermutationsAndTreatTrivialGroups(bleft.beCandidates, bright.beCandidates, currentPermutations.beCandidates);
             initializePermutationsAndTreatTrivialGroups(bleft.gateCandidates, bright.gateCandidates, currentPermutations.gateCandidates);
             initializePermutationsAndTreatTrivialGroups(bleft.pdepCandidates, bright.pdepCandidates, currentPermutations.pdepCandidates);
+            initializePermutationsAndTreatTrivialGroups(bleft.restrictionCandidates, bright.restrictionCandidates, currentPermutations.restrictionCandidates);
             std::cout << bijection.size() << " vs. " << bleft.size() << " vs. " << bright.size() << std::endl;
             assert(bijection.size() == bleft.size());
             
@@ -323,6 +370,15 @@ namespace storage {
                     ++it;
                 }
             }
+            
+            if(!foundNext && !currentPermutations.restrictionCandidates.empty()) {
+                auto it = currentPermutations.restrictionCandidates.begin();
+                while(!foundNext && it != currentPermutations.restrictionCandidates.end()) {
+                    foundNext = std::next_permutation(it->second.begin(), it->second.end());
+                    ++it;
+                }
+            }
+            
 
             if(foundNext) {
                 for(auto const& colour : bleft.beCandidates) {
@@ -336,6 +392,10 @@ namespace storage {
                 for(auto const& colour : bleft.pdepCandidates) {
                     zipVectorsIntoMap(colour.second, currentPermutations.pdepCandidates.find(colour.first)->second, bijection);
                 }
+                
+                for(auto const& colour : bleft.restrictionCandidates) {
+                    zipVectorsIntoMap(colour.second, currentPermutations.restrictionCandidates.find(colour.first)->second, bijection);
+                }
             }
 
             return foundNext;
@@ -378,6 +438,23 @@ namespace storage {
                     if(bijection.at(lDep->dependentEvent()->id()) != rDep->dependentEvent()->id()) {
                         return false;
                     }
+                } else if(dft.isRestriction(indexpair.first)) {
+                    assert(dft.isRestriction(indexpair.second));
+                    auto const& lRestr = dft.getRestriction(indexpair.first);
+                    std::set<size_t> childrenLeftMapped;
+                    for(auto const& child : lRestr->children() ) {
+                        assert(bleft.has(child->id()));
+                        childrenLeftMapped.insert(bijection.at(child->id()));
+                    }
+                    auto const& rRestr = dft.getRestriction(indexpair.second);
+                    std::set<size_t> childrenRight;
+                    for(auto const& child : rRestr->children() ) {
+                        assert(bright.has(child->id()));
+                        childrenRight.insert(child->id());
+                    }
+                    if(childrenLeftMapped != childrenRight) {
+                        return false;
+                    }
                 }
                 else {
                     assert(dft.isBasicElement(indexpair.first));
@@ -405,10 +482,15 @@ namespace storage {
                 candidatesCompatible = false;
                 return;
             }
+            if(bleft.restrictionCandidates.size() != bright.restrictionCandidates.size()) {
+                candidatesCompatible = false;
+                return;
+            }
             
             for (auto const &gc : bleft.gateCandidates) {
                 if (bright.gateCandidates.count(gc.first) == 0) {
                     candidatesCompatible = false;
+                    return;
                 }
             }
             for(auto const& bc : bleft.beCandidates) {
@@ -424,6 +506,13 @@ namespace storage {
                     return;
                 }
             }
+            
+            for(auto const& dc : bleft.restrictionCandidates) {
+                if(bright.restrictionCandidates.count(dc.first) == 0) {
+                    candidatesCompatible = false;
+                    return;
+                }
+            }
         }
 
         /**

From b74cd564e440e25bf17d85a2022a026a597f713f Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Mon, 29 Feb 2016 10:38:08 +0100
Subject: [PATCH 178/246] some further changes

Former-commit-id: ad72bbef3677218e2e875b9b3c7de6450862ba2b
---
 src/storage/dft/DFTIsomorphism.h   | 42 +++++++++++++++++++++---------
 src/storage/dft/elements/DFTGate.h |  4 +++
 2 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
index e487e92bf..542fa954a 100644
--- a/src/storage/dft/DFTIsomorphism.h
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -414,20 +414,38 @@ namespace storage {
                 if(dft.isGate(indexpair.first)) {
                     assert(dft.isGate(indexpair.second));
                     auto const& lGate = dft.getGate(indexpair.first);
-                    std::set<size_t> childrenLeftMapped;
-                    for(auto const& child : lGate->children() ) {
-                        assert(bleft.has(child->id()));
-                        childrenLeftMapped.insert(bijection.at(child->id()));
-                    }
                     auto const& rGate = dft.getGate(indexpair.second);
-                    std::set<size_t> childrenRight;
-                    for(auto const& child : rGate->children() ) {
-                        assert(bright.has(child->id()));
-                        childrenRight.insert(child->id());
-                    }
-                    if(childrenLeftMapped != childrenRight) {
-                        return false;
+                    if(lGate->isDynamicGate()) {
+                        std::vector<size_t> childrenLeftMapped;
+                        for(auto const& child : lGate->children() ) {
+                            assert(bleft.has(child->id()));
+                            childrenLeftMapped.push_back(bijection.at(child->id()));
+                        }
+                        std::vector<size_t> childrenRight;
+                        for(auto const& child : rGate->children() ) {
+                            assert(bright.has(child->id()));
+                            childrenRight.push_back(child->id());
+                        }
+                        if(childrenLeftMapped != childrenRight) {
+                            return false;
+                        } 
+                    } else {
+                        std::set<size_t> childrenLeftMapped;
+                        for(auto const& child : lGate->children() ) {
+                            assert(bleft.has(child->id()));
+                            childrenLeftMapped.insert(bijection.at(child->id()));
+                        }
+                        std::set<size_t> childrenRight;
+                        for(auto const& child : rGate->children() ) {
+                            assert(bright.has(child->id()));
+                            childrenRight.insert(child->id());
+                        }
+                        if(childrenLeftMapped != childrenRight) {
+                            return false;
+                        } 
                     }
+                
+                    
                 } else if(dft.isDependency(indexpair.first)) {
                     assert(dft.isDependency(indexpair.second));
                     auto const& lDep = dft.getDependency(indexpair.first);
diff --git a/src/storage/dft/elements/DFTGate.h b/src/storage/dft/elements/DFTGate.h
index 52f9bcd43..d82906895 100644
--- a/src/storage/dft/elements/DFTGate.h
+++ b/src/storage/dft/elements/DFTGate.h
@@ -35,6 +35,10 @@ namespace storm {
                 return true;
             }
             
+            bool isDynamicGate() const {
+                return !isStaticGateType(this->type());
+            }
+            
             
             virtual std::string typestring() const = 0;
 

From 9d97750ca53f65cc4b5e5e0f8e38491415043c13 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 29 Feb 2016 10:59:16 +0100
Subject: [PATCH 179/246] Improved compareAndSwap on BitVector

Former-commit-id: db953c187a962edf3eadd2ea4e2017b8e00eeb46
---
 src/storage/BitVector.cpp | 128 +++++++++++++++++++++++++++++++++-----
 src/storage/BitVector.h   |   4 +-
 2 files changed, 113 insertions(+), 19 deletions(-)

diff --git a/src/storage/BitVector.cpp b/src/storage/BitVector.cpp
index 02e40aa59..884ea546c 100644
--- a/src/storage/BitVector.cpp
+++ b/src/storage/BitVector.cpp
@@ -670,16 +670,60 @@ namespace storm {
             return endIndex;
         }
         
-        BitVector BitVector::getAsBitVector(uint_fast64_t start, uint_fast64_t length) {
-            BitVector result(length);
+        storm::storage::BitVector BitVector::getAsBitVector(uint_fast64_t start, uint_fast64_t length) const {
+            assert(start + length <= bitCount);
+            storm::storage::BitVector result(length, false);
             
-            uint_fast64_t index = 0;
-            for ( ; index + 63 <= length; index += 63) {
-                result.setFromInt(index, 63, getAsInt(start + index, 63));
+            uint_fast64_t offset = start % 64;
+            uint_fast64_t bucketIndex = start / 64;
+            uint_fast64_t insertBucket = 0;
+            uint_fast64_t getValue;
+            uint_fast64_t writeValue = 0;
+            uint_fast64_t noBits = 0;
+            if (offset == 0) {
+                // Copy complete buckets
+                for ( ; noBits + 64 <= length; ++bucketIndex, ++insertBucket, noBits += 64) {
+                    result.bucketVector[insertBucket] = bucketVector[bucketIndex];
+                }
+            } else {
+                //Get first bits up until next bucket
+                getValue = bucketVector[bucketIndex];
+                writeValue = (getValue << offset);
+                noBits += (64-offset);
+                ++bucketIndex;
+                
+                //Get complete buckets
+                for ( ; noBits + 64 <= length; ++bucketIndex, ++insertBucket, noBits += 64) {
+                    getValue = bucketVector[bucketIndex];
+                    // Get bits till write bucket is full
+                    writeValue |= (getValue >> (64-offset));
+                    result.bucketVector[insertBucket] = writeValue;
+                    // Get bits up until next bucket
+                    writeValue = (getValue << offset);
+                }
             }
-            // Insert remaining bits
-            result.setFromInt(index, length-index, getAsInt(start+index, length-index));
             
+            // Write last bits
+            uint_fast64_t remainingBits = length - noBits;
+            assert(bucketIndex < bucketCount());
+            // Get remaining bits
+            getValue = (bucketVector[bucketIndex] >> (64-remainingBits)) << (64-remainingBits);
+            assert(remainingBits < 64);
+            if (remainingBits <= offset || offset == 0) {
+                // Write completely
+                assert(insertBucket == result.bucketCount()-1);
+                writeValue = getValue;
+                result.bucketVector[insertBucket] = writeValue;
+            } else {
+                // Remaining bits do not fit in value -> need new value
+                assert(insertBucket == result.bucketCount() - 2);
+                writeValue |= (getValue >> (64-offset));
+                result.bucketVector[insertBucket] = writeValue;
+                // Write last bits
+                writeValue = (getValue << (remainingBits-offset));
+                result.bucketVector[++insertBucket] = writeValue;
+            }
+
 #ifdef ASSERT_BITVECTOR
             // Check correctness of getter
             for (uint_fast64_t i = 0; i < length; ++i) {
@@ -690,13 +734,62 @@ namespace storm {
         }
         
         void BitVector::setFromBitVector(uint_fast64_t start, BitVector const& other) {
-            uint_fast64_t index = 0;
-            for ( ; index + 63 <= other.bitCount; index += 63) {
-                setFromInt(start+index, 63, other.getAsInt(index, 63));
+            assert(start + other.bitCount <= bitCount);
+            
+            uint_fast64_t offset = start % 64;
+            uint_fast64_t bucketIndex = start / 64;
+            uint_fast64_t getBucket = 0;
+            uint_fast64_t getValue;
+            uint_fast64_t writeValue = 0;
+            uint_fast64_t noBits = 0;
+            if (offset == 0) {
+                // Copy complete buckets
+                for ( ; noBits + 64 <= other.bitCount; ++bucketIndex, ++getBucket, noBits += 64) {
+                    bucketVector[bucketIndex] = other.bucketVector[getBucket];
+                }
+            } else {
+                //Get first bits up until next bucket
+                getValue = other.bucketVector[getBucket];
+                writeValue = (bucketVector[bucketIndex] >> (64-offset)) << (64-offset);
+                writeValue |= (getValue >> offset);
+                bucketVector[bucketIndex] = writeValue;
+                noBits += (64-offset);
+                ++bucketIndex;
+                
+                //Get complete buckets
+                for ( ; noBits + 64 <= other.bitCount; ++bucketIndex, noBits += 64) {
+                    // Get all remaining bits from other bucket
+                    writeValue = getValue << (64-offset);
+                    // Get bits from next bucket
+                    getValue = other.bucketVector[++getBucket];
+                    writeValue |= getValue >> offset;
+                    bucketVector[bucketIndex] = writeValue;
+                }
             }
-            // Insert remaining bits
-            setFromInt(start+index, other.bitCount-index, other.getAsInt(index, other.bitCount-index));
             
+            // Write last bits
+            uint_fast64_t remainingBits = other.bitCount - noBits;
+            assert(bucketIndex < bucketCount());
+            assert(getBucket < other.bucketCount());
+            // Get remaining bits
+            getValue = other.bucketVector[getBucket] << (64-offset);
+            assert(remainingBits < 64);
+            if (remainingBits <= offset || offset == 0) {
+                // Write completely
+                assert(getBucket == other.bucketCount()-1);
+                getValue = (getValue >> (64-offset-remainingBits)) << (64-offset-remainingBits);
+                writeValue = (bucketVector[bucketIndex] << (offset+remainingBits)) >> (offset+remainingBits);
+                writeValue |= getValue;
+                bucketVector[bucketIndex] = writeValue;
+            } else {
+                // Remaining bits do not come from one bucket -> consider two buckets
+                assert(getBucket == other.bucketCount() - 2);
+                getValue |= other.bucketVector[++getBucket] >> offset;
+                writeValue = (bucketVector[bucketIndex] << (offset+remainingBits)) >> (offset+remainingBits);
+                writeValue |= getValue;
+                bucketVector[bucketIndex] = writeValue;
+            }
+     
 #ifdef ASSERT_BITVECTOR
             // Check correctness of setter
             for (uint_fast64_t i = 0; i < other.bitCount; ++i) {
@@ -707,6 +800,7 @@ namespace storm {
         
         bool BitVector::compareAndSwap(uint_fast64_t start1, uint_fast64_t start2, uint_fast64_t length) {
             if (length < 64) {
+                // Just use one number
                 uint_fast64_t elem1 = getAsInt(start1, length);
                 uint_fast64_t elem2 = getAsInt(start2, length);
                 if (elem1 < elem2) {
@@ -717,7 +811,7 @@ namespace storm {
                 }
                 return false;
             } else {
-                //TODO improve performance
+                // Use bit vectors
                 BitVector elem1 = getAsBitVector(start1, length);
                 BitVector elem2 = getAsBitVector(start2, length);
                 
@@ -787,21 +881,21 @@ namespace storm {
             return out;
         }
         
-        void BitVector::printBits(std::ostream& out) {
+        void BitVector::printBits(std::ostream& out) const {
             out << "bit vector(" << getNumberOfSetBits() << "/" << bitCount << ") ";
             uint_fast64_t index = 0;
-            for ( ; index * 64 <= bitCount; ++index) {
+            for ( ; index * 64 + 64 <= bitCount; ++index) {
                 std::bitset<64> tmp(bucketVector[index]);
                 out << tmp << "|";
             }
             
-            --index;
             // Print last bits
             if (index * 64 < bitCount) {
                 assert(index == bucketVector.size() - 1);
                 std::bitset<64> tmp(bucketVector[index]);
                 for (size_t i = 0; i + index * 64 < bitCount; ++i) {
-                    out << tmp[i];
+                    // Bits are counted from rightmost in bitset
+                    out << tmp[63-i];
                 }
             }
             out << std::endl;
diff --git a/src/storage/BitVector.h b/src/storage/BitVector.h
index e3f81ebc9..2338faac6 100644
--- a/src/storage/BitVector.h
+++ b/src/storage/BitVector.h
@@ -508,7 +508,7 @@ namespace storm {
              * @param length The number of bits to get.
              * @return A new bit vector holding the selected bits.
              */
-            BitVector getAsBitVector(uint_fast64_t start, uint_fast64_t length);
+            BitVector getAsBitVector(uint_fast64_t start, uint_fast64_t length) const;
             
             /*!
              * Sets the exact bit pattern of the given bit vector starting at the given bit index. Note: the given bit
@@ -524,7 +524,7 @@ namespace storm {
              *
              * @param out Stream to print to.
              */
-            void printBits(std::ostream& out);
+            void printBits(std::ostream& out) const;
             
             /*!
              * Retrieves the number of buckets of the underlying storage.

From f935f502dd44309ee38670f7af17afc15917af83 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 29 Feb 2016 15:49:33 +0100
Subject: [PATCH 180/246] Activate pCTMCs for storm

Former-commit-id: 5cacb49d18817483dd2f7f2c9d3a546debf0dd15
---
 src/cli/entrypoints.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cli/entrypoints.h b/src/cli/entrypoints.h
index bbb9d6404..8071d99c1 100644
--- a/src/cli/entrypoints.h
+++ b/src/cli/entrypoints.h
@@ -29,7 +29,7 @@ namespace storm {
         inline void verifySparseModel(std::shared_ptr<storm::models::sparse::Model<storm::RationalFunction>> model, std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas, bool onlyInitialStatesRelevant) {
 
             for (auto const& formula : formulas) {
-                STORM_LOG_THROW(model->getType() == storm::models::ModelType::Dtmc, storm::exceptions::InvalidSettingsException, "Currently parametric verification is only available for DTMCs.");
+                STORM_LOG_THROW(model->getType() == storm::models::ModelType::Dtmc || model->getType() == storm::models::ModelType::Ctmc, storm::exceptions::InvalidSettingsException, "Currently parametric verification is only available for DTMCs and CTMCs.");
                 std::cout << std::endl << "Model checking property: " << *formula << " ...";
                 std::unique_ptr<storm::modelchecker::CheckResult> result(storm::verifySparseModel(model, formula, onlyInitialStatesRelevant));
                 if (result) {

From 9b8dd018cfcde5a6cd53f5affb3fefb1ced0aaff Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 29 Feb 2016 19:08:32 +0100
Subject: [PATCH 181/246] Fixed problem with gate as trigger events for
 dependencies

Former-commit-id: 87cd1115bbe7dd4cb672d99b9d1671478626de5a
---
 src/builder/ExplicitDFTModelBuilder.cpp |  4 +++-
 src/storage/dft/DFT.cpp                 | 32 ++++++++++++++++++-------
 src/storage/dft/DFTState.cpp            | 19 ++++++++-------
 3 files changed, 37 insertions(+), 18 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index f14408190..1c9c64684 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -196,12 +196,14 @@ namespace storm {
                     while (!queues.failurePropagationDone()) {
                         DFTGatePointer next = queues.nextFailurePropagation();
                         next->checkFails(*newState, queues);
+                        newState->updateFailableDependencies(next->id());
                     }
                     
                     while(!queues.restrictionChecksDone()) {
                         DFTRestrictionPointer next = queues.nextRestrictionCheck();
                         next->checkFails(*newState, queues);
-                    } 
+                        newState->updateFailableDependencies(next->id());
+                    }
                     
                     if(newState->isInvalid()) {
                         continue;
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 9a12fe2f6..bf68a095c 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -56,14 +56,24 @@ namespace storm {
                     topModuleSet.insert(elem->id());
                 }
             }
-
+            // Erase spare modules
             for(auto const& module : mSpareModules) {
                 for(auto const& index : module.second) {
                     topModuleSet.erase(index);
                 }
             }
+            // Extend top module and insert those elements which are part of the top module and a spare module
+            mElements[mTopLevelIndex]->extendSpareModule(topModuleSet);
             mTopModule = std::vector<size_t>(topModuleSet.begin(), topModuleSet.end());
-            
+            // Clear all spare modules where at least one element is also in the top module
+            if (!mTopModule.empty()) {
+                for (auto& module : mSpareModules) {
+                    if (std::find(module.second.begin(), module.second.end(), mTopModule.front()) != module.second.end()) {
+                        module.second.clear();
+                    }
+                }
+            }
+
             //Reserve space for failed spares
             ++mMaxSpareChildCount;
             size_t usageInfoBits = storm::utility::math::uint64_log2(mMaxSpareChildCount) + 1;
@@ -240,6 +250,10 @@ namespace storm {
             std::stringstream stream;
             stream << "[" << mElements[mTopLevelIndex]->id() << "] {";
             std::vector<size_t>::const_iterator it = mTopModule.begin();
+            if (it == mTopModule.end()) {
+                stream << "}" << std::endl;
+                return stream.str();
+            }
             assert(it != mTopModule.end());
             stream << mElements[(*it)]->name();
             ++it;
@@ -251,13 +265,15 @@ namespace storm {
 
             for(auto const& spareModule : mSpareModules) {
                 stream << "[" << mElements[spareModule.first]->name() << "] = {";
-                std::vector<size_t>::const_iterator it = spareModule.second.begin();
-                assert(it != spareModule.second.end());
-                stream << mElements[(*it)]->name();
-                ++it;
-                while(it != spareModule.second.end()) {
-                    stream <<  ", " << mElements[(*it)]->name();
+                if (!spareModule.second.empty()) {
+                    std::vector<size_t>::const_iterator it = spareModule.second.begin();
+                    assert(it != spareModule.second.end());
+                    stream << mElements[(*it)]->name();
                     ++it;
+                    while(it != spareModule.second.end()) {
+                        stream <<  ", " << mElements[(*it)]->name();
+                        ++it;
+                    }
                 }
                 stream << "}" << std::endl;
             }
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 419403d55..1d34362f9 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -129,15 +129,16 @@ namespace storm {
 
         template<typename ValueType>
         bool DFTState<ValueType>::updateFailableDependencies(size_t id) {
-            assert(hasFailed(id));
-            for (size_t i = 0; i < mDft.getDependencies().size(); ++i) {
-                std::shared_ptr<DFTDependency<ValueType> const> dependency = mDft.getDependency(mDft.getDependencies()[i]);
-                if (dependency->triggerEvent()->id() == id) {
-                    if (getElementState(dependency->dependentEvent()->id()) == DFTElementState::Operational) {
-                        assert(!isFailsafe(dependency->dependentEvent()->id()));
-                        mFailableDependencies.push_back(dependency->id());
-                        STORM_LOG_TRACE("New dependency failure: " << dependency->toString());
-                    }
+            if (!hasFailed(id)) {
+                return false;
+            }
+            
+            for (auto dependency : mDft.getElement(id)->outgoingDependencies()) {
+                assert(dependency->triggerEvent()->id() == id);
+                if (getElementState(dependency->dependentEvent()->id()) == DFTElementState::Operational) {
+                    assert(!isFailsafe(dependency->dependentEvent()->id()));
+                    mFailableDependencies.push_back(dependency->id());
+                    STORM_LOG_TRACE("New dependency failure: " << dependency->toString());
                 }
             }
             return nrFailableDependencies() > 0;

From 7f4fa270088b1adc8ea11346d7ce5af810cf5865 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 1 Mar 2016 10:21:21 +0100
Subject: [PATCH 182/246] Initialize closed for MA

Former-commit-id: 292352f2580315b8e5c48d0736bfb9314c96b146
---
 src/models/sparse/MarkovAutomaton.cpp | 19 ++++++++++++++++---
 src/models/sparse/MarkovAutomaton.h   |  7 +++++++
 2 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/src/models/sparse/MarkovAutomaton.cpp b/src/models/sparse/MarkovAutomaton.cpp
index 8276f519d..aa5ffc5e2 100644
--- a/src/models/sparse/MarkovAutomaton.cpp
+++ b/src/models/sparse/MarkovAutomaton.cpp
@@ -19,8 +19,9 @@ namespace storm {
                                                         std::vector<ValueType> const& exitRates,
                                                         std::unordered_map<std::string, RewardModelType> const& rewardModels,
                                                         boost::optional<std::vector<LabelSet>> const& optionalChoiceLabeling)
-            : NondeterministicModel<ValueType, RewardModelType>(storm::models::ModelType::MarkovAutomaton, transitionMatrix, stateLabeling, rewardModels, optionalChoiceLabeling), markovianStates(markovianStates), exitRates(exitRates), closed(false) {
+            : NondeterministicModel<ValueType, RewardModelType>(storm::models::ModelType::MarkovAutomaton, transitionMatrix, stateLabeling, rewardModels, optionalChoiceLabeling), markovianStates(markovianStates), exitRates(exitRates) {
                 this->turnRatesToProbabilities();
+                closed = !hasHybridState();
             }
             
             template <typename ValueType, typename RewardModelType>
@@ -30,8 +31,9 @@ namespace storm {
                                                         std::vector<ValueType> const& exitRates,
                                                         std::unordered_map<std::string, RewardModelType>&& rewardModels,
                                                         boost::optional<std::vector<LabelSet>>&& optionalChoiceLabeling)
-            : NondeterministicModel<ValueType, RewardModelType>(storm::models::ModelType::MarkovAutomaton, std::move(transitionMatrix), std::move(stateLabeling), std::move(rewardModels), std::move(optionalChoiceLabeling)), markovianStates(markovianStates), exitRates(std::move(exitRates)), closed(false) {
+            : NondeterministicModel<ValueType, RewardModelType>(storm::models::ModelType::MarkovAutomaton, std::move(transitionMatrix), std::move(stateLabeling), std::move(rewardModels), std::move(optionalChoiceLabeling)), markovianStates(markovianStates), exitRates(std::move(exitRates)) {
                 this->turnRatesToProbabilities();
+                closed = !hasHybridState();
             }
             
             template <typename ValueType, typename RewardModelType>
@@ -42,9 +44,10 @@ namespace storm {
                                                                          bool probabilities,
                                                                          std::unordered_map<std::string, RewardModelType>&& rewardModels,
                                                                          boost::optional<std::vector<LabelSet>>&& optionalChoiceLabeling)
-            : NondeterministicModel<ValueType, RewardModelType>(storm::models::ModelType::MarkovAutomaton, std::move(transitionMatrix), std::move(stateLabeling), std::move(rewardModels), std::move(optionalChoiceLabeling)), markovianStates(markovianStates), exitRates(std::move(exitRates)), closed(false) {
+            : NondeterministicModel<ValueType, RewardModelType>(storm::models::ModelType::MarkovAutomaton, std::move(transitionMatrix), std::move(stateLabeling), std::move(rewardModels), std::move(optionalChoiceLabeling)), markovianStates(markovianStates), exitRates(std::move(exitRates)) {
                 assert(probabilities);
                 assert(this->getTransitionMatrix().isProbabilistic());
+                closed = !hasHybridState();
             }
             
             template <typename ValueType, typename RewardModelType>
@@ -67,6 +70,16 @@ namespace storm {
                 return !this->markovianStates.get(state);
             }
             
+            template <typename ValueType, typename RewardModelType>
+            bool MarkovAutomaton<ValueType, RewardModelType>::hasHybridState() const {
+                for (uint_fast64_t state = 0; state < this->getNumberOfStates(); ++state) {
+                    if (this->isHybridState(state)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            
             template <typename ValueType, typename RewardModelType>
             std::vector<ValueType> const& MarkovAutomaton<ValueType, RewardModelType>::getExitRates() const {
                 return this->exitRates;
diff --git a/src/models/sparse/MarkovAutomaton.h b/src/models/sparse/MarkovAutomaton.h
index e335f5050..d97ff1517 100644
--- a/src/models/sparse/MarkovAutomaton.h
+++ b/src/models/sparse/MarkovAutomaton.h
@@ -157,6 +157,13 @@ namespace storm {
                  */
                 void turnRatesToProbabilities();
                 
+                /*!
+                 * Check if at least one hybrid state exists.
+                 *
+                 * @return True, if at least one hybrid state exists, false if none exists.
+                 */
+                bool hasHybridState() const;
+                
                 // A bit vector representing the set of Markovian states.
                 storm::storage::BitVector markovianStates;
                 

From f8b9ece2fd9b788ba163934c1203cf753448e01e Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 1 Mar 2016 10:21:55 +0100
Subject: [PATCH 183/246] Added mini test for BitVector

Former-commit-id: 8ec7395c0d80a1cb31eeef8b2cf9e74a50639238
---
 test/functional/storage/BitVectorTest.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/test/functional/storage/BitVectorTest.cpp b/test/functional/storage/BitVectorTest.cpp
index db92724fe..3e4d53235 100644
--- a/test/functional/storage/BitVectorTest.cpp
+++ b/test/functional/storage/BitVectorTest.cpp
@@ -510,4 +510,17 @@ TEST(BitVectorTest, Iterator) {
     for (auto bit : vector) {
         ASSERT_TRUE(bit % 2 == 0);
     }
+}
+
+TEST(BitVectorTest, CompareAndSwap) {
+    storm::storage::BitVector vector(140);
+    vector.setFromInt(0, 64, 2377830234574424100);
+    vector.setFromInt(64, 64, 1152921504607379586);
+    vector.setFromInt(128, 12, 2080);
+    
+    bool result = vector.compareAndSwap(0, 68, 68);
+    ASSERT_FALSE(result);
+    
+    result = vector.compareAndSwap(68, 0, 68);
+    ASSERT_TRUE(result);
 }
\ No newline at end of file

From e4c270288904fdb531969501823b1a177bedb5b8 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 1 Mar 2016 12:18:01 +0100
Subject: [PATCH 184/246] Fixed problem in MaximalEndComponents

Former-commit-id: 950b9cfdfa677f47567e2c90fdadd3a65867dac4
---
 .../helper/SparseMarkovAutomatonCslHelper.cpp | 46 +++++++------
 src/storage/Decomposition.cpp                 |  5 ++
 src/storage/Decomposition.h                   |  7 ++
 .../MaximalEndComponentDecomposition.cpp      | 68 ++++++++++---------
 4 files changed, 72 insertions(+), 54 deletions(-)

diff --git a/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp b/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp
index d926917a5..95007a9e6 100644
--- a/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp
+++ b/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp
@@ -407,33 +407,35 @@ namespace storm {
                         infinityStates = storm::storage::BitVector(numberOfStates);
                     }
                 }
-                
                 // Now we identify the states for which values need to be computed.
                 storm::storage::BitVector maybeStates = ~(goalStates | infinityStates);
-                
-                // Then, we can eliminate the rows and columns for all states whose values are already known to be 0.
-                std::vector<ValueType> x(maybeStates.getNumberOfSetBits());
-                storm::storage::SparseMatrix<ValueType> submatrix = transitionMatrix.getSubmatrix(true, maybeStates, maybeStates);
-                
-                // Now prepare the expected reward values for all states so they can be used as the right-hand side of the equation system.
-                std::vector<ValueType> rewardValues(stateRewards);
-                for (auto state : markovianStates) {
-                    rewardValues[state] = rewardValues[state] / exitRateVector[state];
-                }
-                
-                // Finally, prepare the actual right-hand side.
-                std::vector<ValueType> b(submatrix.getRowCount());
-                storm::utility::vector::selectVectorValuesRepeatedly(b, maybeStates, transitionMatrix.getRowGroupIndices(), rewardValues);
-                
-                // Solve the corresponding system of equations.
-                std::unique_ptr<storm::solver::MinMaxLinearEquationSolver<ValueType>> solver = minMaxLinearEquationSolverFactory.create(submatrix);
-                solver->solveEquationSystem(dir, x, b);
-                
+
                 // Create resulting vector.
                 std::vector<ValueType> result(numberOfStates);
                 
-                // Set values of resulting vector according to previous result and return the result.
-                storm::utility::vector::setVectorValues<ValueType>(result, maybeStates, x);
+                if (!maybeStates.empty()) {
+                    // Then, we can eliminate the rows and columns for all states whose values are already known.
+                    std::vector<ValueType> x(maybeStates.getNumberOfSetBits());
+                    storm::storage::SparseMatrix<ValueType> submatrix = transitionMatrix.getSubmatrix(true, maybeStates, maybeStates);
+                    
+                    // Now prepare the expected reward values for all states so they can be used as the right-hand side of the equation system.
+                    std::vector<ValueType> rewardValues(stateRewards);
+                    for (auto state : markovianStates) {
+                        rewardValues[state] = rewardValues[state] / exitRateVector[state];
+                    }
+                    
+                    // Finally, prepare the actual right-hand side.
+                    std::vector<ValueType> b(submatrix.getRowCount());
+                    storm::utility::vector::selectVectorValuesRepeatedly(b, maybeStates, transitionMatrix.getRowGroupIndices(), rewardValues);
+                    
+                    // Solve the corresponding system of equations.
+                    std::unique_ptr<storm::solver::MinMaxLinearEquationSolver<ValueType>> solver = minMaxLinearEquationSolverFactory.create(submatrix);
+                    solver->solveEquationSystem(dir, x, b);
+                    
+                    // Set values of resulting vector according to previous result and return the result.
+                    storm::utility::vector::setVectorValues<ValueType>(result, maybeStates, x);
+                }
+
                 storm::utility::vector::setVectorValues(result, goalStates, storm::utility::zero<ValueType>());
                 storm::utility::vector::setVectorValues(result, infinityStates, storm::utility::infinity<ValueType>());
                 
diff --git a/src/storage/Decomposition.cpp b/src/storage/Decomposition.cpp
index 4e2ebcb02..54d7ef12e 100644
--- a/src/storage/Decomposition.cpp
+++ b/src/storage/Decomposition.cpp
@@ -41,6 +41,11 @@ namespace storm {
             return blocks.size();
         }
         
+        template <typename BlockType>
+        bool Decomposition<BlockType>::empty() const {
+            return blocks.empty();
+        }
+        
         template <typename BlockType>
         typename Decomposition<BlockType>::iterator Decomposition<BlockType>::begin() {
             return blocks.begin();
diff --git a/src/storage/Decomposition.h b/src/storage/Decomposition.h
index ce522c171..76f8a28a8 100644
--- a/src/storage/Decomposition.h
+++ b/src/storage/Decomposition.h
@@ -63,6 +63,13 @@ namespace storm {
              */
             std::size_t size() const;
             
+            /*!
+             * Checks if the decomposition is empty.
+             *
+             * @return True, if the decomposition is empty.
+             */
+            bool empty() const;
+            
             /*!
              * Retrieves an iterator that points to the first block of this decomposition.
              *
diff --git a/src/storage/MaximalEndComponentDecomposition.cpp b/src/storage/MaximalEndComponentDecomposition.cpp
index 31c421224..a944ecd23 100644
--- a/src/storage/MaximalEndComponentDecomposition.cpp
+++ b/src/storage/MaximalEndComponentDecomposition.cpp
@@ -86,48 +86,52 @@ namespace storm {
                 mecChanged |= sccs.size() > 1 || (sccs.size() > 0 && sccs[0].size() < mec.size());
                 
                 // Check for each of the SCCs whether there is at least one action for each state that does not leave the SCC.
-                for (auto& scc : sccs) {
-                    statesToCheck.set(scc.begin(), scc.end());
-                    
-                    while (!statesToCheck.empty()) {
-                        storm::storage::BitVector statesToRemove(numberOfStates);
+                if (sccs.empty()) {
+                    mecChanged = true;
+                } else {
+                    for (auto& scc : sccs) {
+                        statesToCheck.set(scc.begin(), scc.end());
                         
-                        for (auto state : statesToCheck) {
-                            bool keepStateInMEC = false;
+                        while (!statesToCheck.empty()) {
+                            storm::storage::BitVector statesToRemove(numberOfStates);
                             
-                            for (uint_fast64_t choice = nondeterministicChoiceIndices[state]; choice < nondeterministicChoiceIndices[state + 1]; ++choice) {
-                                bool choiceContainedInMEC = true;
-                                for (auto const& entry : transitionMatrix.getRow(choice)) {
-                                    if (!scc.containsState(entry.getColumn())) {
-                                        choiceContainedInMEC = false;
+                            for (auto state : statesToCheck) {
+                                bool keepStateInMEC = false;
+                                
+                                for (uint_fast64_t choice = nondeterministicChoiceIndices[state]; choice < nondeterministicChoiceIndices[state + 1]; ++choice) {
+                                    bool choiceContainedInMEC = true;
+                                    for (auto const& entry : transitionMatrix.getRow(choice)) {
+                                        if (!scc.containsState(entry.getColumn())) {
+                                            choiceContainedInMEC = false;
+                                            break;
+                                        }
+                                    }
+                                    
+                                    // If there is at least one choice whose successor states are fully contained in the MEC, we can leave the state in the MEC.
+                                    if (choiceContainedInMEC) {
+                                        keepStateInMEC = true;
                                         break;
                                     }
                                 }
                                 
-                                // If there is at least one choice whose successor states are fully contained in the MEC, we can leave the state in the MEC.
-                                if (choiceContainedInMEC) {
-                                    keepStateInMEC = true;
-                                    break;
+                                if (!keepStateInMEC) {
+                                    statesToRemove.set(state, true);
                                 }
                             }
                             
-                            if (!keepStateInMEC) {
-                                statesToRemove.set(state, true);
+                            // Now erase the states that have no option to stay inside the MEC with all successors.
+                            mecChanged |= !statesToRemove.empty();
+                            for (uint_fast64_t state : statesToRemove) {
+                                scc.erase(state);
                             }
-                        }
-                        
-                        // Now erase the states that have no option to stay inside the MEC with all successors.
-                        mecChanged |= !statesToRemove.empty();
-                        for (uint_fast64_t state : statesToRemove) {
-                            scc.erase(state);
-                        }
-                        
-                        // Now check which states should be reconsidered, because successors of them were removed.
-                        statesToCheck.clear();
-                        for (auto state : statesToRemove) {
-                            for (auto const& entry : backwardTransitions.getRow(state)) {
-                                if (scc.containsState(entry.getColumn())) {
-                                    statesToCheck.set(entry.getColumn());
+                            
+                            // Now check which states should be reconsidered, because successors of them were removed.
+                            statesToCheck.clear();
+                            for (auto state : statesToRemove) {
+                                for (auto const& entry : backwardTransitions.getRow(state)) {
+                                    if (scc.containsState(entry.getColumn())) {
+                                        statesToCheck.set(entry.getColumn());
+                                    }
                                 }
                             }
                         }

From 37a86d81906bcc18c690c6036412249ee99d8e3f Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 1 Mar 2016 13:22:14 +0100
Subject: [PATCH 185/246] Compile fixes for gcc

Former-commit-id: cb1b187ef84f512ff5583d7c3d276cac9157ed05
---
 src/settings/Option.cpp          | 3 ++-
 src/storage/BitVectorHashMap.cpp | 1 +
 src/storage/dd/Bdd.cpp           | 4 +++-
 src/utility/macros.h             | 3 ++-
 4 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/settings/Option.cpp b/src/settings/Option.cpp
index b5cba7759..cba074b58 100644
--- a/src/settings/Option.cpp
+++ b/src/settings/Option.cpp
@@ -2,6 +2,7 @@
 
 #include <iomanip>
 #include <string>
+#include <algorithm>
 #include "ArgumentBase.h"
 #include "Argument.h"
 
@@ -211,4 +212,4 @@ namespace storm {
             return out;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/storage/BitVectorHashMap.cpp b/src/storage/BitVectorHashMap.cpp
index 07eefee1d..760ffe039 100644
--- a/src/storage/BitVectorHashMap.cpp
+++ b/src/storage/BitVectorHashMap.cpp
@@ -1,6 +1,7 @@
 #include "src/storage/BitVectorHashMap.h"
 
 #include <iostream>
+#include <algorithm>
 
 #include "src/utility/macros.h"
 
diff --git a/src/storage/dd/Bdd.cpp b/src/storage/dd/Bdd.cpp
index 8f176048e..f8bf6b368 100644
--- a/src/storage/dd/Bdd.cpp
+++ b/src/storage/dd/Bdd.cpp
@@ -1,3 +1,5 @@
+#include <algorithm>
+
 #include "src/storage/dd/Bdd.h"
 #include "src/storage/dd/Add.h"
 #include "src/storage/dd/Odd.h"
@@ -360,4 +362,4 @@ namespace storm {
         template Add<DdType::Sylvan, double> Bdd<DdType::Sylvan>::ite(Add<DdType::Sylvan, double> const& thenAdd, Add<DdType::Sylvan, double> const& elseAdd) const;
         template Add<DdType::Sylvan, uint_fast64_t> Bdd<DdType::Sylvan>::ite(Add<DdType::Sylvan, uint_fast64_t> const& thenAdd, Add<DdType::Sylvan, uint_fast64_t> const& elseAdd) const;
     }
-}
\ No newline at end of file
+}
diff --git a/src/utility/macros.h b/src/utility/macros.h
index 4f70b1691..16dd4d70e 100644
--- a/src/utility/macros.h
+++ b/src/utility/macros.h
@@ -2,6 +2,7 @@
 #define STORM_UTILITY_MACROS_H_
 
 #include <cassert>
+#include <cstring>
 #include "storm-config.h"
 
 #ifndef STORM_LOGGING_FRAMEWORK
@@ -272,4 +273,4 @@ LOG4CPLUS_INFO(logger, "Enabled trace mode, log output gets printed to console."
     STORM_PRINT(message);                       \
 }
 
-#endif /* STORM_UTILITY_MACROS_H_ */
\ No newline at end of file
+#endif /* STORM_UTILITY_MACROS_H_ */

From 4c2b1d7c22019a0ff8c9a16cfbf45e7e48336fb3 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 1 Mar 2016 13:22:43 +0100
Subject: [PATCH 186/246] Model info for benchmarking scripts

Former-commit-id: 7a686f5f79f5951edee96fb434a84312476b1a2a
---
 src/storm-dyftee.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index e167633bd..c1bafd78a 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -46,7 +46,8 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
 
     
     model->printModelInformationToStream(std::cout);
-    
+    std::cout << "No. states (Explored): " << model->getNumberOfStates() << std::endl;
+    std::cout << "No. transitions (Explored): " << model->getNumberOfTransitions() << std::endl;
     std::cout << "Bisimulation..." << std::endl;
     
     if (model->getNumberOfStates() > 500 && model->isOfType(storm::models::ModelType::Ctmc)) {
@@ -54,6 +55,8 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     }
     
     model->printModelInformationToStream(std::cout);
+    std::cout << "No. states (Bisimulation): " << model->getNumberOfStates() << std::endl;
+    std::cout << "No. transitions (Bisimulation): " << model->getNumberOfTransitions() << std::endl;
     
     // Model checking
     std::cout << "Model checking..." << std::endl;

From c05e6711111a200c4fec993ad80b07f79cf4b3f4 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 1 Mar 2016 13:28:38 +0100
Subject: [PATCH 187/246] Handling of min and max for non-determinism

Former-commit-id: 1a3a38c5115e19e93ed24f4d433e7705520988a6
---
 src/storm-dyftee.cpp | 39 +++++++++++++++++++++++++++------------
 1 file changed, 27 insertions(+), 12 deletions(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index e167633bd..3d93d4107 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -47,14 +47,12 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     
     model->printModelInformationToStream(std::cout);
     
-    std::cout << "Bisimulation..." << std::endl;
-    
     if (model->getNumberOfStates() > 500 && model->isOfType(storm::models::ModelType::Ctmc)) {
-            model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), formulas, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
+        std::cout << "Bisimulation..." << std::endl;
+        model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), formulas, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
+        model->printModelInformationToStream(std::cout);
     }
     
-    model->printModelInformationToStream(std::cout);
-    
     // Model checking
     std::cout << "Model checking..." << std::endl;
     std::unique_ptr<storm::modelchecker::CheckResult> result(storm::verifySparseModel(model, formulas[0]));
@@ -81,20 +79,25 @@ int main(int argc, char** argv) {
     // Parse cli arguments
     bool parametric = false;
     bool symred = false;
+    bool minimal = true;
     std::string filename = argv[1];
+    std::string operatorType = "";
+    std::string targetFormula = "";
     std::string pctlFormula = "";
     for (int i = 2; i < argc; ++i) {
         std::string option = argv[i];
         if (option == "--parametric") {
             parametric = true;
         } else if (option == "--expectedtime") {
-            assert(pctlFormula.empty());
-            pctlFormula = "ET=?[F \"failed\"]";
+            assert(targetFormula.empty());
+            operatorType = "ET";
+            targetFormula = "F \"failed\"";
         } else if (option == "--probability") {
-            assert(pctlFormula.empty());
-            pctlFormula = "P=? [F \"failed\"]";
+            assert(targetFormula.empty());
+            operatorType = "P";;
+            targetFormula = "F \"failed\"";
         } else if (option == "--timebound") {
-            assert(pctlFormula.empty());
+            assert(targetFormula.empty());
             ++i;
             assert(i < argc);
             double timeBound;
@@ -105,8 +108,9 @@ int main(int argc, char** argv) {
                 return 2;
             }
             std::stringstream stream;
-            stream << "P=? [F<=" << timeBound << " \"failed\"]";
-            pctlFormula = stream.str();
+            stream << "F<=" << timeBound << " \"failed\"";
+            operatorType = "P";
+            targetFormula = stream.str();
         } else if (option == "--trace") {
             STORM_GLOBAL_LOGLEVEL_TRACE();
         } else if (option == "--debug") {
@@ -118,11 +122,22 @@ int main(int argc, char** argv) {
             pctlFormula = argv[i];
         } else if (option == "--symred") {
             symred = true;
+        } else if (option == "--min") {
+            minimal = true;
+        } else if (option == "--max") {
+            minimal = false;
         } else {
             std::cout << "Option '" << option << "' not recognized." << std::endl;
             return 1;
         }
     }
+    
+    // Construct pctlFormula
+    if (!targetFormula.empty()) {
+        assert(pctlFormula.empty());
+        pctlFormula = operatorType + (minimal ? "min" : "max") + "=?[" + targetFormula + "]";
+    }
+    
     assert(!pctlFormula.empty());
 
     storm::utility::setUp();

From 7b7b999548844103bde63c37b493ec8de2bf3950 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 1 Mar 2016 16:44:34 +0100
Subject: [PATCH 188/246] Bisimulation for small models as well

Former-commit-id: 51bcbc23d820363c447dbdaaaa51426844d520a3
---
 src/storm-dyftee.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index c30e6e5ba..13b43f5ff 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -49,7 +49,7 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     std::cout << "No. states (Explored): " << model->getNumberOfStates() << std::endl;
     std::cout << "No. transitions (Explored): " << model->getNumberOfTransitions() << std::endl;
     
-    if (model->getNumberOfStates() > 500 && model->isOfType(storm::models::ModelType::Ctmc)) {
+    if (model->isOfType(storm::models::ModelType::Ctmc)) {
         std::cout << "Bisimulation..." << std::endl;
         model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), formulas, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
         model->printModelInformationToStream(std::cout);

From b75b5f1928d8e39d83509a665367a1cd5b77039f Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 1 Mar 2016 17:31:52 +0100
Subject: [PATCH 189/246] No bisimulation for parametric case

Former-commit-id: 7b30c7e5af3af1fd8a6d21edddf7fb4a07da36df
---
 src/storm-dyftee.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 13b43f5ff..97f583e28 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -15,7 +15,7 @@
  * @param property PCTC formula capturing the property to check.
  */
 template <typename ValueType>
-void analyzeDFT(std::string filename, std::string property, bool symred = false) {
+void analyzeDFT(std::string filename, std::string property, bool symred = false, bool bisimulation = true) {
     storm::settings::SettingsManager& manager = storm::settings::mutableManager();
     manager.setFromString("");
 
@@ -49,7 +49,7 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     std::cout << "No. states (Explored): " << model->getNumberOfStates() << std::endl;
     std::cout << "No. transitions (Explored): " << model->getNumberOfTransitions() << std::endl;
     
-    if (model->isOfType(storm::models::ModelType::Ctmc)) {
+    if (bisimulation && model->isOfType(storm::models::ModelType::Ctmc)) {
         std::cout << "Bisimulation..." << std::endl;
         model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), formulas, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
         model->printModelInformationToStream(std::cout);
@@ -149,8 +149,8 @@ int main(int argc, char** argv) {
     std::cout << "Running " << (parametric ? "parametric " : "") << "DFT analysis on file " << filename << " with property " << pctlFormula << std::endl;
 
     if (parametric) {
-        analyzeDFT<storm::RationalFunction>(filename, pctlFormula, symred);
+        analyzeDFT<storm::RationalFunction>(filename, pctlFormula, symred, false);
     } else {
-        analyzeDFT<double>(filename, pctlFormula, symred);
+        analyzeDFT<double>(filename, pctlFormula, symred, true);
     }
 }

From b8c7f063c1cdbe54b2364bb16877bdb334e15f22 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 2 Mar 2016 00:36:15 +0100
Subject: [PATCH 190/246] Maybe fix try to fix bisimulation instead of
 deactivating

Former-commit-id: 772956d2ed7162d5dc4d5130d783ef18f38d24c6
---
 src/storm-dyftee.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 97f583e28..13b43f5ff 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -15,7 +15,7 @@
  * @param property PCTC formula capturing the property to check.
  */
 template <typename ValueType>
-void analyzeDFT(std::string filename, std::string property, bool symred = false, bool bisimulation = true) {
+void analyzeDFT(std::string filename, std::string property, bool symred = false) {
     storm::settings::SettingsManager& manager = storm::settings::mutableManager();
     manager.setFromString("");
 
@@ -49,7 +49,7 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false,
     std::cout << "No. states (Explored): " << model->getNumberOfStates() << std::endl;
     std::cout << "No. transitions (Explored): " << model->getNumberOfTransitions() << std::endl;
     
-    if (bisimulation && model->isOfType(storm::models::ModelType::Ctmc)) {
+    if (model->isOfType(storm::models::ModelType::Ctmc)) {
         std::cout << "Bisimulation..." << std::endl;
         model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), formulas, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
         model->printModelInformationToStream(std::cout);
@@ -149,8 +149,8 @@ int main(int argc, char** argv) {
     std::cout << "Running " << (parametric ? "parametric " : "") << "DFT analysis on file " << filename << " with property " << pctlFormula << std::endl;
 
     if (parametric) {
-        analyzeDFT<storm::RationalFunction>(filename, pctlFormula, symred, false);
+        analyzeDFT<storm::RationalFunction>(filename, pctlFormula, symred);
     } else {
-        analyzeDFT<double>(filename, pctlFormula, symred, true);
+        analyzeDFT<double>(filename, pctlFormula, symred);
     }
 }

From 174058bb5e39dbbdfc70185930ee9795d7e86356 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 2 Mar 2016 11:53:41 +0100
Subject: [PATCH 191/246] Do not destroy the universe by dividing by 0

Former-commit-id: bd784f7adeca0f114e80da3870857bd14c24a8b6
---
 src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
index 3ffe7bbe8..18a56f5ab 100644
--- a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
+++ b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
@@ -663,8 +663,8 @@ namespace storm {
                 // Initialize rewards.
                 std::vector<ValueType> totalRewardVector;
                 for (size_t i = 0; i < exitRateVector.size(); ++i) {
-                    if (targetStates[i]) {
-                        // Set reward for target states to 0.
+                    if (targetStates[i] || storm::utility::isZero(exitRateVector[i])) {
+                        // Set reward for target states or states without outgoing transitions to 0.
                         totalRewardVector.push_back(storm::utility::zero<ValueType>());
                     } else {
                         // Reward is (1 / exitRate).
@@ -685,8 +685,8 @@ namespace storm {
                 // Initialize rewards.
                 std::vector<ValueType> totalRewardVector;
                 for (size_t i = 0; i < exitRateVector.size(); ++i) {
-                    if (targetStates[i]) {
-                        // Set reward for target states to 0.
+                    if (targetStates[i] || storm::utility::isZero(exitRateVector[i])) {
+                        // Set reward for target states or states without outgoing transitions to 0.
                         totalRewardVector.push_back(storm::utility::zero<ValueType>());
                     } else {
                         // Reward is (1 / exitRate).

From 1e79e5b2a43cc94415edbf5dbb2d006e310282a1 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 2 Mar 2016 15:24:29 +0100
Subject: [PATCH 192/246] Only print debug matrix for small state sizes

Former-commit-id: c2e793d9b9f9fa4a3bedd8af52fe009706021b72
---
 src/builder/ExplicitDFTModelBuilder.cpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 1c9c64684..3c5a39702 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -57,9 +57,13 @@ namespace storm {
             modelComponents.markovianStates = storm::storage::BitVector(stateSize, tmpMarkovianStates);
             // Build transition matrix
             modelComponents.transitionMatrix = transitionMatrixBuilder.build(stateSize, stateSize);
-            STORM_LOG_DEBUG("Transition matrix: " << std::endl << modelComponents.transitionMatrix);
-            STORM_LOG_DEBUG("Exit rates: " << modelComponents.exitRates);
-            STORM_LOG_DEBUG("Markovian states: " << modelComponents.markovianStates);
+            if (stateSize <= 15) {
+                STORM_LOG_TRACE("Transition matrix: " << std::endl << modelComponents.transitionMatrix);
+            } else {
+                STORM_LOG_TRACE("Transition matrix: too big to print");
+            }
+            STORM_LOG_TRACE("Exit rates: " << modelComponents.exitRates);
+            STORM_LOG_TRACE("Markovian states: " << modelComponents.markovianStates);
             
             // Build state labeling
             modelComponents.stateLabeling = storm::models::sparse::StateLabeling(mStates.size() + (mergeFailedStates ? 1 : 0));

From e322c568207240e1327963c7c42d03b0d232ee17 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 2 Mar 2016 15:30:00 +0100
Subject: [PATCH 193/246] findModularisationRewrite

Former-commit-id: ba948b7720f6742a8ebe2f101f17c422b30b24ab
---
 src/storage/dft/DFT.cpp | 35 +++++++++++++++++++++++++++++++++++
 src/storage/dft/DFT.h   |  2 ++
 src/storm-dyftee.cpp    |  8 ++++++++
 3 files changed, 45 insertions(+)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index bf68a095c..890e2de25 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -436,6 +436,41 @@ namespace storm {
             }
             return DFTIndependentSymmetries(res);
         }
+        
+        template<typename ValueType>
+        std::vector<size_t> DFT<ValueType>::findModularisationRewrite() const {
+           for(auto const& e : mElements) {
+               if(e->isGate() && (e->type() == DFTElementType::AND || e->type() == DFTElementType::OR) ) {
+                   // suitable parent gate! - Lets check the independent submodules of the children
+                   auto const& children = std::static_pointer_cast<DFTGate<ValueType>>(e)->children();
+                   for(auto const& child : children) {
+                       //std::cout << "check idea for: " << child->id() << std::endl;;
+                       auto ISD = std::static_pointer_cast<DFTGate<ValueType>>(child)->independentSubDft(true);
+                       // In the ISD, check for other children:
+                       //std::cout << "** subdft = ";
+                       for(auto const& isdelemid : ISD) {
+                           std::cout << isdelemid << " ";
+                       }
+                       std::cout << std::endl;
+                       
+                       std::vector<size_t> rewrite = {e->id(), child->id()};
+                       for(size_t isdElemId : ISD) {
+                           if(isdElemId == child->id()) continue;
+                           if(std::find_if(children.begin(), children.end(), [&isdElemId](std::shared_ptr<DFTElement<ValueType>> const& e) { return e->id() == isdElemId; } ) != children.end()) {
+                               //std::cout << "** found child in subdft: " <<  isdElemId << std::endl;
+                               rewrite.push_back(isdElemId);
+                           }
+                       }
+                       if(rewrite.size() > 2) {
+                           return rewrite;
+                       }
+                       
+                   }    
+               }
+           } 
+           return {};
+        }
+    
 
         template<typename ValueType>
         std::pair<std::vector<size_t>, std::vector<size_t>> DFT<ValueType>::getSortedParentAndOutDepIds(size_t index) const {
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 32e807197..75092e479 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -236,6 +236,8 @@ namespace storm {
             DFTIndependentSymmetries findSymmetries(DFTColouring<ValueType> const& colouring) const;
 
             std::vector<size_t> immediateFailureCauses(size_t index) const;
+            
+            std::vector<size_t> findModularisationRewrite() const;
         private:
             std::pair<std::vector<size_t>, std::vector<size_t>> getSortedParentAndOutDepIds(size_t index) const;
             
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 13b43f5ff..c5997ddd3 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -29,6 +29,14 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     std::vector<std::shared_ptr<const storm::logic::Formula>> formulas(parsedFormulas.begin(), parsedFormulas.end());
     assert(formulas.size() == 1);
     std::cout << "Parsed formula." << std::endl;
+    auto modIdea = dft.findModularisationRewrite();
+    std::cout << "Modularisation idea: " << std::endl;
+    
+    for( auto const& i  : modIdea ) {
+        std::cout << i << ", ";
+    }
+    std::cout << std::endl;
+    
     std::map<size_t, std::vector<std::vector<size_t>>> emptySymmetry;
     storm::storage::DFTIndependentSymmetries symmetries(emptySymmetry);
     if(symred) {

From a6f8ba37168df42233eb5f33245514cd8d214165 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 2 Mar 2016 15:30:22 +0100
Subject: [PATCH 194/246] seq examples

Former-commit-id: 42c0f279b9c8dee9e8c03f342e42a58cf738ff5b
---
 examples/dft/seq1.dft | 2 +-
 examples/dft/seq2.dft | 6 ++++++
 examples/dft/seq3.dft | 6 ++++++
 examples/dft/seq3.txt | 6 ++++++
 examples/dft/seq4.dft | 6 ++++++
 examples/dft/seq5.dft | 7 +++++++
 examples/dft/seq6.dft | 8 ++++++++
 7 files changed, 40 insertions(+), 1 deletion(-)
 create mode 100644 examples/dft/seq2.dft
 create mode 100644 examples/dft/seq3.dft
 create mode 100644 examples/dft/seq3.txt
 create mode 100644 examples/dft/seq4.dft
 create mode 100644 examples/dft/seq5.dft
 create mode 100644 examples/dft/seq6.dft

diff --git a/examples/dft/seq1.dft b/examples/dft/seq1.dft
index 8f5459fd2..6fd99bc3b 100644
--- a/examples/dft/seq1.dft
+++ b/examples/dft/seq1.dft
@@ -1,5 +1,5 @@
 toplevel "A";
 "A" and "B" "C";
-"X" seq "B" "C";
+"X" seq "B" "C"
 "B" lambda=0.5 dorm=0.3;
 "C" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/seq2.dft b/examples/dft/seq2.dft
new file mode 100644
index 000000000..408d4c26d
--- /dev/null
+++ b/examples/dft/seq2.dft
@@ -0,0 +1,6 @@
+toplevel "A";
+"A" and "B" "C" "D";
+"X" seq "B" "C" "D";
+"B" lambda=0.5 dorm=0.3;
+"C" lambda=0.5 dorm=0.3;
+"D" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/seq3.dft b/examples/dft/seq3.dft
new file mode 100644
index 000000000..b22b9e8b6
--- /dev/null
+++ b/examples/dft/seq3.dft
@@ -0,0 +1,6 @@
+toplevel "A";
+"A" and "C" "D";
+"X" seq "B" "C" "D";
+"B" lambda=0.5 dorm=0.3;
+"C" lambda=0.5 dorm=0.3;
+"D" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/seq3.txt b/examples/dft/seq3.txt
new file mode 100644
index 000000000..b22b9e8b6
--- /dev/null
+++ b/examples/dft/seq3.txt
@@ -0,0 +1,6 @@
+toplevel "A";
+"A" and "C" "D";
+"X" seq "B" "C" "D";
+"B" lambda=0.5 dorm=0.3;
+"C" lambda=0.5 dorm=0.3;
+"D" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/seq4.dft b/examples/dft/seq4.dft
new file mode 100644
index 000000000..260a88266
--- /dev/null
+++ b/examples/dft/seq4.dft
@@ -0,0 +1,6 @@
+toplevel "A";
+"A" or "C" "D";
+"X" seq "B" "C" "D";
+"B" lambda=0.5 dorm=0.3;
+"C" lambda=0.5 dorm=0.3;
+"D" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/seq5.dft b/examples/dft/seq5.dft
new file mode 100644
index 000000000..60bf149af
--- /dev/null
+++ b/examples/dft/seq5.dft
@@ -0,0 +1,7 @@
+toplevel "A";
+"A" and "T1" "B3";
+"T1" or "B1" "B2";
+"X" seq "B1" "B2" "B3";
+"B1" lambda=0.5 dorm=0.3;
+"B2" lambda=0.5 dorm=0.3;
+"B3" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/seq6.dft b/examples/dft/seq6.dft
new file mode 100644
index 000000000..8453cb411
--- /dev/null
+++ b/examples/dft/seq6.dft
@@ -0,0 +1,8 @@
+toplevel "A";
+"A" and "T1" "T2";
+"T1" pand "B1" "B2"; 
+"T2" pand "B3" "B4;
+"B1" lambda=0.7 dorm=0.3;
+"B2" lambda=0.5 dorm=0.3;
+"B3" lambda=0.5 dorm=0.3;
+"B4" lambda=0.7 dorm=0.3;

From 52573c90ca6886dfeef45e84be3ef695d9bef3e9 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 2 Mar 2016 16:10:47 +0100
Subject: [PATCH 195/246] Copy DFT

Former-commit-id: 97eb17a5d9c34d8212f8431de52405442248f537
---
 src/storage/dft/DFT.cpp           | 90 ++++++++++++++++++++++++++++++-
 src/storage/dft/DFT.h             |  9 ++++
 src/storage/dft/DFTBuilder.cpp    | 85 ++++++++++++++++++++++++++++-
 src/storage/dft/DFTBuilder.h      | 25 +++++++--
 src/storage/dft/elements/DFTVot.h |  4 ++
 src/storm-dyftee.cpp              |  3 ++
 6 files changed, 210 insertions(+), 6 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index bf68a095c..a4a15947c 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -2,6 +2,7 @@
 
 #include <map>
 #include "DFT.h"
+#include "DFTBuilder.h"
 #include "src/exceptions/NotSupportedException.h"
 
 #include "DFTIsomorphism.h"
@@ -228,7 +229,87 @@ namespace storm {
             }
             return stateIndex;
         }
-
+        
+        template<typename ValueType>
+        DFT<ValueType> DFT<ValueType>::optimize() const {
+            std::vector<std::vector<size_t>> rewriteIds = findModulesRewrite();
+            if (rewriteIds.empty()) {
+                // No rewrite needed
+                return *this;
+            }
+            
+            DFTBuilder<ValueType> builder;
+            
+            // Accumulate elements which must be rewritten
+            std::set<size_t> rewriteSet;
+            for (std::vector<size_t> rewrites : rewriteIds) {
+                rewriteSet.insert(rewrites.front());
+            }
+            // Copy all other elements which do not change
+            for (auto elem : mElements) {
+                if (rewriteSet.count(elem->id()) == 0) {
+                    builder.copyElement(elem);
+                }
+            }
+            
+            // Add rewritten elements
+            for (std::vector<size_t> rewrites : rewriteIds) {
+                assert(rewrites.size() > 1);
+                assert(mElements[rewrites[1]]->hasParents());
+                assert(mElements[rewrites[1]]->parents().front()->isGate());
+                DFTGatePointer originalParent = std::static_pointer_cast<DFTGate<ValueType>>(mElements[rewrites[1]]->parents().front());
+                std::string newParentName = builder.getUniqueName(originalParent->name());
+                
+                // Accumulate children names
+                std::vector<std::string> childrenNames;
+                for (size_t i = 1; i < rewrites.size(); ++i) {
+                    assert(mElements[rewrites[i]]->parents().front()->id() == originalParent->id()); // Children have the same father
+                    childrenNames.push_back(mElements[rewrites[i]]->name());
+                }
+                
+                // Add element inbetween parent and children
+                switch (originalParent->type()) {
+                    case DFTElementType::AND:
+                        builder.addAndElement(newParentName, childrenNames);
+                        break;
+                    case DFTElementType::OR:
+                        builder.addOrElement(newParentName, childrenNames);
+                        break;
+                    case DFTElementType::BE:
+                    case DFTElementType::CONSTF:
+                    case DFTElementType::CONSTS:
+                    case DFTElementType::VOT:
+                    case DFTElementType::PAND:
+                    case DFTElementType::SPARE:
+                    case DFTElementType::POR:
+                    case DFTElementType::PDEP:
+                    case DFTElementType::SEQ:
+                    case DFTElementType::MUTEX:
+                        // Other elements are not supported
+                        assert(false);
+                        break;
+                    default:
+                        assert(false);
+                }
+                
+                // Add parent with the new child newParent and all its remaining children
+                childrenNames.clear();
+                childrenNames.push_back(newParentName);
+                for (auto const& child : originalParent->children()) {
+                    if (std::find(rewrites.begin()+1, rewrites.end(), child->id()) == rewrites.end()) {
+                        // Child was not rewritten and must be kept
+                        childrenNames.push_back(child->name());
+                    }
+                }
+                builder.copyGate(originalParent, childrenNames);
+            }
+            
+            builder.setTopLevel(mElements[mTopLevelIndex]->name());
+            // TODO use reference?
+            DFT<ValueType> newDft = builder.build();
+            return newDft.optimize();
+        }
+        
         template<typename ValueType>
         std::string DFT<ValueType>::getElementsString() const {
             std::stringstream stream;
@@ -449,6 +530,13 @@ namespace storm {
             return res;
         }
         
+        template<typename ValueType>
+        std::vector<std::vector<size_t>> DFT<ValueType>::findModulesRewrite() const {
+            std::vector<std::vector<size_t>> modulesRewrite;
+            // TODO write
+            return modulesRewrite;
+        }
+        
 
         // Explicitly instantiate the class.
         template class DFT<double>;
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 32e807197..557914d7e 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -34,6 +34,8 @@ namespace storm {
 
         // Forward declarations
         template<typename T> class DFTColouring;
+        
+        template<typename T> class DFTBuilder;
 
         
         
@@ -72,6 +74,10 @@ namespace storm {
             size_t generateStateInfo(DFTStateGenerationInfo& generationInfo, size_t id, storm::storage::BitVector& visited, size_t stateIndex) const;
 
             size_t performStateGenerationInfoDFS(DFTStateGenerationInfo& generationInfo, std::queue<size_t>& visitQueue, storm::storage::BitVector& visited, size_t stateIndex) const;
+        
+            DFT<ValueType> optimize() const;
+            
+            void copyElements(std::vector<size_t> elements, DFTBuilder<ValueType> builder) const;
             
             size_t stateVectorSize() const {
                 return mStateVectorSize;
@@ -236,6 +242,9 @@ namespace storm {
             DFTIndependentSymmetries findSymmetries(DFTColouring<ValueType> const& colouring) const;
 
             std::vector<size_t> immediateFailureCauses(size_t index) const;
+            
+            std::vector<std::vector<size_t>> findModulesRewrite() const;
+            
         private:
             std::pair<std::vector<size_t>, std::vector<size_t>> getSortedParentAndOutDepIds(size_t index) const;
             
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index 08d85d879..f3d83e4c0 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -70,7 +70,8 @@ namespace storm {
             for(DFTElementPointer e : elems) {
                 e->setId(id++);
             }
-            return DFT<ValueType>(elems, mElements[topLevelIdentifier]);
+            assert(!mTopLevelIdentifier.empty());
+            return DFT<ValueType>(elems, mElements[mTopLevelIdentifier]);
         }
 
         template<typename ValueType>
@@ -180,7 +181,6 @@ namespace storm {
             }
         }
 
-        // TODO Matthias: use typedefs
         template<typename ValueType>
         std::vector<std::shared_ptr<DFTElement<ValueType>>> DFTBuilder<ValueType>::topoSort() {
             std::map<DFTElementPointer, topoSortColour, OrderElementsById<ValueType>> visited;
@@ -195,6 +195,87 @@ namespace storm {
             //std::reverse(L.begin(), L.end()); 
             return L;
         }
+        
+        template<typename ValueType>
+        std::string DFTBuilder<ValueType>::getUniqueName(std::string name) {
+            return name + "_" + std::to_string(++mUniqueOffset);
+        }
+        
+        template<typename ValueType>
+        void DFTBuilder<ValueType>::copyElement(DFTElementPointer element) {
+            std::vector<std::string> children;
+            switch (element->type()) {
+                case DFTElementType::AND:
+                case DFTElementType::OR:
+                case DFTElementType::PAND:
+                case DFTElementType::POR:
+                case DFTElementType::SPARE:
+                case DFTElementType::VOT:
+                {
+                    for (DFTElementPointer const& elem : std::static_pointer_cast<DFTGate<ValueType>>(element)->children()) {
+                        children.push_back(elem->name());
+                    }
+                    copyGate(std::static_pointer_cast<DFTGate<ValueType>>(element), children);
+                    break;
+                }
+                case DFTElementType::BE:
+                {
+                    std::shared_ptr<DFTBE<ValueType>> be = std::static_pointer_cast<DFTBE<ValueType>>(element);
+                    ValueType dormancyFactor = storm::utility::zero<ValueType>();
+                    if (!storm::utility::isZero(be->passiveFailureRate())) {
+                        dormancyFactor = be->activeFailureRate() / be->passiveFailureRate();
+                    }
+                    addBasicElement(be->name(), be->activeFailureRate(), dormancyFactor);
+                    break;
+                }
+                case DFTElementType::CONSTF:
+                case DFTElementType::CONSTS:
+                    // TODO
+                    assert(false);
+                    break;
+                case DFTElementType::PDEP:
+                {
+                    DFTDependencyPointer dependency = std::static_pointer_cast<DFTDependency<ValueType>>(element);
+                    children.push_back(dependency->triggerEvent()->name());
+                    children.push_back(dependency->dependentEvent()->name());
+                    addDepElement(element->name(), children, dependency->probability());
+                    break;
+                }
+                case DFTElementType::SEQ:
+                case DFTElementType::MUTEX:
+                {
+                    for (DFTElementPointer const& elem : std::static_pointer_cast<DFTRestriction<ValueType>>(element)->children()) {
+                        children.push_back(elem->name());
+                    }
+                    addRestriction(element->name(), children, element->type());
+                    break;
+                }
+                default:
+                    assert(false);
+                    break;
+            }
+        }
+
+        template<typename ValueType>
+        void DFTBuilder<ValueType>::copyGate(DFTGatePointer gate, std::vector<std::string> const& children) {
+            switch (gate->type()) {
+                case DFTElementType::AND:
+                case DFTElementType::OR:
+                case DFTElementType::PAND:
+                case DFTElementType::POR:
+                case DFTElementType::SPARE:
+                    addStandardGate(gate->name(), children, gate->type());
+                    break;
+                case DFTElementType::VOT:
+                    addVotElement(gate->name(), std::static_pointer_cast<DFTVot<ValueType>>(gate)->threshold(), children);
+                    break;
+                default:
+                    assert(false);
+                    break;
+            }
+        }
+
+
 
         // Explicitly instantiate the class.
         template class DFTBuilder<double>;
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index 8ef0d6cf1..6c6fcc143 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -26,7 +26,8 @@ namespace storm {
 
         private:
             std::size_t mNextId = 0;
-            std::string topLevelIdentifier;
+            std::size_t mUniqueOffset = 0;
+            std::string mTopLevelIdentifier;
             std::unordered_map<std::string, DFTElementPointer> mElements;
             std::unordered_map<DFTElementPointer, std::vector<std::string>> mChildNames;
             std::unordered_map<DFTRestrictionPointer, std::vector<std::string>> mRestrictionChildNames;
@@ -140,18 +141,36 @@ namespace storm {
             }
             
             bool setTopLevel(std::string const& tle) {
-                topLevelIdentifier = tle;
+                mTopLevelIdentifier = tle;
                 return mElements.count(tle) > 0;
             }
             
+            std::string getUniqueName(std::string name);
+            
             DFT<ValueType> build();
+            
+            /**
+             * Copy element and insert it again in the builder.
+             *
+             * @param element Element to copy.
+             */
+            void copyElement(DFTElementPointer element);
+
+            /**
+             * Copy gate with given children and insert it again in the builder. The current children of the element
+             * are discarded.
+             *
+             * @param gate Gate to copy.
+             * @param children New children of copied element.
+             */
+            void copyGate(DFTGatePointer gate, std::vector<std::string> const& children);
 
-         
         private:
             
             unsigned computeRank(DFTElementPointer const& elem);
             
             bool addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementType tp);
+
             bool addRestriction(std::string const& name, std::vector<std::string> const& children, DFTElementType tp);
 
             enum class topoSortColour {WHITE, BLACK, GREY}; 
diff --git a/src/storage/dft/elements/DFTVot.h b/src/storage/dft/elements/DFTVot.h
index 0233d979d..776055848 100644
--- a/src/storage/dft/elements/DFTVot.h
+++ b/src/storage/dft/elements/DFTVot.h
@@ -51,6 +51,10 @@ namespace storm {
                     }
                 }
             }
+            
+            unsigned threshold() const {
+                return mThreshold;
+            }
 
             virtual DFTElementType type() const override {
                 return DFTElementType::VOT;
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 13b43f5ff..6240bf374 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -29,6 +29,9 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     std::vector<std::shared_ptr<const storm::logic::Formula>> formulas(parsedFormulas.begin(), parsedFormulas.end());
     assert(formulas.size() == 1);
     std::cout << "Parsed formula." << std::endl;
+    
+    dft = dft.optimize();
+    
     std::map<size_t, std::vector<std::vector<size_t>>> emptySymmetry;
     storm::storage::DFTIndependentSymmetries symmetries(emptySymmetry);
     if(symred) {

From f12e02f8ff0c2543a4207cef4ec4f91ef2fee086 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Wed, 2 Mar 2016 17:14:50 +0100
Subject: [PATCH 196/246] dont modularise modules

Former-commit-id: 90f95b2065c1c0d25eea32c3b27b95f3611a7fd4
---
 src/storage/dft/DFT.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 890e2de25..4d6e88d0f 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -461,7 +461,7 @@ namespace storm {
                                rewrite.push_back(isdElemId);
                            }
                        }
-                       if(rewrite.size() > 2) {
+                       if(rewrite.size() > 2 && rewrite.size() < e->children().size() - 1) {
                            return rewrite;
                        }
                        

From 28a49659dbbf5cb81cdc3c9d8acd0b3e6ba25261 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 2 Mar 2016 17:36:56 +0100
Subject: [PATCH 197/246] Small fixes

Former-commit-id: ee8ef605c370ba7219335e0cc48c5c82861bf471
---
 src/storage/dft/DFT.cpp        | 2 +-
 src/storage/dft/DFTBuilder.cpp | 3 +++
 src/storage/dft/DFTBuilder.h   | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 2a0bfa244..242995834 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -551,7 +551,7 @@ namespace storm {
                                rewrite.push_back(isdElemId);
                            }
                        }
-                       if(rewrite.size() > 2 && rewrite.size() < e->children().size() - 1) {
+                       if(rewrite.size() > 2 && rewrite.size() < children.size() - 1) {
                            return rewrite;
                        }
                        
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index f3d83e4c0..ea273e234 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -12,6 +12,9 @@
 
 namespace storm {
     namespace storage {
+        
+        template<typename ValueType>
+        std::size_t DFTBuilder<ValueType>::mUniqueOffset = 0;
 
         template<typename ValueType>
         DFT<ValueType> DFTBuilder<ValueType>::build() {
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index 6c6fcc143..d630c24fb 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -26,7 +26,7 @@ namespace storm {
 
         private:
             std::size_t mNextId = 0;
-            std::size_t mUniqueOffset = 0;
+            static std::size_t mUniqueOffset;
             std::string mTopLevelIdentifier;
             std::unordered_map<std::string, DFTElementPointer> mElements;
             std::unordered_map<DFTElementPointer, std::vector<std::string>> mChildNames;

From 3f41aa55f802c14b454497975d5a35817c4a0052 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 3 Mar 2016 14:57:51 +0100
Subject: [PATCH 198/246] Cleaned up debug output

Former-commit-id: daabe84596916b55b1cc0716a2ba736c726336eb
---
 .../SparseDtmcEliminationModelChecker.cpp     |  2 +
 src/storage/dft/DFT.cpp                       | 23 ++++-------
 src/storage/dft/DFTIsomorphism.h              |  4 +-
 src/storage/dft/SymmetricUnits.h              |  8 ++--
 src/storm-dyftee.cpp                          | 40 ++++++++++++-------
 src/utility/vector.h                          | 20 ++++++++++
 6 files changed, 60 insertions(+), 37 deletions(-)

diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
index ecf795182..db972f49a 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
@@ -1233,6 +1233,8 @@ namespace storm {
         
         template class StatePriorityQueue<double>;
         template class SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<double>>;
+        template uint_fast64_t estimateComplexity(double const& value);
+            
             
 #ifdef STORM_HAVE_CARL
         template class StatePriorityQueue<storm::RationalFunction>;
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 242995834..c40fadceb 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -7,6 +7,7 @@
 
 #include "DFTIsomorphism.h"
 #include "utility/iota_n.h"
+#include "utility/vector.h"
 
 namespace storm {
     namespace storage {
@@ -233,12 +234,8 @@ namespace storm {
         template<typename ValueType>
         DFT<ValueType> DFT<ValueType>::optimize() const {
             std::vector<size_t> modIdea = findModularisationRewrite();
-            std::cout << "Modularisation idea: " << std::endl;
-    
-            for( auto const& i  : modIdea ) {
-                std::cout << i << ", ";
-            }
-
+            STORM_LOG_DEBUG("Modularisation idea: " << storm::utility::vector::toString(modIdea));
+            
             if (modIdea.empty()) {
                 // No rewrite needed
                 return *this;
@@ -316,6 +313,7 @@ namespace storm {
             builder.setTopLevel(mElements[mTopLevelIndex]->name());
             // TODO use reference?
             DFT<ValueType> newDft = builder.build();
+            STORM_LOG_TRACE(newDft.getElementsString());
             return newDft.optimize();
         }
         
@@ -487,20 +485,20 @@ namespace storm {
                             std::sort(sortedParent2Ids.begin(), sortedParent2Ids.end());
                             
                             if(influencedElem1Ids == getSortedParentAndOutDepIds(*it2)) {
-                                std::cout << "Considering ids " << *it1 << ", " << *it2 << " for isomorphism." << std::endl;
+                                STORM_LOG_TRACE("Considering ids " << *it1 << ", " << *it2 << " for isomorphism.");
                                 bool isSymmetry = false;
                                 std::vector<size_t> isubdft1 = getGate(*it1)->independentSubDft(false);
                                 std::vector<size_t> isubdft2 = getGate(*it2)->independentSubDft(false);
                                 if(isubdft1.empty() || isubdft2.empty() || isubdft1.size() != isubdft2.size()) {
                                     continue;
                                 }
-                                std::cout << "Checking subdfts from " << *it1 << ", " << *it2 << " for isomorphism." << std::endl;
+                                STORM_LOG_TRACE("Checking subdfts from " << *it1 << ", " << *it2 << " for isomorphism.");
                                 auto LHS = colouring.colourSubdft(isubdft1);
                                 auto RHS = colouring.colourSubdft(isubdft2);
                                 auto IsoCheck = DFTIsomorphismCheck<ValueType>(LHS, RHS, *this);
                                 isSymmetry = IsoCheck.findIsomorphism();
                                 if(isSymmetry) {
-                                    std::cout << "subdfts are symmetric" << std::endl;
+                                    STORM_LOG_TRACE("Subdfts are symmetric");
                                     foundEqClassFor.insert(*it2);
                                     if(symClass.empty()) {
                                         for(auto const& i : isubdft1) {
@@ -534,20 +532,13 @@ namespace storm {
                    // suitable parent gate! - Lets check the independent submodules of the children
                    auto const& children = std::static_pointer_cast<DFTGate<ValueType>>(e)->children();
                    for(auto const& child : children) {
-                       //std::cout << "check idea for: " << child->id() << std::endl;;
                        auto ISD = std::static_pointer_cast<DFTGate<ValueType>>(child)->independentSubDft(true);
                        // In the ISD, check for other children:
-                       //std::cout << "** subdft = ";
-                       for(auto const& isdelemid : ISD) {
-                           std::cout << isdelemid << " ";
-                       }
-                       std::cout << std::endl;
                        
                        std::vector<size_t> rewrite = {e->id(), child->id()};
                        for(size_t isdElemId : ISD) {
                            if(isdElemId == child->id()) continue;
                            if(std::find_if(children.begin(), children.end(), [&isdElemId](std::shared_ptr<DFTElement<ValueType>> const& e) { return e->id() == isdElemId; } ) != children.end()) {
-                               //std::cout << "** found child in subdft: " <<  isdElemId << std::endl;
                                rewrite.push_back(isdElemId);
                            }
                        }
diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
index 542fa954a..b1f845b9f 100644
--- a/src/storage/dft/DFTIsomorphism.h
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -249,7 +249,7 @@ namespace storage {
         }
 
         void colourize(std::shared_ptr<const DFTGate<ValueType>> const& gate) {
-             std::cout <<  "Colour " << gate->id() << ": "  << gate->type() << " " << gate->nrChildren() << " " << gate->rank() << "." << std::endl;
+             STORM_LOG_TRACE("Colour " << gate->id() << ": "  << gate->type() << " " << gate->nrChildren() << " " << gate->rank() << ".");
              gateColour[gate->id()] = gateColourizer(gate->type(), gate->nrChildren(), gate->nrParents(), 0, gate->rank());
         }
         
@@ -336,7 +336,7 @@ namespace storage {
             initializePermutationsAndTreatTrivialGroups(bleft.gateCandidates, bright.gateCandidates, currentPermutations.gateCandidates);
             initializePermutationsAndTreatTrivialGroups(bleft.pdepCandidates, bright.pdepCandidates, currentPermutations.pdepCandidates);
             initializePermutationsAndTreatTrivialGroups(bleft.restrictionCandidates, bright.restrictionCandidates, currentPermutations.restrictionCandidates);
-            std::cout << bijection.size() << " vs. " << bleft.size() << " vs. " << bright.size() << std::endl;
+            STORM_LOG_TRACE(bijection.size() << " vs. " << bleft.size() << " vs. " << bright.size());
             assert(bijection.size() == bleft.size());
             
         }
diff --git a/src/storage/dft/SymmetricUnits.h b/src/storage/dft/SymmetricUnits.h
index 6521ee8d2..58a70e492 100644
--- a/src/storage/dft/SymmetricUnits.h
+++ b/src/storage/dft/SymmetricUnits.h
@@ -12,16 +12,14 @@ namespace storm {
         
         inline std::ostream& operator<<(std::ostream& os, DFTIndependentSymmetries const& s)  {
             for(auto const& cl : s.groups) {
-                std::cout << "SYM GROUP FOR " << cl.first << std::endl;
+                os << "Symmetry group for " << cl.first << std::endl;
                 for(auto const& eqClass : cl.second) {
                     for(auto const& i : eqClass) {
-                        std::cout << i << " ";
+                        os << i << " ";
                     }
-                    std::cout << std::endl;
+                    os << std::endl;
                 }
             }
-            
-            
             return os;
         }
     }
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 6240bf374..49f97b76b 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -20,53 +20,65 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     manager.setFromString("");
 
     // Parsing DFT
-    std::cout << "Parsing DFT file..." << std::endl;
+    std::chrono::high_resolution_clock::time_point parsingStart = std::chrono::high_resolution_clock::now();
     storm::parser::DFTGalileoParser<ValueType> parser;
     storm::storage::DFT<ValueType> dft = parser.parseDFT(filename);
-    std::cout << "Built data structure" << std::endl;
-    std::cout << "Parse formula..." << std::endl;
     std::vector<std::shared_ptr<storm::logic::Formula>> parsedFormulas = storm::parseFormulasForExplicit(property);
     std::vector<std::shared_ptr<const storm::logic::Formula>> formulas(parsedFormulas.begin(), parsedFormulas.end());
     assert(formulas.size() == 1);
-    std::cout << "Parsed formula." << std::endl;
     
+    // Optimize DFT
     dft = dft.optimize();
-    
     std::map<size_t, std::vector<std::vector<size_t>>> emptySymmetry;
     storm::storage::DFTIndependentSymmetries symmetries(emptySymmetry);
     if(symred) {
         auto colouring = dft.colourDFT();
         symmetries = dft.findSymmetries(colouring);
-        std::cout << "Symmetries: " << symmetries << std::endl;
+        std::cout << "Found " << symmetries.groups.size() << " symmetries." << std::endl;
+        STORM_LOG_TRACE("Symmetries: " << std::endl << symmetries);
     }
-        
+    std::chrono::high_resolution_clock::time_point parsingEnd = std::chrono::high_resolution_clock::now();
+    
     // Building Markov Automaton
     std::cout << "Building Model..." << std::endl;
     storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft, symmetries);
     typename storm::builder::ExplicitDFTModelBuilder<ValueType>::LabelOptions labeloptions; // TODO initialize this with the formula
     std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildModel(labeloptions);
-    std::cout << "Built Model" << std::endl;
-
-    
-    model->printModelInformationToStream(std::cout);
+    //model->printModelInformationToStream(std::cout);
     std::cout << "No. states (Explored): " << model->getNumberOfStates() << std::endl;
     std::cout << "No. transitions (Explored): " << model->getNumberOfTransitions() << std::endl;
+    std::chrono::high_resolution_clock::time_point explorationEnd = std::chrono::high_resolution_clock::now();
     
+    // Bisimulation
     if (model->isOfType(storm::models::ModelType::Ctmc)) {
         std::cout << "Bisimulation..." << std::endl;
         model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), formulas, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
-        model->printModelInformationToStream(std::cout);
+        //model->printModelInformationToStream(std::cout);
     }
-    
     std::cout << "No. states (Bisimulation): " << model->getNumberOfStates() << std::endl;
     std::cout << "No. transitions (Bisimulation): " << model->getNumberOfTransitions() << std::endl;
+    std::chrono::high_resolution_clock::time_point bisimulationEnd = std::chrono::high_resolution_clock::now();
     
     // Model checking
     std::cout << "Model checking..." << std::endl;
     std::unique_ptr<storm::modelchecker::CheckResult> result(storm::verifySparseModel(model, formulas[0]));
     assert(result);
-    std::cout << "Result: ";
     result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
+    
+    // Times
+    std::chrono::high_resolution_clock::time_point modelCheckingEnd = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> parsingTime = parsingEnd - parsingStart;
+    std::chrono::duration<double> explorationTime = explorationEnd - parsingEnd;
+    std::chrono::duration<double> bisimulationTime = bisimulationEnd - explorationEnd;
+    std::chrono::duration<double> modelCheckingTime = modelCheckingEnd - bisimulationEnd;
+    std::chrono::duration<double> totalTime = modelCheckingEnd - parsingStart;
+    std::cout << "Times:" << std::endl;
+    std::cout << "Parsing:\t" << parsingTime.count() << std::endl;
+    std::cout << "Exploration:\t" << explorationTime.count() << std::endl;
+    std::cout << "Bisimulaton:\t" << bisimulationTime.count() << std::endl;
+    std::cout << "Modelchecking:\t" << modelCheckingTime.count() << std::endl;
+    std::cout << "Total:\t\t" << totalTime.count() << std::endl;
+    std::cout << "Result: ";
     std::cout << *result << std::endl;
 }
 
diff --git a/src/utility/vector.h b/src/utility/vector.h
index aa526cf54..b5480de9b 100644
--- a/src/utility/vector.h
+++ b/src/utility/vector.h
@@ -705,6 +705,26 @@ namespace storm {
                 assert(result.size() == filter.getNumberOfSetBits());
                 return result;
             }
+            
+            /*!
+             * Output vector as string.
+             *
+             * @param vector Vector to output.
+             * @return String containing the representation of the vector.
+             */
+            template<typename ValueType>
+            std::string toString(std::vector<ValueType> vector) {
+                std::stringstream stream;
+                stream << "vector (" << vector.size() << ") [ ";
+                for (uint_fast64_t i = 0; i < vector.size() - 1; ++i) {
+                    stream << vector[i] << ", ";
+                }
+                if (!vector.empty()) {
+                    stream << vector.back();
+                }
+                stream << " ]";
+                return stream.str();
+            }
         } // namespace vector
     } // namespace utility
 } // namespace storm

From 796d7652df67dfcd38ca533371f36c65c00c0268 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 3 Mar 2016 18:49:00 +0100
Subject: [PATCH 199/246] Fixed problem with bounds in MA model checker

Former-commit-id: c40c4e479513338c7739d15d99aa75343761cfa7
---
 .../csl/SparseMarkovAutomatonCslModelChecker.cpp     | 12 ++++++++++--
 .../csl/helper/SparseMarkovAutomatonCslHelper.cpp    |  6 +-----
 .../csl/helper/SparseMarkovAutomatonCslHelper.h      |  2 +-
 src/utility/vector.h                                 |  6 +++---
 4 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.cpp b/src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.cpp
index da8d72c47..05e2cf823 100644
--- a/src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.cpp
+++ b/src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.cpp
@@ -45,8 +45,16 @@ namespace storm {
             STORM_LOG_THROW(this->getModel().isClosed(), storm::exceptions::InvalidPropertyException, "Unable to compute time-bounded reachability probabilities in non-closed Markov automaton.");
             std::unique_ptr<CheckResult> rightResultPointer = this->check(pathFormula.getRightSubformula());
             ExplicitQualitativeCheckResult const& rightResult = rightResultPointer->asExplicitQualitativeCheckResult();
-
-            std::vector<ValueType> result = storm::modelchecker::helper::SparseMarkovAutomatonCslHelper<ValueType>::computeBoundedUntilProbabilities(checkTask.getOptimizationDirection(), this->getModel().getTransitionMatrix(), this->getModel().getExitRates(), this->getModel().getMarkovianStates(), rightResult.getTruthValuesVector(), pathFormula.getIntervalBounds(), *minMaxLinearEquationSolverFactory);
+            double lowerBound = 0;
+            double upperBound = 0;
+            if (!pathFormula.hasDiscreteTimeBound()) {
+                std::pair<double, double> const& intervalBounds =  pathFormula.getIntervalBounds();
+                lowerBound = intervalBounds.first;
+                upperBound = intervalBounds.second;
+            } else {
+                upperBound = pathFormula.getDiscreteTimeBound();
+            }
+            std::vector<ValueType> result = storm::modelchecker::helper::SparseMarkovAutomatonCslHelper<ValueType>::computeBoundedUntilProbabilities(checkTask.getOptimizationDirection(), this->getModel().getTransitionMatrix(), this->getModel().getExitRates(), this->getModel().getMarkovianStates(), rightResult.getTruthValuesVector(), lowerBound, upperBound, *minMaxLinearEquationSolverFactory);
             return std::unique_ptr<CheckResult>(new ExplicitQuantitativeCheckResult<ValueType>(std::move(result)));
         }
                 
diff --git a/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp b/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp
index 95007a9e6..00a4e57c0 100644
--- a/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp
+++ b/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp
@@ -119,13 +119,9 @@ namespace storm {
             
 
             template<typename ValueType>
-            std::vector<ValueType> SparseMarkovAutomatonCslHelper<ValueType>::computeBoundedUntilProbabilities(OptimizationDirection dir, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& markovianStates, storm::storage::BitVector const& psiStates, std::pair<double, double> const& boundsPair, storm::utility::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory) {
+            std::vector<ValueType> SparseMarkovAutomatonCslHelper<ValueType>::computeBoundedUntilProbabilities(OptimizationDirection dir, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& markovianStates, storm::storage::BitVector const& psiStates, double lowerBound, double upperBound, storm::utility::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory) {
                 uint_fast64_t numberOfStates = transitionMatrix.getRowGroupCount();
                 
-                // 'Unpack' the bounds to make them more easily accessible.
-                double lowerBound = boundsPair.first;
-                double upperBound = boundsPair.second;
-                
                 // (1) Compute the accuracy we need to achieve the required error bound.
                 ValueType maxExitRate = 0;
                 for (auto value : exitRateVector) {
diff --git a/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.h b/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.h
index 5b24fe569..764eb542c 100644
--- a/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.h
+++ b/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.h
@@ -14,7 +14,7 @@ namespace storm {
             template <typename ValueType>
             class SparseMarkovAutomatonCslHelper {
             public:
-                static std::vector<ValueType> computeBoundedUntilProbabilities(OptimizationDirection dir, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& markovianStates, storm::storage::BitVector const& psiStates, std::pair<double, double> const& boundsPair, storm::utility::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory);
+                static std::vector<ValueType> computeBoundedUntilProbabilities(OptimizationDirection dir, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& markovianStates, storm::storage::BitVector const& psiStates, double lowerBound, double upperBound, storm::utility::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory);
                 
                 static std::vector<ValueType> computeUntilProbabilities(OptimizationDirection dir, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, bool qualitative, storm::utility::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory);
                 
diff --git a/src/utility/vector.h b/src/utility/vector.h
index b5480de9b..d9ad13e64 100644
--- a/src/utility/vector.h
+++ b/src/utility/vector.h
@@ -716,10 +716,10 @@ namespace storm {
             std::string toString(std::vector<ValueType> vector) {
                 std::stringstream stream;
                 stream << "vector (" << vector.size() << ") [ ";
-                for (uint_fast64_t i = 0; i < vector.size() - 1; ++i) {
-                    stream << vector[i] << ", ";
-                }
                 if (!vector.empty()) {
+                    for (uint_fast64_t i = 0; i < vector.size() - 1; ++i) {
+                        stream << vector[i] << ", ";
+                    }
                     stream << vector.back();
                 }
                 stream << " ]";

From ccec8b8f7a270bd2437e46a33d200f2473940372 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 7 Mar 2016 13:45:53 +0100
Subject: [PATCH 200/246] Renaming

Former-commit-id: f10a647dc53c2f598816e50a22a5fee736c35d8d
---
 src/storm-dyftee.cpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 49f97b76b..1f170072b 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -19,15 +19,15 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     storm::settings::SettingsManager& manager = storm::settings::mutableManager();
     manager.setFromString("");
 
-    // Parsing DFT
-    std::chrono::high_resolution_clock::time_point parsingStart = std::chrono::high_resolution_clock::now();
+    // Building DFT
+    std::chrono::high_resolution_clock::time_point buildingStart = std::chrono::high_resolution_clock::now();
     storm::parser::DFTGalileoParser<ValueType> parser;
     storm::storage::DFT<ValueType> dft = parser.parseDFT(filename);
     std::vector<std::shared_ptr<storm::logic::Formula>> parsedFormulas = storm::parseFormulasForExplicit(property);
     std::vector<std::shared_ptr<const storm::logic::Formula>> formulas(parsedFormulas.begin(), parsedFormulas.end());
     assert(formulas.size() == 1);
     
-    // Optimize DFT
+    // Optimizing DFT
     dft = dft.optimize();
     std::map<size_t, std::vector<std::vector<size_t>>> emptySymmetry;
     storm::storage::DFTIndependentSymmetries symmetries(emptySymmetry);
@@ -37,7 +37,7 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
         std::cout << "Found " << symmetries.groups.size() << " symmetries." << std::endl;
         STORM_LOG_TRACE("Symmetries: " << std::endl << symmetries);
     }
-    std::chrono::high_resolution_clock::time_point parsingEnd = std::chrono::high_resolution_clock::now();
+    std::chrono::high_resolution_clock::time_point buildingEnd = std::chrono::high_resolution_clock::now();
     
     // Building Markov Automaton
     std::cout << "Building Model..." << std::endl;
@@ -67,15 +67,15 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false)
     
     // Times
     std::chrono::high_resolution_clock::time_point modelCheckingEnd = std::chrono::high_resolution_clock::now();
-    std::chrono::duration<double> parsingTime = parsingEnd - parsingStart;
-    std::chrono::duration<double> explorationTime = explorationEnd - parsingEnd;
+    std::chrono::duration<double> buildingTime = buildingEnd - buildingStart;
+    std::chrono::duration<double> explorationTime = explorationEnd - buildingEnd;
     std::chrono::duration<double> bisimulationTime = bisimulationEnd - explorationEnd;
     std::chrono::duration<double> modelCheckingTime = modelCheckingEnd - bisimulationEnd;
-    std::chrono::duration<double> totalTime = modelCheckingEnd - parsingStart;
+    std::chrono::duration<double> totalTime = modelCheckingEnd - buildingStart;
     std::cout << "Times:" << std::endl;
-    std::cout << "Parsing:\t" << parsingTime.count() << std::endl;
+    std::cout << "Building:\t" << buildingTime.count() << std::endl;
     std::cout << "Exploration:\t" << explorationTime.count() << std::endl;
-    std::cout << "Bisimulaton:\t" << bisimulationTime.count() << std::endl;
+    std::cout << "Bisimulation:\t" << bisimulationTime.count() << std::endl;
     std::cout << "Modelchecking:\t" << modelCheckingTime.count() << std::endl;
     std::cout << "Total:\t\t" << totalTime.count() << std::endl;
     std::cout << "Result: ";

From 83b6496fd22b178278e1cc727b66fbe8d658bd9f Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 7 Mar 2016 17:25:20 +0100
Subject: [PATCH 201/246] Fixed bugs in BitVector

Former-commit-id: 8f1d5cbfac29ea2467d42c544d6ee883ae833981
---
 src/storage/BitVector.cpp | 51 ++++++++++++++++++++++++---------------
 1 file changed, 31 insertions(+), 20 deletions(-)

diff --git a/src/storage/BitVector.cpp b/src/storage/BitVector.cpp
index 572efea20..6bfd4ea5e 100644
--- a/src/storage/BitVector.cpp
+++ b/src/storage/BitVector.cpp
@@ -710,25 +710,26 @@ namespace storm {
             // Get remaining bits
             getValue = (bucketVector[bucketIndex] >> (64-remainingBits)) << (64-remainingBits);
             assert(remainingBits < 64);
-            if (remainingBits <= offset || offset == 0) {
-                // Write completely
-                assert(insertBucket == result.bucketCount()-1);
-                writeValue = getValue;
-                result.bucketVector[insertBucket] = writeValue;
-            } else {
-                // Remaining bits do not fit in value -> need new value
-                assert(insertBucket == result.bucketCount() - 2);
-                writeValue |= (getValue >> (64-offset));
-                result.bucketVector[insertBucket] = writeValue;
-                // Write last bits
-                writeValue = (getValue << (remainingBits-offset));
+            // Write bucket
+            assert(insertBucket <= result.bucketCount()-1);
+            writeValue |= getValue >> (64-offset);
+            result.bucketVector[insertBucket] = writeValue;
+            if (remainingBits >= offset) {
+                // Write last bits in new value
+                writeValue = (getValue << offset);
                 result.bucketVector[++insertBucket] = writeValue;
             }
 
 #ifdef ASSERT_BITVECTOR
             // Check correctness of getter
             for (uint_fast64_t i = 0; i < length; ++i) {
-                STORM_LOG_ASSERT(result.get(i) == get(start + i), "Getting of bits not correct for index " << i);
+                if (result.get(i) != get(start + i)) {
+                    std::cout << "Getting of bits not correct for index " << i << std::endl;
+                    std::cout << "Getting from " << start << " with length " << length << std::endl;
+                    printBits(std::cout);
+                    result.printBits(std::cout);
+                    assert(false);
+                }
             }
 #endif
             return result;
@@ -775,26 +776,36 @@ namespace storm {
             // Get remaining bits
             getValue = other.bucketVector[getBucket] << (64-offset);
             assert(remainingBits < 64);
-            if (remainingBits <= offset || offset == 0) {
+            if (remainingBits <= offset) {
                 // Write completely
                 assert(getBucket == other.bucketCount()-1);
-                getValue = (getValue >> (64-offset-remainingBits)) << (64-offset-remainingBits);
-                writeValue = (bucketVector[bucketIndex] << (offset+remainingBits)) >> (offset+remainingBits);
+                writeValue = (bucketVector[bucketIndex] << (offset+remainingBits)) >> remainingBits;
                 writeValue |= getValue;
                 bucketVector[bucketIndex] = writeValue;
             } else {
                 // Remaining bits do not come from one bucket -> consider two buckets
                 assert(getBucket == other.bucketCount() - 2);
-                getValue |= other.bucketVector[++getBucket] >> offset;
-                writeValue = (bucketVector[bucketIndex] << (offset+remainingBits)) >> (offset+remainingBits);
-                writeValue |= getValue;
+                writeValue = getValue;
+                getValue = other.bucketVector[++getBucket];
+                writeValue |= getValue >> offset;
+                bucketVector[bucketIndex] = writeValue;
+                remainingBits = remainingBits + offset - 64;
+                // Write last bucket
+                writeValue = (bucketVector[++bucketIndex] << remainingBits) >> remainingBits;
+                writeValue |= getValue << (64-offset);
                 bucketVector[bucketIndex] = writeValue;
             }
      
 #ifdef ASSERT_BITVECTOR
             // Check correctness of setter
             for (uint_fast64_t i = 0; i < other.bitCount; ++i) {
-                STORM_LOG_ASSERT(other.get(i) == get(start + i), "Setting of bits not correct for index " << i);
+                if (other.get(i) != get(start + i)) {
+                    std::cout << "Setting of bits not correct for index " << i << std::endl;
+                    std::cout << "Setting from " << start << " with length " << other.bitCount << std::endl;
+                    printBits(std::cout);
+                    other.printBits(std::cout);
+                    assert(false);
+                }
             }
 #endif
         }

From 811d04c2a705ea9289ed048caa68ce092da4c516 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 8 Mar 2016 13:29:31 +0100
Subject: [PATCH 202/246] Fixed bug in BitVector

Former-commit-id: ae967348791271d2fdac5b88dd58d9212e1918a7
---
 src/storage/BitVector.cpp | 82 ++++++++++++++++++++++++++-------------
 1 file changed, 55 insertions(+), 27 deletions(-)

diff --git a/src/storage/BitVector.cpp b/src/storage/BitVector.cpp
index 6bfd4ea5e..9ad566258 100644
--- a/src/storage/BitVector.cpp
+++ b/src/storage/BitVector.cpp
@@ -673,6 +673,9 @@ namespace storm {
         
         storm::storage::BitVector BitVector::getAsBitVector(uint_fast64_t start, uint_fast64_t length) const {
             assert(start + length <= bitCount);
+#ifdef ASSERT_BITVECTOR
+            BitVector original(*this);
+#endif
             storm::storage::BitVector result(length, false);
             
             uint_fast64_t offset = start % 64;
@@ -711,13 +714,18 @@ namespace storm {
             getValue = (bucketVector[bucketIndex] >> (64-remainingBits)) << (64-remainingBits);
             assert(remainingBits < 64);
             // Write bucket
-            assert(insertBucket <= result.bucketCount()-1);
-            writeValue |= getValue >> (64-offset);
-            result.bucketVector[insertBucket] = writeValue;
-            if (remainingBits >= offset) {
-                // Write last bits in new value
-                writeValue = (getValue << offset);
-                result.bucketVector[++insertBucket] = writeValue;
+            assert(insertBucket < result.bucketCount());
+            if (offset == 0) {
+                result.bucketVector[insertBucket]= getValue;
+            } else {
+                writeValue |= getValue >> (64-offset);
+                result.bucketVector[insertBucket] = writeValue;
+                if (remainingBits > offset) {
+                    // Write last bits in new value
+                    writeValue = (getValue << offset);
+                    assert(insertBucket+1 < result.bucketCount());
+                    result.bucketVector[++insertBucket] = writeValue;
+                }
             }
 
 #ifdef ASSERT_BITVECTOR
@@ -731,11 +739,26 @@ namespace storm {
                     assert(false);
                 }
             }
+            for (uint_fast64_t i = 0; i < bitCount; ++i) {
+                if (i < start || i >= start+length) {
+                    if (original.get(i) != get(i)) {
+                        std::cout << "Getting did change bitvector at index " << i << std::endl;
+                        std::cout << "Getting from " << start << " with length " << length << std::endl;
+                        printBits(std::cout);
+                        original.printBits(std::cout);
+                        assert(false);
+                    }
+                }
+            }
+
 #endif
             return result;
         }
         
         void BitVector::setFromBitVector(uint_fast64_t start, BitVector const& other) {
+#ifdef ASSERT_BITVECTOR
+            BitVector original(*this);
+#endif
             assert(start + other.bitCount <= bitCount);
             
             uint_fast64_t offset = start % 64;
@@ -771,30 +794,24 @@ namespace storm {
             
             // Write last bits
             uint_fast64_t remainingBits = other.bitCount - noBits;
+            assert(remainingBits < 64);
             assert(bucketIndex < bucketCount());
             assert(getBucket < other.bucketCount());
-            // Get remaining bits
-            getValue = other.bucketVector[getBucket] << (64-offset);
-            assert(remainingBits < 64);
-            if (remainingBits <= offset) {
-                // Write completely
-                assert(getBucket == other.bucketCount()-1);
-                writeValue = (bucketVector[bucketIndex] << (offset+remainingBits)) >> remainingBits;
-                writeValue |= getValue;
-                bucketVector[bucketIndex] = writeValue;
-            } else {
-                // Remaining bits do not come from one bucket -> consider two buckets
+            // Get remaining bits of bucket
+            getValue = other.bucketVector[getBucket];
+            if (offset > 0) {
+                getValue = getValue << (64-offset);
+            }
+            // Get unchanged part of bucket
+            writeValue = (bucketVector[bucketIndex] << remainingBits) >> remainingBits;
+            if (remainingBits > offset && offset > 0) {
+                // Remaining bits do not come from one bucket -> consider next bucket
                 assert(getBucket == other.bucketCount() - 2);
-                writeValue = getValue;
-                getValue = other.bucketVector[++getBucket];
-                writeValue |= getValue >> offset;
-                bucketVector[bucketIndex] = writeValue;
-                remainingBits = remainingBits + offset - 64;
-                // Write last bucket
-                writeValue = (bucketVector[++bucketIndex] << remainingBits) >> remainingBits;
-                writeValue |= getValue << (64-offset);
-                bucketVector[bucketIndex] = writeValue;
+                getValue |= other.bucketVector[++getBucket] >> offset;
             }
+            // Write completely
+            writeValue |= getValue;
+            bucketVector[bucketIndex] = writeValue;
      
 #ifdef ASSERT_BITVECTOR
             // Check correctness of setter
@@ -807,6 +824,17 @@ namespace storm {
                     assert(false);
                 }
             }
+            for (uint_fast64_t i = 0; i < bitCount; ++i) {
+                if (i < start || i >= start+other.bitCount) {
+                    if (original.get(i) != get(i)) {
+                        std::cout << "Setting did change bitvector at index " << i << std::endl;
+                        std::cout << "Setting from " << start << " with length " << other.bitCount << std::endl;
+                        printBits(std::cout);
+                        original.printBits(std::cout);
+                        assert(false);
+                    }
+                }
+            }
 #endif
         }
         

From 4284c633f4bbef188ef3d19713f0ba72c62a757e Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 10 Mar 2016 16:56:28 +0100
Subject: [PATCH 203/246] StateGenerationInfo does not use DFS for symmetries

Former-commit-id: 7111f5764a28aa38e3b7a751a8006a1e11fd0c8b
---
 src/storage/dft/DFT.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index c40fadceb..650712ebd 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -113,10 +113,11 @@ namespace storm {
                 for (auto const& symmetryGroup : symmetries.groups) {
                     assert(!symmetryGroup.second.empty());
 
-                    // Perform DFS for first subtree of each symmetry
-                    visitQueue.push(symmetryGroup.first);
+                    // Insert all elements of first subtree of each symmetry
                     size_t groupIndex = stateIndex;
-                    stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
+                    for (std::vector<size_t> const& symmetryElement : symmetryGroup.second) {
+                        stateIndex = generateStateInfo(generationInfo, symmetryElement[0], visited, stateIndex);
+                    }
                     size_t offset = stateIndex - groupIndex;
                     
                     // Mirror symmetries

From a2a3a734a605e74b00eab861261aa15e7e0756a1 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 11 Mar 2016 00:04:19 +0100
Subject: [PATCH 204/246] First version of symmetry for shared spares. Still
 some problems in contrast to Dortmund which had absolutely no problems with
 Tottenham.

Former-commit-id: c03062d4bd4b01f949cfa5c0660d5c4906a0f9d5
---
 examples/dft/symmetry_shared.dft          |   7 ++
 src/storage/dft/DFT.cpp                   | 116 ++++++++++++++++++----
 src/storage/dft/DFT.h                     |   2 +
 src/storage/dft/DFTIsomorphism.h          | 113 +++++++++++++++------
 src/storage/dft/elements/DFTBE.h          |   6 +-
 src/storage/dft/elements/DFTDependency.h  |  11 +-
 src/storage/dft/elements/DFTElement.cpp   |  10 +-
 src/storage/dft/elements/DFTElement.h     |   4 +-
 src/storage/dft/elements/DFTGate.h        |  10 +-
 src/storage/dft/elements/DFTRestriction.h |  10 +-
 src/storage/dft/elements/DFTSpare.h       |  39 ++++++++
 11 files changed, 251 insertions(+), 77 deletions(-)
 create mode 100644 examples/dft/symmetry_shared.dft

diff --git a/examples/dft/symmetry_shared.dft b/examples/dft/symmetry_shared.dft
new file mode 100644
index 000000000..73ebed519
--- /dev/null
+++ b/examples/dft/symmetry_shared.dft
@@ -0,0 +1,7 @@
+toplevel "A";
+"A" and "B" "B'";
+"B" wsp "C" "D";
+"B'" wsp "C'" "D";
+"C" lambda=0.5 dorm=0;
+"D" lambda=0.5 dorm=0;
+"C'" lambda=0.5 dorm=0;
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 650712ebd..e9b4c659e 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -454,6 +454,98 @@ namespace storm {
             return DFTColouring<ValueType>(*this);
         }
 
+        template<typename ValueType>
+        std::map<size_t, size_t> DFT<ValueType>::findBijection(size_t index1, size_t index2, DFTColouring<ValueType> const& colouring, bool sparesAsLeaves) const {
+            STORM_LOG_TRACE("Considering ids " << index1 << ", " << index2 << " for isomorphism.");
+            bool sharedSpareMode = false;
+            std::map<size_t, size_t> bijection;
+            
+            if (isBasicElement(index1)) {
+                if (!isBasicElement(index2)) {
+                    return {};
+                }
+                if (colouring.hasSameColour(index1, index2)) {
+                    bijection[index1] = index2;
+                    return bijection;
+                } else {
+                    return {};
+                }
+            }
+            
+            assert(isGate(index1));
+            assert(isGate(index2));
+            std::vector<size_t> isubdft1 = getGate(index1)->independentSubDft(false);
+            std::vector<size_t> isubdft2 = getGate(index2)->independentSubDft(false);
+            if(isubdft1.empty() || isubdft2.empty() || isubdft1.size() != isubdft2.size()) {
+                if (isubdft1.empty() && isubdft2.empty() && sparesAsLeaves) {
+                    // Check again for shared spares
+                    sharedSpareMode = true;
+                    isubdft1 = getGate(index1)->independentSubDft(false, true);
+                    isubdft2 = getGate(index2)->independentSubDft(false, true);
+                    if(isubdft1.empty() || isubdft2.empty() || isubdft1.size() != isubdft2.size()) {
+                        return {};
+                    }
+                } else {
+                    return {};
+                }
+            }
+            STORM_LOG_TRACE("Checking subdfts from " << index1 << ", " << index2 << " for isomorphism.");
+            auto LHS = colouring.colourSubdft(isubdft1);
+            auto RHS = colouring.colourSubdft(isubdft2);
+            auto IsoCheck = DFTIsomorphismCheck<ValueType>(LHS, RHS, *this);
+            
+            while (IsoCheck.findNextIsomorphism()) {
+                bijection = IsoCheck.getIsomorphism();
+                if (sharedSpareMode) {
+                    bool bijectionSpareCompatible = true;
+                    for (size_t elementId : isubdft1) {
+                        if (getElement(elementId)->isSpareGate()) {
+                            std::shared_ptr<DFTSpare<ValueType>> spareLeft = std::static_pointer_cast<DFTSpare<ValueType>>(mElements[elementId]);
+                            std::shared_ptr<DFTSpare<ValueType>> spareRight = std::static_pointer_cast<DFTSpare<ValueType>>(mElements[bijection.at(elementId)]);
+                            
+                            if (spareLeft->nrChildren() != spareRight->nrChildren()) {
+                                bijectionSpareCompatible = false;
+                                break;
+                            }
+                            // Check bijection for spare children
+                            for (size_t i = 0; i < spareLeft->nrChildren(); ++i) {
+                                size_t childLeftId = spareLeft->children().at(i)->id();
+                                size_t childRightId = spareRight->children().at(i)->id();
+
+                                assert(bijection.count(childLeftId) == 0);
+                                if (childLeftId == childRightId) {
+                                    // Ignore shared child
+                                    continue;
+                                }
+                                
+                                // TODO generalize for more than one parent
+                                if (spareLeft->children().at(i)->nrParents() != 1 || spareRight->children().at(i)->nrParents() != 1) {
+                                    bijectionSpareCompatible = false;
+                                    break;
+                                }
+                                
+                                std::map<size_t, size_t> tmpBijection = findBijection(childLeftId, childRightId, colouring, false);
+                                if (!tmpBijection.empty()) {
+                                    bijection.insert(tmpBijection.begin(), tmpBijection.end());
+                                } else {
+                                    bijectionSpareCompatible = false;
+                                    break;
+                                }
+                            }
+                            if (!bijectionSpareCompatible) {
+                                break;
+                            }
+                        }
+                    }
+                    if (bijectionSpareCompatible) {
+                        return bijection;
+                    }
+                } else {
+                    return bijection;
+                }
+            } // end while
+            return {};
+        }
 
         template<typename ValueType>
         DFTIndependentSymmetries DFT<ValueType>::findSymmetries(DFTColouring<ValueType> const& colouring) const {
@@ -486,33 +578,21 @@ namespace storm {
                             std::sort(sortedParent2Ids.begin(), sortedParent2Ids.end());
                             
                             if(influencedElem1Ids == getSortedParentAndOutDepIds(*it2)) {
-                                STORM_LOG_TRACE("Considering ids " << *it1 << ", " << *it2 << " for isomorphism.");
-                                bool isSymmetry = false;
-                                std::vector<size_t> isubdft1 = getGate(*it1)->independentSubDft(false);
-                                std::vector<size_t> isubdft2 = getGate(*it2)->independentSubDft(false);
-                                if(isubdft1.empty() || isubdft2.empty() || isubdft1.size() != isubdft2.size()) {
-                                    continue;
-                                }
-                                STORM_LOG_TRACE("Checking subdfts from " << *it1 << ", " << *it2 << " for isomorphism.");
-                                auto LHS = colouring.colourSubdft(isubdft1);
-                                auto RHS = colouring.colourSubdft(isubdft2);
-                                auto IsoCheck = DFTIsomorphismCheck<ValueType>(LHS, RHS, *this);
-                                isSymmetry = IsoCheck.findIsomorphism();
-                                if(isSymmetry) {
+                                std::map<size_t, size_t> bijection = findBijection(*it1, *it2, colouring, true);
+                                if (!bijection.empty()) {
                                     STORM_LOG_TRACE("Subdfts are symmetric");
                                     foundEqClassFor.insert(*it2);
                                     if(symClass.empty()) {
-                                        for(auto const& i : isubdft1) {
-                                            symClass.push_back(std::vector<size_t>({i}));
+                                        for(auto const& i : bijection) {
+                                            symClass.push_back(std::vector<size_t>({i.first}));
                                         }
                                     }
                                     auto symClassIt = symClass.begin();
-                                    for(auto const& i : isubdft1) {
-                                        symClassIt->emplace_back(IsoCheck.getIsomorphism().at(i));
+                                    for(auto const& i : bijection) {
+                                        symClassIt->emplace_back(i.second);
                                         ++symClassIt;
                                         
                                     }
-                                    
                                 }
                             }
                         }
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 64805ade4..f28d244f0 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -238,6 +238,8 @@ namespace storm {
             std::vector<size_t> getIndependentSubDftRoots(size_t index) const;
 
             DFTColouring<ValueType> colourDFT() const;
+            
+            std::map<size_t, size_t> findBijection(size_t index1, size_t index2, DFTColouring<ValueType> const& colouring, bool sparesAsLeaves) const;
 
             DFTIndependentSymmetries findSymmetries(DFTColouring<ValueType> const& colouring) const;
 
diff --git a/src/storage/dft/DFTIsomorphism.h b/src/storage/dft/DFTIsomorphism.h
index b1f845b9f..d94640d9c 100644
--- a/src/storage/dft/DFTIsomorphism.h
+++ b/src/storage/dft/DFTIsomorphism.h
@@ -202,6 +202,10 @@ namespace storage {
                 }
             }
         }
+        
+        bool hasSameColour(size_t index1, size_t index2) const {
+            return beColour.at(index1) == beColour.at(index2);
+        }
 
 
         BijectionCandidates<ValueType> colourSubdft(std::vector<size_t> const& subDftIndices) const {
@@ -308,13 +312,21 @@ namespace storage {
         }
 
         /**
-         * Check whether an isomorphism exists.
+         * Check whether another isomorphism exists.
          *
-         * @return true iff an isomorphism exists.
+         * @return true iff another isomorphism exists.
          */
-        bool findIsomorphism() {
-            if(!candidatesCompatible) return false;
-            constructInitialBijection();
+        bool findNextIsomorphism() {
+            if(!candidatesCompatible){
+                return false;
+            }
+            if (bijection.empty()) {
+                constructInitialBijection();
+            } else {
+                if (!findNextBijection()) {
+                    return false;
+                }
+            }
             while(!check()) {
                 // continue our search
                 if(!findNextBijection()) {
@@ -382,19 +394,31 @@ namespace storage {
 
             if(foundNext) {
                 for(auto const& colour : bleft.beCandidates) {
-                    zipVectorsIntoMap(colour.second, currentPermutations.beCandidates.find(colour.first)->second, bijection);
+                    if (colour.second.size() > 1) {
+                        assert(currentPermutations.beCandidates.find(colour.first) != currentPermutations.beCandidates.end());
+                        zipVectorsIntoMap(colour.second, currentPermutations.beCandidates.find(colour.first)->second, bijection);
+                    }
                 }
 
                 for(auto const& colour : bleft.gateCandidates) {
-                    zipVectorsIntoMap(colour.second, currentPermutations.gateCandidates.find(colour.first)->second, bijection);
+                    if (colour.second.size() > 1) {
+                        assert(currentPermutations.gateCandidates.find(colour.first) != currentPermutations.gateCandidates.end());
+                        zipVectorsIntoMap(colour.second, currentPermutations.gateCandidates.find(colour.first)->second, bijection);
+                    }
                 }
 
                 for(auto const& colour : bleft.pdepCandidates) {
-                    zipVectorsIntoMap(colour.second, currentPermutations.pdepCandidates.find(colour.first)->second, bijection);
+                    if (colour.second.size() > 1) {
+                        assert(currentPermutations.pdepCandidates.find(colour.first) != currentPermutations.pdepCandidates.end());
+                        zipVectorsIntoMap(colour.second, currentPermutations.pdepCandidates.find(colour.first)->second, bijection);
+                    }
                 }
                 
                 for(auto const& colour : bleft.restrictionCandidates) {
-                    zipVectorsIntoMap(colour.second, currentPermutations.restrictionCandidates.find(colour.first)->second, bijection);
+                    if (colour.second.size() > 1) {
+                        assert(currentPermutations.restrictionCandidates.find(colour.first) != currentPermutations.restrictionCandidates.end());
+                        zipVectorsIntoMap(colour.second, currentPermutations.restrictionCandidates.find(colour.first)->second, bijection);
+                    }
                 }
             }
 
@@ -405,7 +429,7 @@ namespace storage {
         /**
          *
          */
-        bool check() {
+        bool check() const {
             assert(bijection.size() == bleft.size());
             // We can skip BEs, as they are identified by they're homomorphic if they are in the same class
             for(auto const& indexpair : bijection) {
@@ -418,13 +442,23 @@ namespace storage {
                     if(lGate->isDynamicGate()) {
                         std::vector<size_t> childrenLeftMapped;
                         for(auto const& child : lGate->children() ) {
-                            assert(bleft.has(child->id()));
-                            childrenLeftMapped.push_back(bijection.at(child->id()));
+                            if (bleft.has(child->id())) {
+                                childrenLeftMapped.push_back(bijection.at(child->id()));
+                            } else {
+                                // Indicate shared child which is not part of the symmetry
+                                // For dynamic gates the order is important
+                                childrenLeftMapped.push_back(-1);
+                            }
                         }
                         std::vector<size_t> childrenRight;
                         for(auto const& child : rGate->children() ) {
-                            assert(bright.has(child->id()));
-                            childrenRight.push_back(child->id());
+                            if (bright.has(child->id())) {
+                                childrenRight.push_back(child->id());
+                            } else {
+                                // Indicate shared child which is not part of the symmetry
+                                // For dynamic gates the order is important
+                                childrenRight.push_back(-1);
+                            }
                         }
                         if(childrenLeftMapped != childrenRight) {
                             return false;
@@ -432,13 +466,15 @@ namespace storage {
                     } else {
                         std::set<size_t> childrenLeftMapped;
                         for(auto const& child : lGate->children() ) {
-                            assert(bleft.has(child->id()));
-                            childrenLeftMapped.insert(bijection.at(child->id()));
+                            if (bleft.has(child->id())) {
+                                childrenLeftMapped.insert(bijection.at(child->id()));
+                            }
                         }
                         std::set<size_t> childrenRight;
                         for(auto const& child : rGate->children() ) {
-                            assert(bright.has(child->id()));
-                            childrenRight.insert(child->id());
+                            if (bright.has(child->id())) {
+                                childrenRight.insert(child->id());
+                            }
                         }
                         if(childrenLeftMapped != childrenRight) {
                             return false;
@@ -459,16 +495,26 @@ namespace storage {
                 } else if(dft.isRestriction(indexpair.first)) {
                     assert(dft.isRestriction(indexpair.second));
                     auto const& lRestr = dft.getRestriction(indexpair.first);
-                    std::set<size_t> childrenLeftMapped;
+                    std::vector<size_t> childrenLeftMapped;
                     for(auto const& child : lRestr->children() ) {
-                        assert(bleft.has(child->id()));
-                        childrenLeftMapped.insert(bijection.at(child->id()));
+                        if (bleft.has(child->id())) {
+                            childrenLeftMapped.push_back(bijection.at(child->id()));
+                        } else {
+                            // Indicate shared child which is not part of the symmetry
+                            // For dynamic gates the order is important
+                            childrenLeftMapped.push_back(-1);
+                        }
                     }
                     auto const& rRestr = dft.getRestriction(indexpair.second);
-                    std::set<size_t> childrenRight;
+                    std::vector<size_t> childrenRight;
                     for(auto const& child : rRestr->children() ) {
-                        assert(bright.has(child->id()));
-                        childrenRight.insert(child->id());
+                        if (bright.has(child->id())) {
+                            childrenRight.push_back(child->id());
+                        } else {
+                            // Indicate shared child which is not part of the symmetry
+                            // For dynamic gates the order is important
+                            childrenRight.push_back(-1);
+                        }
                     }
                     if(childrenLeftMapped != childrenRight) {
                         return false;
@@ -487,50 +533,51 @@ namespace storage {
         /**
          * Returns true if the colours are compatible.
          */
-        void checkCompatibility() {
+        bool checkCompatibility() {
             if(bleft.gateCandidates.size() != bright.gateCandidates.size()) {
                 candidatesCompatible = false;
-                return;
+                return false;
             }
             if(bleft.beCandidates.size() != bright.beCandidates.size()) {
                 candidatesCompatible = false;
-                return;
+                return false;
             }
             if(bleft.beCandidates.size() != bright.beCandidates.size()) {
                 candidatesCompatible = false;
-                return;
+                return false;
             }
             if(bleft.restrictionCandidates.size() != bright.restrictionCandidates.size()) {
                 candidatesCompatible = false;
-                return;
+                return false;
             }
             
             for (auto const &gc : bleft.gateCandidates) {
                 if (bright.gateCandidates.count(gc.first) == 0) {
                     candidatesCompatible = false;
-                    return;
+                    return false;
                 }
             }
             for(auto const& bc : bleft.beCandidates) {
                 if(bright.beCandidates.count(bc.first) == 0) {
                     candidatesCompatible = false;
-                    return;
+                    return false;
                 }
             }
                
             for(auto const& dc : bleft.pdepCandidates) {
                 if(bright.pdepCandidates.count(dc.first) == 0) {
                     candidatesCompatible = false;
-                    return;
+                    return false;
                 }
             }
             
             for(auto const& dc : bleft.restrictionCandidates) {
                 if(bright.restrictionCandidates.count(dc.first) == 0) {
                     candidatesCompatible = false;
-                    return;
+                    return false;
                 }
             }
+            return true;
         }
 
         /**
diff --git a/src/storage/dft/elements/DFTBE.h b/src/storage/dft/elements/DFTBE.h
index a9c5b030d..58e580262 100644
--- a/src/storage/dft/elements/DFTBE.h
+++ b/src/storage/dft/elements/DFTBE.h
@@ -71,15 +71,15 @@ namespace storm {
                 return storm::utility::isZero(mPassiveFailureRate);
             }
             
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents, bool sparesAsLeaves) const override {
                  if(elemsInSubtree.count(this->id())) return;
-                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                 if(elemsInSubtree.empty()) {
                     // Parent in the subdft, ie it is *not* a subdft
                     return;
                 }
                 for(auto const& incDep : mIngoingDependencies) {
-                    incDep->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                    incDep->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                     if(elemsInSubtree.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
                         return;
diff --git a/src/storage/dft/elements/DFTDependency.h b/src/storage/dft/elements/DFTDependency.h
index c7f3f6bfd..44a5ab9df 100644
--- a/src/storage/dft/elements/DFTDependency.h
+++ b/src/storage/dft/elements/DFTDependency.h
@@ -83,20 +83,19 @@ namespace storm {
                 return std::vector<size_t>(unit.begin(), unit.end());
             }
 
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
-                 if(elemsInSubtree.count(this->id())) return;
-                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents, bool sparesAsLeaves) const override {
+                if(elemsInSubtree.count(this->id())) return;
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                 if(elemsInSubtree.empty()) {
                     // Parent in the subdft, ie it is *not* a subdft
                     return;
                 }
-                mDependentEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                mDependentEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                 if(elemsInSubtree.empty()) {
                     // Parent in the subdft, ie it is *not* a subdft
                     return;
                 }
-                mTriggerEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
-                
+                mTriggerEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                 
             }
             
diff --git a/src/storage/dft/elements/DFTElement.cpp b/src/storage/dft/elements/DFTElement.cpp
index 0ee8a3cd2..803199508 100644
--- a/src/storage/dft/elements/DFTElement.cpp
+++ b/src/storage/dft/elements/DFTElement.cpp
@@ -68,14 +68,14 @@ namespace storm {
         }
 
         template<typename ValueType>
-        std::vector<size_t> DFTElement<ValueType>::independentSubDft(bool blockParents) const {
+        std::vector<size_t> DFTElement<ValueType>::independentSubDft(bool blockParents, bool sparesAsLeaves) const {
             std::vector<size_t> res;
             res.push_back(this->id());
             return res;
         }
 
         template<typename ValueType>
-        void DFTElement<ValueType>::extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const {
+        void DFTElement<ValueType>::extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents, bool sparesAsLeaves) const {
             if(elemsInSubtree.count(this->id()) > 0) return;
             if(std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), mId) != parentsOfSubRoot.end()) {
                 // This is a parent of the suspected root, thus it is not a subdft.
@@ -87,13 +87,13 @@ namespace storm {
                 if(blockParents && std::find(parentsOfSubRoot.begin(), parentsOfSubRoot.end(), parent->id()) != parentsOfSubRoot.end()) {
                     continue;
                 }
-                parent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                parent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                 if(elemsInSubtree.empty()) {
                     return;
                 }
             }
             for(auto const& dep : mOutgoingDependencies) {
-                dep->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                dep->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                 if(elemsInSubtree.empty()) {
                     return;
                 }
@@ -101,7 +101,7 @@ namespace storm {
             }
             
             for(auto const& restr : mRestrictions) {
-                restr->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                restr->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                 if(elemsInSubtree.empty()) {
                     return;
                 }
diff --git a/src/storage/dft/elements/DFTElement.h b/src/storage/dft/elements/DFTElement.h
index 2b3b05c98..8a8a35d28 100644
--- a/src/storage/dft/elements/DFTElement.h
+++ b/src/storage/dft/elements/DFTElement.h
@@ -286,12 +286,12 @@ namespace storm {
              *  - a probabilistic dependency
              *  such that there exists a  path from x to a child of this does not go through this.
              */
-            virtual std::vector<size_t> independentSubDft(bool blockParents) const;
+            virtual std::vector<size_t> independentSubDft(bool blockParents, bool sparesAsLeaves = false) const;
             /**
              * Helper to the independent subtree computation
              * @see independentSubDft
              */
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const;
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents, bool sparesAsLeaves) const;
 
             virtual bool isTypeEqualTo(DFTElement<ValueType> const& other) const {
                 return type() == other.type();
diff --git a/src/storage/dft/elements/DFTGate.h b/src/storage/dft/elements/DFTGate.h
index d82906895..67fa0f70a 100644
--- a/src/storage/dft/elements/DFTGate.h
+++ b/src/storage/dft/elements/DFTGate.h
@@ -73,7 +73,7 @@ namespace storm {
                 }
             }
 
-            virtual std::vector<size_t> independentSubDft(bool blockParents) const override {
+            virtual std::vector<size_t> independentSubDft(bool blockParents, bool sparesAsLeaves = false) const override {
                 auto prelRes = DFTElement<ValueType>::independentSubDft(blockParents);
                 if(prelRes.empty()) {
                     // No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft.
@@ -82,7 +82,7 @@ namespace storm {
                 std::set<size_t> unit(prelRes.begin(), prelRes.end());
                 std::vector<size_t> pids = this->parentIds();
                 for(auto const& child : mChildren) {
-                    child->extendSubDft(unit, pids, blockParents);
+                    child->extendSubDft(unit, pids, blockParents, sparesAsLeaves);
                     if(unit.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
                         break;
@@ -91,15 +91,15 @@ namespace storm {
                 return std::vector<size_t>(unit.begin(), unit.end());
             }
 
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents, bool sparesAsLeaves) const override {
                 if(elemsInSubtree.count(this->id()) > 0) return;
-                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                 if(elemsInSubtree.empty()) {
                     // Parent in the subdft, ie it is *not* a subdft
                     return;
                 }
                 for(auto const& child : mChildren) {
-                    child->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                    child->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                     if(elemsInSubtree.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
                         return;
diff --git a/src/storage/dft/elements/DFTRestriction.h b/src/storage/dft/elements/DFTRestriction.h
index dc2e6116e..25441b5b1 100644
--- a/src/storage/dft/elements/DFTRestriction.h
+++ b/src/storage/dft/elements/DFTRestriction.h
@@ -69,7 +69,7 @@ namespace storm {
                 }
             }
 
-            virtual std::vector<size_t> independentSubDft(bool blockParents) const override {
+            virtual std::vector<size_t> independentSubDft(bool blockParents, bool sparesAsLeaves) const override {
                 auto prelRes = DFTElement<ValueType>::independentSubDft(blockParents);
                 if(prelRes.empty()) {
                     // No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft.
@@ -78,7 +78,7 @@ namespace storm {
                 std::set<size_t> unit(prelRes.begin(), prelRes.end());
                 std::vector<size_t> pids = this->parentIds();
                 for(auto const& child : mChildren) {
-                    child->extendSubDft(unit, pids, blockParents);
+                    child->extendSubDft(unit, pids, blockParents, sparesAsLeaves);
                     if(unit.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
                         break;
@@ -87,15 +87,15 @@ namespace storm {
                 return std::vector<size_t>(unit.begin(), unit.end());
             }
 
-            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents) const override {
+            virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents, bool sparesAsLeaves) const override {
                 if(elemsInSubtree.count(this->id()) > 0) return;
-                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                 if(elemsInSubtree.empty()) {
                     // Parent in the subdft, ie it is *not* a subdft
                     return;
                 }
                 for(auto const& child : mChildren) {
-                    child->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents);
+                    child->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                     if(elemsInSubtree.empty()) {
                         // Parent in the subdft, ie it is *not* a subdft
                         return;
diff --git a/src/storage/dft/elements/DFTSpare.h b/src/storage/dft/elements/DFTSpare.h
index dd3689311..81017ff19 100644
--- a/src/storage/dft/elements/DFTSpare.h
+++ b/src/storage/dft/elements/DFTSpare.h
@@ -64,6 +64,45 @@ namespace storm {
                     }
                 }
             }
+            
+            std::vector<size_t> independentSubDft(bool blockParents, bool sparesAsLeaves = false) const override {
+                auto prelRes = DFTElement<ValueType>::independentSubDft(blockParents);
+                if(prelRes.empty()) {
+                    // No elements (especially not this->id) in the prelimanry result, so we know already that it is not a subdft.
+                    return prelRes;
+                }
+                std::set<size_t> unit(prelRes.begin(), prelRes.end());
+                std::vector<size_t> pids = this->parentIds();
+                if (!sparesAsLeaves) {
+                    for(auto const& child : this->mChildren) {
+                        child->extendSubDft(unit, pids, blockParents, sparesAsLeaves);
+                        if(unit.empty()) {
+                            // Parent in the subdft, ie it is *not* a subdft
+                            break;
+                        }
+                    }
+                }
+                return std::vector<size_t>(unit.begin(), unit.end());
+            }
+            
+            void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents, bool sparesAsLeaves) const override {
+                if(elemsInSubtree.count(this->id()) > 0) return;
+                DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
+                if(elemsInSubtree.empty()) {
+                    // Parent in the subdft, ie it is *not* a subdft
+                    return;
+                }
+                if (!sparesAsLeaves) {
+                    for(auto const& child : this->mChildren) {
+                        child->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
+                        if(elemsInSubtree.empty()) {
+                            // Parent in the subdft, ie it is *not* a subdft
+                            return;
+                        }
+                    }
+                }
+            }
+
 
         };
     }

From 7e8b790451b01f0fd0c1dc27272eda8695bee65b Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 11 Mar 2016 11:49:53 +0100
Subject: [PATCH 205/246] Preparation for pseudo state generation from bit
 vector

Former-commit-id: a273f13a676bb7b1a9f5ae2b1ced896c40808e81
---
 src/builder/ExplicitDFTModelBuilder.cpp | 39 ++++++++++++++++++++-----
 src/builder/ExplicitDFTModelBuilder.h   |  2 +-
 src/storage/dft/DFTState.cpp            |  7 +++++
 src/storage/dft/DFTState.h              |  5 ++++
 4 files changed, 45 insertions(+), 8 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 3c5a39702..d57dec2e7 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -246,10 +246,11 @@ namespace storm {
                             if (!changed && newStateId >= OFFSET_PSEUDO_STATE) {
                                 newStateId = newStateId - OFFSET_PSEUDO_STATE;
                                 assert(newStateId < mPseudoStatesMapping.size());
-                                if (mPseudoStatesMapping[newStateId] == 0) {
+                                if (mPseudoStatesMapping[newStateId].first == 0) {
                                     // Create pseudo state now
+                                    assert(mPseudoStatesMapping[newStateId].second == newState->status());
                                     newState->setId(newIndex++);
-                                    mPseudoStatesMapping[newStateId] = newState->getId();
+                                    mPseudoStatesMapping[newStateId].first = newState->getId();
                                     newStateId = newState->getId();
                                     mStates.setOrAdd(newState->status(), newStateId);
                                     stateQueue.push(newState);
@@ -261,7 +262,7 @@ namespace storm {
                             if (changed) {
                                 // Remember to create state later on
                                 newState->setId(mPseudoStatesMapping.size() + OFFSET_PSEUDO_STATE);
-                                mPseudoStatesMapping.push_back(0);
+                                mPseudoStatesMapping.push_back(std::make_pair(0, newState->status()));
                                 newStateId = mStates.findOrAdd(newState->status(), newState->getId());
                                 STORM_LOG_TRACE("New state for later creation: " << mDft.getStateString(newState));
                             } else {
@@ -345,9 +346,9 @@ namespace storm {
                         if (it->first >= OFFSET_PSEUDO_STATE) {
                             uint_fast64_t newId = it->first - OFFSET_PSEUDO_STATE;
                             assert(newId < mPseudoStatesMapping.size());
-                            if (mPseudoStatesMapping[newId] > 0) {
+                            if (mPseudoStatesMapping[newId].first > 0) {
                                 // State exists already
-                                newId = mPseudoStatesMapping[newId];
+                                newId = mPseudoStatesMapping[newId].first;
                                 auto itFind = outgoingTransitions.find(newId);
                                 if (itFind != outgoingTransitions.end()) {
                                     // Add probability from pseudo state to instantiation
@@ -382,11 +383,35 @@ namespace storm {
                 exitRates.push_back(exitRate);
                 assert(exitRates.size()-1 == state->getId());
 
+                if (stateQueue.empty()) {
+                    // Before ending the exploration check for pseudo states which are no be initialized yet
+                    for (auto & pseudoStatePair : mPseudoStatesMapping) {
+                        if (pseudoStatePair.first == 0) {
+                            // Create state from pseudo state and explore
+                            assert(mStates.contains(pseudoStatePair.second));
+                            assert(mStates.getValue(pseudoStatePair.second) >= OFFSET_PSEUDO_STATE);
+                            STORM_LOG_TRACE("Create pseudo state from bit vector " << pseudoStatePair.second);
+                            DFTStatePointer pseudoState = std::make_shared<storm::storage::DFTState<ValueType>>(pseudoStatePair.second, mDft, *mStateGenerationInfo, newIndex++);
+                            assert(pseudoStatePair.second == pseudoState->status());
+                            pseudoStatePair.first = pseudoState->getId();
+                            mStates.setOrAdd(pseudoState->status(), pseudoState->getId());
+                            stateQueue.push(pseudoState);
+                            STORM_LOG_TRACE("Explore pseudo state " << mDft.getStateString(pseudoState) << " with id " << pseudoState->getId());
+                            break;
+                        }
+                    }
+                }
+                
             } // end while queue
-            assert(std::find(mPseudoStatesMapping.begin(), mPseudoStatesMapping.end(), 0) == mPseudoStatesMapping.end());
+            
+            std::vector<uint_fast64_t> pseudoStatesVector;
+            for (auto const& pseudoStatePair : mPseudoStatesMapping) {
+                pseudoStatesVector.push_back(pseudoStatePair.first);
+            }
+            assert(std::find(pseudoStatesVector.begin(), pseudoStatesVector.end(), 0) == pseudoStatesVector.end());
             
             // Replace pseudo states in matrix
-            transitionMatrixBuilder.replaceColumns(mPseudoStatesMapping, OFFSET_PSEUDO_STATE);
+            transitionMatrixBuilder.replaceColumns(pseudoStatesVector, OFFSET_PSEUDO_STATE);
             
             assert(!deterministic || rowOffset == 0);
             return deterministic;
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 13b3eaf0d..7fc343be2 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -52,7 +52,7 @@ namespace storm {
             storm::storage::DFT<ValueType> const& mDft;
             std::shared_ptr<storm::storage::DFTStateGenerationInfo> mStateGenerationInfo;
             storm::storage::BitVectorHashMap<uint_fast64_t> mStates;
-            std::vector<uint_fast64_t> mPseudoStatesMapping;
+            std::vector<std::pair<uint_fast64_t, storm::storage::BitVector>> mPseudoStatesMapping; // vector of (id to concrete state, bitvector)
             size_t newIndex = 0;
             bool mergeFailedStates = true;
             size_t failedIndex = 0;
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 1d34362f9..b7061b9b2 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -22,6 +22,13 @@ namespace storm {
             std::vector<size_t> alwaysActiveBEs = dft.nonColdBEs();
             mIsCurrentlyFailableBE.insert(mIsCurrentlyFailableBE.end(), alwaysActiveBEs.begin(), alwaysActiveBEs.end());
         }
+        
+        template<typename ValueType>
+        DFTState<ValueType>::DFTState(storm::storage::BitVector const& status, DFT<ValueType> const& dft, DFTStateGenerationInfo const& stateGenerationInfo, size_t id) : mStatus(status), mId(id), mDft(dft), mStateGenerationInfo(stateGenerationInfo) {
+            // TODO implement
+            assert(false);
+        }
+        
 
         template<typename ValueType>
         DFTElementState DFTState<ValueType>::getElementState(size_t id) const {
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 826e510d5..faf183411 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -36,6 +36,11 @@ namespace storm {
         public:
             DFTState(DFT<ValueType> const& dft, DFTStateGenerationInfo const& stateGenerationInfo, size_t id);
             
+            /**
+             * Construct state from underlying bitvector.
+             */
+            DFTState(storm::storage::BitVector const& status, DFT<ValueType> const& dft, DFTStateGenerationInfo const& stateGenerationInfo, size_t id);
+            
             DFTElementState getElementState(size_t id) const;
             
             DFTDependencyState getDependencyState(size_t id) const;

From 652aeb75624cddc7e0b37f5edd2b13ef789dae27 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 11 Mar 2016 14:01:59 +0100
Subject: [PATCH 206/246] Fixed compile error with CarlRationalNumber instead
 of RationalNumber

Former-commit-id: 0fbb4ad1c102926aaa92b1b0ce049a2953b1fef9
---
 src/utility/constants.cpp                     | 14 ++++----
 src/utility/parametric.h                      |  2 +-
 .../utility/ModelInstantiatorTest.cpp         | 34 +++++++++----------
 3 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/src/utility/constants.cpp b/src/utility/constants.cpp
index 6b3bb296b..06c934864 100644
--- a/src/utility/constants.cpp
+++ b/src/utility/constants.cpp
@@ -133,13 +133,13 @@ namespace storm {
         }
         
         template<>
-        double convertNumber(RationalNumber const& number){
+        double convertNumber(CarlRationalNumber const& number){
             return carl::toDouble(number);
         }
         
         template<>
-        RationalNumber convertNumber(double const& number){
-            return carl::rationalize<RationalNumber>(number);
+        CarlRationalNumber convertNumber(double const& number){
+            return carl::rationalize<CarlRationalNumber>(number);
         }
 
 #endif
@@ -241,7 +241,7 @@ namespace storm {
         template RationalFunction& simplify(RationalFunction& value);
         template RationalFunction&& simplify(RationalFunction&& value);
         
-        /*template Polynomial one();
+        template Polynomial one();
         template Polynomial zero();
         
         template bool isOne(CarlRationalNumber const& value);
@@ -249,10 +249,10 @@ namespace storm {
         template bool isConstant(CarlRationalNumber const& value);
         
         template CarlRationalNumber one();
-        template CarlRationalNumber zero();*/
+        template CarlRationalNumber zero();
        
-        template double convertNumber(RationalNumber const& number);
-        template RationalNumber convertNumber(double const& number);
+        template double convertNumber(CarlRationalNumber const& number);
+        template CarlRationalNumber convertNumber(double const& number);
         
         template bool isOne(Interval const& value);
         template bool isZero(Interval const& value);
diff --git a/src/utility/parametric.h b/src/utility/parametric.h
index 2ebf1e18c..ec2c9aa84 100644
--- a/src/utility/parametric.h
+++ b/src/utility/parametric.h
@@ -30,7 +30,7 @@ namespace storm {
             template<>
             struct VariableType<storm::RationalFunction> { typedef storm::Variable type; };
             template<>
-            struct CoefficientType<storm::RationalFunction> { typedef storm::RationalNumber type; };
+            struct CoefficientType<storm::RationalFunction> { typedef storm::CarlRationalNumber type; };
 #endif
             
             /*!
diff --git a/test/functional/utility/ModelInstantiatorTest.cpp b/test/functional/utility/ModelInstantiatorTest.cpp
index af8f5b8d2..0bf692a60 100644
--- a/test/functional/utility/ModelInstantiatorTest.cpp
+++ b/test/functional/utility/ModelInstantiatorTest.cpp
@@ -39,13 +39,13 @@ TEST(ModelInstantiatorTest, Brp_Prob) {
     EXPECT_FALSE(dtmc->hasRewardModel());
     
     {
-        std::map<storm::Variable, storm::RationalNumber> valuation;
+        std::map<storm::Variable, storm::CarlRationalNumber> valuation;
         storm::Variable const& pL = carl::VariablePool::getInstance().findVariableWithName("pL");
         ASSERT_NE(pL, carl::Variable::NO_VARIABLE);
         storm::Variable const& pK = carl::VariablePool::getInstance().findVariableWithName("pK");
         ASSERT_NE(pK, carl::Variable::NO_VARIABLE);
-        valuation.insert(std::make_pair(pL,carl::rationalize<storm::RationalNumber>(0.8)));
-        valuation.insert(std::make_pair(pK,carl::rationalize<storm::RationalNumber>(0.9)));
+        valuation.insert(std::make_pair(pL,carl::rationalize<storm::CarlRationalNumber>(0.8)));
+        valuation.insert(std::make_pair(pK,carl::rationalize<storm::CarlRationalNumber>(0.9)));
 
         storm::models::sparse::Dtmc<double> const& instantiated(modelInstantiator.instantiate(valuation));
 
@@ -72,13 +72,13 @@ TEST(ModelInstantiatorTest, Brp_Prob) {
     }
     
     {
-        std::map<storm::Variable, storm::RationalNumber> valuation;
+        std::map<storm::Variable, storm::CarlRationalNumber> valuation;
         storm::Variable const& pL = carl::VariablePool::getInstance().findVariableWithName("pL");
         ASSERT_NE(pL, carl::Variable::NO_VARIABLE);
         storm::Variable const& pK = carl::VariablePool::getInstance().findVariableWithName("pK");
         ASSERT_NE(pK, carl::Variable::NO_VARIABLE);
-        valuation.insert(std::make_pair(pL,carl::rationalize<storm::RationalNumber>(1)));
-        valuation.insert(std::make_pair(pK,carl::rationalize<storm::RationalNumber>(1)));
+        valuation.insert(std::make_pair(pL,carl::rationalize<storm::CarlRationalNumber>(1)));
+        valuation.insert(std::make_pair(pK,carl::rationalize<storm::CarlRationalNumber>(1)));
 
         storm::models::sparse::Dtmc<double> const& instantiated(modelInstantiator.instantiate(valuation));
 
@@ -105,13 +105,13 @@ TEST(ModelInstantiatorTest, Brp_Prob) {
     }
     
     {
-        std::map<storm::Variable, storm::RationalNumber> valuation;
+        std::map<storm::Variable, storm::CarlRationalNumber> valuation;
         storm::Variable const& pL = carl::VariablePool::getInstance().findVariableWithName("pL");
         ASSERT_NE(pL, carl::Variable::NO_VARIABLE);
         storm::Variable const& pK = carl::VariablePool::getInstance().findVariableWithName("pK");
         ASSERT_NE(pK, carl::Variable::NO_VARIABLE);
-        valuation.insert(std::make_pair(pL,carl::rationalize<storm::RationalNumber>(1)));
-        valuation.insert(std::make_pair(pK,carl::rationalize<storm::RationalNumber>(0.9)));
+        valuation.insert(std::make_pair(pL,carl::rationalize<storm::CarlRationalNumber>(1)));
+        valuation.insert(std::make_pair(pK,carl::rationalize<storm::CarlRationalNumber>(0.9)));
 
         storm::models::sparse::Dtmc<double> const& instantiated(modelInstantiator.instantiate(valuation));
 
@@ -159,7 +159,7 @@ TEST(ModelInstantiatorTest, Brp_Rew) {
     storm::utility::ModelInstantiator<storm::models::sparse::Dtmc<storm::RationalFunction>, storm::models::sparse::Dtmc<double>> modelInstantiator(*dtmc);
     
     {
-        std::map<storm::Variable, storm::RationalNumber> valuation;
+        std::map<storm::Variable, storm::CarlRationalNumber> valuation;
         storm::Variable const& pL = carl::VariablePool::getInstance().findVariableWithName("pL");
         ASSERT_NE(pL, carl::Variable::NO_VARIABLE);
         storm::Variable const& pK = carl::VariablePool::getInstance().findVariableWithName("pK");
@@ -168,10 +168,10 @@ TEST(ModelInstantiatorTest, Brp_Rew) {
         ASSERT_NE(pK, carl::Variable::NO_VARIABLE);
         storm::Variable const& TOAck = carl::VariablePool::getInstance().findVariableWithName("TOAck");
         ASSERT_NE(pK, carl::Variable::NO_VARIABLE);
-        valuation.insert(std::make_pair(pL,carl::rationalize<storm::RationalNumber>(0.9)));
-        valuation.insert(std::make_pair(pK,carl::rationalize<storm::RationalNumber>(0.3)));
-        valuation.insert(std::make_pair(TOMsg,carl::rationalize<storm::RationalNumber>(0.3)));
-        valuation.insert(std::make_pair(TOAck,carl::rationalize<storm::RationalNumber>(0.5)));
+        valuation.insert(std::make_pair(pL,carl::rationalize<storm::CarlRationalNumber>(0.9)));
+        valuation.insert(std::make_pair(pK,carl::rationalize<storm::CarlRationalNumber>(0.3)));
+        valuation.insert(std::make_pair(TOMsg,carl::rationalize<storm::CarlRationalNumber>(0.3)));
+        valuation.insert(std::make_pair(TOAck,carl::rationalize<storm::CarlRationalNumber>(0.5)));
 
         storm::models::sparse::Dtmc<double> const& instantiated(modelInstantiator.instantiate(valuation));
 
@@ -231,13 +231,13 @@ TEST(ModelInstantiatorTest, consensus) {
 
     storm::utility::ModelInstantiator<storm::models::sparse::Mdp<storm::RationalFunction>, storm::models::sparse::Mdp<double>> modelInstantiator(*mdp);
     
-    std::map<storm::Variable, storm::RationalNumber> valuation;
+    std::map<storm::Variable, storm::CarlRationalNumber> valuation;
     storm::Variable const& p1 = carl::VariablePool::getInstance().findVariableWithName("p1");
     ASSERT_NE(p1, carl::Variable::NO_VARIABLE);
     storm::Variable const& p2 = carl::VariablePool::getInstance().findVariableWithName("p2");
     ASSERT_NE(p2, carl::Variable::NO_VARIABLE);
-    valuation.insert(std::make_pair(p1,carl::rationalize<storm::RationalNumber>(0.51)));
-    valuation.insert(std::make_pair(p2,carl::rationalize<storm::RationalNumber>(0.49)));
+    valuation.insert(std::make_pair(p1,carl::rationalize<storm::CarlRationalNumber>(0.51)));
+    valuation.insert(std::make_pair(p2,carl::rationalize<storm::CarlRationalNumber>(0.49)));
     storm::models::sparse::Mdp<double> const& instantiated(modelInstantiator.instantiate(valuation));
 
     ASSERT_EQ(mdp->getTransitionMatrix().getRowGroupIndices(), instantiated.getTransitionMatrix().getRowGroupIndices());

From 306eb8a9ccbbd14d357b0a352d0bdec96b41a0a3 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 11 Mar 2016 15:13:24 +0100
Subject: [PATCH 207/246] Construct state from bit vector

Former-commit-id: 705af6d503fafdc8520e5769511f8802144bded8
---
 examples/dft/mcs.dft         | 22 ++++++++++++++++++++++
 src/storage/dft/DFTState.cpp | 28 +++++++++++++++++++++++++---
 2 files changed, 47 insertions(+), 3 deletions(-)
 create mode 100644 examples/dft/mcs.dft

diff --git a/examples/dft/mcs.dft b/examples/dft/mcs.dft
new file mode 100644
index 000000000..733a7a599
--- /dev/null
+++ b/examples/dft/mcs.dft
@@ -0,0 +1,22 @@
+toplevel "n12";
+"n12" or "n1" "n103" "n7";
+"n103" wsp "n106" "n14";
+"n7" and "n18" "n26";
+"n26" or "n28" "n19" "n23";
+"n19" wsp "n16" "n13";
+"n23" wsp "n0" "n17";
+"n18" or "n15" "n9" "n3";
+"n3" wsp "n2" "n17";
+"n9" wsp "n8" "n27";
+"n16" lambda=8.0 dorm=0.0;
+"n0" lambda=0.003 dorm=0.0;
+"n13" lambda=8.0 dorm=0.5;
+"n2" lambda=0.003 dorm=0.0;
+"n17" lambda=0.003 dorm=0.5;
+"n15" lambda=0.05 dorm=0.0;
+"n106" lambda=1.2 dorm=0.0;
+"n14" lambda=0.6 dorm=0.0;
+"n1" lambda=2.0E-4 dorm=0.0;
+"n27" lambda=8.0 dorm=0.5;
+"n8" lambda=8.0 dorm=0.0;
+"n28" lambda=0.05 dorm=0.0;
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index b7061b9b2..c17bad0b6 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -25,10 +25,32 @@ namespace storm {
         
         template<typename ValueType>
         DFTState<ValueType>::DFTState(storm::storage::BitVector const& status, DFT<ValueType> const& dft, DFTStateGenerationInfo const& stateGenerationInfo, size_t id) : mStatus(status), mId(id), mDft(dft), mStateGenerationInfo(stateGenerationInfo) {
-            // TODO implement
-            assert(false);
+            
+            for(size_t index = 0; index < mDft.nrElements(); ++index) {
+                // Initialize currently failable BE
+                if (mDft.isBasicElement(index) && isOperational(index)) {
+                    if (!mDft.getBasicElement(index)->isColdBasicElement() || !mDft.hasRepresentant(index) || isActive(mDft.getRepresentant(index)->id())) {
+                        mIsCurrentlyFailableBE.push_back(index);
+                        STORM_LOG_TRACE("Currently failable: " << mDft.getBasicElement(index)->toString());
+                    }
+                } else if (mDft.getElement(index)->isSpareGate()) {
+                    // Initialize used representants
+                    uint_fast64_t useId = uses(index);
+                    mUsedRepresentants.push_back(useId);
+                    STORM_LOG_TRACE("Spare " << index << " uses " << useId);
+                }
+            }
+            
+            // Initialize failable dependencies
+            for (size_t dependencyId : mDft.getDependencies()) {
+                std::shared_ptr<DFTDependency<ValueType> const> dependency = mDft.getDependency(dependencyId);
+                assert(dependencyId == dependency->id());
+                if (hasFailed(dependency->triggerEvent()->id()) && getElementState(dependency->dependentEvent()->id()) == DFTElementState::Operational) {
+                    mFailableDependencies.push_back(dependencyId);
+                    STORM_LOG_TRACE("New dependency failure: " << dependency->toString());
+                }
+            }
         }
-        
 
         template<typename ValueType>
         DFTElementState DFTState<ValueType>::getElementState(size_t id) const {

From a21715cbc38d249c9b060e7a06d95212b425f6d7 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sat, 12 Mar 2016 00:15:47 +0100
Subject: [PATCH 208/246] Nested symmetries seem to work for at least binary
 symmetries

Former-commit-id: dfa2052d1802239b4f8ae800a1a2b6cf14f97772
---
 src/storage/dft/DFT.cpp                  |  27 ++++--
 src/storage/dft/DFTStateGenerationInfo.h |  28 +++++-
 src/storage/dft/SymmetricUnits.h         | 110 ++++++++++++++++++++++-
 3 files changed, 155 insertions(+), 10 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index e9b4c659e..dd771f230 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -110,22 +110,35 @@ namespace storm {
                 visitQueue.push(mTopLevelIndex);
                 stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
             } else {
-                for (auto const& symmetryGroup : symmetries.groups) {
-                    assert(!symmetryGroup.second.empty());
+                for (size_t symmetryIndex : symmetries.sortedSymmetries) {
+                    assert(!visited[symmetryIndex]);
+                    auto const& symmetryGroup = symmetries.groups.at(symmetryIndex);
+                    assert(!symmetryGroup.empty());
 
                     // Insert all elements of first subtree of each symmetry
                     size_t groupIndex = stateIndex;
-                    for (std::vector<size_t> const& symmetryElement : symmetryGroup.second) {
-                        stateIndex = generateStateInfo(generationInfo, symmetryElement[0], visited, stateIndex);
+                    for (std::vector<size_t> const& symmetryElement : symmetryGroup) {
+                        if (visited[symmetryElement[0]]) {
+                            groupIndex = std::min(groupIndex, generationInfo.getStateIndex(symmetryElement[0]));
+                        } else {
+                            stateIndex = generateStateInfo(generationInfo, symmetryElement[0], visited, stateIndex);
+                        }
                     }
                     size_t offset = stateIndex - groupIndex;
                     
                     // Mirror symmetries
-                    size_t noSymmetricElements = symmetryGroup.second.front().size();
+                    size_t noSymmetricElements = symmetryGroup.front().size();
                     assert(noSymmetricElements > 1);
 
-                    for (std::vector<size_t> symmetricElements : symmetryGroup.second) {
+                    for (std::vector<size_t> symmetricElements : symmetryGroup) {
                         assert(symmetricElements.size() == noSymmetricElements);
+                        if (visited[symmetricElements[1]]) {
+                            // Elements already mirrored
+                            for (size_t index : symmetricElements) {
+                                assert(visited[index]);
+                            }
+                            continue;
+                        }
 
                         // Initialize for original element
                         size_t originalElement = symmetricElements[0];
@@ -181,6 +194,8 @@ namespace storm {
                     stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
                 }
             }
+            
+            generationInfo.generateSymmetries(symmetries);
 
             STORM_LOG_TRACE(generationInfo);
             assert(stateIndex == mStateVectorSize);
diff --git a/src/storage/dft/DFTStateGenerationInfo.h b/src/storage/dft/DFTStateGenerationInfo.h
index 4b3ef92c9..d4bbdee8b 100644
--- a/src/storage/dft/DFTStateGenerationInfo.h
+++ b/src/storage/dft/DFTStateGenerationInfo.h
@@ -10,7 +10,7 @@ namespace storm {
             std::vector<size_t> mIdToStateIndex; // id -> index first bit in state
             std::map<size_t, std::vector<size_t>> mSeqRestrictionPreElements; // id -> list of restriction pre elements;
             std::map<size_t, std::vector<size_t>> mSeqRestrictionPostElements; // id -> list of restriction post elements;
-            std::vector<std::pair<size_t, std::vector<size_t>>> mSymmetries; // pair (lenght of symmetry group, vector indicating the starting points of the symmetry groups)
+            std::vector<std::pair<size_t, std::vector<size_t>>> mSymmetries; // pair (length of symmetry group, vector indicating the starting points of the symmetry groups)
 
         public:
 
@@ -70,6 +70,32 @@ namespace storm {
             void addSymmetry(size_t length, std::vector<size_t>& startingIndices) {
                 mSymmetries.push_back(std::make_pair(length, startingIndices));
             }
+            
+            /**
+             * Generate more symmetries by combining two symmetries
+             */
+            void generateSymmetries(storm::storage::DFTIndependentSymmetries const& symmetries) {
+                for (size_t i = 0; i < mSymmetries.size(); ++i) {
+                    size_t childStart = mSymmetries[i].second[0];
+                    size_t childLength = mSymmetries[i].first;
+                    for (size_t j = i+1; j < mSymmetries.size(); ++j) {
+                        size_t parentStart = mSymmetries[j].second[0];
+                        size_t parentLength = mSymmetries[j].first;
+                        // Check if child lies in parent
+                        if (parentStart <= childStart && childStart + childLength < parentStart + parentLength) {
+                            // Get symmetric start by applying the bijection
+                            std::vector<size_t> newStarts;
+                            for (size_t symmetryStarts : mSymmetries[i].second) {
+                                newStarts.push_back(symmetryStarts + parentLength);
+                            }
+                            // Insert after child
+                            mSymmetries.insert(mSymmetries.begin() + i + 1, std::make_pair(childLength, newStarts));
+                            ++i;
+                            break;
+                        }
+                    }
+                }
+            }
 
             size_t getSymmetrySize() const {
                 return mSymmetries.size();
diff --git a/src/storage/dft/SymmetricUnits.h b/src/storage/dft/SymmetricUnits.h
index 58a70e492..33c8efeae 100644
--- a/src/storage/dft/SymmetricUnits.h
+++ b/src/storage/dft/SymmetricUnits.h
@@ -1,19 +1,123 @@
 #pragma once
 
+#include "src/utility/macros.h"
+
 namespace storm {
     namespace storage {
         struct DFTIndependentSymmetries {
             std::map<size_t, std::vector<std::vector<size_t>>> groups;
             
+            std::vector<size_t> sortedSymmetries;
+            
+            bool existsInFirstSymmetry(size_t index, size_t value) {
+                for (std::vector<size_t> symmetry : groups[index]) {
+                    if (symmetry.front() == value) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            
+            bool existsInSymmetry(size_t index, size_t value) {
+                for (std::vector<size_t> symmetry : groups[index]) {
+                    for (size_t index : symmetry) {
+                        if (index == value) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+            
+            /**
+             * Apply symmetry and get bijection. Result is symmetry(value)[index]
+             *
+             * @param symmetry The symmetry.
+             * @param value The value to apply the bijection to.
+             * @param index The index of the symmetry group to apply.
+             * @return Symmetric value, -1 if the bijection could not be applied.
+             */
+            int applySymmetry(std::vector<std::vector<size_t>> const& symmetry, size_t value, size_t index) const {
+                for (std::vector<size_t> element : symmetry) {
+                    if (element[0] == value) {
+                        return element[index];
+                    }
+                }
+                return -1;
+            }
+            
+            std::vector<std::vector<size_t>> createSymmetry(std::vector<std::vector<size_t>> parentSymmetry, std::vector<std::vector<size_t>> childSymmetry, size_t index) {
+                std::vector<std::vector<size_t>> result;
+                for (std::vector<size_t> childSymmetry : childSymmetry) {
+                    std::vector<size_t> symmetry;
+                    for (size_t child : childSymmetry) {
+                        int bijectionValue = applySymmetry(parentSymmetry, child, index);
+                        if (bijectionValue >= 0) {
+                            symmetry.push_back(bijectionValue);
+                        } else {
+                            return result;
+                        }
+                    }
+                    result.push_back(symmetry);
+                }
+                return result;
+            }
+            
+            void sortHierarchical(size_t parent, std::vector<size_t>& candidates) {
+                std::vector<size_t> children;
+                for (int i = candidates.size() - 1; i >= 0; --i) {
+                    size_t currentRoot = candidates[i];
+                    if (existsInSymmetry(parent, currentRoot)) {
+                        // Is child
+                        STORM_LOG_TRACE(currentRoot << " is child of " << parent);
+                        children.insert(children.begin(), currentRoot);
+                        candidates.erase(candidates.begin()+i);
+                    }
+                }
+                for (size_t i = 0; i < children.size(); ++i) {
+                    std::vector<std::vector<size_t>> possibleSymmetry = createSymmetry(groups.at(parent), groups.at(children[i]), 1);
+                    for (size_t j = i + 1; j < children.size(); ++j) {
+                        if (possibleSymmetry == groups.at(children[j])) {
+                            STORM_LOG_TRACE("Child " << children[j] << " ignored as created by symmetries " << parent << " and " << children[j]);
+                            groups.erase(children[j]);
+                            children.erase(children.begin() + j);
+                        }
+                    }
+                }
+                while (!children.empty()) {
+                    // Insert largest element
+                    size_t largestChild = children.back();
+                    children.pop_back();
+                    sortHierarchical(largestChild, children);
+                    sortedSymmetries.push_back(largestChild);
+                }
+            }
+            
             DFTIndependentSymmetries(std::map<size_t, std::vector<std::vector<size_t>>> groups) : groups(groups) {
+                std::vector<size_t> sortedGroups;
+                for (auto const& cl : groups) {
+                    sortedGroups.push_back(cl.first);
+                }
+                // Sort by length of symmetry
+                std::sort(sortedGroups.begin(), sortedGroups.end(), [&](const size_t left, const size_t right) {
+                    return groups.at(left).size() < groups.at(right).size();
+                });
                 
+                // Sort hierarchical
+                while (!sortedGroups.empty()) {
+                    // Insert largest element
+                    size_t currentRoot = sortedGroups.back();
+                    sortedGroups.pop_back();
+                    sortHierarchical(currentRoot, sortedGroups);
+                    sortedSymmetries.push_back(currentRoot);
+                }
             }
         };
         
         inline std::ostream& operator<<(std::ostream& os, DFTIndependentSymmetries const& s)  {
-            for(auto const& cl : s.groups) {
-                os << "Symmetry group for " << cl.first << std::endl;
-                for(auto const& eqClass : cl.second) {
+            for(size_t index : s.sortedSymmetries) {
+                os << "Symmetry group for " << index << std::endl;
+                for(auto const& eqClass : s.groups.at(index)) {
                     for(auto const& i : eqClass) {
                         os << i << " ";
                     }

From 150f177bcd7e5d11f80d672db8a25f62bfd7a57e Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sat, 12 Mar 2016 15:13:36 +0100
Subject: [PATCH 209/246] Symred on mcs seems to work now

Former-commit-id: d6a830f8a1757fe4c924ad98e1b256b3c4a66fb3
---
 src/storage/dft/DFTStateGenerationInfo.h | 20 ++++++++++++++------
 src/storage/dft/SymmetricUnits.h         | 24 ++++++++++++++++--------
 2 files changed, 30 insertions(+), 14 deletions(-)

diff --git a/src/storage/dft/DFTStateGenerationInfo.h b/src/storage/dft/DFTStateGenerationInfo.h
index d4bbdee8b..e700d8700 100644
--- a/src/storage/dft/DFTStateGenerationInfo.h
+++ b/src/storage/dft/DFTStateGenerationInfo.h
@@ -75,22 +75,30 @@ namespace storm {
              * Generate more symmetries by combining two symmetries
              */
             void generateSymmetries(storm::storage::DFTIndependentSymmetries const& symmetries) {
+                // Iterate over possible children
                 for (size_t i = 0; i < mSymmetries.size(); ++i) {
                     size_t childStart = mSymmetries[i].second[0];
                     size_t childLength = mSymmetries[i].first;
+                    // Iterate over possible parents
                     for (size_t j = i+1; j < mSymmetries.size(); ++j) {
                         size_t parentStart = mSymmetries[j].second[0];
                         size_t parentLength = mSymmetries[j].first;
                         // Check if child lies in parent
                         if (parentStart <= childStart && childStart + childLength < parentStart + parentLength) {
-                            // Get symmetric start by applying the bijection
-                            std::vector<size_t> newStarts;
-                            for (size_t symmetryStarts : mSymmetries[i].second) {
-                                newStarts.push_back(symmetryStarts + parentLength);
+                            std::vector<std::vector<size_t>> newSymmetries;
+                            for (size_t index = 1; index < mSymmetries[j].second.size(); ++index) {
+                                // Get symmetric start by applying the bijection
+                                std::vector<size_t> newStarts;
+                                for (size_t symmetryStarts : mSymmetries[i].second) {
+                                    newStarts.push_back(symmetryStarts + mSymmetries[j].second[index]);
+                                }
+                                newSymmetries.push_back(newStarts);
                             }
                             // Insert after child
-                            mSymmetries.insert(mSymmetries.begin() + i + 1, std::make_pair(childLength, newStarts));
-                            ++i;
+                            for (size_t index = 0; index < newSymmetries.size(); ++index) {
+                                mSymmetries.insert(mSymmetries.begin() + i + 1 + index, std::make_pair(childLength, newSymmetries[index]));
+                            }
+                            i += mSymmetries[j].second.size();
                             break;
                         }
                     }
diff --git a/src/storage/dft/SymmetricUnits.h b/src/storage/dft/SymmetricUnits.h
index 33c8efeae..82d747115 100644
--- a/src/storage/dft/SymmetricUnits.h
+++ b/src/storage/dft/SymmetricUnits.h
@@ -64,6 +64,7 @@ namespace storm {
             }
             
             void sortHierarchical(size_t parent, std::vector<size_t>& candidates) {
+                // Find subsymmetries of current symmetry
                 std::vector<size_t> children;
                 for (int i = candidates.size() - 1; i >= 0; --i) {
                     size_t currentRoot = candidates[i];
@@ -74,16 +75,23 @@ namespace storm {
                         candidates.erase(candidates.begin()+i);
                     }
                 }
+                
+                // Find child symmetries which are created by parent and other child symmetries
                 for (size_t i = 0; i < children.size(); ++i) {
-                    std::vector<std::vector<size_t>> possibleSymmetry = createSymmetry(groups.at(parent), groups.at(children[i]), 1);
-                    for (size_t j = i + 1; j < children.size(); ++j) {
-                        if (possibleSymmetry == groups.at(children[j])) {
-                            STORM_LOG_TRACE("Child " << children[j] << " ignored as created by symmetries " << parent << " and " << children[j]);
-                            groups.erase(children[j]);
-                            children.erase(children.begin() + j);
+                    // Iterate over all possible symmetry groups
+                    for (size_t index = 1; index < groups.at(parent).front().size(); ++index) {
+                        std::vector<std::vector<size_t>> possibleSymmetry = createSymmetry(groups.at(parent), groups.at(children[i]), index);
+                        for (size_t j = i + 1; j < children.size(); ++j) {
+                            if (possibleSymmetry == groups.at(children[j])) {
+                                STORM_LOG_TRACE("Child " << children[j] << " ignored as created by symmetries " << parent << " and " << children[i]);
+                                groups.erase(children[j]);
+                                children.erase(children.begin() + j);
+                            }
                         }
                     }
                 }
+                
+                // Apply sorting recursively
                 while (!children.empty()) {
                     // Insert largest element
                     size_t largestChild = children.back();
@@ -98,9 +106,9 @@ namespace storm {
                 for (auto const& cl : groups) {
                     sortedGroups.push_back(cl.first);
                 }
-                // Sort by length of symmetry
+                // Sort by length of symmetry or (if equal) by lower first element
                 std::sort(sortedGroups.begin(), sortedGroups.end(), [&](const size_t left, const size_t right) {
-                    return groups.at(left).size() < groups.at(right).size();
+                    return groups.at(left).size() < groups.at(right).size() || (groups.at(left).size() == groups.at(right).size() && groups.at(left).front().front() < groups.at(left).front().front());
                 });
                 
                 // Sort hierarchical

From 5a066b9ae0a36dfea6252165fbdec9fb0cb83894 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sat, 12 Mar 2016 15:32:48 +0100
Subject: [PATCH 210/246] Used duplicate variable name

Former-commit-id: 3f47dfb3d1f9927ab9bd60897c56ad0b000610b4
---
 src/storage/dft/SymmetricUnits.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/storage/dft/SymmetricUnits.h b/src/storage/dft/SymmetricUnits.h
index 82d747115..643305045 100644
--- a/src/storage/dft/SymmetricUnits.h
+++ b/src/storage/dft/SymmetricUnits.h
@@ -48,9 +48,9 @@ namespace storm {
             
             std::vector<std::vector<size_t>> createSymmetry(std::vector<std::vector<size_t>> parentSymmetry, std::vector<std::vector<size_t>> childSymmetry, size_t index) {
                 std::vector<std::vector<size_t>> result;
-                for (std::vector<size_t> childSymmetry : childSymmetry) {
+                for (std::vector<size_t> childSym : childSymmetry) {
                     std::vector<size_t> symmetry;
-                    for (size_t child : childSymmetry) {
+                    for (size_t child : childSym) {
                         int bijectionValue = applySymmetry(parentSymmetry, child, index);
                         if (bijectionValue >= 0) {
                             symmetry.push_back(bijectionValue);
@@ -135,4 +135,4 @@ namespace storm {
             return os;
         }
     }
-}
\ No newline at end of file
+}

From 6ca6ab27e89c1e4d4d25c9ce80c4d34312889a37 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sat, 12 Mar 2016 18:02:30 +0100
Subject: [PATCH 211/246] Activate failed representatives

Former-commit-id: dcda573443bcec1efb4e1ab98c8171d9b7b3d720
---
 src/storage/dft/DFTState.cpp            | 13 ++++++++++++-
 src/storage/dft/elements/DFTElement.cpp |  2 +-
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index c17bad0b6..558192678 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -123,16 +123,28 @@ namespace storm {
 
         template<typename ValueType>
         void DFTState<ValueType>::setFailed(size_t id) {
+            if (mDft.isRepresentative(id)) {
+                // Activate failed element
+                activate(id);
+            }
             mStatus.set(mStateGenerationInfo.getStateIndex(id));
         }
 
         template<typename ValueType>
         void DFTState<ValueType>::setFailsafe(size_t id) {
+            if (mDft.isRepresentative(id)) {
+                // Activate failed element
+                activate(id);
+            }
             mStatus.set(mStateGenerationInfo.getStateIndex(id)+1);
         }
 
         template<typename ValueType>
         void DFTState<ValueType>::setDontCare(size_t id) {
+            if (mDft.isRepresentative(id)) {
+                // Activate failed element
+                activate(id);
+            }
             mStatus.setFromInt(mStateGenerationInfo.getStateIndex(id), 2, static_cast<uint_fast64_t>(DFTElementState::DontCare) );
         }
         
@@ -207,7 +219,6 @@ namespace storm {
         template<typename ValueType>
         void DFTState<ValueType>::activate(size_t repr) {
             size_t activationIndex = mStateGenerationInfo.getSpareActivationIndex(repr);
-            assert(!mStatus[activationIndex]);
             mStatus.set(activationIndex);
         }
 
diff --git a/src/storage/dft/elements/DFTElement.cpp b/src/storage/dft/elements/DFTElement.cpp
index 803199508..1f0ab892d 100644
--- a/src/storage/dft/elements/DFTElement.cpp
+++ b/src/storage/dft/elements/DFTElement.cpp
@@ -37,7 +37,7 @@ namespace storm {
             }
             
             state.setDontCare(mId);
-            if (hasParentSpare && !state.isActive(mId)) {
+            if (hasParentSpare) {
                 // Activate child for consistency in failed spares
                 state.activate(mId);
             }

From db3c40e6d738f026b791ee47ad89924569dd8e40 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Sat, 12 Mar 2016 18:46:01 +0100
Subject: [PATCH 212/246] Fixed bugs

Former-commit-id: d602972afc29bbdeb6c6eb338a393c60d3135ce7
---
 src/storage/dft/DFTState.cpp             | 10 +---------
 src/storage/dft/DFTStateGenerationInfo.h |  2 +-
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 558192678..24291b446 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -123,26 +123,18 @@ namespace storm {
 
         template<typename ValueType>
         void DFTState<ValueType>::setFailed(size_t id) {
-            if (mDft.isRepresentative(id)) {
-                // Activate failed element
-                activate(id);
-            }
             mStatus.set(mStateGenerationInfo.getStateIndex(id));
         }
 
         template<typename ValueType>
         void DFTState<ValueType>::setFailsafe(size_t id) {
-            if (mDft.isRepresentative(id)) {
-                // Activate failed element
-                activate(id);
-            }
             mStatus.set(mStateGenerationInfo.getStateIndex(id)+1);
         }
 
         template<typename ValueType>
         void DFTState<ValueType>::setDontCare(size_t id) {
             if (mDft.isRepresentative(id)) {
-                // Activate failed element
+                // Activate dont care element
                 activate(id);
             }
             mStatus.setFromInt(mStateGenerationInfo.getStateIndex(id), 2, static_cast<uint_fast64_t>(DFTElementState::DontCare) );
diff --git a/src/storage/dft/DFTStateGenerationInfo.h b/src/storage/dft/DFTStateGenerationInfo.h
index e700d8700..513a6a7a0 100644
--- a/src/storage/dft/DFTStateGenerationInfo.h
+++ b/src/storage/dft/DFTStateGenerationInfo.h
@@ -98,7 +98,7 @@ namespace storm {
                             for (size_t index = 0; index < newSymmetries.size(); ++index) {
                                 mSymmetries.insert(mSymmetries.begin() + i + 1 + index, std::make_pair(childLength, newSymmetries[index]));
                             }
-                            i += mSymmetries[j].second.size();
+                            i += newSymmetries.size();
                             break;
                         }
                     }

From 9ae9700d5c9f4dbb5e1073b27f9bc1f712c60a04 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Sat, 12 Mar 2016 20:43:37 +0100
Subject: [PATCH 213/246] modularisation on and and or

Former-commit-id: 50950ba49767282d35ac4b7dba78dc9c98af5f2b
---
 src/modelchecker/DFTAnalyser.h | 158 +++++++++++++++++++++++++++++++++
 src/storage/dft/DFT.cpp        |  40 +++++++++
 src/storage/dft/DFT.h          |   7 ++
 src/storm-dyftee.cpp           |  76 +++-------------
 4 files changed, 218 insertions(+), 63 deletions(-)
 create mode 100644 src/modelchecker/DFTAnalyser.h

diff --git a/src/modelchecker/DFTAnalyser.h b/src/modelchecker/DFTAnalyser.h
new file mode 100644
index 000000000..93bc7c7b1
--- /dev/null
+++ b/src/modelchecker/DFTAnalyser.h
@@ -0,0 +1,158 @@
+#pragma once
+
+#include "logic/Formula.h"
+#include "parser/DFTGalileoParser.h"
+#include "builder/ExplicitDFTModelBuilder.h"
+#include "modelchecker/results/CheckResult.h"
+#include "utility/storm.h"
+#include "storage/dft/DFTIsomorphism.h"
+
+
+#include <chrono>
+
+template<typename ValueType>
+class DFTAnalyser {
+    
+    std::chrono::duration<double> buildingTime = std::chrono::duration<double>::zero();
+    std::chrono::duration<double> explorationTime = std::chrono::duration<double>::zero();
+    std::chrono::duration<double> bisimulationTime = std::chrono::duration<double>::zero();
+    std::chrono::duration<double> modelCheckingTime = std::chrono::duration<double>::zero();
+    std::chrono::duration<double> totalTime = std::chrono::duration<double>::zero();
+    ValueType checkResult = storm::utility::zero<ValueType>();
+public:
+    void check(storm::storage::DFT<ValueType> dft , std::shared_ptr<const storm::logic::Formula> const& formula, bool symred = true, bool allowModularisation = true) {
+        
+        // Building DFT
+        std::chrono::high_resolution_clock::time_point totalStart = std::chrono::high_resolution_clock::now();
+        
+        
+        // Optimizing DFT
+        dft = dft.optimize();
+        std::vector<storm::storage::DFT<ValueType>> dfts;
+        checkResult = checkHelper(dft, formula, symred, allowModularisation);
+        totalTime = std::chrono::high_resolution_clock::now() - totalStart;
+            
+        
+            
+    }
+    
+private:
+    ValueType checkHelper(storm::storage::DFT<ValueType> const& dft , std::shared_ptr<const storm::logic::Formula> const& formula, bool symred = true, bool allowModularisation = true)  {
+        std::cout << "check helper called" << std::endl;
+        bool invResults = false;
+        std::vector<storm::storage::DFT<ValueType>> dfts = {dft};
+        std::vector<ValueType> res;
+        
+        if(allowModularisation) {
+            std::cout << dft.topLevelType() << std::endl;
+            if(dft.topLevelType() == storm::storage::DFTElementType::AND) {
+                std::cout << "top modularisation called AND" << std::endl;
+                dfts = dft.topModularisation();
+                if(dfts.size() > 1) {
+                    for(auto const ft : dfts) {
+                        res.push_back(checkHelper(ft, formula, symred, allowModularisation));
+                    }
+                }
+            }
+            if(dft.topLevelType() == storm::storage::DFTElementType::OR) {
+                std::cout << "top modularisation called OR" << std::endl;
+                dfts = dft.topModularisation();
+                if(dfts.size() > 1) {
+                    for(auto const ft : dfts) {
+                        res.push_back(checkHelper(ft, formula, symred, allowModularisation));
+                    }
+                }
+                invResults = true;
+            }
+        } 
+        if(res.empty()) {
+            // Model based modularisation.
+            auto const& models = buildMarkovModels(dfts, formula, symred);
+
+
+            for (auto const& model : models) {
+                // Model checking
+                std::cout << "Model checking..." << std::endl;
+                std::chrono::high_resolution_clock::time_point modelCheckingStart = std::chrono::high_resolution_clock::now();
+                std::unique_ptr<storm::modelchecker::CheckResult> result(storm::verifySparseModel(model, formula));
+                std::cout << "done." << std::endl;
+                assert(result);
+                result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
+                modelCheckingTime += std::chrono::high_resolution_clock::now() -  modelCheckingStart;
+                res.push_back(result->asExplicitQuantitativeCheckResult<ValueType>().getValueMap().begin()->second);
+            }
+        }
+        
+        ValueType result = storm::utility::one<ValueType>();
+        for(auto const& r : res) {
+            if(invResults) {
+                result *= storm::utility::one<ValueType>() - r;
+            } else {
+                result *= r;
+            }
+        }
+        if(invResults) {
+            return storm::utility::one<ValueType>() - result;
+        }
+        return result;
+    }
+    
+    
+    std::vector<std::shared_ptr<storm::models::sparse::Model<ValueType>>> buildMarkovModels(std::vector<storm::storage::DFT<ValueType>> const&  dfts,   std::shared_ptr<const storm::logic::Formula> const& formula, bool symred) {
+        std::vector<std::shared_ptr<storm::models::sparse::Model<ValueType>>> models;
+        for(auto& dft : dfts) {
+            std::chrono::high_resolution_clock::time_point buildingStart = std::chrono::high_resolution_clock::now();
+
+            std::map<size_t, std::vector<std::vector<size_t>>> emptySymmetry;
+            storm::storage::DFTIndependentSymmetries symmetries(emptySymmetry);
+            if(symred) {
+                auto colouring = dft.colourDFT();
+                symmetries = dft.findSymmetries(colouring);
+                std::cout << "Found " << symmetries.groups.size() << " symmetries." << std::endl;
+                STORM_LOG_TRACE("Symmetries: " << std::endl << symmetries);
+            }
+            std::chrono::high_resolution_clock::time_point buildingEnd = std::chrono::high_resolution_clock::now();
+            buildingTime += buildingEnd - buildingStart;
+            
+            // Building Markov Automaton
+            std::cout << "Building Model..." << std::endl;
+            storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft, symmetries);
+            typename storm::builder::ExplicitDFTModelBuilder<ValueType>::LabelOptions labeloptions; // TODO initialize this with the formula
+            std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildModel(labeloptions);
+            //model->printModelInformationToStream(std::cout);
+            std::cout << "No. states (Explored): " << model->getNumberOfStates() << std::endl;
+            std::cout << "No. transitions (Explored): " << model->getNumberOfTransitions() << std::endl;
+            std::chrono::high_resolution_clock::time_point explorationEnd = std::chrono::high_resolution_clock::now();
+            explorationTime += explorationEnd -buildingEnd;
+
+            // Bisimulation
+            if (model->isOfType(storm::models::ModelType::Ctmc)) {
+                std::cout << "Bisimulation..." << std::endl;
+                model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), {formula}, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
+                //model->printModelInformationToStream(std::cout);
+            }
+            std::cout << "No. states (Bisimulation): " << model->getNumberOfStates() << std::endl;
+            std::cout << "No. transitions (Bisimulation): " << model->getNumberOfTransitions() << std::endl;
+            bisimulationTime += std::chrono::high_resolution_clock::now() - explorationEnd;
+            models.push_back(model);
+        }
+        return models;
+    }
+    
+public:
+    void printTimings(std::ostream& os = std::cout) {
+        os << "Times:" << std::endl;
+        os << "Building:\t" << buildingTime.count() << std::endl;
+        os << "Exploration:\t" << explorationTime.count() << std::endl;
+        os << "Bisimulation:\t" << bisimulationTime.count() << std::endl;
+        os << "Modelchecking:\t" << modelCheckingTime.count() << std::endl;
+        os << "Total:\t\t" << totalTime.count() << std::endl;
+    }
+    
+    void printResult(std::ostream& os = std::cout) {
+        
+        os << "Result: [";
+        os << checkResult << "]" << std::endl;
+    }
+    
+};
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index dd771f230..482e8203c 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -247,6 +247,46 @@ namespace storm {
             return stateIndex;
         }
         
+        template<typename ValueType>
+        std::vector<DFT<ValueType>>  DFT<ValueType>::topModularisation() const {
+            assert(isGate(mTopLevelIndex));
+            auto const& children = getGate(mTopLevelIndex)->children();
+            std::map<size_t, std::vector<size_t>> subdfts;
+            for(auto const& child : children) {
+                std::vector<size_t> isubdft;
+                if(child->nrParents() > 1 || child->hasOutgoingDependencies()) {
+                    return {*this};
+                }
+                if (isGate(child->id())) {
+                    isubdft = getGate(child->id())->independentSubDft(false);
+                } else {
+                    assert(isBasicElement(child->id()));
+                    if(!getBasicElement(child->id())->hasIngoingDependencies()) {
+                        isubdft = {child->id()};
+                    }
+                    
+                }
+                if(isubdft.empty()) {
+                    return {*this};
+                } else {
+                    subdfts[child->id()] = isubdft;
+                }
+            }
+            
+            std::vector<DFT<ValueType>> res;
+            for(auto const& subdft : subdfts) {
+                DFTBuilder<ValueType> builder;
+            
+                for(size_t id : subdft.second) {
+                    builder.copyElement(mElements[id]);
+                }
+                builder.setTopLevel(mElements[subdft.first]->name());
+                res.push_back(builder.build());
+            }
+            return res;
+            
+        }
+        
         template<typename ValueType>
         DFT<ValueType> DFT<ValueType>::optimize() const {
             std::vector<size_t> modIdea = findModularisationRewrite();
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index f28d244f0..0f4832fb5 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -6,6 +6,7 @@
 #include <unordered_map>
 #include <list>
 #include <map>
+#include <vector>
 
 #include <boost/iterator/counting_iterator.hpp>
 
@@ -95,6 +96,10 @@ namespace storm {
                 return mTopLevelIndex;
             }
             
+            DFTElementType topLevelType() const {
+                return mElements[getTopLevelIndex()]->type();
+            }
+            
             size_t getMaxSpareChildCount() const {
                 return mMaxSpareChildCount;
             }
@@ -187,6 +192,8 @@ namespace storm {
                 return elements;
             }
             
+            std::vector<DFT<ValueType>> topModularisation() const;
+            
             bool isRepresentative(size_t id) const {
                 for (auto const& parent : getElement(id)->parents()) {
                     if (parent->isSpareGate()) {
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 1f170072b..f280bbebf 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -1,11 +1,7 @@
 #include "logic/Formula.h"
-#include "parser/DFTGalileoParser.h"
 #include "utility/initialize.h"
-#include "builder/ExplicitDFTModelBuilder.h"
-#include "modelchecker/results/CheckResult.h"
 #include "utility/storm.h"
-#include "storage/dft/DFTIsomorphism.h"
-
+#include "modelchecker/DFTAnalyser.h"
 #include <boost/lexical_cast.hpp>
 
 /*!
@@ -15,71 +11,20 @@
  * @param property PCTC formula capturing the property to check.
  */
 template <typename ValueType>
-void analyzeDFT(std::string filename, std::string property, bool symred = false) {
+void analyzeDFT(std::string filename, std::string property, bool symred = false, bool allowModularisation = false) {
     storm::settings::SettingsManager& manager = storm::settings::mutableManager();
     manager.setFromString("");
 
-    // Building DFT
-    std::chrono::high_resolution_clock::time_point buildingStart = std::chrono::high_resolution_clock::now();
     storm::parser::DFTGalileoParser<ValueType> parser;
     storm::storage::DFT<ValueType> dft = parser.parseDFT(filename);
     std::vector<std::shared_ptr<storm::logic::Formula>> parsedFormulas = storm::parseFormulasForExplicit(property);
     std::vector<std::shared_ptr<const storm::logic::Formula>> formulas(parsedFormulas.begin(), parsedFormulas.end());
     assert(formulas.size() == 1);
     
-    // Optimizing DFT
-    dft = dft.optimize();
-    std::map<size_t, std::vector<std::vector<size_t>>> emptySymmetry;
-    storm::storage::DFTIndependentSymmetries symmetries(emptySymmetry);
-    if(symred) {
-        auto colouring = dft.colourDFT();
-        symmetries = dft.findSymmetries(colouring);
-        std::cout << "Found " << symmetries.groups.size() << " symmetries." << std::endl;
-        STORM_LOG_TRACE("Symmetries: " << std::endl << symmetries);
-    }
-    std::chrono::high_resolution_clock::time_point buildingEnd = std::chrono::high_resolution_clock::now();
-    
-    // Building Markov Automaton
-    std::cout << "Building Model..." << std::endl;
-    storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft, symmetries);
-    typename storm::builder::ExplicitDFTModelBuilder<ValueType>::LabelOptions labeloptions; // TODO initialize this with the formula
-    std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildModel(labeloptions);
-    //model->printModelInformationToStream(std::cout);
-    std::cout << "No. states (Explored): " << model->getNumberOfStates() << std::endl;
-    std::cout << "No. transitions (Explored): " << model->getNumberOfTransitions() << std::endl;
-    std::chrono::high_resolution_clock::time_point explorationEnd = std::chrono::high_resolution_clock::now();
-    
-    // Bisimulation
-    if (model->isOfType(storm::models::ModelType::Ctmc)) {
-        std::cout << "Bisimulation..." << std::endl;
-        model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), formulas, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
-        //model->printModelInformationToStream(std::cout);
-    }
-    std::cout << "No. states (Bisimulation): " << model->getNumberOfStates() << std::endl;
-    std::cout << "No. transitions (Bisimulation): " << model->getNumberOfTransitions() << std::endl;
-    std::chrono::high_resolution_clock::time_point bisimulationEnd = std::chrono::high_resolution_clock::now();
-    
-    // Model checking
-    std::cout << "Model checking..." << std::endl;
-    std::unique_ptr<storm::modelchecker::CheckResult> result(storm::verifySparseModel(model, formulas[0]));
-    assert(result);
-    result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
-    
-    // Times
-    std::chrono::high_resolution_clock::time_point modelCheckingEnd = std::chrono::high_resolution_clock::now();
-    std::chrono::duration<double> buildingTime = buildingEnd - buildingStart;
-    std::chrono::duration<double> explorationTime = explorationEnd - buildingEnd;
-    std::chrono::duration<double> bisimulationTime = bisimulationEnd - explorationEnd;
-    std::chrono::duration<double> modelCheckingTime = modelCheckingEnd - bisimulationEnd;
-    std::chrono::duration<double> totalTime = modelCheckingEnd - buildingStart;
-    std::cout << "Times:" << std::endl;
-    std::cout << "Building:\t" << buildingTime.count() << std::endl;
-    std::cout << "Exploration:\t" << explorationTime.count() << std::endl;
-    std::cout << "Bisimulation:\t" << bisimulationTime.count() << std::endl;
-    std::cout << "Modelchecking:\t" << modelCheckingTime.count() << std::endl;
-    std::cout << "Total:\t\t" << totalTime.count() << std::endl;
-    std::cout << "Result: ";
-    std::cout << *result << std::endl;
+    DFTAnalyser<ValueType> analyser;
+    analyser.check(dft, formulas[0], symred, allowModularisation);
+    analyser.printTimings();
+    analyser.printResult();
 }
 
 /*!
@@ -100,6 +45,8 @@ int main(int argc, char** argv) {
     bool parametric = false;
     bool symred = false;
     bool minimal = true;
+    bool allowModular = true;
+    bool enableModularisation = false;
     std::string filename = argv[1];
     std::string operatorType = "";
     std::string targetFormula = "";
@@ -112,6 +59,7 @@ int main(int argc, char** argv) {
             assert(targetFormula.empty());
             operatorType = "ET";
             targetFormula = "F \"failed\"";
+            allowModular = false;
         } else if (option == "--probability") {
             assert(targetFormula.empty());
             operatorType = "P";;
@@ -142,6 +90,8 @@ int main(int argc, char** argv) {
             pctlFormula = argv[i];
         } else if (option == "--symred") {
             symred = true;
+        } else if (option == "--modularisation") {
+            enableModularisation = true;
         } else if (option == "--min") {
             minimal = true;
         } else if (option == "--max") {
@@ -164,8 +114,8 @@ int main(int argc, char** argv) {
     std::cout << "Running " << (parametric ? "parametric " : "") << "DFT analysis on file " << filename << " with property " << pctlFormula << std::endl;
 
     if (parametric) {
-        analyzeDFT<storm::RationalFunction>(filename, pctlFormula, symred);
+        analyzeDFT<storm::RationalFunction>(filename, pctlFormula, symred, allowModular && enableModularisation );
     } else {
-        analyzeDFT<double>(filename, pctlFormula, symred);
+        analyzeDFT<double>(filename, pctlFormula, symred, allowModular && enableModularisation);
     }
 }

From e5fd60449830058b3fc95f2097bc03ac29548c7b Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 14 Mar 2016 16:42:53 +0100
Subject: [PATCH 214/246] Flag for disabling DC propagation

Former-commit-id: 1fa850ef266cc00bb51068934823a1ca95ff79da
---
 src/builder/ExplicitDFTModelBuilder.cpp |  4 ++--
 src/builder/ExplicitDFTModelBuilder.h   |  3 ++-
 src/modelchecker/DFTAnalyser.h          | 12 ++++++------
 src/storm-dyftee.cpp                    | 11 +++++++----
 4 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index d57dec2e7..f5296a487 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -15,7 +15,7 @@ namespace storm {
         }
         
         template <typename ValueType>
-        ExplicitDFTModelBuilder<ValueType>::ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft, storm::storage::DFTIndependentSymmetries const& symmetries) : mDft(dft), mStates(((mDft.stateVectorSize() / 64) + 1) * 64, INITIAL_BUCKETSIZE) {
+        ExplicitDFTModelBuilder<ValueType>::ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft, storm::storage::DFTIndependentSymmetries const& symmetries, bool enableDC) : mDft(dft), mStates(((mDft.stateVectorSize() / 64) + 1) * 64, INITIAL_BUCKETSIZE), enableDC(enableDC) {
             // stateVectorSize is bound for size of bitvector
 
             mStateGenerationInfo = std::make_shared<storm::storage::DFTStateGenerationInfo>(mDft.buildStateGenerationInfo(symmetries));
@@ -218,7 +218,7 @@ namespace storm {
                         next->checkFailsafe(*newState, queues);
                     }
 
-                    while (!queues.dontCarePropagationDone()) {
+                    while (enableDC && !queues.dontCarePropagationDone()) {
                         DFTElementPointer next = queues.nextDontCarePropagation();
                         next->checkDontCareAnymore(*newState, queues);
                     }
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 7fc343be2..4f1dff514 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -55,6 +55,7 @@ namespace storm {
             std::vector<std::pair<uint_fast64_t, storm::storage::BitVector>> mPseudoStatesMapping; // vector of (id to concrete state, bitvector)
             size_t newIndex = 0;
             bool mergeFailedStates = true;
+            bool enableDC = true;
             size_t failedIndex = 0;
             size_t initialStateIndex = 0;
 
@@ -65,7 +66,7 @@ namespace storm {
                 std::set<std::string> beLabels = {};
             };
             
-            ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft, storm::storage::DFTIndependentSymmetries const& symmetries);
+            ExplicitDFTModelBuilder(storm::storage::DFT<ValueType> const& dft, storm::storage::DFTIndependentSymmetries const& symmetries, bool enableDC);
 
             std::shared_ptr<storm::models::sparse::Model<ValueType>> buildModel(LabelOptions const& labelOpts);
 
diff --git a/src/modelchecker/DFTAnalyser.h b/src/modelchecker/DFTAnalyser.h
index 93bc7c7b1..0bf9d491e 100644
--- a/src/modelchecker/DFTAnalyser.h
+++ b/src/modelchecker/DFTAnalyser.h
@@ -20,7 +20,7 @@ class DFTAnalyser {
     std::chrono::duration<double> totalTime = std::chrono::duration<double>::zero();
     ValueType checkResult = storm::utility::zero<ValueType>();
 public:
-    void check(storm::storage::DFT<ValueType> dft , std::shared_ptr<const storm::logic::Formula> const& formula, bool symred = true, bool allowModularisation = true) {
+    void check(storm::storage::DFT<ValueType> dft , std::shared_ptr<const storm::logic::Formula> const& formula, bool symred = true, bool allowModularisation = true, bool enableDC = true) {
         
         // Building DFT
         std::chrono::high_resolution_clock::time_point totalStart = std::chrono::high_resolution_clock::now();
@@ -29,7 +29,7 @@ public:
         // Optimizing DFT
         dft = dft.optimize();
         std::vector<storm::storage::DFT<ValueType>> dfts;
-        checkResult = checkHelper(dft, formula, symred, allowModularisation);
+        checkResult = checkHelper(dft, formula, symred, allowModularisation, enableDC);
         totalTime = std::chrono::high_resolution_clock::now() - totalStart;
             
         
@@ -37,7 +37,7 @@ public:
     }
     
 private:
-    ValueType checkHelper(storm::storage::DFT<ValueType> const& dft , std::shared_ptr<const storm::logic::Formula> const& formula, bool symred = true, bool allowModularisation = true)  {
+    ValueType checkHelper(storm::storage::DFT<ValueType> const& dft , std::shared_ptr<const storm::logic::Formula> const& formula, bool symred = true, bool allowModularisation = true, bool enableDC = true)  {
         std::cout << "check helper called" << std::endl;
         bool invResults = false;
         std::vector<storm::storage::DFT<ValueType>> dfts = {dft};
@@ -67,7 +67,7 @@ private:
         } 
         if(res.empty()) {
             // Model based modularisation.
-            auto const& models = buildMarkovModels(dfts, formula, symred);
+            auto const& models = buildMarkovModels(dfts, formula, symred, enableDC);
 
 
             for (auto const& model : models) {
@@ -98,7 +98,7 @@ private:
     }
     
     
-    std::vector<std::shared_ptr<storm::models::sparse::Model<ValueType>>> buildMarkovModels(std::vector<storm::storage::DFT<ValueType>> const&  dfts,   std::shared_ptr<const storm::logic::Formula> const& formula, bool symred) {
+    std::vector<std::shared_ptr<storm::models::sparse::Model<ValueType>>> buildMarkovModels(std::vector<storm::storage::DFT<ValueType>> const&  dfts,   std::shared_ptr<const storm::logic::Formula> const& formula, bool symred, bool enableDC) {
         std::vector<std::shared_ptr<storm::models::sparse::Model<ValueType>>> models;
         for(auto& dft : dfts) {
             std::chrono::high_resolution_clock::time_point buildingStart = std::chrono::high_resolution_clock::now();
@@ -116,7 +116,7 @@ private:
             
             // Building Markov Automaton
             std::cout << "Building Model..." << std::endl;
-            storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft, symmetries);
+            storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft, symmetries, enableDC);
             typename storm::builder::ExplicitDFTModelBuilder<ValueType>::LabelOptions labeloptions; // TODO initialize this with the formula
             std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildModel(labeloptions);
             //model->printModelInformationToStream(std::cout);
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index f280bbebf..ea0da3a14 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -11,7 +11,7 @@
  * @param property PCTC formula capturing the property to check.
  */
 template <typename ValueType>
-void analyzeDFT(std::string filename, std::string property, bool symred = false, bool allowModularisation = false) {
+void analyzeDFT(std::string filename, std::string property, bool symred = false, bool allowModularisation = false, bool enableDC = true) {
     storm::settings::SettingsManager& manager = storm::settings::mutableManager();
     manager.setFromString("");
 
@@ -22,7 +22,7 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false,
     assert(formulas.size() == 1);
     
     DFTAnalyser<ValueType> analyser;
-    analyser.check(dft, formulas[0], symred, allowModularisation);
+    analyser.check(dft, formulas[0], symred, allowModularisation, enableDC);
     analyser.printTimings();
     analyser.printResult();
 }
@@ -47,6 +47,7 @@ int main(int argc, char** argv) {
     bool minimal = true;
     bool allowModular = true;
     bool enableModularisation = false;
+    bool disableDC = false;
     std::string filename = argv[1];
     std::string operatorType = "";
     std::string targetFormula = "";
@@ -92,6 +93,8 @@ int main(int argc, char** argv) {
             symred = true;
         } else if (option == "--modularisation") {
             enableModularisation = true;
+        } else if (option == "--disabledc") {
+            disableDC = true;
         } else if (option == "--min") {
             minimal = true;
         } else if (option == "--max") {
@@ -114,8 +117,8 @@ int main(int argc, char** argv) {
     std::cout << "Running " << (parametric ? "parametric " : "") << "DFT analysis on file " << filename << " with property " << pctlFormula << std::endl;
 
     if (parametric) {
-        analyzeDFT<storm::RationalFunction>(filename, pctlFormula, symred, allowModular && enableModularisation );
+        analyzeDFT<storm::RationalFunction>(filename, pctlFormula, symred, allowModular && enableModularisation, !disableDC );
     } else {
-        analyzeDFT<double>(filename, pctlFormula, symred, allowModular && enableModularisation);
+        analyzeDFT<double>(filename, pctlFormula, symred, allowModular && enableModularisation, !disableDC);
     }
 }

From e390e1c39d01c5ad6fc98d6a54dd0a87e1b0f680 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Mon, 14 Mar 2016 20:47:14 +0100
Subject: [PATCH 215/246] several updates for better modularisation and support
 for VOT-modularisation

Former-commit-id: 97d5d03a868debcea7ae474b6ae070bfa9247ea4
---
 src/modelchecker/DFTAnalyser.h | 74 +++++++++++++++++++++++++---------
 src/storage/dft/DFT.cpp        |  4 +-
 src/storage/dft/DFT.h          |  4 ++
 src/utility/bitoperations.h    | 17 ++++++++
 4 files changed, 77 insertions(+), 22 deletions(-)
 create mode 100644 src/utility/bitoperations.h

diff --git a/src/modelchecker/DFTAnalyser.h b/src/modelchecker/DFTAnalyser.h
index 93bc7c7b1..de128af64 100644
--- a/src/modelchecker/DFTAnalyser.h
+++ b/src/modelchecker/DFTAnalyser.h
@@ -6,6 +6,7 @@
 #include "modelchecker/results/CheckResult.h"
 #include "utility/storm.h"
 #include "storage/dft/DFTIsomorphism.h"
+#include "utility/bitoperations.h"
 
 
 #include <chrono>
@@ -42,28 +43,42 @@ private:
         bool invResults = false;
         std::vector<storm::storage::DFT<ValueType>> dfts = {dft};
         std::vector<ValueType> res;
+        size_t nrK = 0; // K out of M 
+        size_t nrM = 0; // K out of M
         
         if(allowModularisation) {
-            std::cout << dft.topLevelType() << std::endl;
             if(dft.topLevelType() == storm::storage::DFTElementType::AND) {
-                std::cout << "top modularisation called AND" << std::endl;
+                STORM_LOG_TRACE("top modularisation called AND");
                 dfts = dft.topModularisation();
-                if(dfts.size() > 1) {
-                    for(auto const ft : dfts) {
-                        res.push_back(checkHelper(ft, formula, symred, allowModularisation));
-                    }
-                }
+                STORM_LOG_TRACE("Modularsation into " << dfts.size() << " submodules.");
+                nrK = dfts.size();
+                nrM = dfts.size();
             }
             if(dft.topLevelType() == storm::storage::DFTElementType::OR) {
-                std::cout << "top modularisation called OR" << std::endl;
+                STORM_LOG_TRACE("top modularisation called OR");
                 dfts = dft.topModularisation();
-                if(dfts.size() > 1) {
-                    for(auto const ft : dfts) {
-                        res.push_back(checkHelper(ft, formula, symred, allowModularisation));
-                    }
-                }
+                STORM_LOG_TRACE("Modularsation into " << dfts.size() << " submodules.");
+                nrK = 0;
+                nrM = dfts.size();
                 invResults = true;
             }
+            if(dft.topLevelType() == storm::storage::DFTElementType::VOT) {
+                STORM_LOG_TRACE("top modularisation called VOT");
+                dfts = dft.topModularisation();
+                STORM_LOG_TRACE("Modularsation into " << dfts.size() << " submodules.");
+                nrK = std::static_pointer_cast<storm::storage::DFTVot<ValueType> const>(dft.getTopLevelGate())->threshold();
+                nrM = dfts.size();
+                if(nrK <= nrM/2) {
+                    nrK -= 1;
+                    invResults = true;
+                }
+            }
+            if(dfts.size() > 1) {
+                STORM_LOG_TRACE("Recursive CHECK Call");
+                for(auto const ft : dfts) {
+                    res.push_back(checkHelper(ft, formula, symred, allowModularisation));
+                }
+            }
         } 
         if(res.empty()) {
             // Model based modularisation.
@@ -82,14 +97,33 @@ private:
                 res.push_back(result->asExplicitQuantitativeCheckResult<ValueType>().getValueMap().begin()->second);
             }
         }
+        if(nrM <= 1) {
+            // No modularisation done.
+            assert(res.size()==1);
+            return res[0];
+        }
         
-        ValueType result = storm::utility::one<ValueType>();
-        for(auto const& r : res) {
-            if(invResults) {
-                result *= storm::utility::one<ValueType>() - r;
-            } else {
-                result *= r;
-            }
+        STORM_LOG_TRACE("Combining all results... K=" << nrK << "; M=" << nrM << "; invResults=" << (invResults?"On":"Off"));
+        ValueType result = storm::utility::zero<ValueType>();
+        int limK = invResults ? -1 : nrM+1;
+        int chK = invResults ? -1 : 1;
+        for(int cK = nrK; cK != limK; cK += chK ) {
+            assert(cK >= 0);
+            size_t permutation = smallestIntWithNBitsSet(static_cast<size_t>(cK));
+            do {
+                STORM_LOG_TRACE("Permutation="<<permutation);
+                ValueType permResult = storm::utility::one<ValueType>();
+                for(size_t i = 0; i < res.size(); ++i) {
+                    if(permutation & (1 << i)) {
+                        permResult *= res[i];
+                    } else {
+                        permResult *= storm::utility::one<ValueType>() - res[i];
+                    }
+                }
+                STORM_LOG_TRACE("Result for permutation:"<<permResult);
+                permutation = nextBitPermutation(permutation);
+                result += permResult;
+            } while(permutation < (1 << nrM) && permutation != 0);
         }
         if(invResults) {
             return storm::utility::one<ValueType>() - result;
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 482e8203c..4111a2113 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -261,8 +261,8 @@ namespace storm {
                     isubdft = getGate(child->id())->independentSubDft(false);
                 } else {
                     assert(isBasicElement(child->id()));
-                    if(!getBasicElement(child->id())->hasIngoingDependencies()) {
-                        isubdft = {child->id()};
+                    if(getBasicElement(child->id())->hasIngoingDependencies()) {
+                        return {*this};
                     }
                     
                 }
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 0f4832fb5..d82c45dfa 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -167,6 +167,10 @@ namespace storm {
                 return std::static_pointer_cast<DFTBE<ValueType> const>(mElements[index]);
             }
 
+            std::shared_ptr<DFTGate<ValueType> const> getTopLevelGate() const {
+                return getGate(mTopLevelIndex);
+            }
+            
             std::shared_ptr<DFTGate<ValueType> const> getGate(size_t index) const {
                 assert(isGate(index));
                 return std::static_pointer_cast<DFTGate<ValueType> const>(mElements[index]);
diff --git a/src/utility/bitoperations.h b/src/utility/bitoperations.h
new file mode 100644
index 000000000..55456dd61
--- /dev/null
+++ b/src/utility/bitoperations.h
@@ -0,0 +1,17 @@
+#pragma once
+
+inline size_t smallestIntWithNBitsSet(size_t n) {
+    assert(sizeof(size_t) == 8);
+    assert(n < 64); // TODO fix this for 32 bit architectures!
+    if(n==0) return static_cast<size_t>(0);
+    return (1 << n) - 1;
+}
+
+inline size_t nextBitPermutation(size_t v) {
+    if(v==0) return static_cast<size_t>(0);
+    // From https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
+    unsigned int t = (v | (v - 1)) + 1;  
+    return t | ((((t & -t) / (v & -v)) >> 1) - 1);  
+}
+        
+        
\ No newline at end of file

From 2c15c897510daa9a517d7a8839a0b3f6326d1256 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 14 Mar 2016 23:15:07 +0100
Subject: [PATCH 216/246] No DC propagation for failed toplevel

Former-commit-id: a2cf30e0718699411e8972f2c2b8bbb3de6b9455
---
 src/builder/ExplicitDFTModelBuilder.cpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index f5296a487..09fde00ef 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -212,21 +212,23 @@ namespace storm {
                     if(newState->isInvalid()) {
                         continue;
                     }
-
-                    while (!queues.failsafePropagationDone()) {
+                    bool dftFailed = newState->hasFailed(mDft.getTopLevelIndex());
+                    
+                    while (!dftFailed && !queues.failsafePropagationDone()) {
                         DFTGatePointer next = queues.nextFailsafePropagation();
                         next->checkFailsafe(*newState, queues);
                     }
 
-                    while (enableDC && !queues.dontCarePropagationDone()) {
+                    while (!dftFailed && enableDC && !queues.dontCarePropagationDone()) {
                         DFTElementPointer next = queues.nextDontCarePropagation();
                         next->checkDontCareAnymore(*newState, queues);
                     }
                     
                     // Update failable dependencies
-                    newState->updateFailableDependencies(nextBE->id());
+                    if (!dftFailed) {
+                        newState->updateFailableDependencies(nextBE->id());
+                    }
                     
-                    bool dftFailed = newState->hasFailed(mDft.getTopLevelIndex());
                     uint_fast64_t newStateId;
                     if(dftFailed && mergeFailedStates) {
                         newStateId = failedIndex;

From 25e2a9c070110b5346b1f086a5d2e726e5f67c7f Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 14 Mar 2016 23:52:26 +0100
Subject: [PATCH 217/246] Removed assertion

Former-commit-id: a6a64068084841907a4ba7c3cb77a63e76b8ebd3
---
 src/storage/dft/DFT.cpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 4111a2113..653a5dc78 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -26,23 +26,18 @@ namespace storm {
                 }
                 else if (elem->isSpareGate()) {
                     ++mNrOfSpares;
-                    bool firstChild = true;
                     mMaxSpareChildCount = std::max(mMaxSpareChildCount, std::static_pointer_cast<DFTSpare<ValueType>>(elem)->children().size());
                     for(auto const& spareReprs : std::static_pointer_cast<DFTSpare<ValueType>>(elem)->children()) {
                         std::set<size_t> module = {spareReprs->id()};
                         spareReprs->extendSpareModule(module);
                         std::vector<size_t> sparesAndBes;
                         for(size_t modelem : module) {
-                            if (spareReprs->id() != modelem && (isRepresentative(modelem) || (!firstChild && mTopLevelIndex == modelem))) {
-                                STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Module for '" << spareReprs->name() << "' contains more than one representative.");
-                            }
                             if(mElements[modelem]->isSpareGate() || mElements[modelem]->isBasicElement()) {
                                 sparesAndBes.push_back(modelem);
                                 mRepresentants.insert(std::make_pair(modelem, spareReprs->id()));
                             }
                         }
                         mSpareModules.insert(std::make_pair(spareReprs->id(), sparesAndBes));
-                        firstChild = false;
                     }
 
                 } else if (elem->isDependency()) {

From d68829602253e6fb01f5ce6fcd7bbfd6bf68f195 Mon Sep 17 00:00:00 2001
From: sjunges <sebastian.junges@rwth-aachen.de>
Date: Tue, 15 Mar 2016 00:21:10 +0100
Subject: [PATCH 218/246] even more modularisation oppurtunaties are now taken

Former-commit-id: de8fd4c848df80c14380437fe6847eacab504d19
---
 src/modelchecker/DFTAnalyser.h | 5 ++---
 src/storage/dft/DFT.cpp        | 4 ++++
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/modelchecker/DFTAnalyser.h b/src/modelchecker/DFTAnalyser.h
index 0058f41f0..519b8090a 100644
--- a/src/modelchecker/DFTAnalyser.h
+++ b/src/modelchecker/DFTAnalyser.h
@@ -21,15 +21,14 @@ class DFTAnalyser {
     std::chrono::duration<double> totalTime = std::chrono::duration<double>::zero();
     ValueType checkResult = storm::utility::zero<ValueType>();
 public:
-    void check(storm::storage::DFT<ValueType> dft , std::shared_ptr<const storm::logic::Formula> const& formula, bool symred = true, bool allowModularisation = true, bool enableDC = true) {
+    void check(storm::storage::DFT<ValueType> const& origDft , std::shared_ptr<const storm::logic::Formula> const& formula, bool symred = true, bool allowModularisation = true, bool enableDC = true) {
         
         // Building DFT
         std::chrono::high_resolution_clock::time_point totalStart = std::chrono::high_resolution_clock::now();
         
         
         // Optimizing DFT
-        dft = dft.optimize();
-        std::vector<storm::storage::DFT<ValueType>> dfts;
+        storm::storage::DFT<ValueType> dft = origDft.optimize();
         checkResult = checkHelper(dft, formula, symred, allowModularisation, enableDC);
         totalTime = std::chrono::high_resolution_clock::now() - totalStart;
             
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 4111a2113..b679b8a81 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -255,6 +255,7 @@ namespace storm {
             for(auto const& child : children) {
                 std::vector<size_t> isubdft;
                 if(child->nrParents() > 1 || child->hasOutgoingDependencies()) {
+                    STORM_LOG_TRACE("child " << child->name() << "does not allow modularisation.");
                     return {*this};
                 }
                 if (isGate(child->id())) {
@@ -262,7 +263,10 @@ namespace storm {
                 } else {
                     assert(isBasicElement(child->id()));
                     if(getBasicElement(child->id())->hasIngoingDependencies()) {
+                        STORM_LOG_TRACE("child " << child->name() << "does not allow modularisation.");
                         return {*this};
+                    } else {
+                        isubdft = {child->id()};
                     }
                     
                 }

From 4db05a7c208a14d137d68c4c238b806bcfa64ae4 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 15 Mar 2016 15:50:46 +0100
Subject: [PATCH 219/246] Fixed bug with wrong dormancyFactor when copying
 elements

Former-commit-id: 3c2ddcc08a23ecc1184c76eaa31539c0f03cacd1
---
 src/storage/dft/DFTBuilder.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index ea273e234..8241ea70a 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -226,7 +226,7 @@ namespace storm {
                     std::shared_ptr<DFTBE<ValueType>> be = std::static_pointer_cast<DFTBE<ValueType>>(element);
                     ValueType dormancyFactor = storm::utility::zero<ValueType>();
                     if (!storm::utility::isZero(be->passiveFailureRate())) {
-                        dormancyFactor = be->activeFailureRate() / be->passiveFailureRate();
+                        dormancyFactor = be->passiveFailureRate() / be->activeFailureRate();
                     }
                     addBasicElement(be->name(), be->activeFailureRate(), dormancyFactor);
                     break;

From ebbc4ce7b4b9f2887ecb578ee1d443da3564a8f2 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 15 Mar 2016 18:09:24 +0100
Subject: [PATCH 220/246] Fixed compile issues introduced in merge

Former-commit-id: 059b7c84b3b2c7fd9088657621fcbc75c2bf06d1
---
 .../csl/SparseCtmcCslModelChecker.cpp         |  6 +-
 .../csl/SparseCtmcCslModelChecker.h           |  2 +-
 .../csl/helper/SparseCtmcCslHelper.cpp        |  6 +-
 .../csl/helper/SparseCtmcCslHelper.h          |  6 +-
 src/parser/FormulaParser.cpp                  |  6 +-
 src/storage/BitVector.cpp                     | 81 ++++++++++---------
 src/storage/FlexibleSparseMatrix.cpp          | 10 +--
 src/storage/FlexibleSparseMatrix.h            | 12 +--
 src/storage/SparseMatrix.cpp                  | 64 +++++----------
 src/storm-dyftee.cpp                          |  2 +-
 src/utility/storm.h                           |  8 +-
 11 files changed, 93 insertions(+), 110 deletions(-)

diff --git a/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp b/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
index e3cea0fb6..8356620c1 100644
--- a/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
+++ b/src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
@@ -34,7 +34,7 @@ namespace storm {
         template <typename SparseCtmcModelType>
         bool SparseCtmcCslModelChecker<SparseCtmcModelType>::canHandle(CheckTask<storm::logic::Formula> const& checkTask) const {
             storm::logic::Formula const& formula = checkTask.getFormula();
-            return formula.isInFragment(storm::logic::csrl().setGloballyFormulasAllowed(false).setLongRunAverageRewardFormulasAllowed(false).setLongRunAverageProbabilitiesAllowed(true).setExpectedTimeAllowed(true));
+            return formula.isInFragment(storm::logic::csrl().setGloballyFormulasAllowed(false).setLongRunAverageRewardFormulasAllowed(false).setLongRunAverageProbabilitiesAllowed(true).setTimeAllowed(true));
         }
         
         template <typename SparseCtmcModelType>
@@ -114,12 +114,12 @@ namespace storm {
         }
 
         template <typename SparseCtmcModelType>
-        std::unique_ptr<CheckResult> SparseCtmcCslModelChecker<SparseCtmcModelType>::computeExpectedTimes(CheckTask<storm::logic::EventuallyFormula> const& checkTask) {
+        std::unique_ptr<CheckResult> SparseCtmcCslModelChecker<SparseCtmcModelType>::computeReachabilityTimes(storm::logic::RewardMeasureType rewardMeasureType, CheckTask<storm::logic::EventuallyFormula> const& checkTask) {
             storm::logic::EventuallyFormula const& eventuallyFormula = checkTask.getFormula();
             std::unique_ptr<CheckResult> subResultPointer = this->check(eventuallyFormula.getSubformula());
             ExplicitQualitativeCheckResult& subResult = subResultPointer->asExplicitQualitativeCheckResult();
 
-            std::vector<ValueType> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<ValueType>::computeExpectedTimes(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), this->getModel().getExitRateVector(), this->getModel().getInitialStates(), subResult.getTruthValuesVector(), checkTask.isQualitativeSet(), *linearEquationSolverFactory);
+            std::vector<ValueType> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<ValueType>::computeReachabilityTimes(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), this->getModel().getExitRateVector(), this->getModel().getInitialStates(), subResult.getTruthValuesVector(), checkTask.isQualitativeSet(), *linearEquationSolverFactory);
             return std::unique_ptr<CheckResult>(new ExplicitQuantitativeCheckResult<ValueType>(std::move(numericResult)));
         }
 
diff --git a/src/modelchecker/csl/SparseCtmcCslModelChecker.h b/src/modelchecker/csl/SparseCtmcCslModelChecker.h
index 4d838d4d8..802841dee 100644
--- a/src/modelchecker/csl/SparseCtmcCslModelChecker.h
+++ b/src/modelchecker/csl/SparseCtmcCslModelChecker.h
@@ -28,7 +28,7 @@ namespace storm {
             virtual std::unique_ptr<CheckResult> computeInstantaneousRewards(storm::logic::RewardMeasureType rewardMeasureType, CheckTask<storm::logic::InstantaneousRewardFormula> const& checkTask) override;
             virtual std::unique_ptr<CheckResult> computeReachabilityRewards(storm::logic::RewardMeasureType rewardMeasureType, CheckTask<storm::logic::EventuallyFormula> const& checkTask) override;
             virtual std::unique_ptr<CheckResult> computeLongRunAverageProbabilities(CheckTask<storm::logic::StateFormula> const& checkTask) override;
-            virtual std::unique_ptr<CheckResult> computeExpectedTimes(CheckTask<storm::logic::EventuallyFormula> const& checkTask) override;
+            virtual std::unique_ptr<CheckResult> computeReachabilityTimes(storm::logic::RewardMeasureType rewardMeasureType, CheckTask<storm::logic::EventuallyFormula> const& checkTask) override;
 
         private:
             // An object that is used for solving linear equations and performing matrix-vector multiplication.
diff --git a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
index ff04148aa..d0f8a1b69 100644
--- a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
+++ b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
@@ -656,7 +656,7 @@ namespace storm {
             }
 
             template <typename ValueType>
-            std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory) {
+            std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeReachabilityTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory) {
                 // Compute expected time on CTMC by reduction to DTMC with rewards.
                 storm::storage::SparseMatrix<ValueType> probabilityMatrix = computeProbabilityMatrix(rateMatrix, exitRateVector);
 
@@ -677,7 +677,7 @@ namespace storm {
 
             
             template <typename ValueType>
-            std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeExpectedTimesElimination(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative) {
+            std::vector<ValueType> SparseCtmcCslHelper<ValueType>::computeReachabilityTimesElimination(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative) {
                 // Use "normal" function again, if RationalFunction finally is supported.
                 // Compute expected time on CTMC by reduction to DTMC with rewards.
                 storm::storage::SparseMatrix<ValueType> probabilityMatrix = computeProbabilityMatrix(rateMatrix, exitRateVector);
@@ -704,7 +704,7 @@ namespace storm {
 
 #ifdef STORM_HAVE_CARL
             template std::vector<storm::RationalFunction> SparseCtmcCslHelper<storm::RationalFunction>::computeUntilProbabilitiesElimination(storm::storage::SparseMatrix<storm::RationalFunction> const& rateMatrix, storm::storage::SparseMatrix<storm::RationalFunction> const& backwardTransitions, std::vector<storm::RationalFunction> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, bool qualitative);
-            template std::vector<storm::RationalFunction> SparseCtmcCslHelper<storm::RationalFunction>::computeExpectedTimesElimination(storm::storage::SparseMatrix<storm::RationalFunction> const& rateMatrix, storm::storage::SparseMatrix<storm::RationalFunction> const& backwardTransitions, std::vector<storm::RationalFunction> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative);
+            template std::vector<storm::RationalFunction> SparseCtmcCslHelper<storm::RationalFunction>::computeReachabilityTimesElimination(storm::storage::SparseMatrix<storm::RationalFunction> const& rateMatrix, storm::storage::SparseMatrix<storm::RationalFunction> const& backwardTransitions, std::vector<storm::RationalFunction> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative);
 #endif
         }
     }
diff --git a/src/modelchecker/csl/helper/SparseCtmcCslHelper.h b/src/modelchecker/csl/helper/SparseCtmcCslHelper.h
index 14a98f752..2b4dd6043 100644
--- a/src/modelchecker/csl/helper/SparseCtmcCslHelper.h
+++ b/src/modelchecker/csl/helper/SparseCtmcCslHelper.h
@@ -29,8 +29,8 @@ namespace storm {
                 
                 static std::vector<ValueType> computeLongRunAverageProbabilities(storm::storage::SparseMatrix<ValueType> const& probabilityMatrix, storm::storage::BitVector const& psiStates, std::vector<ValueType> const* exitRateVector, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory);
                 
-                static std::vector<ValueType> computeExpectedTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory);
-                static std::vector<ValueType> computeExpectedTimesElimination(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative);
+                static std::vector<ValueType> computeReachabilityTimes(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative, storm::utility::solver::LinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory);
+                static std::vector<ValueType> computeReachabilityTimesElimination(storm::storage::SparseMatrix<ValueType> const& rateMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::vector<ValueType> const& exitRateVector, storm::storage::BitVector const& initialStates, storm::storage::BitVector const& targetStates, bool qualitative);
 
                 /*!
                  * Computes the matrix representing the transitions of the uniformized CTMC.
@@ -82,4 +82,4 @@ namespace storm {
     }
 }
 
-#endif /* STORM_MODELCHECKER_SPARSE_CTMC_CSL_MODELCHECKER_HELPER_H_ */
\ No newline at end of file
+#endif /* STORM_MODELCHECKER_SPARSE_CTMC_CSL_MODELCHECKER_HELPER_H_ */
diff --git a/src/parser/FormulaParser.cpp b/src/parser/FormulaParser.cpp
index 97614507a..22803d9c1 100644
--- a/src/parser/FormulaParser.cpp
+++ b/src/parser/FormulaParser.cpp
@@ -280,7 +280,7 @@ namespace storm {
             booleanLiteralFormula = (qi::lit("true")[qi::_a = true] | qi::lit("false")[qi::_a = false])[qi::_val = phoenix::bind(&FormulaParserGrammar::createBooleanLiteralFormula, phoenix::ref(*this), qi::_a)];
             booleanLiteralFormula.name("boolean literal formula");
             
-            operatorFormula = probabilityOperator | rewardOperator | longRunAverageOperator | expectedTimeOperator;
+            operatorFormula = probabilityOperator | rewardOperator | longRunAverageOperator | timeOperator;
             operatorFormula.name("operator formulas");
             
             atomicStateFormula = booleanLiteralFormula | labelFormula | expressionFormula | (qi::lit("(") > stateFormula > qi::lit(")")) | operatorFormula;
@@ -355,7 +355,7 @@ namespace storm {
             debug(probabilityOperator);
             debug(rewardOperator);
             debug(longRunAverageOperator);
-            debug(expectedTimeOperator);
+            debug(timeOperator);
             debug(pathFormulaWithoutUntil);
             debug(pathFormula);
 //            debug(conditionalFormula);
@@ -379,7 +379,7 @@ namespace storm {
             qi::on_error<qi::fail>(probabilityOperator, handler(qi::_1, qi::_2, qi::_3, qi::_4));
             qi::on_error<qi::fail>(rewardOperator, handler(qi::_1, qi::_2, qi::_3, qi::_4));
             qi::on_error<qi::fail>(longRunAverageOperator, handler(qi::_1, qi::_2, qi::_3, qi::_4));
-            qi::on_error<qi::fail>(expectedTimeOperator, handler(qi::_1, qi::_2, qi::_3, qi::_4));
+            qi::on_error<qi::fail>(timeOperator, handler(qi::_1, qi::_2, qi::_3, qi::_4));
             qi::on_error<qi::fail>(operatorInformation, handler(qi::_1, qi::_2, qi::_3, qi::_4));
             qi::on_error<qi::fail>(pathFormulaWithoutUntil, handler(qi::_1, qi::_2, qi::_3, qi::_4));
             qi::on_error<qi::fail>(pathFormula, handler(qi::_1, qi::_2, qi::_3, qi::_4));
diff --git a/src/storage/BitVector.cpp b/src/storage/BitVector.cpp
index f5aea6370..28f6bdcff 100644
--- a/src/storage/BitVector.cpp
+++ b/src/storage/BitVector.cpp
@@ -468,10 +468,10 @@ namespace storm {
             if (bitIndexInBucket  < 62) { // bitIndexInBucket + 2 < 64
                 // If the value stops before the end of the bucket, we need to erase some lower bits.
                 mask &= ~((1ull << (62 - (bitIndexInBucket))) - 1ull);
-                return (bucketVector[bucket] & mask) >> (62 - bitIndexInBucket);
+                return (buckets[bucket] & mask) >> (62 - bitIndexInBucket);
             } else {
                 // In this case, it suffices to take the current mask.
-                return bucketVector[bucket] & mask;
+                return buckets[bucket] & mask;
             }
         }
         
@@ -669,29 +669,29 @@ namespace storm {
             storm::storage::BitVector result(length, false);
             
             uint_fast64_t offset = start % 64;
-            uint_fast64_t bucketIndex = start / 64;
-            uint_fast64_t insertBucket = 0;
+            uint64_t* getBucket = buckets + (start / 64);
+            uint64_t* insertBucket = result.buckets;
             uint_fast64_t getValue;
             uint_fast64_t writeValue = 0;
             uint_fast64_t noBits = 0;
             if (offset == 0) {
                 // Copy complete buckets
-                for ( ; noBits + 64 <= length; ++bucketIndex, ++insertBucket, noBits += 64) {
-                    result.bucketVector[insertBucket] = bucketVector[bucketIndex];
+                for ( ; noBits + 64 <= length; ++getBucket, ++insertBucket, noBits += 64) {
+                    *insertBucket = *getBucket;
                 }
             } else {
                 //Get first bits up until next bucket
-                getValue = bucketVector[bucketIndex];
+                getValue = *getBucket;
                 writeValue = (getValue << offset);
                 noBits += (64-offset);
-                ++bucketIndex;
+                ++getBucket;
                 
                 //Get complete buckets
-                for ( ; noBits + 64 <= length; ++bucketIndex, ++insertBucket, noBits += 64) {
-                    getValue = bucketVector[bucketIndex];
+                for ( ; noBits + 64 <= length; ++getBucket, ++insertBucket, noBits += 64) {
+                    getValue = *getBucket;
                     // Get bits till write bucket is full
                     writeValue |= (getValue >> (64-offset));
-                    result.bucketVector[insertBucket] = writeValue;
+                    *insertBucket = writeValue;
                     // Get bits up until next bucket
                     writeValue = (getValue << offset);
                 }
@@ -699,22 +699,23 @@ namespace storm {
             
             // Write last bits
             uint_fast64_t remainingBits = length - noBits;
-            assert(bucketIndex < bucketCount());
+            assert(getBucket != buckets + bucketCount());
             // Get remaining bits
-            getValue = (bucketVector[bucketIndex] >> (64-remainingBits)) << (64-remainingBits);
+            getValue = (*getBucket >> (64-remainingBits)) << (64-remainingBits);
             assert(remainingBits < 64);
             // Write bucket
-            assert(insertBucket < result.bucketCount());
+            assert(insertBucket != result.buckets + result.bucketCount());
             if (offset == 0) {
-                result.bucketVector[insertBucket]= getValue;
+                *insertBucket = getValue;
             } else {
                 writeValue |= getValue >> (64-offset);
-                result.bucketVector[insertBucket] = writeValue;
+                *insertBucket = writeValue;
                 if (remainingBits > offset) {
                     // Write last bits in new value
                     writeValue = (getValue << offset);
-                    assert(insertBucket+1 < result.bucketCount());
-                    result.bucketVector[++insertBucket] = writeValue;
+                    ++insertBucket;
+                    assert(insertBucket != result.buckets + result.bucketCount());
+                    *insertBucket = writeValue;
                 }
             }
 
@@ -752,56 +753,58 @@ namespace storm {
             assert(start + other.bitCount <= bitCount);
             
             uint_fast64_t offset = start % 64;
-            uint_fast64_t bucketIndex = start / 64;
-            uint_fast64_t getBucket = 0;
+            uint64_t* insertBucket = buckets + (start / 64);
+            uint64_t* getBucket = other.buckets;
             uint_fast64_t getValue;
             uint_fast64_t writeValue = 0;
             uint_fast64_t noBits = 0;
             if (offset == 0) {
                 // Copy complete buckets
-                for ( ; noBits + 64 <= other.bitCount; ++bucketIndex, ++getBucket, noBits += 64) {
-                    bucketVector[bucketIndex] = other.bucketVector[getBucket];
+                for ( ; noBits + 64 <= other.bitCount; ++insertBucket, ++getBucket, noBits += 64) {
+                    *insertBucket = *getBucket;
                 }
             } else {
                 //Get first bits up until next bucket
-                getValue = other.bucketVector[getBucket];
-                writeValue = (bucketVector[bucketIndex] >> (64-offset)) << (64-offset);
+                getValue = *getBucket;
+                writeValue = (*insertBucket >> (64-offset)) << (64-offset);
                 writeValue |= (getValue >> offset);
-                bucketVector[bucketIndex] = writeValue;
+                *insertBucket = writeValue;
                 noBits += (64-offset);
-                ++bucketIndex;
+                ++insertBucket;
                 
                 //Get complete buckets
-                for ( ; noBits + 64 <= other.bitCount; ++bucketIndex, noBits += 64) {
+                for ( ; noBits + 64 <= other.bitCount; ++insertBucket, noBits += 64) {
                     // Get all remaining bits from other bucket
                     writeValue = getValue << (64-offset);
                     // Get bits from next bucket
-                    getValue = other.bucketVector[++getBucket];
+                    ++getBucket;
+                    getValue = *getBucket;
                     writeValue |= getValue >> offset;
-                    bucketVector[bucketIndex] = writeValue;
+                    *insertBucket = writeValue;
                 }
             }
             
             // Write last bits
             uint_fast64_t remainingBits = other.bitCount - noBits;
             assert(remainingBits < 64);
-            assert(bucketIndex < bucketCount());
-            assert(getBucket < other.bucketCount());
+            assert(insertBucket != buckets + bucketCount());
+            assert(getBucket != other.buckets + other.bucketCount());
             // Get remaining bits of bucket
-            getValue = other.bucketVector[getBucket];
+            getValue = *getBucket;
             if (offset > 0) {
                 getValue = getValue << (64-offset);
             }
             // Get unchanged part of bucket
-            writeValue = (bucketVector[bucketIndex] << remainingBits) >> remainingBits;
+            writeValue = (*insertBucket << remainingBits) >> remainingBits;
             if (remainingBits > offset && offset > 0) {
                 // Remaining bits do not come from one bucket -> consider next bucket
-                assert(getBucket == other.bucketCount() - 2);
-                getValue |= other.bucketVector[++getBucket] >> offset;
+                ++getBucket;
+                assert(getBucket != other.buckets + other.bucketCount());
+                getValue |= *getBucket >> offset;
             }
             // Write completely
             writeValue |= getValue;
-            bucketVector[bucketIndex] = writeValue;
+            *insertBucket = writeValue;
      
 #ifdef ASSERT_BITVECTOR
             // Check correctness of setter
@@ -919,14 +922,14 @@ namespace storm {
             out << "bit vector(" << getNumberOfSetBits() << "/" << bitCount << ") ";
             uint_fast64_t index = 0;
             for ( ; index * 64 + 64 <= bitCount; ++index) {
-                std::bitset<64> tmp(bucketVector[index]);
+                std::bitset<64> tmp(buckets[index]);
                 out << tmp << "|";
             }
             
             // Print last bits
             if (index * 64 < bitCount) {
-                assert(index == bucketVector.size() - 1);
-                std::bitset<64> tmp(bucketVector[index]);
+                assert(index == bucketCount() - 1);
+                std::bitset<64> tmp(buckets[index]);
                 for (size_t i = 0; i + index * 64 < bitCount; ++i) {
                     // Bits are counted from rightmost in bitset
                     out << tmp[63-i];
diff --git a/src/storage/FlexibleSparseMatrix.cpp b/src/storage/FlexibleSparseMatrix.cpp
index 60422dc08..2e3a4e876 100644
--- a/src/storage/FlexibleSparseMatrix.cpp
+++ b/src/storage/FlexibleSparseMatrix.cpp
@@ -13,8 +13,8 @@ namespace storm {
         }
         
         template<typename ValueType>
-        FlexibleSparseMatrix<ValueType>::FlexibleSparseMatrix(storm::storage::SparseMatrix<ValueType> const& matrix, bool setAllValuesToOne) : data(matrix.getRowCount()), columnCount(matrix.getColumnCount()), nonzeroEntryCount(matrix.getNonzeroEntryCount()), nontrivialRowGrouping(matrix.hasNontrivialRowGrouping()) {
-            if (nontrivialRowGrouping) {
+        FlexibleSparseMatrix<ValueType>::FlexibleSparseMatrix(storm::storage::SparseMatrix<ValueType> const& matrix, bool setAllValuesToOne) : data(matrix.getRowCount()), columnCount(matrix.getColumnCount()), nonzeroEntryCount(matrix.getNonzeroEntryCount()), trivialRowGrouping(matrix.hasTrivialRowGrouping()) {
+            if (!trivialRowGrouping) {
                 rowGroupIndices = matrix.getRowGroupIndices();
             }
             for (index_type rowIndex = 0; rowIndex < matrix.getRowCount(); ++rowIndex) {
@@ -130,8 +130,8 @@ namespace storm {
         }
         
         template<typename ValueType>
-        bool FlexibleSparseMatrix<ValueType>::hasNontrivialRowGrouping() const {
-            return nontrivialRowGrouping;
+        bool FlexibleSparseMatrix<ValueType>::hasTrivialRowGrouping() const {
+            return trivialRowGrouping;
         }
 
         template<typename ValueType>
@@ -208,7 +208,7 @@ namespace storm {
             }
             out << std::endl;
             
-            if (matrix.hasNontrivialRowGrouping()) {
+            if (!matrix.hasTrivialRowGrouping()) {
                 // Iterate over all row groups
                 FlexibleIndex rowGroupCount = matrix.getRowGroupCount();
                 for (FlexibleIndex rowGroup = 0; rowGroup < rowGroupCount; ++rowGroup) {
diff --git a/src/storage/FlexibleSparseMatrix.h b/src/storage/FlexibleSparseMatrix.h
index 28100e0a2..d5e6c2124 100644
--- a/src/storage/FlexibleSparseMatrix.h
+++ b/src/storage/FlexibleSparseMatrix.h
@@ -149,11 +149,11 @@ namespace storm {
             bool empty() const;
             
             /*!
-             * Retrieves whether the matrix has a (possibly) non-trivial row grouping.
+             * Retrieves whether the matrix has a (possibly) trivial row grouping.
              *
-             * @return True iff the matrix has a (possibly) non-trivial row grouping.
+             * @return True iff the matrix has a (possibly) trivial row grouping.
              */
-            bool hasNontrivialRowGrouping() const;
+            bool hasTrivialRowGrouping() const;
 
             /*!
              * Creates a submatrix of the current matrix in place by dropping all rows and columns whose bits are not
@@ -198,9 +198,9 @@ namespace storm {
             // The number of entries in the matrix.
             index_type nonzeroEntryCount;
             
-            // A flag that indicates whether the matrix has a non-trivial row-grouping, i.e. (possibly) more than one
-            // row per row group.
-            bool nontrivialRowGrouping;
+            // A flag indicating whether the matrix has a trivial row grouping. Note that this may be true and yet
+            // there may be row group indices, because they were requested from the outside.
+            bool trivialRowGrouping;
             
             // A vector indicating the row groups of the matrix.
             std::vector<index_type> rowGroupIndices;
diff --git a/src/storage/SparseMatrix.cpp b/src/storage/SparseMatrix.cpp
index 69f12b696..d4028b55d 100644
--- a/src/storage/SparseMatrix.cpp
+++ b/src/storage/SparseMatrix.cpp
@@ -264,9 +264,26 @@ namespace storm {
             // Sort columns per row
             typename SparseMatrix<ValueType>::index_type endGroups;
             typename SparseMatrix<ValueType>::index_type endRows;
-            for (index_type group = 0; group < rowGroupIndices.size(); ++group) {
-                endGroups = group < rowGroupIndices.size()-1 ? rowGroupIndices[group+1] : rowIndications.size();
-                for (index_type i = rowGroupIndices[group]; i < endGroups; ++i) {
+            
+            if (hasCustomRowGrouping) {
+                for (index_type group = 0; group < rowGroupIndices.get().size(); ++group) {
+                    endGroups = group < rowGroupIndices.get().size()-1 ? rowGroupIndices.get()[group+1] : rowIndications.size();
+                    for (index_type i = rowGroupIndices.get()[group]; i < endGroups; ++i) {
+                        endRows = i < rowIndications.size()-1 ? rowIndications[i+1] : columnsAndValues.size();
+                        // Sort the row
+                        std::sort(columnsAndValues.begin() + rowIndications[i], columnsAndValues.begin() + endRows,
+                                  [](MatrixEntry<index_type, value_type> const& a, MatrixEntry<index_type, value_type> const& b) {
+                                      return a.getColumn() < b.getColumn();
+                                  });
+                        // Assert no equal elements
+                        assert(std::is_sorted(columnsAndValues.begin() + rowIndications[i], columnsAndValues.begin() + endRows,
+                                              [](MatrixEntry<index_type, value_type> const& a, MatrixEntry<index_type, value_type> const& b) {
+                                                  return a.getColumn() <= b.getColumn();
+                                              }));
+                    }
+                }
+            } else {
+                for (index_type i = 0; i < rowIndications.size(); ++i) {
                     endRows = i < rowIndications.size()-1 ? rowIndications[i+1] : columnsAndValues.size();
                     // Sort the row
                     std::sort(columnsAndValues.begin() + rowIndications[i], columnsAndValues.begin() + endRows,
@@ -279,47 +296,10 @@ namespace storm {
                                               return a.getColumn() <= b.getColumn();
                                           }));
                 }
+
             }
         }
-        
-        template<typename ValueType>
-        bool SparseMatrixBuilder<ValueType>::replaceColumns(std::vector<index_type> const& replacements, index_type offset) {
-            bool matrixChanged = false;
-            
-            // Walk through all rows.
-            for (index_type row = 0; row < rowIndications.size(); ++row) {
-                bool rowChanged = false;
-                index_type rowEnd = row < rowIndications.size()-1 ? rowIndications[row+1] : columnsAndValues.size();
-                
-                for (auto it = columnsAndValues.begin() + rowIndications[row], ite = columnsAndValues.begin() + rowEnd; it != ite; ++it) {
-                    if (it->getColumn() >= offset && it->getColumn() != replacements[it->getColumn() - offset]) {
-                        it->setColumn(replacements[it->getColumn() - offset]);
-                        rowChanged = true;
-                    }
-                    // Update highest column in a way that only works if the highest appearing index does not become
-                    // lower during performing the replacement.
-                    highestColumn = std::max(highestColumn, it->getColumn());
-                }
-                
-                if (rowChanged) {
-                    matrixChanged = true;
-                    
-                    // Sort the row.
-                    std::sort(columnsAndValues.begin() + rowIndications[row], columnsAndValues.begin() + rowEnd,
-                              [](MatrixEntry<index_type, value_type> const& a, MatrixEntry<index_type, value_type> const& b) {
-                                  return a.getColumn() < b.getColumn();
-                              });
-                    // Assert no equal elements
-                    STORM_LOG_ASSERT(std::is_sorted(columnsAndValues.begin() + rowIndications[row], columnsAndValues.begin() + rowEnd,
-                                                    [](MatrixEntry<index_type, value_type> const& a, MatrixEntry<index_type, value_type> const& b) {
-                                                        return a.getColumn() <= b.getColumn();
-                                                    }), "Must not have different elements with the same column in a row.");
-                }
-            }
-            
-            return matrixChanged;
-        }
-        
+
         template<typename ValueType>
         SparseMatrix<ValueType>::rows::rows(iterator begin, index_type entryCount) : beginIterator(begin), entryCount(entryCount) {
             // Intentionally left empty.
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index ea0da3a14..4f6c1f7e0 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -58,7 +58,7 @@ int main(int argc, char** argv) {
             parametric = true;
         } else if (option == "--expectedtime") {
             assert(targetFormula.empty());
-            operatorType = "ET";
+            operatorType = "T";
             targetFormula = "F \"failed\"";
             allowModular = false;
         } else if (option == "--probability") {
diff --git a/src/utility/storm.h b/src/utility/storm.h
index 96087e30a..ea58705b8 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -356,10 +356,10 @@ namespace storm {
             STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "The parametric engine currently does not support MDPs.");
         } else if (model->getType() == storm::models::ModelType::Ctmc) {
             // Hack to avoid instantiating the CTMC Model Checker which currently does not work for rational functions
-            if (formula->isExpectedTimeOperatorFormula()) {
+            if (formula->isTimeOperatorFormula()) {
                 // Compute expected time for pCTMCs
-                STORM_LOG_THROW(formula->asExpectedTimeOperatorFormula().getSubformula().isReachbilityExpectedTimeFormula(), storm::exceptions::NotSupportedException, "The parametric engine only supports Eventually formulas for this property");
-                storm::logic::EventuallyFormula eventuallyFormula = formula->asExpectedTimeOperatorFormula().getSubformula().asEventuallyFormula();
+                STORM_LOG_THROW(formula->asTimeOperatorFormula().getSubformula().isReachabilityTimeFormula(), storm::exceptions::NotSupportedException, "The parametric engine only supports reachability formulas for this property");
+                storm::logic::EventuallyFormula eventuallyFormula = formula->asTimeOperatorFormula().getSubformula().asReachabilityTimeFormula();
                 STORM_LOG_THROW(eventuallyFormula.getSubformula().isInFragment(storm::logic::propositional()), storm::exceptions::NotSupportedException, "The parametric engine does not support nested formulas on CTMCs");
 
                 // Compute goal states
@@ -368,7 +368,7 @@ namespace storm {
                 std::unique_ptr<storm::modelchecker::CheckResult> subResultPointer = propositionalModelchecker.check(eventuallyFormula.getSubformula());
                 storm::storage::BitVector const& targetStates = subResultPointer->asExplicitQualitativeCheckResult().getTruthValuesVector();
 
-                std::vector<storm::RationalFunction> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<storm::RationalFunction>::computeExpectedTimesElimination(ctmc->getTransitionMatrix(), ctmc->getBackwardTransitions(), ctmc->getExitRateVector(), ctmc->getInitialStates(), targetStates, false);
+                std::vector<storm::RationalFunction> numericResult = storm::modelchecker::helper::SparseCtmcCslHelper<storm::RationalFunction>::computeReachabilityTimesElimination(ctmc->getTransitionMatrix(), ctmc->getBackwardTransitions(), ctmc->getExitRateVector(), ctmc->getInitialStates(), targetStates, false);
                 result = std::unique_ptr<storm::modelchecker::CheckResult>(new storm::modelchecker::ExplicitQuantitativeCheckResult<storm::RationalFunction>(std::move(numericResult)));
 
             } else if (formula->isProbabilityOperatorFormula()) {

From bdad8aedd70da4d5eeaca136047c29799397771f Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 16 Mar 2016 16:59:30 +0100
Subject: [PATCH 221/246] Set dependencies to dont care after dependent event
 has failed

Former-commit-id: 506f5c3107492d91fda2f90152a19c966cf453ef
---
 examples/dft/pdep_symmetry.dft          |  4 ++--
 src/builder/ExplicitDFTModelBuilder.cpp |  1 +
 src/storage/dft/DFTState.cpp            | 26 +++++++++++++++++++++----
 src/storage/dft/DFTState.h              |  8 ++++++++
 4 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/examples/dft/pdep_symmetry.dft b/examples/dft/pdep_symmetry.dft
index 43224d790..5c9254aa5 100644
--- a/examples/dft/pdep_symmetry.dft
+++ b/examples/dft/pdep_symmetry.dft
@@ -2,8 +2,8 @@ toplevel "A";
 "A" and "B" "B'";
 "B" and "C" "D" "PDEP";
 "B'" and "C'" "D'" "PDEP'";
-"PDEP" pdep=0.6 "B" "C";
-"PDEP'" pdep=0.6 "B'" "C'";
+"PDEP" pdep=0.6 "C" "D";
+"PDEP'" pdep=0.6 "C'" "D'";
 "C" lambda=0.5 dorm=0;
 "D" lambda=0.5 dorm=0;
 "C'" lambda=0.5 dorm=0;
diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 09fde00ef..103e87af3 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -227,6 +227,7 @@ namespace storm {
                     // Update failable dependencies
                     if (!dftFailed) {
                         newState->updateFailableDependencies(nextBE->id());
+                        newState->updateDontCareDependencies(nextBE->id());
                     }
                     
                     uint_fast64_t newStateId;
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 24291b446..1468a36ff 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -142,14 +142,21 @@ namespace storm {
         
         template<typename ValueType>
         void DFTState<ValueType>::setDependencySuccessful(size_t id) {
-            // No distinction between successful dependency and no dependency at all
-            // => we do not set bit
-            //mStatus.set(mStateGenerationInfo.mIdToStateIndex(id));
+            // Only distinguish between passive and dont care dependencies
+            //mStatus.set(mStateGenerationInfo.getStateIndex(id));
+            setDependencyDontCare(id);
         }
 
         template<typename ValueType>
         void DFTState<ValueType>::setDependencyUnsuccessful(size_t id) {
-            mStatus.set(mStateGenerationInfo.getStateIndex(id)+1);
+            // Only distinguish between passive and dont care dependencies
+            //mStatus.set(mStateGenerationInfo.getStateIndex(id)+1);
+            setDependencyDontCare(id);
+        }
+        
+        template<typename ValueType>
+        void DFTState<ValueType>::setDependencyDontCare(size_t id) {
+            mStatus.setFromInt(mStateGenerationInfo.getStateIndex(id), 2, static_cast<uint_fast64_t>(DFTDependencyState::DontCare));
         }
 
         template<typename ValueType>
@@ -176,6 +183,17 @@ namespace storm {
             }
             return nrFailableDependencies() > 0;
         }
+        
+        template<typename ValueType>
+        void DFTState<ValueType>::updateDontCareDependencies(size_t id) {
+            assert(mDft.isBasicElement(id));
+            assert(hasFailed(id));
+            
+            for (auto dependency : mDft.getBasicElement(id)->ingoingDependencies()) {
+                assert(dependency->dependentEvent()->id() == id);
+                setDependencyDontCare(dependency->id());
+            }
+        }
 
         template<typename ValueType>
         std::pair<std::shared_ptr<DFTBE<ValueType> const>, bool> DFTState<ValueType>::letNextBEFail(size_t index)
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index faf183411..1311d74ae 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -79,6 +79,8 @@ namespace storm {
 
             void setDependencyUnsuccessful(size_t id);
 
+            void setDependencyDontCare(size_t id);
+
             void beNoLongerFailable(size_t id);
             
             void activate(size_t repr);
@@ -162,6 +164,12 @@ namespace storm {
              * @return true if failable dependent events exist
              */
             bool updateFailableDependencies(size_t id);
+            
+            /**
+             * Sets all dependencies dont care whose dependent event is the newly failed BE.
+             * @param id Id of the newly failed element
+             */
+            void updateDontCareDependencies(size_t id);
 
             /**
              * Sets the next BE as failed

From 7c60e4275d98b5e207f956492ec9d5efa48ceb01 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 16 Mar 2016 18:18:53 +0100
Subject: [PATCH 222/246] Some more parametric DFT examples

Former-commit-id: a2401c9453242663bb864d8e53a94efeae2a0b4c
---
 examples/dft/nonmonoton_param.dft |  8 ++++++++
 examples/dft/spare_param.dft      |  9 +++++++++
 examples/dft/symmetry_param.dft   | 10 ++++++++++
 3 files changed, 27 insertions(+)
 create mode 100644 examples/dft/nonmonoton_param.dft
 create mode 100644 examples/dft/spare_param.dft
 create mode 100644 examples/dft/symmetry_param.dft

diff --git a/examples/dft/nonmonoton_param.dft b/examples/dft/nonmonoton_param.dft
new file mode 100644
index 000000000..e83f3b012
--- /dev/null
+++ b/examples/dft/nonmonoton_param.dft
@@ -0,0 +1,8 @@
+param x;
+param y;
+toplevel "A";
+"A" or "B" "Z";
+"B" pand "D" "S";
+"Z" lambda=y dorm=0;
+"D" lambda=100 dorm=0;
+"S" lambda=100*x dorm=0;
diff --git a/examples/dft/spare_param.dft b/examples/dft/spare_param.dft
new file mode 100644
index 000000000..5378b13d2
--- /dev/null
+++ b/examples/dft/spare_param.dft
@@ -0,0 +1,9 @@
+param x;
+param y;
+toplevel "SF";
+"SF" or "FW" "BW";
+"FW" wsp "W1" "WS";
+"BW" wsp "W2" "WS";
+"W1" lambda=x dorm=0;
+"W2" lambda=1 dorm=0;
+"WS" lambda=y dorm=0;
diff --git a/examples/dft/symmetry_param.dft b/examples/dft/symmetry_param.dft
new file mode 100644
index 000000000..412968c80
--- /dev/null
+++ b/examples/dft/symmetry_param.dft
@@ -0,0 +1,10 @@
+param x;
+param y;
+toplevel "A";
+"A" and "B" "B'";
+"B" and "C" "D";
+"B'" and "C'" "D'";
+"C" lambda=x dorm=0;
+"D" lambda=y dorm=0;
+"C'" lambda=x dorm=0;
+"D'" lambda=y dorm=0;

From fe7037e7fd7d151509ae186c0371bf242b21d22f Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 17 Mar 2016 10:47:50 +0100
Subject: [PATCH 223/246] Support for POR (priority or)

Former-commit-id: f0e782bcb1024ff36a6afcb3989fb132b8e56a6c
---
 src/parser/DFTGalileoParser.cpp   |  2 ++
 src/storage/dft/elements/DFTPor.h | 20 ++++++++++++++++++--
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index 65ad82437..0a0aa5b32 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -100,6 +100,8 @@ namespace storm {
                         success = builder.addVotElement(name, threshold, childNames);
                     } else if (tokens[1] == "pand") {
                         success = builder.addPandElement(name, childNames);
+                    } else if (tokens[1] == "por") {
+                        success = builder.addPorElement(name, childNames);
                     } else if (tokens[1] == "wsp" || tokens[1] == "csp") {
                         success = builder.addSpareElement(name, childNames);
                     } else if (tokens[1] == "seq") {
diff --git a/src/storage/dft/elements/DFTPor.h b/src/storage/dft/elements/DFTPor.h
index 1aaa943b0..c37331354 100644
--- a/src/storage/dft/elements/DFTPor.h
+++ b/src/storage/dft/elements/DFTPor.h
@@ -11,11 +11,27 @@ namespace storm {
             {}
 
             void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                 assert(false);
+                 if(state.isOperational(this->mId)) {
+                    if (state.hasFailed(this->mChildren.front()->id())) {
+                        // First child has failed before others
+                        this->fail(state, queues);
+                    } else {
+                        for (size_t i = 1; i < this->nrChildren(); ++i) {
+                            if (state.hasFailed(this->mChildren[i]->id())) {
+                                // Child has failed before first child
+                                this->failsafe(state, queues);
+                                this->childrenDontCare(state, queues);
+                            }
+                        }
+                    }
+                }
             }
 
             void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                assert(false);
+                if (state.isFailsafe(this->mChildren.front()->id())) {
+                    this->failsafe(state, queues);
+                    this->childrenDontCare(state, queues);
+                }
             }
 
             virtual DFTElementType type() const override {

From 5796da9a5cc81be97f662561fc5425b06de67f51 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 17 Mar 2016 11:28:14 +0100
Subject: [PATCH 224/246] Refactoring

Former-commit-id: ab8665d114efa8f314bb15ebe1e0c6507d06a8f8
---
 src/builder/ExplicitDFTModelBuilder.cpp | 115 +++++++++++-------------
 src/builder/ExplicitDFTModelBuilder.h   |   2 +
 2 files changed, 56 insertions(+), 61 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 103e87af3..7f892a822 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -234,48 +234,7 @@ namespace storm {
                     if(dftFailed && mergeFailedStates) {
                         newStateId = failedIndex;
                     } else {
-                        // Order state by symmetry
-                        STORM_LOG_TRACE("Check for symmetry: " << mDft.getStateString(newState));
-                        bool changed = newState->orderBySymmetry();
-                        STORM_LOG_TRACE("State " << (changed ? "changed to " : "did not change") << (changed ? mDft.getStateString(newState) : ""));
-                        
-                        // Check if state already exists
-                        if (mStates.contains(newState->status())) {
-                            // State already exists
-                            newStateId = mStates.getValue(newState->status());
-                            STORM_LOG_TRACE("State " << mDft.getStateString(newState) << " with id " << newStateId << " already exists");
-                            
-                            // Check if possible pseudo state can be created now
-                            if (!changed && newStateId >= OFFSET_PSEUDO_STATE) {
-                                newStateId = newStateId - OFFSET_PSEUDO_STATE;
-                                assert(newStateId < mPseudoStatesMapping.size());
-                                if (mPseudoStatesMapping[newStateId].first == 0) {
-                                    // Create pseudo state now
-                                    assert(mPseudoStatesMapping[newStateId].second == newState->status());
-                                    newState->setId(newIndex++);
-                                    mPseudoStatesMapping[newStateId].first = newState->getId();
-                                    newStateId = newState->getId();
-                                    mStates.setOrAdd(newState->status(), newStateId);
-                                    stateQueue.push(newState);
-                                    STORM_LOG_TRACE("Now create state " << mDft.getStateString(newState) << " with id " << newStateId);
-                                }
-                            }
-                        } else {
-                            // New state
-                            if (changed) {
-                                // Remember to create state later on
-                                newState->setId(mPseudoStatesMapping.size() + OFFSET_PSEUDO_STATE);
-                                mPseudoStatesMapping.push_back(std::make_pair(0, newState->status()));
-                                newStateId = mStates.findOrAdd(newState->status(), newState->getId());
-                                STORM_LOG_TRACE("New state for later creation: " << mDft.getStateString(newState));
-                            } else {
-                                // Create new state
-                                newState->setId(newIndex++);
-                                newStateId = mStates.findOrAdd(newState->status(), newState->getId());
-                                STORM_LOG_TRACE("New state: " << mDft.getStateString(newState));
-                                stateQueue.push(newState);
-                            }
-                        }
+                        newStateId = addState(newState, stateQueue);
                     }
 
                     // Set transitions
@@ -286,25 +245,10 @@ namespace storm {
                         STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newStateId << " with probability " << dependency->probability());
 
                         if (!storm::utility::isOne(dependency->probability())) {
-                            // TODO Matthias: use symmetry as well
                             // Add transition to state where dependency was unsuccessful
                             DFTStatePointer unsuccessfulState = std::make_shared<storm::storage::DFTState<ValueType>>(*state);
                             unsuccessfulState->letDependencyBeUnsuccessful(smallest-1);
-                            uint_fast64_t unsuccessfulStateId;
-                            if (mStates.contains(unsuccessfulState->status())) {
-                                // Unsuccessful state already exists
-                                unsuccessfulStateId = mStates.getValue(unsuccessfulState->status());
-                                STORM_LOG_TRACE("State " << mDft.getStateString(unsuccessfulState) << " with id " << unsuccessfulStateId << " already exists");
-                            } else {
-                                // New unsuccessful state
-                                unsuccessfulState->setId(newIndex++);
-                                unsuccessfulStateId = mStates.findOrAdd(unsuccessfulState->status(), unsuccessfulState->getId());
-                                STORM_LOG_TRACE("New state " << mDft.getStateString(unsuccessfulState));
-                                
-                                // Add unsuccessful state to search queue
-                                stateQueue.push(unsuccessfulState);
-                            }
-
+                            uint_fast64_t unsuccessfulStateId = addState(unsuccessfulState, stateQueue);
                             ValueType remainingProbability = storm::utility::one<ValueType>() - dependency->probability();
                             transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, unsuccessfulStateId, remainingProbability);
                             STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << unsuccessfulStateId << " with probability " << remainingProbability);
@@ -322,17 +266,16 @@ namespace storm {
                             // rate and not the new state we are going to
                             isActive = state->isActive(mDft.getRepresentant(nextBE->id())->id());
                         }
-                        STORM_LOG_TRACE("BE " << nextBE->name() << " is " << (isActive ? "active" : "not active"));
                         ValueType rate = isActive ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
                         auto resultFind = outgoingTransitions.find(newStateId);
                         if (resultFind != outgoingTransitions.end()) {
                             // Add to existing transition
                             resultFind->second += rate;
-                            STORM_LOG_TRACE("Updated transition from " << state->getId() << " to " << resultFind->first << " with rate " << rate << " to new rate " << resultFind->second);
+                            STORM_LOG_TRACE("Updated transition from " << state->getId() << " to " << resultFind->first << " with " << (isActive ? "active" : "passive") << " rate " << rate << " to new rate " << resultFind->second);
                         } else {
                             // Insert new transition
                             outgoingTransitions.insert(std::make_pair(newStateId, rate));
-                            STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newStateId << " with rate " << rate);
+                            STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newStateId << " with " << (isActive ? "active" : "passive") << " rate " << rate);
                         }
                         exitRate += rate;
                     }
@@ -420,6 +363,56 @@ namespace storm {
             return deterministic;
         }
 
+        template <typename ValueType>
+        uint_fast64_t ExplicitDFTModelBuilder<ValueType>::addState(DFTStatePointer state, std::queue<DFTStatePointer>& stateQueue) {
+            // Order state by symmetry
+            STORM_LOG_TRACE("Check for symmetry: " << mDft.getStateString(state));
+            bool changed = state->orderBySymmetry();
+            STORM_LOG_TRACE("State " << (changed ? "changed to " : "did not change") << (changed ? mDft.getStateString(state) : ""));
+            
+            uint_fast64_t stateId;
+            
+            // Check if state already exists
+            if (mStates.contains(state->status())) {
+                // State already exists
+                stateId = mStates.getValue(state->status());
+                STORM_LOG_TRACE("State " << mDft.getStateString(state) << " with id " << stateId << " already exists");
+                
+                // Check if possible pseudo state can be created now
+                if (!changed && stateId >= OFFSET_PSEUDO_STATE) {
+                    stateId -= OFFSET_PSEUDO_STATE;
+                    assert(stateId < mPseudoStatesMapping.size());
+                    if (mPseudoStatesMapping[stateId].first == 0) {
+                        // Create pseudo state now
+                        assert(mPseudoStatesMapping[stateId].second == state->status());
+                        state->setId(newIndex++);
+                        mPseudoStatesMapping[stateId].first = state->getId();
+                        stateId = state->getId();
+                        mStates.setOrAdd(state->status(), stateId);
+                        stateQueue.push(state);
+                        STORM_LOG_TRACE("Now create state " << mDft.getStateString(state) << " with id " << stateId);
+                    }
+                }
+            } else {
+                // New state
+                if (changed) {
+                    // Remember to create state later on
+                    state->setId(mPseudoStatesMapping.size() + OFFSET_PSEUDO_STATE);
+                    mPseudoStatesMapping.push_back(std::make_pair(0, state->status()));
+                    stateId = mStates.findOrAdd(state->status(), state->getId());
+                    STORM_LOG_TRACE("New state for later creation: " << mDft.getStateString(state));
+                } else {
+                    // Create new state
+                    state->setId(newIndex++);
+                    stateId = mStates.findOrAdd(state->status(), state->getId());
+                    STORM_LOG_TRACE("New state: " << mDft.getStateString(state));
+                    stateQueue.push(state);
+                }
+            }
+            return stateId;
+        }
+
+
         // Explicitly instantiate the class.
         template class ExplicitDFTModelBuilder<double>;
 
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 4f1dff514..2f197255e 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -72,6 +72,8 @@ namespace storm {
 
         private:
             bool exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates);
+            
+            uint_fast64_t addState(DFTStatePointer state, std::queue<DFTStatePointer>& stateQueue);
 
         };
     }

From 2c172cd0827e33609cb7209a3e88b6ffac5abec8 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 17 Mar 2016 11:55:40 +0100
Subject: [PATCH 225/246] Refactoring

Former-commit-id: e9af97f7afd148d23f1667ce82f12cfba63d4881
---
 src/builder/ExplicitDFTModelBuilder.cpp | 9 +++------
 src/models/sparse/MarkovAutomaton.h     | 2 +-
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 7f892a822..018e0eb90 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -124,7 +124,7 @@ namespace storm {
             } else {
                 std::shared_ptr<storm::models::sparse::MarkovAutomaton<ValueType>> ma = std::make_shared<storm::models::sparse::MarkovAutomaton<ValueType>>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.markovianStates), std::move(modelComponents.exitRates), true);
                 if (ma->hasOnlyTrivialNondeterminism()) {
-                 // Markov automaton can be converted into CTMC
+                    // Markov automaton can be converted into CTMC
                     model = ma->convertToCTMC();
                 } else {
                     model = ma;
@@ -287,8 +287,7 @@ namespace storm {
                 } else {
                     // Try to merge pseudo states with their instantiation
                     // TODO Matthias: improve?
-                    auto it = outgoingTransitions.begin();
-                    while (it != outgoingTransitions.end()) {
+                    for (auto it = outgoingTransitions.begin(); it != outgoingTransitions.end(); ) {
                         if (it->first >= OFFSET_PSEUDO_STATE) {
                             uint_fast64_t newId = it->first - OFFSET_PSEUDO_STATE;
                             assert(newId < mPseudoStatesMapping.size());
@@ -306,9 +305,7 @@ namespace storm {
                                     STORM_LOG_TRACE("Instantiated pseudo state " << newId << " with rate " << it->second);
                                 }
                                 // Remove pseudo state
-                                auto itErase = it;
-                                ++it;
-                                outgoingTransitions.erase(itErase);
+                                it = outgoingTransitions.erase(it);
                             } else {
                                 ++it;
                             }
diff --git a/src/models/sparse/MarkovAutomaton.h b/src/models/sparse/MarkovAutomaton.h
index 45c8855d9..4251640fc 100644
--- a/src/models/sparse/MarkovAutomaton.h
+++ b/src/models/sparse/MarkovAutomaton.h
@@ -56,9 +56,9 @@ namespace storm {
                  * @param stateLabeling The labeling of the states.
                  * @param markovianStates A bit vector indicating the Markovian states of the automaton.
                  * @param exitRates A vector storing the exit rates of the states.
+                 * @param probabilities Flag if transitions matrix contains probabilities or rates
                  * @param rewardModels A mapping of reward model names to reward models.
                  * @param optionalChoiceLabeling A vector that represents the labels associated with the choices of each state.
-                 * @param probabilities Flag if transitions matrix contains probabilities or rates
                  */
                 MarkovAutomaton(storm::storage::SparseMatrix<ValueType>&& transitionMatrix,
                                 storm::models::sparse::StateLabeling&& stateLabeling,

From 869b0f95d1d318a3572383ebc7c7bd3043f16b51 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 17 Mar 2016 17:03:46 +0100
Subject: [PATCH 226/246] Support for pdeps with more than one child

Former-commit-id: f3de8f2abd2ff3cb40d7fdc739166ec929b10ba5
---
 examples/dft/be_nonfail.dft             |  4 +++
 examples/dft/pdep4.dft                  |  7 +++++
 examples/dft/por.dft                    |  5 ++++
 src/builder/ExplicitDFTModelBuilder.cpp |  5 ++--
 src/storage/dft/DFT.h                   |  2 +-
 src/storage/dft/DFTBuilder.cpp          |  2 +-
 src/storage/dft/DFTBuilder.h            | 40 +++++++++++++++----------
 src/storage/dft/DFTState.cpp            |  6 ++--
 src/storage/dft/elements/DFTBE.h        |  8 ++++-
 9 files changed, 55 insertions(+), 24 deletions(-)
 create mode 100644 examples/dft/be_nonfail.dft
 create mode 100644 examples/dft/pdep4.dft
 create mode 100644 examples/dft/por.dft

diff --git a/examples/dft/be_nonfail.dft b/examples/dft/be_nonfail.dft
new file mode 100644
index 000000000..d53dca551
--- /dev/null
+++ b/examples/dft/be_nonfail.dft
@@ -0,0 +1,4 @@
+toplevel "A";
+"A" and "B" "C";
+"B" lambda=0 dorm=0.3;
+"C" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/pdep4.dft b/examples/dft/pdep4.dft
new file mode 100644
index 000000000..eace91847
--- /dev/null
+++ b/examples/dft/pdep4.dft
@@ -0,0 +1,7 @@
+toplevel "SF";
+"SF" pand "S" "A" "B";
+"PDEP" pdep=0.2 "S" "A" "B";
+
+"S" lambda=0.5 dorm=0;
+"A" lambda=0.5 dorm=0;
+"B" lambda=0.5 dorm=0;
diff --git a/examples/dft/por.dft b/examples/dft/por.dft
new file mode 100644
index 000000000..020687f62
--- /dev/null
+++ b/examples/dft/por.dft
@@ -0,0 +1,5 @@
+toplevel "A";
+"A" por "B" "C" "D";
+"B" lambda=0.4 dorm=0.0;
+"C" lambda=0.2 dorm=0.0;
+"D" lambda=0.2 dorm=0.0;
diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 018e0eb90..fa8be6e1a 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -160,7 +160,7 @@ namespace storm {
                 transitionMatrixBuilder.newRowGroup(state->getId() + rowOffset);
 
                 // Add self loop for target states
-                if (mDft.hasFailed(state) || mDft.isFailsafe(state)) {
+                if (mDft.hasFailed(state) || mDft.isFailsafe(state) || state->nrFailableBEs() == 0) {
                     transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, state->getId(), storm::utility::one<ValueType>());
                     STORM_LOG_TRACE("Added self loop for " << state->getId());
                     exitRates.push_back(storm::utility::one<ValueType>());
@@ -168,8 +168,6 @@ namespace storm {
                     markovianStates.push_back(state->getId());
                     // No further exploration required
                     continue;
-                } else {
-                    STORM_LOG_THROW(state->nrFailableBEs() > 0, storm::exceptions::UnexpectedException, "State " << state->getId() << " is no target state but behaves like one");
                 }
 
                 // Let BE fail
@@ -267,6 +265,7 @@ namespace storm {
                             isActive = state->isActive(mDft.getRepresentant(nextBE->id())->id());
                         }
                         ValueType rate = isActive ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
+                        assert(!storm::utility::isZero(rate));
                         auto resultFind = outgoingTransitions.find(newStateId);
                         if (resultFind != outgoingTransitions.end()) {
                             // Add to existing transition
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index d82c45dfa..071a7e56a 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -130,7 +130,7 @@ namespace storm {
             std::vector<size_t> nonColdBEs() const {
                 std::vector<size_t> result;
                 for(DFTElementPointer elem : mElements) {
-                    if(elem->isBasicElement() && !elem->isColdBasicElement()) {
+                    if(elem->isBasicElement() && std::static_pointer_cast<DFTBE<ValueType>>(elem)->canFail() && !elem->isColdBasicElement()) {
                         result.push_back(elem->id());
                     }
                 }
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index 8241ea70a..6998529f8 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -225,7 +225,7 @@ namespace storm {
                 {
                     std::shared_ptr<DFTBE<ValueType>> be = std::static_pointer_cast<DFTBE<ValueType>>(element);
                     ValueType dormancyFactor = storm::utility::zero<ValueType>();
-                    if (!storm::utility::isZero(be->passiveFailureRate())) {
+                    if (be->canFail()) {
                         dormancyFactor = be->passiveFailureRate() / be->activeFailureRate();
                     }
                     addBasicElement(be->name(), be->activeFailureRate(), dormancyFactor);
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index d630c24fb..168b27755 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -85,24 +85,32 @@ namespace storm {
                 //TODO Matthias: collect constraints for SMT solving
                 //0 <= probability <= 1
                 if (!storm::utility::isOne(probability) && children.size() > 2) {
-                    //TODO Matthias: introduce additional element for probability and then add pdeps with probability 1 to children
-                    STORM_LOG_ERROR("Probability != 1 for more than one child currently not supported.");
-                    return false;
-                }
-
-                for (size_t i = 1; i < children.size(); ++i) {
-                    std::string nameDep = name + "_" + std::to_string(i);
-                    if(mElements.count(nameDep) != 0) {
-                        // Element with that name already exists.
-                        STORM_LOG_ERROR("Element with name: " << nameDep << " already exists.");
-                        return false;
+                    // Introduce additional element for first capturing the proabilistic dependency
+                    std::string nameAdditional = name + "_additional";
+                    addBasicElement(nameAdditional, storm::utility::zero<ValueType>(), storm::utility::zero<ValueType>());
+                    // First consider probabilistic dependency
+                    addDepElement(name + "_pdep", {children.front(), nameAdditional}, probability);
+                    // Then consider dependencies to the children if probabilistic dependency failed
+                    std::vector<std::string> newChildren = children;
+                    newChildren[0] = nameAdditional;
+                    addDepElement(name, newChildren, storm::utility::one<ValueType>());
+                    return true;
+                } else {
+                    // Add dependencies
+                    for (size_t i = 1; i < children.size(); ++i) {
+                        std::string nameDep = name + "_" + std::to_string(i);
+                        if(mElements.count(nameDep) != 0) {
+                            // Element with that name already exists.
+                            STORM_LOG_ERROR("Element with name: " << nameDep << " already exists.");
+                            return false;
+                        }
+                        assert(storm::utility::isOne(probability) || children.size() == 2);
+                        DFTDependencyPointer element = std::make_shared<DFTDependency<ValueType>>(mNextId++, nameDep, trigger, children[i], probability);
+                        mElements[element->name()] = element;
+                        mDependencies.push_back(element);
                     }
-                    assert(storm::utility::isOne(probability) || children.size() == 2);
-                    DFTDependencyPointer element = std::make_shared<DFTDependency<ValueType>>(mNextId++, nameDep, trigger, children[i], probability);
-                    mElements[element->name()] = element;
-                    mDependencies.push_back(element);
+                    return true;
                 }
-                return true;
             }
 
             bool addVotElement(std::string const& name, unsigned threshold, std::vector<std::string> const& children) {
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 1468a36ff..4d603e501 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -29,7 +29,8 @@ namespace storm {
             for(size_t index = 0; index < mDft.nrElements(); ++index) {
                 // Initialize currently failable BE
                 if (mDft.isBasicElement(index) && isOperational(index)) {
-                    if (!mDft.getBasicElement(index)->isColdBasicElement() || !mDft.hasRepresentant(index) || isActive(mDft.getRepresentant(index)->id())) {
+                    std::shared_ptr<const DFTBE<ValueType>> be = mDft.getBasicElement(index);
+                    if ((!be->isColdBasicElement() && be->canFail()) || !mDft.hasRepresentant(index) || isActive(mDft.getRepresentant(index)->id())) {
                         mIsCurrentlyFailableBE.push_back(index);
                         STORM_LOG_TRACE("Currently failable: " << mDft.getBasicElement(index)->toString());
                     }
@@ -212,6 +213,7 @@ namespace storm {
                 // Consider "normal" failure
                 assert(index < nrFailableBEs());
                 std::pair<std::shared_ptr<DFTBE<ValueType> const>,bool> res(mDft.getBasicElement(mIsCurrentlyFailableBE[index]), false);
+                assert(res.first->canFail());
                 mIsCurrentlyFailableBE.erase(mIsCurrentlyFailableBE.begin() + index);
                 setFailed(res.first->id());
                 return res;
@@ -244,7 +246,7 @@ namespace storm {
                 activate(representativeId);
             }
             for(size_t elem : mDft.module(representativeId)) {
-                if(mDft.getElement(elem)->isColdBasicElement() && isOperational(elem)) {
+                if(mDft.getElement(elem)->isColdBasicElement() && isOperational(elem) && mDft.getBasicElement(elem)->canFail()) {
                     mIsCurrentlyFailableBE.push_back(elem);
                 } else if (mDft.getElement(elem)->isSpareGate() && !isActive(uses(elem))) {
                     propagateActivation(uses(elem));
diff --git a/src/storage/dft/elements/DFTBE.h b/src/storage/dft/elements/DFTBE.h
index 58e580262..e7f912fd4 100644
--- a/src/storage/dft/elements/DFTBE.h
+++ b/src/storage/dft/elements/DFTBE.h
@@ -33,6 +33,10 @@ namespace storm {
                 return mPassiveFailureRate;
             }
             
+            bool canFail() const {
+                return !storm::utility::isZero(mActiveFailureRate);
+            }
+            
             bool addIngoingDependency(DFTDependencyPointer const& e) {
                 assert(e->dependentEvent()->id() == this->id());
                 if(std::find(mIngoingDependencies.begin(), mIngoingDependencies.end(), e) != mIngoingDependencies.end()) {
@@ -72,7 +76,9 @@ namespace storm {
             }
             
             virtual void extendSubDft(std::set<size_t>& elemsInSubtree, std::vector<size_t> const& parentsOfSubRoot, bool blockParents, bool sparesAsLeaves) const override {
-                 if(elemsInSubtree.count(this->id())) return;
+                if(elemsInSubtree.count(this->id())) {
+                    return;
+                }
                 DFTElement<ValueType>::extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves);
                 if(elemsInSubtree.empty()) {
                     // Parent in the subdft, ie it is *not* a subdft

From c23eb7312974381c22af6885e967054b2362910e Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 17 Mar 2016 17:31:45 +0100
Subject: [PATCH 227/246] Cleaned examples

Former-commit-id: 37a0ad6cc84026e81f60754cd9db7054277ca9b2
---
 examples/dft/{seq1.dft => seq.dft} |  0
 examples/dft/seq3.txt              |  6 ------
 examples/dft/seq4.dft              | 11 ++++++-----
 examples/dft/seq5.dft              | 10 ++++++----
 examples/dft/seq6.dft              |  8 --------
 5 files changed, 12 insertions(+), 23 deletions(-)
 rename examples/dft/{seq1.dft => seq.dft} (100%)
 delete mode 100644 examples/dft/seq3.txt
 delete mode 100644 examples/dft/seq6.dft

diff --git a/examples/dft/seq1.dft b/examples/dft/seq.dft
similarity index 100%
rename from examples/dft/seq1.dft
rename to examples/dft/seq.dft
diff --git a/examples/dft/seq3.txt b/examples/dft/seq3.txt
deleted file mode 100644
index b22b9e8b6..000000000
--- a/examples/dft/seq3.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-toplevel "A";
-"A" and "C" "D";
-"X" seq "B" "C" "D";
-"B" lambda=0.5 dorm=0.3;
-"C" lambda=0.5 dorm=0.3;
-"D" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/seq4.dft b/examples/dft/seq4.dft
index 260a88266..60bf149af 100644
--- a/examples/dft/seq4.dft
+++ b/examples/dft/seq4.dft
@@ -1,6 +1,7 @@
 toplevel "A";
-"A" or "C" "D";
-"X" seq "B" "C" "D";
-"B" lambda=0.5 dorm=0.3;
-"C" lambda=0.5 dorm=0.3;
-"D" lambda=0.5 dorm=0.3;
+"A" and "T1" "B3";
+"T1" or "B1" "B2";
+"X" seq "B1" "B2" "B3";
+"B1" lambda=0.5 dorm=0.3;
+"B2" lambda=0.5 dorm=0.3;
+"B3" lambda=0.5 dorm=0.3;
diff --git a/examples/dft/seq5.dft b/examples/dft/seq5.dft
index 60bf149af..77b13ddeb 100644
--- a/examples/dft/seq5.dft
+++ b/examples/dft/seq5.dft
@@ -1,7 +1,9 @@
 toplevel "A";
-"A" and "T1" "B3";
-"T1" or "B1" "B2";
-"X" seq "B1" "B2" "B3";
-"B1" lambda=0.5 dorm=0.3;
+"A" and "T1" "T2";
+"T1" pand "B1" "B2"; 
+"T2" pand "B3" "B4";
+"X" seq "B4" "B3";
+"B1" lambda=0.7 dorm=0.3;
 "B2" lambda=0.5 dorm=0.3;
 "B3" lambda=0.5 dorm=0.3;
+"B4" lambda=0.7 dorm=0.3;
diff --git a/examples/dft/seq6.dft b/examples/dft/seq6.dft
deleted file mode 100644
index 8453cb411..000000000
--- a/examples/dft/seq6.dft
+++ /dev/null
@@ -1,8 +0,0 @@
-toplevel "A";
-"A" and "T1" "T2";
-"T1" pand "B1" "B2"; 
-"T2" pand "B3" "B4;
-"B1" lambda=0.7 dorm=0.3;
-"B2" lambda=0.5 dorm=0.3;
-"B3" lambda=0.5 dorm=0.3;
-"B4" lambda=0.7 dorm=0.3;

From 2e9089eca67d3a66a65389e2ca26dc3a5204e8ed Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 17 Mar 2016 18:12:04 +0100
Subject: [PATCH 228/246] Small changes

Former-commit-id: aa36b0ae302e0fccb8b7f403153466c8f68afba3
---
 src/storage/dft/DFT.cpp               | 46 ++++++++++++++++++++-------
 src/storage/dft/DFT.h                 |  9 ++++--
 src/storage/dft/DFTState.cpp          | 12 +++++--
 src/storage/dft/DFTState.h            |  2 ++
 src/storage/dft/elements/DFTBE.h      |  4 +--
 src/storage/dft/elements/DFTElement.h |  4 ---
 6 files changed, 56 insertions(+), 21 deletions(-)

diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index 9a1b086fc..ea4417915 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -79,10 +79,6 @@ namespace storm {
 
         template<typename ValueType>
         DFTStateGenerationInfo DFT<ValueType>::buildStateGenerationInfo(storm::storage::DFTIndependentSymmetries const& symmetries) const {
-            // Use symmetry
-            // Collect all elements in the first subtree
-            // TODO make recursive to use for nested subtrees
-
             DFTStateGenerationInfo generationInfo(nrElements(), mMaxSpareChildCount);
             
             // Generate Pre and Post info for restrictions
@@ -92,19 +88,17 @@ namespace storm {
                     generationInfo.setRestrictionPostElements(elem->id(), elem->seqRestrictionPosts());
                 }
             }
-            
 
-            // Perform DFS and insert all elements of subtree sequentially
             size_t stateIndex = 0;
             std::queue<size_t> visitQueue;
             storm::storage::BitVector visited(nrElements(), false);
 
-            // TODO make subfunction for this?
             if (symmetries.groups.empty()) {
                 // Perform DFS for whole tree
                 visitQueue.push(mTopLevelIndex);
                 stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex);
             } else {
+                // Generate information according to symmetries
                 for (size_t symmetryIndex : symmetries.sortedSymmetries) {
                     assert(!visited[symmetryIndex]);
                     auto const& symmetryGroup = symmetries.groups.at(symmetryIndex);
@@ -430,7 +424,7 @@ namespace storm {
                 stream << "[" << elem->id() << "]";
                 stream << elem->toString();
                 if (elem->isDependency()) {
-                    stream << "\t** " << storm::storage::toChar(state->getDependencyState(elem->id()));
+                    stream << "\t** " << storm::storage::toChar(state->getDependencyState(elem->id())) << "[dep]";
                 } else {
                     stream << "\t** " << storm::storage::toChar(state->getElementState(elem->id()));
                     if(elem->isSpareGate()) {
@@ -445,10 +439,9 @@ namespace storm {
             }
             return stream.str();
         }
-
-        // TODO rewrite to only use bitvector and id
+        
         template<typename ValueType>
-        std::string DFT<ValueType>::getStateString(DFTStatePointer const& state) const{
+        std::string DFT<ValueType>::getStateString(DFTStatePointer const& state) const {
             std::stringstream stream;
             stream << "(" << state->getId() << ") ";
             for (auto const& elem : mElements) {
@@ -467,6 +460,37 @@ namespace storm {
                 }
             }
             return stream.str();
+        }        
+
+        template<typename ValueType>
+        std::string DFT<ValueType>::getStateString(storm::storage::BitVector const& status, DFTStateGenerationInfo const& stateGenerationInfo, size_t id) const {
+            std::stringstream stream;
+            stream << "(" << id << ") ";
+            for (auto const& elem : mElements) {
+                size_t elemIndex = stateGenerationInfo.getStateIndex(elem->id());
+                int elementState = DFTState<ValueType>::getElementStateInt(status, elemIndex);
+                if (elem->isDependency()) {
+                    stream << storm::storage::toChar(static_cast<DFTDependencyState>(elementState)) << "[dep]";
+                } else {
+                    stream << storm::storage::toChar(static_cast<DFTElementState>(elementState));
+                    if(elem->isSpareGate()) {
+                        stream << "[";
+                        size_t nrUsedChild = status.getAsInt(stateGenerationInfo.getSpareUsageIndex(elem->id()), stateGenerationInfo.usageInfoBits());
+                        size_t useId;
+                        if (nrUsedChild == getMaxSpareChildCount()) {
+                            useId = elem->id();
+                        } else {
+                            useId = getChild(elem->id(), nrUsedChild);
+                        }
+                        bool isActive = status[stateGenerationInfo.getSpareActivationIndex(useId)];
+                        if(useId == elem->id() || isActive) {
+                            stream << "actively ";
+                        }
+                        stream << "using " << useId << "]";
+                    }
+                }
+            }
+            return stream.str();
         }
         
         template<typename ValueType>
diff --git a/src/storage/dft/DFT.h b/src/storage/dft/DFT.h
index 071a7e56a..6fdfd08ef 100644
--- a/src/storage/dft/DFT.h
+++ b/src/storage/dft/DFT.h
@@ -130,8 +130,11 @@ namespace storm {
             std::vector<size_t> nonColdBEs() const {
                 std::vector<size_t> result;
                 for(DFTElementPointer elem : mElements) {
-                    if(elem->isBasicElement() && std::static_pointer_cast<DFTBE<ValueType>>(elem)->canFail() && !elem->isColdBasicElement()) {
-                        result.push_back(elem->id());
+                    if(elem->isBasicElement()) {
+                        std::shared_ptr<DFTBE<ValueType>> be = std::static_pointer_cast<DFTBE<ValueType>>(elem);
+                        if (be->canFail() && !be->isColdBasicElement()) {
+                            result.push_back(be->id());
+                        }
                     }
                 }
                 return result;
@@ -246,6 +249,8 @@ namespace storm {
 
             std::string getStateString(DFTStatePointer const& state) const;
 
+            std::string getStateString(storm::storage::BitVector const& status, DFTStateGenerationInfo const& stateGenerationInfo, size_t id) const;
+
             std::vector<size_t> getIndependentSubDftRoots(size_t index) const;
 
             DFTColouring<ValueType> colourDFT() const;
diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index 4d603e501..b1c9a4fc1 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -67,6 +67,11 @@ namespace storm {
         int DFTState<ValueType>::getElementStateInt(size_t id) const {
             return mStatus.getAsInt(mStateGenerationInfo.getStateIndex(id), 2);
         }
+        
+        template<typename ValueType>
+        int DFTState<ValueType>::getElementStateInt(storm::storage::BitVector const& state, size_t indexId) {
+            return state.getAsInt(indexId, 2);
+        }
 
         template<typename ValueType>
         size_t DFTState<ValueType>::getId() const {
@@ -246,8 +251,11 @@ namespace storm {
                 activate(representativeId);
             }
             for(size_t elem : mDft.module(representativeId)) {
-                if(mDft.getElement(elem)->isColdBasicElement() && isOperational(elem) && mDft.getBasicElement(elem)->canFail()) {
-                    mIsCurrentlyFailableBE.push_back(elem);
+                if(mDft.isBasicElement(elem) && isOperational(elem)) {
+                    std::shared_ptr<const DFTBE<ValueType>> be = mDft.getBasicElement(elem);
+                    if (be->isColdBasicElement() && be->canFail()) {
+                        mIsCurrentlyFailableBE.push_back(elem);
+                    }
                 } else if (mDft.getElement(elem)->isSpareGate() && !isActive(uses(elem))) {
                     propagateActivation(uses(elem));
                 }
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 1311d74ae..5b68d46ae 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -47,6 +47,8 @@ namespace storm {
 
             int getElementStateInt(size_t id) const;
 
+            static int getElementStateInt(storm::storage::BitVector const& state, size_t indexId);
+            
             size_t getId() const;
 
             void setId(size_t id);
diff --git a/src/storage/dft/elements/DFTBE.h b/src/storage/dft/elements/DFTBE.h
index e7f912fd4..d41e37344 100644
--- a/src/storage/dft/elements/DFTBE.h
+++ b/src/storage/dft/elements/DFTBE.h
@@ -67,11 +67,11 @@ namespace storm {
                 return stream.str();
             }
             
-            bool isBasicElement() const override{
+            bool isBasicElement() const override {
                 return true;
             }
             
-            bool isColdBasicElement() const override{
+            bool isColdBasicElement() const {
                 return storm::utility::isZero(mPassiveFailureRate);
             }
             
diff --git a/src/storage/dft/elements/DFTElement.h b/src/storage/dft/elements/DFTElement.h
index 8a8a35d28..366d0fe91 100644
--- a/src/storage/dft/elements/DFTElement.h
+++ b/src/storage/dft/elements/DFTElement.h
@@ -93,10 +93,6 @@ namespace storm {
                 return false;
             }
             
-            virtual bool isColdBasicElement() const {
-                return false;
-            }
-
             /**
              * Returns true if the element is a spare gate
              */

From f529a1315f6f2628ae19702b45f490798715c429 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Fri, 18 Mar 2016 15:37:48 +0100
Subject: [PATCH 229/246] Settings module do not need settings manager

Former-commit-id: b26ccc902dcac8914b12eaee5eb4dc9f91768e64
---
 src/settings/SettingsManager.cpp              | 26 +++++++++----------
 src/settings/modules/BisimulationSettings.cpp |  2 +-
 src/settings/modules/BisimulationSettings.h   |  6 ++---
 .../CounterexampleGeneratorSettings.cpp       |  2 +-
 .../modules/CounterexampleGeneratorSettings.h |  6 ++---
 src/settings/modules/CuddSettings.cpp         |  2 +-
 src/settings/modules/CuddSettings.h           |  6 ++---
 src/settings/modules/DebugSettings.cpp        |  2 +-
 src/settings/modules/DebugSettings.h          |  6 ++---
 src/settings/modules/GeneralSettings.cpp      |  2 +-
 src/settings/modules/GeneralSettings.h        |  6 ++---
 src/settings/modules/GlpkSettings.cpp         |  2 +-
 src/settings/modules/GlpkSettings.h           |  6 ++---
 .../modules/GmmxxEquationSolverSettings.cpp   |  2 +-
 .../modules/GmmxxEquationSolverSettings.h     |  6 ++---
 src/settings/modules/GurobiSettings.cpp       |  2 +-
 src/settings/modules/GurobiSettings.h         |  6 ++---
 src/settings/modules/ModuleSettings.cpp       |  6 +----
 src/settings/modules/ModuleSettings.h         | 11 +-------
 .../modules/NativeEquationSolverSettings.cpp  |  2 +-
 .../modules/NativeEquationSolverSettings.h    |  6 ++---
 src/settings/modules/ParametricSettings.cpp   |  2 +-
 src/settings/modules/ParametricSettings.h     |  6 ++---
 ...rseDtmcEliminationModelCheckerSettings.cpp |  2 +-
 ...parseDtmcEliminationModelCheckerSettings.h |  6 ++---
 src/settings/modules/SylvanSettings.cpp       |  2 +-
 src/settings/modules/SylvanSettings.h         |  6 ++---
 ...alValueIterationEquationSolverSettings.cpp |  2 +-
 ...icalValueIterationEquationSolverSettings.h |  6 ++---
 29 files changed, 54 insertions(+), 93 deletions(-)

diff --git a/src/settings/SettingsManager.cpp b/src/settings/SettingsManager.cpp
index fffb10366..7ca1efca2 100644
--- a/src/settings/SettingsManager.cpp
+++ b/src/settings/SettingsManager.cpp
@@ -35,19 +35,19 @@ namespace storm {
         
         SettingsManager::SettingsManager() : modules(), longNameToOptions(), shortNameToOptions(), moduleOptions() {
             // Register all known settings modules.
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GeneralSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::DebugSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::CounterexampleGeneratorSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::CuddSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::SylvanSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GmmxxEquationSolverSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::NativeEquationSolverSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::BisimulationSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GlpkSettings(*this)));
-			this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GurobiSettings(*this)));
-			this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::TopologicalValueIterationEquationSolverSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::ParametricSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::SparseDtmcEliminationModelCheckerSettings(*this)));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GeneralSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::DebugSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::CounterexampleGeneratorSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::CuddSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::SylvanSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GmmxxEquationSolverSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::NativeEquationSolverSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::BisimulationSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GlpkSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GurobiSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::TopologicalValueIterationEquationSolverSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::ParametricSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::SparseDtmcEliminationModelCheckerSettings()));
         }
         
         SettingsManager::~SettingsManager() {
diff --git a/src/settings/modules/BisimulationSettings.cpp b/src/settings/modules/BisimulationSettings.cpp
index db3bdce9e..1926e93ef 100644
--- a/src/settings/modules/BisimulationSettings.cpp
+++ b/src/settings/modules/BisimulationSettings.cpp
@@ -13,7 +13,7 @@ namespace storm {
             const std::string BisimulationSettings::moduleName = "bisimulation";
             const std::string BisimulationSettings::typeOptionName = "type";
             
-            BisimulationSettings::BisimulationSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            BisimulationSettings::BisimulationSettings() : ModuleSettings(moduleName) {
                 std::vector<std::string> types = { "strong", "weak" };
                 this->addOption(storm::settings::OptionBuilder(moduleName, typeOptionName, true, "Sets the kind of bisimulation quotienting used. Available are: { strong, weak }.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the type to use.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(types)).setDefaultValueString("strong").build()).build());
             }
diff --git a/src/settings/modules/BisimulationSettings.h b/src/settings/modules/BisimulationSettings.h
index 3e2d1efe7..7bace55ce 100644
--- a/src/settings/modules/BisimulationSettings.h
+++ b/src/settings/modules/BisimulationSettings.h
@@ -16,11 +16,9 @@ namespace storm {
                 enum class BisimulationType { Strong, Weak };
                 
                 /*!
-                 * Creates a new set of bisimulation settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of bisimulation settings.
                  */
-                BisimulationSettings(storm::settings::SettingsManager& settingsManager);
+                BisimulationSettings();
                 
                 /*!
                  * Retrieves whether strong bisimulation is to be used.
diff --git a/src/settings/modules/CounterexampleGeneratorSettings.cpp b/src/settings/modules/CounterexampleGeneratorSettings.cpp
index e4f8d2a32..6ad644822 100644
--- a/src/settings/modules/CounterexampleGeneratorSettings.cpp
+++ b/src/settings/modules/CounterexampleGeneratorSettings.cpp
@@ -17,7 +17,7 @@ namespace storm {
             const std::string CounterexampleGeneratorSettings::encodeReachabilityOptionName = "encreach";
             const std::string CounterexampleGeneratorSettings::schedulerCutsOptionName = "schedcuts";
             
-            CounterexampleGeneratorSettings::CounterexampleGeneratorSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            CounterexampleGeneratorSettings::CounterexampleGeneratorSettings() : ModuleSettings(moduleName) {
                 std::vector<std::string> techniques = {"maxsat", "milp"};
                 this->addOption(storm::settings::OptionBuilder(moduleName, minimalCommandSetOptionName, true, "Computes a counterexample for the given model in terms of a minimal command set. Note that this requires the model to be given in a symbolic format.")
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("method", "Sets which technique is used to derive the counterexample. Available are {milp, maxsat}").setDefaultValueString("maxsat").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(techniques)).build()).build());
diff --git a/src/settings/modules/CounterexampleGeneratorSettings.h b/src/settings/modules/CounterexampleGeneratorSettings.h
index 049747183..6103f0102 100644
--- a/src/settings/modules/CounterexampleGeneratorSettings.h
+++ b/src/settings/modules/CounterexampleGeneratorSettings.h
@@ -13,11 +13,9 @@ namespace storm {
             class CounterexampleGeneratorSettings : public ModuleSettings {
             public:
                 /*!
-                 * Creates a new set of counterexample settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of counterexample settings.
                  */
-                CounterexampleGeneratorSettings(storm::settings::SettingsManager& settingsManager);
+                CounterexampleGeneratorSettings();
                 
                 /*!
                  * Retrieves whether the option to generate a minimal command set was set.
diff --git a/src/settings/modules/CuddSettings.cpp b/src/settings/modules/CuddSettings.cpp
index 1cd54d011..bf15d1cc6 100644
--- a/src/settings/modules/CuddSettings.cpp
+++ b/src/settings/modules/CuddSettings.cpp
@@ -16,7 +16,7 @@ namespace storm {
             const std::string CuddSettings::maximalMemoryOptionName = "maxmem";
             const std::string CuddSettings::reorderOptionName = "reorder";
             
-            CuddSettings::CuddSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            CuddSettings::CuddSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, precisionOptionName, true, "Sets the precision used by Cudd.").addArgument(storm::settings::ArgumentBuilder::createDoubleArgument("value", "The precision up to which to constants are considered to be different.").setDefaultValueDouble(1e-15).addValidationFunctionDouble(storm::settings::ArgumentValidators::doubleRangeValidatorExcluding(0.0, 1.0)).build()).build());
                 
                 this->addOption(storm::settings::OptionBuilder(moduleName, maximalMemoryOptionName, true, "Sets the upper bound of memory available to Cudd in MB.").addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("value", "The memory available to Cudd (0 means unlimited).").setDefaultValueUnsignedInteger(4096).build()).build());
diff --git a/src/settings/modules/CuddSettings.h b/src/settings/modules/CuddSettings.h
index db59ddc77..8aaa8f007 100644
--- a/src/settings/modules/CuddSettings.h
+++ b/src/settings/modules/CuddSettings.h
@@ -16,11 +16,9 @@ namespace storm {
                 enum class ReorderingTechnique { None, Random, RandomPivot, Sift, SiftConv, SymmetricSift, SymmetricSiftConv, GroupSift, GroupSiftConv, Win2, Win2Conv, Win3, Win3Conv, Win4, Win4Conv, Annealing, Genetic, Exact };
                 
                 /*!
-                 * Creates a new set of CUDD settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of CUDD settings.
                  */
-                CuddSettings(storm::settings::SettingsManager& settingsManager);
+                CuddSettings();
                 
                 /*!
                  * Retrieves the precision that CUDD is supposed to use for distinguishing constants.
diff --git a/src/settings/modules/DebugSettings.cpp b/src/settings/modules/DebugSettings.cpp
index cf2867181..16d035015 100644
--- a/src/settings/modules/DebugSettings.cpp
+++ b/src/settings/modules/DebugSettings.cpp
@@ -16,7 +16,7 @@ namespace storm {
             const std::string DebugSettings::logfileOptionName = "logfile";
             const std::string DebugSettings::logfileOptionShortName = "l";
  
-            DebugSettings::DebugSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            DebugSettings::DebugSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, debugOptionName, false, "Print debug output.").build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, traceOptionName, false, "Print even more debug output.").build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, logfileOptionName, false, "If specified, the log output will also be written to this file.").setShortName(logfileOptionShortName)
diff --git a/src/settings/modules/DebugSettings.h b/src/settings/modules/DebugSettings.h
index 024246b68..f78a4e3a8 100644
--- a/src/settings/modules/DebugSettings.h
+++ b/src/settings/modules/DebugSettings.h
@@ -13,11 +13,9 @@ namespace storm {
             class DebugSettings : public ModuleSettings {
             public:
                 /*!
-                 * Creates a new set of debug settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of debug settings.
                  */
-                DebugSettings(storm::settings::SettingsManager& settingsManager);
+                DebugSettings();
                 
                 /*!
                  * Retrieves whether the debug option was set.
diff --git a/src/settings/modules/GeneralSettings.cpp b/src/settings/modules/GeneralSettings.cpp
index 9979c6824..0b477d667 100644
--- a/src/settings/modules/GeneralSettings.cpp
+++ b/src/settings/modules/GeneralSettings.cpp
@@ -66,7 +66,7 @@ namespace storm {
             const std::string GeneralSettings::parametricOptionName = "parametric";
 #endif
 
-            GeneralSettings::GeneralSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            GeneralSettings::GeneralSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, helpOptionName, false, "Shows all available options, arguments and descriptions.").setShortName(helpOptionShortName)
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("hint", "A regular expression to show help for all matching entities or 'all' for the complete help.").setDefaultValueString("all").build()).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, prismCompatibilityOptionName, false, "Enables PRISM compatibility. This may be necessary to process some PRISM models.").setShortName(prismCompatibilityOptionShortName).build());
diff --git a/src/settings/modules/GeneralSettings.h b/src/settings/modules/GeneralSettings.h
index ad268db93..cf8a9318e 100644
--- a/src/settings/modules/GeneralSettings.h
+++ b/src/settings/modules/GeneralSettings.h
@@ -32,11 +32,9 @@ namespace storm {
                 };
 
                 /*!
-                 * Creates a new set of general settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of general settings.
                  */
-                GeneralSettings(storm::settings::SettingsManager& settingsManager);
+                GeneralSettings();
 
                 /*!
                  * Retrieves whether the help option was set.
diff --git a/src/settings/modules/GlpkSettings.cpp b/src/settings/modules/GlpkSettings.cpp
index a459ddbb8..8e879fc6d 100644
--- a/src/settings/modules/GlpkSettings.cpp
+++ b/src/settings/modules/GlpkSettings.cpp
@@ -16,7 +16,7 @@ namespace storm {
             const std::string GlpkSettings::integerToleranceOption = "inttol";
             const std::string GlpkSettings::outputOptionName = "output";
             
-            GlpkSettings::GlpkSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            GlpkSettings::GlpkSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, outputOptionName, true, "If set, the glpk output will be printed to the command line.").build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, integerToleranceOption, true, "Sets glpk's precision for integer variables.").addArgument(storm::settings::ArgumentBuilder::createDoubleArgument("value", "The precision to achieve.").setDefaultValueDouble(1e-06).addValidationFunctionDouble(storm::settings::ArgumentValidators::doubleRangeValidatorExcluding(0.0, 1.0)).build()).build());
             }
diff --git a/src/settings/modules/GlpkSettings.h b/src/settings/modules/GlpkSettings.h
index b58e91746..2f33009fa 100644
--- a/src/settings/modules/GlpkSettings.h
+++ b/src/settings/modules/GlpkSettings.h
@@ -13,11 +13,9 @@ namespace storm {
             class GlpkSettings : public ModuleSettings {
             public:
                 /*!
-                 * Creates a new set of glpk settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of glpk settings.
                  */
-                GlpkSettings(storm::settings::SettingsManager& settingsManager);
+                GlpkSettings();
                 
                 /*!
                  * Retrieves whether the output option was set.
diff --git a/src/settings/modules/GmmxxEquationSolverSettings.cpp b/src/settings/modules/GmmxxEquationSolverSettings.cpp
index fb7cbe307..4904239ba 100644
--- a/src/settings/modules/GmmxxEquationSolverSettings.cpp
+++ b/src/settings/modules/GmmxxEquationSolverSettings.cpp
@@ -22,7 +22,7 @@ namespace storm {
             const std::string GmmxxEquationSolverSettings::precisionOptionName = "precision";
             const std::string GmmxxEquationSolverSettings::absoluteOptionName = "absolute";
 
-            GmmxxEquationSolverSettings::GmmxxEquationSolverSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            GmmxxEquationSolverSettings::GmmxxEquationSolverSettings() : ModuleSettings(moduleName) {
                 std::vector<std::string> methods = {"bicgstab", "qmr", "gmres", "jacobi"};
                 this->addOption(storm::settings::OptionBuilder(moduleName, techniqueOptionName, true, "The method to be used for solving linear equation systems with the gmm++ engine. Available are {bicgstab, qmr, gmres, jacobi}.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the method to use.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(methods)).setDefaultValueString("gmres").build()).build());
                 
diff --git a/src/settings/modules/GmmxxEquationSolverSettings.h b/src/settings/modules/GmmxxEquationSolverSettings.h
index 8cb0761a8..71c7fcee1 100644
--- a/src/settings/modules/GmmxxEquationSolverSettings.h
+++ b/src/settings/modules/GmmxxEquationSolverSettings.h
@@ -22,11 +22,9 @@ namespace storm {
                 enum class ConvergenceCriterion { Absolute, Relative };
                 
                 /*!
-                 * Creates a new set of gmm++ settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of gmm++ settings.
                  */
-                GmmxxEquationSolverSettings(storm::settings::SettingsManager& settingsManager);
+                GmmxxEquationSolverSettings();
                 
                 /*!
                  * Retrieves whether the linear equation system method has been set.
diff --git a/src/settings/modules/GurobiSettings.cpp b/src/settings/modules/GurobiSettings.cpp
index 837c631de..f94fc988c 100644
--- a/src/settings/modules/GurobiSettings.cpp
+++ b/src/settings/modules/GurobiSettings.cpp
@@ -16,7 +16,7 @@ namespace storm {
             const std::string GurobiSettings::threadsOption = "threads";
             const std::string GurobiSettings::outputOption = "output";
             
-            GurobiSettings::GurobiSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            GurobiSettings::GurobiSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, threadsOption, true, "The number of threads that may be used by Gurobi.").addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("count", "The number of threads.").setDefaultValueUnsignedInteger(1).build()).build());
                 
                 this->addOption(storm::settings::OptionBuilder(moduleName, outputOption, true, "If set, the Gurobi output will be printed to the command line.").build());
diff --git a/src/settings/modules/GurobiSettings.h b/src/settings/modules/GurobiSettings.h
index ce7fcd78f..ccad8cbc0 100644
--- a/src/settings/modules/GurobiSettings.h
+++ b/src/settings/modules/GurobiSettings.h
@@ -13,11 +13,9 @@ namespace storm {
             class GurobiSettings : public ModuleSettings {
             public:
                 /*!
-                 * Creates a new set of Gurobi settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of Gurobi settings.
                  */
-                GurobiSettings(storm::settings::SettingsManager& settingsManager);
+                GurobiSettings();
                 
                 /*!
                  * Retrieves whether the integer tolerance has been set.
diff --git a/src/settings/modules/ModuleSettings.cpp b/src/settings/modules/ModuleSettings.cpp
index f99d50e35..1f7a2b7f3 100644
--- a/src/settings/modules/ModuleSettings.cpp
+++ b/src/settings/modules/ModuleSettings.cpp
@@ -10,7 +10,7 @@ namespace storm {
     namespace settings {
         namespace modules {
             
-            ModuleSettings::ModuleSettings(storm::settings::SettingsManager& settingsManager, std::string const& moduleName) : settingsManager(settingsManager), moduleName(moduleName) {
+            ModuleSettings::ModuleSettings(std::string const& moduleName) : moduleName(moduleName) {
                 // Intentionally left empty.
             }
             
@@ -19,10 +19,6 @@ namespace storm {
             }
 
             void ModuleSettings::finalize() { }
-
-            storm::settings::SettingsManager const& ModuleSettings::getSettingsManager() const {
-                return this->settingsManager;
-            }
             
             void ModuleSettings::set(std::string const& name) {
                 return this->getOption(name).setHasOptionBeenSet();
diff --git a/src/settings/modules/ModuleSettings.h b/src/settings/modules/ModuleSettings.h
index 027664433..08c92909d 100644
--- a/src/settings/modules/ModuleSettings.h
+++ b/src/settings/modules/ModuleSettings.h
@@ -27,10 +27,9 @@ namespace storm {
                 /*!
                  * Constructs a new settings object.
                  *
-                 * @param settingsManager The manager responsible for these settings.
                  * @param moduleName The name of the module for which to build the settings.
                  */
-                ModuleSettings(storm::settings::SettingsManager& settingsManager, std::string const& moduleName);
+                ModuleSettings(std::string const& moduleName);
                 
                 /*!
                  * Checks whether the settings are consistent. If they are inconsistent, an exception is thrown.
@@ -77,12 +76,6 @@ namespace storm {
                 uint_fast64_t getPrintLengthOfLongestOption() const;
                 
             protected:
-                /*!
-                 * Retrieves the manager responsible for the settings.
-                 *
-                 * @return The manager responsible for the settings.
-                 */
-                storm::settings::SettingsManager const& getSettingsManager() const;
                 
                 /*!
                  * Retrieves the option with the given long name. If no such option exists, an exception is thrown.
@@ -132,8 +125,6 @@ namespace storm {
                 void addOption(std::shared_ptr<Option> const& option);
                 
             private:
-                // The settings manager responsible for the settings.
-                storm::settings::SettingsManager const& settingsManager;
                 
                 // The name of the module.
                 std::string moduleName;
diff --git a/src/settings/modules/NativeEquationSolverSettings.cpp b/src/settings/modules/NativeEquationSolverSettings.cpp
index 6e64f7deb..7bfb951e1 100644
--- a/src/settings/modules/NativeEquationSolverSettings.cpp
+++ b/src/settings/modules/NativeEquationSolverSettings.cpp
@@ -20,7 +20,7 @@ namespace storm {
             const std::string NativeEquationSolverSettings::precisionOptionName = "precision";
             const std::string NativeEquationSolverSettings::absoluteOptionName = "absolute";
             
-            NativeEquationSolverSettings::NativeEquationSolverSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            NativeEquationSolverSettings::NativeEquationSolverSettings() : ModuleSettings(moduleName) {
                 std::vector<std::string> methods = { "jacobi", "gaussseidel", "sor" };
                 this->addOption(storm::settings::OptionBuilder(moduleName, techniqueOptionName, true, "The method to be used for solving linear equation systems with the native engine. Available are: { jacobi }.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the method to use.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(methods)).setDefaultValueString("jacobi").build()).build());
                 
diff --git a/src/settings/modules/NativeEquationSolverSettings.h b/src/settings/modules/NativeEquationSolverSettings.h
index 01c0fd7c9..7395c6d66 100644
--- a/src/settings/modules/NativeEquationSolverSettings.h
+++ b/src/settings/modules/NativeEquationSolverSettings.h
@@ -19,11 +19,9 @@ namespace storm {
                 enum class ConvergenceCriterion { Absolute, Relative };
                 
                 /*!
-                 * Creates a new set of native equation solver settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of native equation solver settings.
                  */
-                NativeEquationSolverSettings(storm::settings::SettingsManager& settingsManager);
+                NativeEquationSolverSettings();
                 
                 /*!
                  * Retrieves whether the linear equation system technique has been set.
diff --git a/src/settings/modules/ParametricSettings.cpp b/src/settings/modules/ParametricSettings.cpp
index a1388f308..ac5d88329 100644
--- a/src/settings/modules/ParametricSettings.cpp
+++ b/src/settings/modules/ParametricSettings.cpp
@@ -16,7 +16,7 @@ namespace storm {
             const std::string ParametricSettings::exportResultDestinationPathOptionName = "resultfile";
             const std::string ParametricSettings::derivativesOptionName = "derivatives";
             
-            ParametricSettings::ParametricSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            ParametricSettings::ParametricSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, encodeSmt2StrategyOptionName, true, "Set the smt2 encoding strategy.")
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("strategy", "the used strategy").build()).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, exportSmt2DestinationPathOptionName, true, "A path to a file where the result should be saved.")
diff --git a/src/settings/modules/ParametricSettings.h b/src/settings/modules/ParametricSettings.h
index 28789c95f..83af4c1fe 100644
--- a/src/settings/modules/ParametricSettings.h
+++ b/src/settings/modules/ParametricSettings.h
@@ -23,11 +23,9 @@ namespace storm {
 				enum class Smt2EncodingStrategy {FULL_TRANSITION_SYSTEM, ONLY_SCC_ENTRY_STATES, HIGH_INDEGREE, RATIONAL_FUNCTION};
                 
                 /*!
-                 * Creates a new set of parametric model checking settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of parametric model checking settings.
                  */
-                ParametricSettings(storm::settings::SettingsManager& settingsManager);
+                ParametricSettings();
 				
 				/**
 				 * Retrieves whether the model checking result should be exported to a file.
diff --git a/src/settings/modules/SparseDtmcEliminationModelCheckerSettings.cpp b/src/settings/modules/SparseDtmcEliminationModelCheckerSettings.cpp
index c98e5821f..841a24115 100644
--- a/src/settings/modules/SparseDtmcEliminationModelCheckerSettings.cpp
+++ b/src/settings/modules/SparseDtmcEliminationModelCheckerSettings.cpp
@@ -16,7 +16,7 @@ namespace storm {
             const std::string SparseDtmcEliminationModelCheckerSettings::entryStatesLastOptionName = "entrylast";
             const std::string SparseDtmcEliminationModelCheckerSettings::maximalSccSizeOptionName = "sccsize";
             
-            SparseDtmcEliminationModelCheckerSettings::SparseDtmcEliminationModelCheckerSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            SparseDtmcEliminationModelCheckerSettings::SparseDtmcEliminationModelCheckerSettings() : ModuleSettings(moduleName) {
                 std::vector<std::string> orders = {"fw", "fwrev", "bw", "bwrev", "rand", "spen", "dpen", "regex"};
                 this->addOption(storm::settings::OptionBuilder(moduleName, eliminationOrderOptionName, true, "The order that is to be used for the elimination techniques. Available are {fw, fwrev, bw, bwrev, rand, spen, dpen}.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the order in which states are chosen for elimination.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(orders)).setDefaultValueString("fwrev").build()).build());
                 
diff --git a/src/settings/modules/SparseDtmcEliminationModelCheckerSettings.h b/src/settings/modules/SparseDtmcEliminationModelCheckerSettings.h
index 19716c3b2..176c84a67 100644
--- a/src/settings/modules/SparseDtmcEliminationModelCheckerSettings.h
+++ b/src/settings/modules/SparseDtmcEliminationModelCheckerSettings.h
@@ -23,11 +23,9 @@ namespace storm {
                 enum class EliminationMethod { State, Scc, Hybrid};
                 
                 /*!
-                 * Creates a new set of parametric model checking settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of parametric model checking settings.
                  */
-                SparseDtmcEliminationModelCheckerSettings(storm::settings::SettingsManager& settingsManager);
+                SparseDtmcEliminationModelCheckerSettings();
                 
                 /*!
                  * Retrieves the selected elimination method.
diff --git a/src/settings/modules/SylvanSettings.cpp b/src/settings/modules/SylvanSettings.cpp
index e22368162..a14648cd9 100644
--- a/src/settings/modules/SylvanSettings.cpp
+++ b/src/settings/modules/SylvanSettings.cpp
@@ -15,7 +15,7 @@ namespace storm {
             const std::string SylvanSettings::maximalMemoryOptionName = "maxmem";
             const std::string SylvanSettings::threadCountOptionName = "threads";
             
-            SylvanSettings::SylvanSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            SylvanSettings::SylvanSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, maximalMemoryOptionName, true, "Sets the upper bound of memory available to Sylvan in MB.").addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("value", "The memory available to Sylvan.").setDefaultValueUnsignedInteger(4096).build()).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, threadCountOptionName, true, "Sets the number of threads used by Sylvan.").addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("value", "The number of threads available to Sylvan (0 means 'auto-detect').").setDefaultValueUnsignedInteger(0).build()).build());
             }
diff --git a/src/settings/modules/SylvanSettings.h b/src/settings/modules/SylvanSettings.h
index e417fa36c..9dba48a88 100644
--- a/src/settings/modules/SylvanSettings.h
+++ b/src/settings/modules/SylvanSettings.h
@@ -13,11 +13,9 @@ namespace storm {
             class SylvanSettings : public ModuleSettings {
             public:
                 /*!
-                 * Creates a new set of CUDD settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of CUDD settings.
                  */
-                SylvanSettings(storm::settings::SettingsManager& settingsManager);
+                SylvanSettings();
                 
                 /*!
                  * Retrieves the maximal amount of memory (in megabytes) that Sylvan can occupy.
diff --git a/src/settings/modules/TopologicalValueIterationEquationSolverSettings.cpp b/src/settings/modules/TopologicalValueIterationEquationSolverSettings.cpp
index 1ab944e00..dda2e8f82 100644
--- a/src/settings/modules/TopologicalValueIterationEquationSolverSettings.cpp
+++ b/src/settings/modules/TopologicalValueIterationEquationSolverSettings.cpp
@@ -19,7 +19,7 @@ namespace storm {
 			const std::string TopologicalValueIterationEquationSolverSettings::precisionOptionName = "precision";
 			const std::string TopologicalValueIterationEquationSolverSettings::absoluteOptionName = "absolute";
 
-			TopologicalValueIterationEquationSolverSettings::TopologicalValueIterationEquationSolverSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+			TopologicalValueIterationEquationSolverSettings::TopologicalValueIterationEquationSolverSettings() : ModuleSettings(moduleName) {
                 
                 this->addOption(storm::settings::OptionBuilder(moduleName, maximalIterationsOptionName, false, "The maximal number of iterations to perform before iterative solving is aborted.").setShortName(maximalIterationsOptionShortName).addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("count", "The maximal iteration count.").setDefaultValueUnsignedInteger(20000).build()).build());
                 
diff --git a/src/settings/modules/TopologicalValueIterationEquationSolverSettings.h b/src/settings/modules/TopologicalValueIterationEquationSolverSettings.h
index fc9a901f2..0433e04a3 100644
--- a/src/settings/modules/TopologicalValueIterationEquationSolverSettings.h
+++ b/src/settings/modules/TopologicalValueIterationEquationSolverSettings.h
@@ -17,11 +17,9 @@ namespace storm {
 				enum class ConvergenceCriterion { Absolute, Relative };
 
                 /*!
-                 * Creates a new set of topological value iteration settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of topological value iteration settings.
                  */
-				TopologicalValueIterationEquationSolverSettings(storm::settings::SettingsManager& settingsManager);
+				TopologicalValueIterationEquationSolverSettings();
 
                 
                 /*!

From 67d77608bd544d07c58577e7f58b8dc022d67d87 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 21 Mar 2016 14:39:54 +0100
Subject: [PATCH 230/246] Refactoring of settings

Former-commit-id: ea4350fc1c01234bc723939af551287181184395
---
 src/builder/DdPrismModelBuilder.cpp           |   2 +-
 src/builder/ExplicitPrismModelBuilder.cpp     |   8 +-
 src/cli/cli.cpp                               |  23 ++-
 src/cli/entrypoints.h                         |  22 +--
 .../MILPMinimalLabelSetGenerator.h            |   2 +-
 .../SMTMinimalCommandSetGenerator.h           |   4 +-
 .../csl/helper/SparseCtmcCslHelper.cpp        |   2 +-
 .../helper/SparseMarkovAutomatonCslHelper.cpp |   2 +-
 .../SparseDtmcEliminationModelChecker.cpp     |  26 +--
 .../DeterministicSparseTransitionParser.cpp   |   2 +-
 .../MarkovAutomatonSparseTransitionParser.cpp |   4 +-
 ...NondeterministicSparseTransitionParser.cpp |   2 +-
 src/settings/SettingsManager.cpp              |  83 ++------
 src/settings/SettingsManager.h                | 109 +++--------
 src/settings/modules/BisimulationSettings.cpp |   2 +-
 .../CounterexampleGeneratorSettings.cpp       |   2 +-
 src/settings/modules/GlpkSettings.cpp         |   2 +-
 .../modules/GmmxxEquationSolverSettings.cpp   |   2 +-
 src/settings/modules/GurobiSettings.cpp       |   2 +-
 .../modules/NativeEquationSolverSettings.cpp  |   2 +-
 src/solver/AbstractGameSolver.cpp             |   2 +-
 src/solver/GlpkLpSolver.cpp                   |  12 +-
 src/solver/GmmxxLinearEquationSolver.cpp      |   2 +-
 .../GmmxxMinMaxLinearEquationSolver.cpp       |   2 +-
 src/solver/GurobiLpSolver.cpp                 |  16 +-
 src/solver/MinMaxLinearEquationSolver.cpp     |   2 +-
 src/solver/NativeLinearEquationSolver.cpp     |   4 +-
 .../NativeMinMaxLinearEquationSolver.cpp      |   2 +-
 src/solver/SymbolicLinearEquationSolver.cpp   |   2 +-
 .../SymbolicMinMaxLinearEquationSolver.cpp    |   2 +-
 .../TopologicalMinMaxLinearEquationSolver.cpp |   7 +-
 .../BisimulationDecomposition.cpp             |   2 +-
 .../bisimulation/BisimulationDecomposition.h  |   2 +-
 src/storage/dd/cudd/InternalCuddDdManager.cpp |   6 +-
 .../dd/sylvan/InternalSylvanDdManager.cpp     |   4 +-
 src/storage/prism/Program.cpp                 |   4 +-
 src/utility/ConstantsComparator.cpp           |   4 +-
 src/utility/export.h                          |   2 +-
 src/utility/initialize.cpp                    |   4 +-
 src/utility/solver.cpp                        |  12 +-
 src/utility/storm.h                           |  27 ++-
 .../GmmxxCtmcCslModelCheckerTest.cpp          |  46 ++---
 .../GmmxxDtmcPrctlModelCheckerTest.cpp        |  54 ++---
 .../GmmxxHybridCtmcCslModelCheckerTest.cpp    | 184 +++++++++---------
 .../GmmxxHybridDtmcPrctlModelCheckerTest.cpp  |  80 ++++----
 .../GmmxxHybridMdpPrctlModelCheckerTest.cpp   | 112 +++++------
 .../GmmxxMdpPrctlModelCheckerTest.cpp         |  36 ++--
 .../NativeCtmcCslModelCheckerTest.cpp         |  38 ++--
 .../NativeDtmcPrctlModelCheckerTest.cpp       |  48 ++---
 .../NativeHybridCtmcCslModelCheckerTest.cpp   | 184 +++++++++---------
 .../NativeHybridDtmcPrctlModelCheckerTest.cpp |  80 ++++----
 .../NativeHybridMdpPrctlModelCheckerTest.cpp  | 112 +++++------
 .../NativeMdpPrctlModelCheckerTest.cpp        | 152 +++++++--------
 .../SparseDtmcEliminationModelCheckerTest.cpp |  22 +--
 .../SymbolicDtmcPrctlModelCheckerTest.cpp     |  80 ++++----
 .../SymbolicMdpPrctlModelCheckerTest.cpp      | 112 +++++------
 ...ValueIterationMdpPrctlModelCheckerTest.cpp |  52 ++---
 .../solver/FullySymbolicGameSolverTest.cpp    |  16 +-
 test/functional/solver/GameSolverTest.cpp     |   8 +-
 test/functional/solver/GlpkLpSolverTest.cpp   |  24 +--
 .../solver/GmmxxLinearEquationSolverTest.cpp  |  44 ++---
 .../GmmxxMinMaxLinearEquationSolverTest.cpp   |  26 +--
 test/functional/solver/GurobiLpSolverTest.cpp |  24 +--
 .../solver/NativeLinearEquationSolverTest.cpp |   8 +-
 .../NativeMinMaxLinearEquationSolverTest.cpp  |  20 +-
 .../utility/ModelInstantiatorTest.cpp         |   8 +-
 .../GmmxxDtmcPrctModelCheckerTest.cpp         |  12 +-
 .../GmmxxMdpPrctlModelCheckerTest.cpp         |  28 +--
 .../NativeDtmcPrctlModelCheckerTest.cpp       |  12 +-
 .../NativeMdpPrctlModelCheckerTest.cpp        |  28 +--
 .../SymbolicDtmcPrctlModelCheckerTest.cpp     |  48 ++---
 .../SymbolicMdpPrctlModelCheckerTest.cpp      |  48 ++---
 ...ValueIterationMdpPrctlModelCheckerTest.cpp |  28 +--
 73 files changed, 1035 insertions(+), 1162 deletions(-)

diff --git a/src/builder/DdPrismModelBuilder.cpp b/src/builder/DdPrismModelBuilder.cpp
index e265f70c5..7fcb209d0 100644
--- a/src/builder/DdPrismModelBuilder.cpp
+++ b/src/builder/DdPrismModelBuilder.cpp
@@ -1081,7 +1081,7 @@ namespace storm {
 
             if (!deadlockStates.isZero()) {
                 // If we need to fix deadlocks, we do so now.
-                if (!storm::settings::generalSettings().isDontFixDeadlocksSet()) {
+                if (!storm::settings::getModule<storm::settings::modules::GeneralSettings>().isDontFixDeadlocksSet()) {
                     STORM_LOG_INFO("Fixing deadlocks in " << deadlockStates.getNonZeroCount() << " states. The first three of these states are: ");
                     
                     uint_fast64_t count = 0;
diff --git a/src/builder/ExplicitPrismModelBuilder.cpp b/src/builder/ExplicitPrismModelBuilder.cpp
index ef53b9e43..eba19054f 100644
--- a/src/builder/ExplicitPrismModelBuilder.cpp
+++ b/src/builder/ExplicitPrismModelBuilder.cpp
@@ -84,17 +84,17 @@ namespace storm {
         }
         
         template <typename ValueType, typename RewardModelType, typename StateType>
-        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options() : explorationOrder(storm::settings::generalSettings().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(true), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(true), labelsToBuild(), expressionLabels(), terminalStates(), negatedTerminalStates() {
+        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options() : explorationOrder(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(true), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(true), labelsToBuild(), expressionLabels(), terminalStates(), negatedTerminalStates() {
             // Intentionally left empty.
         }
         
         template <typename ValueType, typename RewardModelType, typename StateType>
-        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options(storm::logic::Formula const& formula) : explorationOrder(storm::settings::generalSettings().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(false), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(false), labelsToBuild(std::set<std::string>()), expressionLabels(std::vector<storm::expressions::Expression>()), terminalStates(), negatedTerminalStates() {
+        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options(storm::logic::Formula const& formula) : explorationOrder(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(false), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(false), labelsToBuild(std::set<std::string>()), expressionLabels(std::vector<storm::expressions::Expression>()), terminalStates(), negatedTerminalStates() {
             this->preserveFormula(formula);
         }
         
         template <typename ValueType, typename RewardModelType, typename StateType>
-        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options(std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas) : explorationOrder(storm::settings::generalSettings().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(false), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(false), labelsToBuild(), expressionLabels(), terminalStates(), negatedTerminalStates() {
+        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options(std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas) : explorationOrder(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(false), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(false), labelsToBuild(), expressionLabels(), terminalStates(), negatedTerminalStates() {
             if (formulas.empty()) {
                 this->buildAllRewardModels = true;
                 this->buildAllLabels = true;
@@ -386,7 +386,7 @@ namespace storm {
                 
                 // If there is no behavior, we might have to introduce a self-loop.
                 if (behavior.empty()) {
-                    if (!storm::settings::generalSettings().isDontFixDeadlocksSet() || !behavior.wasExpanded()) {
+                    if (!storm::settings::getModule<storm::settings::modules::GeneralSettings>().isDontFixDeadlocksSet() || !behavior.wasExpanded()) {
                         if (options.buildCommandLabels) {
                             // Insert empty choice labeling for added self-loop transitions.
                             choiceLabels.get().push_back(boost::container::flat_set<uint_fast64_t>());
diff --git a/src/cli/cli.cpp b/src/cli/cli.cpp
index 0b384b539..08ebd74fc 100644
--- a/src/cli/cli.cpp
+++ b/src/cli/cli.cpp
@@ -166,47 +166,46 @@ namespace storm {
             }
             
             bool parseOptions(const int argc, const char* argv[]) {
-                storm::settings::SettingsManager& manager = storm::settings::mutableManager();
                 try {
-                    manager.setFromCommandLine(argc, argv);
+                    storm::settings::mutableManager().setFromCommandLine(argc, argv);
                 } catch (storm::exceptions::OptionParserException& e) {
-                    manager.printHelp();
+                    storm::settings::manager().printHelp();
                     throw e;
                     return false;
                 }
                 
-                if (storm::settings::generalSettings().isHelpSet()) {
-                    storm::settings::manager().printHelp(storm::settings::generalSettings().getHelpModuleName());
+                if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isHelpSet()) {
+                    storm::settings::manager().printHelp(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getHelpModuleName());
                     return false;
                 }
                 
-                if (storm::settings::generalSettings().isVersionSet()) {
+                if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isVersionSet()) {
                     storm::settings::manager().printVersion();
                     return false;
                 }
                 
-                if (storm::settings::generalSettings().isVerboseSet()) {
+                if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isVerboseSet()) {
                     STORM_GLOBAL_LOGLEVEL_INFO();
                 }
-                if (storm::settings::debugSettings().isDebugSet()) {
+                if (storm::settings::getModule<storm::settings::modules::DebugSettings>().isDebugSet()) {
                     STORM_GLOBAL_LOGLEVEL_DEBUG();
                     
                 }
-                if (storm::settings::debugSettings().isTraceSet()) {
+                if (storm::settings::getModule<storm::settings::modules::DebugSettings>().isTraceSet()) {
                     STORM_GLOBAL_LOGLEVEL_TRACE();
                 }
-                if (storm::settings::debugSettings().isLogfileSet()) {
+                if (storm::settings::getModule<storm::settings::modules::DebugSettings>().isLogfileSet()) {
                     storm::utility::initializeFileLogging();
                 }
                 return true;
             }
             
             void processOptions() {
-                if (storm::settings::debugSettings().isLogfileSet()) {
+                if (storm::settings::getModule<storm::settings::modules::DebugSettings>().isLogfileSet()) {
                     storm::utility::initializeFileLogging();
                 }
                 
-                storm::settings::modules::GeneralSettings const& settings = storm::settings::generalSettings();
+                storm::settings::modules::GeneralSettings const& settings = storm::settings::getModule<storm::settings::modules::GeneralSettings>();
                 
                 // If we have to build the model from a symbolic representation, we need to parse the representation first.
                 boost::optional<storm::prism::Program> program;
diff --git a/src/cli/entrypoints.h b/src/cli/entrypoints.h
index 8071d99c1..3e2ee0670 100644
--- a/src/cli/entrypoints.h
+++ b/src/cli/entrypoints.h
@@ -41,9 +41,8 @@ namespace storm {
                     std::cout << " skipped, because the modelling formalism is currently unsupported." << std::endl;
                 }
 
-                storm::settings::modules::ParametricSettings const& parametricSettings = storm::settings::parametricSettings();
-                if (parametricSettings.exportResultToFile()) {
-                    exportParametricResultToFile(result->asExplicitQuantitativeCheckResult<storm::RationalFunction>()[*model->getInitialStates().begin()], storm::models::sparse::Dtmc<storm::RationalFunction>::ConstraintCollector(*(model->template as<storm::models::sparse::Dtmc<storm::RationalFunction>>())), parametricSettings.exportResultPath());
+                if (storm::settings::getModule<storm::settings::modules::ParametricSettings>().exportResultToFile()) {
+                    exportParametricResultToFile(result->asExplicitQuantitativeCheckResult<storm::RationalFunction>()[*model->getInitialStates().begin()], storm::models::sparse::Dtmc<storm::RationalFunction>::ConstraintCollector(*(model->template as<storm::models::sparse::Dtmc<storm::RationalFunction>>())), storm::settings::getModule<storm::settings::modules::ParametricSettings>().exportResultPath());
                 }
             }
         }
@@ -115,10 +114,7 @@ namespace storm {
     
         template<typename ValueType, storm::dd::DdType LibraryType>
         void buildAndCheckSymbolicModel(storm::prism::Program const& program, std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas, bool onlyInitialStatesRelevant = false) {
-
-            storm::settings::modules::GeneralSettings const& settings = storm::settings::generalSettings();
-
-            if (settings.getEngine() == storm::settings::modules::GeneralSettings::Engine::AbstractionRefinement) {
+            if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEngine() == storm::settings::modules::GeneralSettings::Engine::AbstractionRefinement) {
                 verifySymbolicModelWithAbstractionRefinementEngine<LibraryType>(program, formulas, onlyInitialStatesRelevant);
             } else {
                 storm::storage::ModelFormulasPair modelFormulasPair = buildSymbolicModel<ValueType, LibraryType>(program, formulas);
@@ -134,7 +130,7 @@ namespace storm {
                 // Verify the model, if a formula was given.
                 if (!formulas.empty()) {
                     if (modelFormulasPair.model->isSparseModel()) {
-                        if (storm::settings::generalSettings().isCounterexampleSet()) {
+                        if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isCounterexampleSet()) {
                             // If we were requested to generate a counterexample, we now do so for each formula.
                             for (auto const &formula : modelFormulasPair.formulas) {
                                 generateCounterexample<ValueType>(program, modelFormulasPair.model->as<storm::models::sparse::Model<ValueType>>(), formula);
@@ -143,7 +139,7 @@ namespace storm {
                             verifySparseModel<ValueType>(modelFormulasPair.model->as<storm::models::sparse::Model<ValueType>>(), modelFormulasPair.formulas, onlyInitialStatesRelevant);
                         }
                     } else if (modelFormulasPair.model->isSymbolicModel()) {
-                        if (storm::settings::generalSettings().getEngine() == storm::settings::modules::GeneralSettings::Engine::Hybrid) {
+                        if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEngine() == storm::settings::modules::GeneralSettings::Engine::Hybrid) {
                             verifySymbolicModelWithHybridEngine(modelFormulasPair.model->as<storm::models::symbolic::Model<LibraryType>>(),
                                                                 modelFormulasPair.formulas, onlyInitialStatesRelevant);
                         } else {
@@ -159,18 +155,18 @@ namespace storm {
         
         template<typename ValueType>
         void buildAndCheckSymbolicModel(storm::prism::Program const& program, std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas, bool onlyInitialStatesRelevant = false) {
-            if (storm::settings::generalSettings().getDdLibraryType() == storm::dd::DdType::CUDD) {
+            if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getDdLibraryType() == storm::dd::DdType::CUDD) {
                 buildAndCheckSymbolicModel<ValueType, storm::dd::DdType::CUDD>(program, formulas, onlyInitialStatesRelevant);
-            } else if (storm::settings::generalSettings().getDdLibraryType() == storm::dd::DdType::Sylvan) {
+            } else if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getDdLibraryType() == storm::dd::DdType::Sylvan) {
                 buildAndCheckSymbolicModel<ValueType, storm::dd::DdType::Sylvan>(program, formulas, onlyInitialStatesRelevant);
             }
         }
 
         template<typename ValueType>
         void buildAndCheckExplicitModel(std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas, bool onlyInitialStatesRelevant = false) {
-            storm::settings::modules::GeneralSettings const& settings = storm::settings::generalSettings();
+            storm::settings::modules::GeneralSettings const& settings = storm::settings::getModule<storm::settings::modules::GeneralSettings>();
 
-            STORM_LOG_THROW(settings.isExplicitSet(), storm::exceptions::InvalidStateException, "Unable to build explicit model without model files.");
+            STORM_LOG_THROW(storm::settings::getModule<storm::settings::modules::GeneralSettings>().isExplicitSet(), storm::exceptions::InvalidStateException, "Unable to build explicit model without model files.");
             std::shared_ptr<storm::models::ModelBase> model = buildExplicitModel<ValueType>(settings.getTransitionFilename(), settings.getLabelingFilename(), settings.isStateRewardsSet() ? boost::optional<std::string>(settings.getStateRewardsFilename()) : boost::none, settings.isTransitionRewardsSet() ? boost::optional<std::string>(settings.getTransitionRewardsFilename()) : boost::none, settings.isChoiceLabelingSet() ? boost::optional<std::string>(settings.getChoiceLabelingFilename()) : boost::none);
             
             // Preprocess the model if needed.
diff --git a/src/counterexamples/MILPMinimalLabelSetGenerator.h b/src/counterexamples/MILPMinimalLabelSetGenerator.h
index ffc398e34..97c6af030 100644
--- a/src/counterexamples/MILPMinimalLabelSetGenerator.h
+++ b/src/counterexamples/MILPMinimalLabelSetGenerator.h
@@ -1015,7 +1015,7 @@ namespace storm {
                 
                 // Delegate the actual computation work to the function of equal name.
                 auto startTime = std::chrono::high_resolution_clock::now();
-                boost::container::flat_set<uint_fast64_t> usedLabelSet = getMinimalLabelSet(probabilityOperator.getSubformula(), labeledMdp, phiStates, psiStates, threshold, strictBound, true, storm::settings::counterexampleGeneratorSettings().isUseSchedulerCutsSet());
+                boost::container::flat_set<uint_fast64_t> usedLabelSet = getMinimalLabelSet(probabilityOperator.getSubformula(), labeledMdp, phiStates, psiStates, threshold, strictBound, true, storm::settings::getModule<storm::settings::modules::CounterexampleGeneratorSettings>().isUseSchedulerCutsSet());
                 auto endTime = std::chrono::high_resolution_clock::now();
                 std::cout << std::endl << "Computed minimal label set of size " << usedLabelSet.size() << " in " << std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count() << "ms." << std::endl;
 
diff --git a/src/counterexamples/SMTMinimalCommandSetGenerator.h b/src/counterexamples/SMTMinimalCommandSetGenerator.h
index f7a2704b5..ed84d7b10 100644
--- a/src/counterexamples/SMTMinimalCommandSetGenerator.h
+++ b/src/counterexamples/SMTMinimalCommandSetGenerator.h
@@ -1729,7 +1729,7 @@ namespace storm {
 
                 // Compute and emit the time measurements if the corresponding flag was set.
                 totalTime = std::chrono::high_resolution_clock::now() - totalClock;
-                if (storm::settings::generalSettings().isShowStatisticsSet()) {
+                if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isShowStatisticsSet()) {
                     std::cout << std::endl;
                     std::cout << "Time breakdown:" << std::endl;
                     std::cout << "    * time for setup: " << std::chrono::duration_cast<std::chrono::milliseconds>(totalSetupTime).count() << "ms" << std::endl;
@@ -1793,7 +1793,7 @@ namespace storm {
                 
                 // Delegate the actual computation work to the function of equal name.
                 auto startTime = std::chrono::high_resolution_clock::now();
-                auto labelSet = getMinimalCommandSet(probabilityOperator.getSubformula(), program, constantDefinitionString, labeledMdp, phiStates, psiStates, threshold, strictBound, true, storm::settings::counterexampleGeneratorSettings().isEncodeReachabilitySet());
+                auto labelSet = getMinimalCommandSet(probabilityOperator.getSubformula(), program, constantDefinitionString, labeledMdp, phiStates, psiStates, threshold, strictBound, true, storm::settings::getModule<storm::settings::modules::CounterexampleGeneratorSettings>().isEncodeReachabilitySet());
                 auto endTime = std::chrono::high_resolution_clock::now();
                 std::cout << std::endl << "Computed minimal label set of size " << labelSet.size() << " in " << std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count() << "ms." << std::endl;
                 
diff --git a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
index d0f8a1b69..b4c01d13a 100644
--- a/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
+++ b/src/modelchecker/csl/helper/SparseCtmcCslHelper.cpp
@@ -245,7 +245,7 @@ namespace storm {
                 }
                 
                 // Use Fox-Glynn to get the truncation points and the weights.
-                std::tuple<uint_fast64_t, uint_fast64_t, ValueType, std::vector<ValueType>> foxGlynnResult = storm::utility::numerical::getFoxGlynnCutoff(lambda, 1e-300, 1e+300, storm::settings::generalSettings().getPrecision() / 8.0);
+                std::tuple<uint_fast64_t, uint_fast64_t, ValueType, std::vector<ValueType>> foxGlynnResult = storm::utility::numerical::getFoxGlynnCutoff(lambda, 1e-300, 1e+300, storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision() / 8.0);
                 STORM_LOG_DEBUG("Fox-Glynn cutoff points: left=" << std::get<0>(foxGlynnResult) << ", right=" << std::get<1>(foxGlynnResult));
                 
                 // Scale the weights so they add up to one.
diff --git a/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp b/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp
index 01fba2762..0139cdfcd 100644
--- a/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp
+++ b/src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp
@@ -127,7 +127,7 @@ namespace storm {
                 for (auto value : exitRateVector) {
                     maxExitRate = std::max(maxExitRate, value);
                 }
-                ValueType delta = (2 * storm::settings::generalSettings().getPrecision()) / (upperBound * maxExitRate * maxExitRate);
+                ValueType delta = (2 * storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()) / (upperBound * maxExitRate * maxExitRate);
                 
                 // (2) Compute the number of steps we need to make for the interval.
                 uint_fast64_t numberOfSteps = static_cast<uint_fast64_t>(std::ceil((upperBound - lowerBound) / delta));
diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
index 1290b43cb..1b6cbda98 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
@@ -233,7 +233,7 @@ namespace storm {
             
             std::chrono::high_resolution_clock::time_point modelCheckingStart = std::chrono::high_resolution_clock::now();
 
-            storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder order = storm::settings::sparseDtmcEliminationModelCheckerSettings().getEliminationOrder();
+            storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder order = storm::settings::getModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>().getEliminationOrder();
             boost::optional<std::vector<uint_fast64_t>> distanceBasedPriorities;
             if (eliminationOrderNeedsDistances(order)) {
                 distanceBasedPriorities = getDistanceBasedPriorities(transitionMatrix, backwardTransitions, initialStates, stateValues,
@@ -330,7 +330,7 @@ namespace storm {
             std::chrono::high_resolution_clock::time_point modelCheckingEnd = std::chrono::high_resolution_clock::now();
             std::chrono::high_resolution_clock::time_point totalTimeEnd = std::chrono::high_resolution_clock::now();
             
-            if (storm::settings::generalSettings().isShowStatisticsSet()) {
+            if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isShowStatisticsSet()) {
                 std::chrono::high_resolution_clock::duration sccDecompositionTime = sccDecompositionEnd - sccDecompositionStart;
                 std::chrono::milliseconds sccDecompositionTimeInMilliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(sccDecompositionTime);
                 std::chrono::high_resolution_clock::duration conversionTime = conversionEnd - conversionStart;
@@ -645,7 +645,7 @@ namespace storm {
             storm::storage::BitVector trueStates(this->getModel().getNumberOfStates(), true);
             
             // Do some sanity checks to establish some required properties.
-            // STORM_LOG_WARN_COND(storm::settings::sparseDtmcEliminationModelCheckerSettings().getEliminationMethod() == storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationMethod::State, "The chosen elimination method is not available for computing conditional probabilities. Falling back to regular state elimination.");
+            // STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>().getEliminationMethod() == storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationMethod::State, "The chosen elimination method is not available for computing conditional probabilities. Falling back to regular state elimination.");
             STORM_LOG_THROW(this->getModel().getInitialStates().getNumberOfSetBits() == 1, storm::exceptions::IllegalArgumentException, "Input model is required to have exactly one initial state.");
             STORM_LOG_THROW(checkTask.isOnlyInitialStatesRelevantSet(), storm::exceptions::IllegalArgumentException, "Cannot compute conditional probabilities for all states.");
             storm::storage::sparse::state_type initialState = *this->getModel().getInitialStates().begin();
@@ -706,7 +706,7 @@ namespace storm {
             // Before starting the model checking process, we assign priorities to states so we can use them to
             // impose ordering constraints later.
             boost::optional<std::vector<uint_fast64_t>> distanceBasedPriorities;
-            storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder order = storm::settings::sparseDtmcEliminationModelCheckerSettings().getEliminationOrder();
+            storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder order = storm::settings::getModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>().getEliminationOrder();
             if (eliminationOrderNeedsDistances(order)) {
                 distanceBasedPriorities = getDistanceBasedPriorities(submatrix, submatrixTransposed, newInitialStates, oneStepProbabilities,
                                                              eliminationOrderNeedsForwardDistances(order),
@@ -847,7 +847,7 @@ namespace storm {
             STORM_LOG_TRACE("Creating state priority queue for states " << states);
             
             // Get the settings to customize the priority queue.
-            storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder order = storm::settings::sparseDtmcEliminationModelCheckerSettings().getEliminationOrder();
+            storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder order = storm::settings::getModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>().getEliminationOrder();
             
             std::vector<storm::storage::sparse::state_type> sortedStates(states.begin(), states.end());
 
@@ -922,10 +922,10 @@ namespace storm {
             // When using the hybrid technique, we recursively treat the SCCs up to some size.
             std::vector<storm::storage::sparse::state_type> entryStateQueue;
             STORM_LOG_DEBUG("Eliminating " << subsystem.size() << " states using the hybrid elimination technique." << std::endl);
-            uint_fast64_t maximalDepth = treatScc(transitionMatrix, values, initialStates, subsystem, initialStates, forwardTransitions, backwardTransitions, false, 0, storm::settings::sparseDtmcEliminationModelCheckerSettings().getMaximalSccSize(), entryStateQueue, computeResultsForInitialStatesOnly, distanceBasedPriorities);
+            uint_fast64_t maximalDepth = treatScc(transitionMatrix, values, initialStates, subsystem, initialStates, forwardTransitions, backwardTransitions, false, 0, storm::settings::getModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>().getMaximalSccSize(), entryStateQueue, computeResultsForInitialStatesOnly, distanceBasedPriorities);
             
             // If the entry states were to be eliminated last, we need to do so now.
-            if (storm::settings::sparseDtmcEliminationModelCheckerSettings().isEliminateEntryStatesLastSet()) {
+            if (storm::settings::getModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>().isEliminateEntryStatesLastSet()) {
                 STORM_LOG_DEBUG("Eliminating " << entryStateQueue.size() << " entry states as a last step.");
                 std::vector<storm::storage::sparse::state_type> sortedStates(entryStateQueue.begin(), entryStateQueue.end());
                 std::shared_ptr<StatePriorityQueue<ValueType>> queuePriorities = std::shared_ptr<StatePriorityQueue<ValueType>>(new StaticStatePriorityQueue(sortedStates));
@@ -941,7 +941,7 @@ namespace storm {
             storm::storage::FlexibleSparseMatrix<ValueType> flexibleMatrix(transitionMatrix);
             storm::storage::FlexibleSparseMatrix<ValueType> flexibleBackwardTransitions(backwardTransitions);
 
-            storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder order = storm::settings::sparseDtmcEliminationModelCheckerSettings().getEliminationOrder();
+            storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder order = storm::settings::getModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>().getEliminationOrder();
             boost::optional<std::vector<uint_fast64_t>> distanceBasedPriorities;
             if (eliminationOrderNeedsDistances(order)) {
                 distanceBasedPriorities = getDistanceBasedPriorities(transitionMatrix, backwardTransitions, initialStates, oneStepProbabilitiesToTarget,
@@ -952,9 +952,9 @@ namespace storm {
             storm::storage::BitVector subsystem = storm::storage::BitVector(transitionMatrix.getRowCount(), true);
             
             uint_fast64_t maximalDepth = 0;
-            if (storm::settings::sparseDtmcEliminationModelCheckerSettings().getEliminationMethod() == storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationMethod::State) {
+            if (storm::settings::getModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>().getEliminationMethod() == storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationMethod::State) {
                 performOrdinaryStateElimination(flexibleMatrix, flexibleBackwardTransitions, subsystem, initialStates, computeResultsForInitialStatesOnly, values, distanceBasedPriorities);
-            } else if (storm::settings::sparseDtmcEliminationModelCheckerSettings().getEliminationMethod() == storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationMethod::Hybrid) {
+            } else if (storm::settings::getModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>().getEliminationMethod() == storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationMethod::Hybrid) {
                 maximalDepth = performHybridStateElimination(transitionMatrix, flexibleMatrix, flexibleBackwardTransitions, subsystem, initialStates, computeResultsForInitialStatesOnly, values, distanceBasedPriorities);
             }
         
@@ -1020,7 +1020,7 @@ namespace storm {
                     }
                     
                     // Recursively descend in SCC-hierarchy.
-                    uint_fast64_t depth = treatScc(matrix, values, entryStates, newSccAsBitVector, initialStates, forwardTransitions, backwardTransitions, eliminateEntryStates || !storm::settings::sparseDtmcEliminationModelCheckerSettings().isEliminateEntryStatesLastSet(), level + 1, maximalSccSize, entryStateQueue, computeResultsForInitialStatesOnly, distanceBasedPriorities);
+                    uint_fast64_t depth = treatScc(matrix, values, entryStates, newSccAsBitVector, initialStates, forwardTransitions, backwardTransitions, eliminateEntryStates || !storm::settings::getModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>().isEliminateEntryStatesLastSet(), level + 1, maximalSccSize, entryStateQueue, computeResultsForInitialStatesOnly, distanceBasedPriorities);
                     maximalDepth = std::max(maximalDepth, depth);
                 }
             } else {
@@ -1056,8 +1056,8 @@ namespace storm {
             }
             
             std::vector<std::size_t> distances = getStateDistances(transitionMatrix, transitionMatrixTransposed, initialStates, oneStepProbabilities,
-                                                                   storm::settings::sparseDtmcEliminationModelCheckerSettings().getEliminationOrder() == storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder::Forward ||
-                                                                   storm::settings::sparseDtmcEliminationModelCheckerSettings().getEliminationOrder() == storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder::ForwardReversed);
+                                                                   storm::settings::getModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>().getEliminationOrder() == storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder::Forward ||
+                                                                   storm::settings::getModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>().getEliminationOrder() == storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::EliminationOrder::ForwardReversed);
             
             // In case of the forward or backward ordering, we can sort the states according to the distances.
             if (forward ^ reverse) {
diff --git a/src/parser/DeterministicSparseTransitionParser.cpp b/src/parser/DeterministicSparseTransitionParser.cpp
index da200fe2e..efc91643a 100644
--- a/src/parser/DeterministicSparseTransitionParser.cpp
+++ b/src/parser/DeterministicSparseTransitionParser.cpp
@@ -88,7 +88,7 @@ namespace storm {
 
             uint_fast64_t row, col, lastRow = 0;
             double val;
-            bool dontFixDeadlocks = storm::settings::generalSettings().isDontFixDeadlocksSet();
+            bool dontFixDeadlocks = storm::settings::getModule<storm::settings::modules::GeneralSettings>().isDontFixDeadlocksSet();
             bool hadDeadlocks = false;
             bool rowHadDiagonalEntry = false;
 
diff --git a/src/parser/MarkovAutomatonSparseTransitionParser.cpp b/src/parser/MarkovAutomatonSparseTransitionParser.cpp
index 18d87d314..7ea2dd611 100644
--- a/src/parser/MarkovAutomatonSparseTransitionParser.cpp
+++ b/src/parser/MarkovAutomatonSparseTransitionParser.cpp
@@ -17,7 +17,7 @@ namespace storm {
         typename MarkovAutomatonSparseTransitionParser<ValueType>::FirstPassResult MarkovAutomatonSparseTransitionParser<ValueType>::firstPass(char const* buf) {
             MarkovAutomatonSparseTransitionParser::FirstPassResult result;
 
-            bool dontFixDeadlocks = storm::settings::generalSettings().isDontFixDeadlocksSet();
+            bool dontFixDeadlocks = storm::settings::getModule<storm::settings::modules::GeneralSettings>().isDontFixDeadlocksSet();
 
             // Skip the format hint if it is there.
             buf = trimWhitespaces(buf);
@@ -160,7 +160,7 @@ namespace storm {
         typename MarkovAutomatonSparseTransitionParser<ValueType>::Result MarkovAutomatonSparseTransitionParser<ValueType>::secondPass(char const* buf, FirstPassResult const& firstPassResult) {
             Result result(firstPassResult);
 
-            bool dontFixDeadlocks = storm::settings::generalSettings().isDontFixDeadlocksSet();
+            bool dontFixDeadlocks = storm::settings::getModule<storm::settings::modules::GeneralSettings>().isDontFixDeadlocksSet();
 
             // Skip the format hint if it is there.
             buf = trimWhitespaces(buf);
diff --git a/src/parser/NondeterministicSparseTransitionParser.cpp b/src/parser/NondeterministicSparseTransitionParser.cpp
index e89fe76e2..2f40a7425 100644
--- a/src/parser/NondeterministicSparseTransitionParser.cpp
+++ b/src/parser/NondeterministicSparseTransitionParser.cpp
@@ -96,7 +96,7 @@ namespace storm {
             // Initialize variables for the parsing run.
             uint_fast64_t source = 0, target = 0, lastSource = 0, choice = 0, lastChoice = 0, curRow = 0;
             double val = 0.0;
-            bool dontFixDeadlocks = storm::settings::generalSettings().isDontFixDeadlocksSet();
+            bool dontFixDeadlocks = storm::settings::getModule<storm::settings::modules::GeneralSettings>().isDontFixDeadlocksSet();
             bool hadDeadlocks = false;
 
             // The first state already starts a new row group of the matrix.
diff --git a/src/settings/SettingsManager.cpp b/src/settings/SettingsManager.cpp
index 7ca1efca2..a7dc0d029 100644
--- a/src/settings/SettingsManager.cpp
+++ b/src/settings/SettingsManager.cpp
@@ -35,19 +35,19 @@ namespace storm {
         
         SettingsManager::SettingsManager() : modules(), longNameToOptions(), shortNameToOptions(), moduleOptions() {
             // Register all known settings modules.
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GeneralSettings()));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::DebugSettings()));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::CounterexampleGeneratorSettings()));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::CuddSettings()));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::SylvanSettings()));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GmmxxEquationSolverSettings()));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::NativeEquationSolverSettings()));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::BisimulationSettings()));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GlpkSettings()));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GurobiSettings()));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::TopologicalValueIterationEquationSolverSettings()));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::ParametricSettings()));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::SparseDtmcEliminationModelCheckerSettings()));
+            storm::settings::addModule<storm::settings::modules::GeneralSettings>();
+            storm::settings::addModule<storm::settings::modules::DebugSettings>();
+            storm::settings::addModule<storm::settings::modules::CounterexampleGeneratorSettings>();
+            storm::settings::addModule<storm::settings::modules::CuddSettings>();
+            storm::settings::addModule<storm::settings::modules::SylvanSettings>();
+            storm::settings::addModule<storm::settings::modules::GmmxxEquationSolverSettings>();
+            storm::settings::addModule<storm::settings::modules::NativeEquationSolverSettings>();
+            storm::settings::addModule<storm::settings::modules::BisimulationSettings>();
+            storm::settings::addModule<storm::settings::modules::GlpkSettings>();
+            storm::settings::addModule<storm::settings::modules::GurobiSettings>();
+            storm::settings::addModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>();
+            storm::settings::addModule<storm::settings::modules::ParametricSettings>();
+            storm::settings::addModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>();
         }
         
         SettingsManager::~SettingsManager() {
@@ -134,8 +134,8 @@ namespace storm {
             }
 
             // Include the options from a possibly specified configuration file, but don't overwrite existing settings.
-            if (storm::settings::generalSettings().isConfigSet()) {
-                this->setFromConfigurationFile(storm::settings::generalSettings().getConfigFilename());
+            if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isConfigSet()) {
+                this->setFromConfigurationFile(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getConfigFilename());
             }
             
             // Finally, check whether all modules are okay with the current settings.
@@ -492,60 +492,9 @@ namespace storm {
             return SettingsManager::manager();
         }
         
-        storm::settings::modules::GeneralSettings const& generalSettings() {
-            return dynamic_cast<storm::settings::modules::GeneralSettings const&>(manager().getModule(storm::settings::modules::GeneralSettings::moduleName));
-        }
-        
         storm::settings::modules::GeneralSettings& mutableGeneralSettings() {
-            return dynamic_cast<storm::settings::modules::GeneralSettings&>(storm::settings::SettingsManager::manager().getModule(storm::settings::modules::GeneralSettings::moduleName));
-        }
-        
-        storm::settings::modules::DebugSettings const& debugSettings()  {
-            return dynamic_cast<storm::settings::modules::DebugSettings const&>(manager().getModule(storm::settings::modules::DebugSettings::moduleName));
-        }
-        
-        storm::settings::modules::CounterexampleGeneratorSettings const& counterexampleGeneratorSettings() {
-            return dynamic_cast<storm::settings::modules::CounterexampleGeneratorSettings const&>(manager().getModule(storm::settings::modules::CounterexampleGeneratorSettings::moduleName));
-        }
-        
-        storm::settings::modules::CuddSettings const& cuddSettings() {
-            return dynamic_cast<storm::settings::modules::CuddSettings const&>(manager().getModule(storm::settings::modules::CuddSettings::moduleName));
-        }
-
-        storm::settings::modules::SylvanSettings const& sylvanSettings() {
-            return dynamic_cast<storm::settings::modules::SylvanSettings const&>(manager().getModule(storm::settings::modules::SylvanSettings::moduleName));
-        }
-        
-        storm::settings::modules::GmmxxEquationSolverSettings const& gmmxxEquationSolverSettings() {
-            return dynamic_cast<storm::settings::modules::GmmxxEquationSolverSettings const&>(manager().getModule(storm::settings::modules::GmmxxEquationSolverSettings::moduleName));
+            return dynamic_cast<storm::settings::modules::GeneralSettings&>(mutableManager().getModule(storm::settings::modules::GeneralSettings::moduleName));
         }
         
-        storm::settings::modules::NativeEquationSolverSettings const& nativeEquationSolverSettings() {
-            return dynamic_cast<storm::settings::modules::NativeEquationSolverSettings const&>(manager().getModule(storm::settings::modules::NativeEquationSolverSettings::moduleName));
-        }
-        
-        storm::settings::modules::BisimulationSettings const& bisimulationSettings() {
-            return dynamic_cast<storm::settings::modules::BisimulationSettings const&>(manager().getModule(storm::settings::modules::BisimulationSettings::moduleName));
-        }
-        
-        storm::settings::modules::GlpkSettings const& glpkSettings() {
-            return dynamic_cast<storm::settings::modules::GlpkSettings const&>(manager().getModule(storm::settings::modules::GlpkSettings::moduleName));
-        }
-        
-        storm::settings::modules::GurobiSettings const& gurobiSettings() {
-            return dynamic_cast<storm::settings::modules::GurobiSettings const&>(manager().getModule(storm::settings::modules::GurobiSettings::moduleName));
-		}
-
-		storm::settings::modules::TopologicalValueIterationEquationSolverSettings const& topologicalValueIterationEquationSolverSettings() {
-			return dynamic_cast<storm::settings::modules::TopologicalValueIterationEquationSolverSettings const&>(manager().getModule(storm::settings::modules::TopologicalValueIterationEquationSolverSettings::moduleName));
-		}
-        
-        storm::settings::modules::ParametricSettings const& parametricSettings() {
-            return dynamic_cast<storm::settings::modules::ParametricSettings const&>(manager().getModule(storm::settings::modules::ParametricSettings::moduleName));
-        }
-
-        storm::settings::modules::SparseDtmcEliminationModelCheckerSettings const& sparseDtmcEliminationModelCheckerSettings() {
-            return dynamic_cast<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings const&>(manager().getModule(storm::settings::modules::SparseDtmcEliminationModelCheckerSettings::moduleName));
-        }
     }
 }
\ No newline at end of file
diff --git a/src/settings/SettingsManager.h b/src/settings/SettingsManager.h
index 8d6f79964..92dc83cf1 100644
--- a/src/settings/SettingsManager.h
+++ b/src/settings/SettingsManager.h
@@ -36,6 +36,11 @@ namespace storm {
          */
         class SettingsManager {
 		public:
+            
+            // Explicitely delete copy constructor
+            SettingsManager(SettingsManager const&) = delete;
+            void operator=(SettingsManager const&) = delete;
+            
             /*!
              * This function parses the given command line arguments and sets all registered options accordingly. If the
              * command line cannot be matched using the known options, an exception is thrown.
@@ -234,102 +239,32 @@ namespace storm {
         SettingsManager& mutableManager();
         
         /*!
-         * Retrieves the general settings.
-         *
-         * @return An object that allows accessing the general settings.
-         */
-        storm::settings::modules::GeneralSettings const& generalSettings();
-
-        /*!
-         * Retrieves the general settings in a mutable form. This is only meant to be used for debug purposes or very
-         * rare cases where it is necessary.
-         *
-         * @return An object that allows accessing and modifying the general settings.
-         */
-        storm::settings::modules::GeneralSettings& mutableGeneralSettings();
-        
-        /*!
-         * Retrieves the debug settings.
-         *
-         * @return An object that allows accessing the debug settings.
-         */
-        storm::settings::modules::DebugSettings const& debugSettings();
-        
-        /*!
-         * Retrieves the counterexample generator settings.
-         *
-         * @return An object that allows accessing the counterexample generator settings.
-         */
-        storm::settings::modules::CounterexampleGeneratorSettings const& counterexampleGeneratorSettings();
-        
-        /*!
-         * Retrieves the CUDD settings.
-         *
-         * @return An object that allows accessing the CUDD settings.
-         */
-        storm::settings::modules::CuddSettings const& cuddSettings();
-
-        /*!
-         * Retrieves the Sylvan settings.
-         *
-         * @return An object that allows accessing the Sylvan settings.
+         * Add new module to use for the settings. The new module is given as a template argument.
          */
-        storm::settings::modules::SylvanSettings const& sylvanSettings();
-        
-        /*!
-         * Retrieves the settings of the gmm++-based equation solver.
-         *
-         * @return An object that allows accessing the settings of the gmm++-based equation solver.
-         */
-        storm::settings::modules::GmmxxEquationSolverSettings const& gmmxxEquationSolverSettings();
-        
-        /*!
-         * Retrieves the settings of the native equation solver.
-         *
-         * @return An object that allows accessing the settings of the native equation solver.
-         */
-        storm::settings::modules::NativeEquationSolverSettings const& nativeEquationSolverSettings();
-
-        /*!
-         * Retrieves the settings of the native equation solver.
-         *
-         * @return An object that allows accessing the settings of the native equation solver.
-         */
-        storm::settings::modules::BisimulationSettings const& bisimulationSettings();
-        
-        /*!
-         * Retrieves the settings of glpk.
-         *
-         * @return An object that allows accessing the settings of glpk.
-         */
-        storm::settings::modules::GlpkSettings const& glpkSettings();
+        template<typename SettingsType>
+        void addModule() {
+            static_assert(std::is_base_of<storm::settings::modules::ModuleSettings, SettingsType>::value, "Template argument must be derived from ModuleSettings");
+            mutableManager().addModule(std::unique_ptr<modules::ModuleSettings>(new SettingsType()));
+        }
         
         /*!
-         * Retrieves the settings of Gurobi.
+         * Get module. The type of the module is given as a template argument.
          *
-         * @return An object that allows accessing the settings of Gurobi.
+         * @return The module.
          */
-		storm::settings::modules::GurobiSettings const& gurobiSettings();
-
-		/*!
-		* Retrieves the settings of the topological value iteration-based equation solver.
-		*
-		* @return An object that allows accessing the settings of the topological value iteration-based equation solver.
-		*/
-		storm::settings::modules::TopologicalValueIterationEquationSolverSettings const& topologicalValueIterationEquationSolverSettings();
+        template<typename SettingsType>
+        SettingsType getModule() {
+            static_assert(std::is_base_of<storm::settings::modules::ModuleSettings, SettingsType>::value, "Template argument must be derived from ModuleSettings");
+            return dynamic_cast<SettingsType const&>(manager().getModule(SettingsType::moduleName));
+        }
         
         /*!
-         * Retrieves the settings for parametric model checking.
-         *
-         * @return An object that allows accessing the settings for parameteric model checking.
-         */
-        storm::settings::modules::ParametricSettings const& parametricSettings();
-
-        /* Retrieves the settings of the elimination-based DTMC model checker.
+         * Retrieves the general settings in a mutable form. This is only meant to be used for debug purposes or very
+         * rare cases where it is necessary.
          *
-         * @return An object that allows accessing the settings of the elimination-based DTMC model checker.
+         * @return An object that allows accessing and modifying the general settings.
          */
-        storm::settings::modules::SparseDtmcEliminationModelCheckerSettings const& sparseDtmcEliminationModelCheckerSettings();
+        storm::settings::modules::GeneralSettings& mutableGeneralSettings();
         
     } // namespace settings
 } // namespace storm
diff --git a/src/settings/modules/BisimulationSettings.cpp b/src/settings/modules/BisimulationSettings.cpp
index 1926e93ef..3e57b292c 100644
--- a/src/settings/modules/BisimulationSettings.cpp
+++ b/src/settings/modules/BisimulationSettings.cpp
@@ -34,7 +34,7 @@ namespace storm {
             
             bool BisimulationSettings::check() const {
                 bool optionsSet = this->getOption(typeOptionName).getHasOptionBeenSet();
-                STORM_LOG_WARN_COND(storm::settings::generalSettings().isBisimulationSet() || !optionsSet, "Bisimulation minimization is not selected, so setting options for bisimulation has no effect.");
+                STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::GeneralSettings>().isBisimulationSet() || !optionsSet, "Bisimulation minimization is not selected, so setting options for bisimulation has no effect.");
                 return true;
             }
         } // namespace modules
diff --git a/src/settings/modules/CounterexampleGeneratorSettings.cpp b/src/settings/modules/CounterexampleGeneratorSettings.cpp
index 6ad644822..79b57e756 100644
--- a/src/settings/modules/CounterexampleGeneratorSettings.cpp
+++ b/src/settings/modules/CounterexampleGeneratorSettings.cpp
@@ -48,7 +48,7 @@ namespace storm {
             
             bool CounterexampleGeneratorSettings::check() const {
                 // Ensure that the model was given either symbolically or explicitly.
-                STORM_LOG_THROW(!isMinimalCommandSetGenerationSet() || storm::settings::generalSettings().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "For the generation of a minimal command set, the model has to be specified symbolically.");
+                STORM_LOG_THROW(!isMinimalCommandSetGenerationSet() || storm::settings::getModule<storm::settings::modules::GeneralSettings>().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "For the generation of a minimal command set, the model has to be specified symbolically.");
                 
                 if (isMinimalCommandSetGenerationSet()) {
                     STORM_LOG_WARN_COND(isUseMaxSatBasedMinimalCommandSetGenerationSet() || !isEncodeReachabilitySet(), "Encoding reachability is only available for the MaxSat-based minimal command set generation, so selecting it has no effect.");
diff --git a/src/settings/modules/GlpkSettings.cpp b/src/settings/modules/GlpkSettings.cpp
index 8e879fc6d..824f855ed 100644
--- a/src/settings/modules/GlpkSettings.cpp
+++ b/src/settings/modules/GlpkSettings.cpp
@@ -35,7 +35,7 @@ namespace storm {
             
             bool GlpkSettings::check() const {
                 if (isOutputSet() || isIntegerToleranceSet()) {
-                    STORM_LOG_WARN_COND(storm::settings::generalSettings().getLpSolver() == storm::solver::LpSolverType::Glpk, "glpk is not selected as the preferred LP solver, so setting options for glpk might have no effect.");
+                    STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getLpSolver() == storm::solver::LpSolverType::Glpk, "glpk is not selected as the preferred LP solver, so setting options for glpk might have no effect.");
                 }
                 
                 return true;
diff --git a/src/settings/modules/GmmxxEquationSolverSettings.cpp b/src/settings/modules/GmmxxEquationSolverSettings.cpp
index 4904239ba..bfc4770f1 100644
--- a/src/settings/modules/GmmxxEquationSolverSettings.cpp
+++ b/src/settings/modules/GmmxxEquationSolverSettings.cpp
@@ -109,7 +109,7 @@ namespace storm {
                 // This list does not include the precision, because this option is shared with other modules.
                 bool optionsSet = isLinearEquationSystemMethodSet() || isPreconditioningMethodSet() || isRestartIterationCountSet() | isMaximalIterationCountSet() || isConvergenceCriterionSet();
                 
-                STORM_LOG_WARN_COND(storm::settings::generalSettings().getEquationSolver() == storm::solver::EquationSolverType::Gmmxx || !optionsSet, "gmm++ is not selected as the preferred equation solver, so setting options for gmm++ might have no effect.");
+                STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEquationSolver() == storm::solver::EquationSolverType::Gmmxx || !optionsSet, "gmm++ is not selected as the preferred equation solver, so setting options for gmm++ might have no effect.");
                 
                 return true;
             }
diff --git a/src/settings/modules/GurobiSettings.cpp b/src/settings/modules/GurobiSettings.cpp
index f94fc988c..d27a6c8a0 100644
--- a/src/settings/modules/GurobiSettings.cpp
+++ b/src/settings/modules/GurobiSettings.cpp
@@ -46,7 +46,7 @@ namespace storm {
             
             bool GurobiSettings::check() const {
                 if (isOutputSet() || isIntegerToleranceSet() || isNumberOfThreadsSet()) {
-                    STORM_LOG_WARN_COND(storm::settings::generalSettings().getLpSolver() == storm::solver::LpSolverType::Gurobi, "Gurobi is not selected as the preferred LP solver, so setting options for Gurobi might have no effect.");
+                    STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getLpSolver() == storm::solver::LpSolverType::Gurobi, "Gurobi is not selected as the preferred LP solver, so setting options for Gurobi might have no effect.");
                 }
                 
                 return true;
diff --git a/src/settings/modules/NativeEquationSolverSettings.cpp b/src/settings/modules/NativeEquationSolverSettings.cpp
index 7bfb951e1..abc1860ee 100644
--- a/src/settings/modules/NativeEquationSolverSettings.cpp
+++ b/src/settings/modules/NativeEquationSolverSettings.cpp
@@ -81,7 +81,7 @@ namespace storm {
                 // This list does not include the precision, because this option is shared with other modules.
                 bool optionSet = isLinearEquationSystemTechniqueSet() || isMaximalIterationCountSet() || isConvergenceCriterionSet();
                 
-                STORM_LOG_WARN_COND(storm::settings::generalSettings().getEquationSolver() == storm::solver::EquationSolverType::Native || !optionSet, "Native is not selected as the preferred equation solver, so setting options for native might have no effect.");
+                STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEquationSolver() == storm::solver::EquationSolverType::Native || !optionSet, "Native is not selected as the preferred equation solver, so setting options for native might have no effect.");
                 
                 return true;
             }
diff --git a/src/solver/AbstractGameSolver.cpp b/src/solver/AbstractGameSolver.cpp
index 76ea87bd1..c666d61e0 100644
--- a/src/solver/AbstractGameSolver.cpp
+++ b/src/solver/AbstractGameSolver.cpp
@@ -7,7 +7,7 @@ namespace storm {
     namespace solver {
         AbstractGameSolver::AbstractGameSolver() {
             // Get the settings object to customize solving.
-            storm::settings::modules::NativeEquationSolverSettings const& settings = storm::settings::nativeEquationSolverSettings();
+            storm::settings::modules::NativeEquationSolverSettings const& settings = storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>();
 
             // Get appropriate settings.
             maximalNumberOfIterations = settings.getMaximalIterationCount();
diff --git a/src/solver/GlpkLpSolver.cpp b/src/solver/GlpkLpSolver.cpp
index 25512fc33..bcf296865 100644
--- a/src/solver/GlpkLpSolver.cpp
+++ b/src/solver/GlpkLpSolver.cpp
@@ -27,7 +27,7 @@ namespace storm {
             glp_set_prob_name(lp, name.c_str());
             
             // Set whether the glpk output shall be printed to the command line.
-            glp_term_out(storm::settings::debugSettings().isDebugSet() || storm::settings::glpkSettings().isOutputSet() ? GLP_ON : GLP_OFF);
+            glp_term_out(storm::settings::getModule<storm::settings::modules::DebugSettings>().isDebugSet() || storm::settings::getModule<storm::settings::modules::GlpkSettings>().isOutputSet() ? GLP_ON : GLP_OFF);
             
             // Because glpk uses 1-based indexing (wtf!?), we need to put dummy elements into the matrix vectors.
             rowIndices.push_back(0);
@@ -158,13 +158,13 @@ namespace storm {
             // Determine the type of the constraint and add it properly.
             switch (constraint.getOperator()) {
                 case storm::expressions::OperatorType::Less:
-                    glp_set_row_bnds(this->lp, nextConstraintIndex, GLP_UP, 0, rightCoefficients.getConstantPart() - storm::settings::glpkSettings().getIntegerTolerance());
+                    glp_set_row_bnds(this->lp, nextConstraintIndex, GLP_UP, 0, rightCoefficients.getConstantPart() - storm::settings::getModule<storm::settings::modules::GlpkSettings>().getIntegerTolerance());
                     break;
                 case storm::expressions::OperatorType::LessOrEqual:
                     glp_set_row_bnds(this->lp, nextConstraintIndex, GLP_UP, 0, rightCoefficients.getConstantPart());
                     break;
                 case storm::expressions::OperatorType::Greater:
-                    glp_set_row_bnds(this->lp, nextConstraintIndex, GLP_LO, rightCoefficients.getConstantPart() + storm::settings::glpkSettings().getIntegerTolerance(), 0);
+                    glp_set_row_bnds(this->lp, nextConstraintIndex, GLP_LO, rightCoefficients.getConstantPart() + storm::settings::getModule<storm::settings::modules::GlpkSettings>().getIntegerTolerance(), 0);
                     break;
                 case storm::expressions::OperatorType::GreaterOrEqual:
                     glp_set_row_bnds(this->lp, nextConstraintIndex, GLP_LO, rightCoefficients.getConstantPart(), 0);
@@ -200,7 +200,7 @@ namespace storm {
                 glp_iocp* parameters = new glp_iocp();
                 glp_init_iocp(parameters);
                 parameters->presolve = GLP_ON;
-                parameters->tol_int = storm::settings::glpkSettings().getIntegerTolerance();
+                parameters->tol_int = storm::settings::getModule<storm::settings::modules::GlpkSettings>().getIntegerTolerance();
                 error = glp_intopt(this->lp, parameters);
                 delete parameters;
                 
@@ -298,7 +298,7 @@ namespace storm {
             }
 
             // Now check the desired precision was actually achieved.
-            STORM_LOG_THROW(std::abs(static_cast<int>(value) - value) <= storm::settings::glpkSettings().getIntegerTolerance(), storm::exceptions::InvalidStateException, "Illegal value for integer variable in glpk solution (" << value << ").");
+            STORM_LOG_THROW(std::abs(static_cast<int>(value) - value) <= storm::settings::getModule<storm::settings::modules::GlpkSettings>().getIntegerTolerance(), storm::exceptions::InvalidStateException, "Illegal value for integer variable in glpk solution (" << value << ").");
             
             return static_cast<int_fast64_t>(value);
         }
@@ -320,7 +320,7 @@ namespace storm {
                 value = glp_get_col_prim(this->lp, static_cast<int>(variableIndexPair->second));
             }
 
-            STORM_LOG_THROW(std::abs(static_cast<int>(value) - value) <= storm::settings::glpkSettings().getIntegerTolerance(), storm::exceptions::InvalidStateException, "Illegal value for binary variable in glpk solution (" << value << ").");
+            STORM_LOG_THROW(std::abs(static_cast<int>(value) - value) <= storm::settings::getModule<storm::settings::modules::GlpkSettings>().getIntegerTolerance(), storm::exceptions::InvalidStateException, "Illegal value for binary variable in glpk solution (" << value << ").");
             
             return static_cast<bool>(value);
         }
diff --git a/src/solver/GmmxxLinearEquationSolver.cpp b/src/solver/GmmxxLinearEquationSolver.cpp
index eb869481c..faf13f0de 100644
--- a/src/solver/GmmxxLinearEquationSolver.cpp
+++ b/src/solver/GmmxxLinearEquationSolver.cpp
@@ -23,7 +23,7 @@ namespace storm {
         template<typename ValueType>
         GmmxxLinearEquationSolver<ValueType>::GmmxxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A) : originalA(&A), gmmxxMatrix(storm::adapters::GmmxxAdapter::toGmmxxSparseMatrix<ValueType>(A)) {
             // Get the settings object to customize linear solving.
-            storm::settings::modules::GmmxxEquationSolverSettings const& settings = storm::settings::gmmxxEquationSolverSettings();
+            storm::settings::modules::GmmxxEquationSolverSettings const& settings = storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>();
             
             // Get appropriate settings.
             maximalNumberOfIterations = settings.getMaximalIterationCount();
diff --git a/src/solver/GmmxxMinMaxLinearEquationSolver.cpp b/src/solver/GmmxxMinMaxLinearEquationSolver.cpp
index eed6fb258..ece0c241e 100644
--- a/src/solver/GmmxxMinMaxLinearEquationSolver.cpp
+++ b/src/solver/GmmxxMinMaxLinearEquationSolver.cpp
@@ -16,7 +16,7 @@ namespace storm {
         
         template<typename ValueType>
         GmmxxMinMaxLinearEquationSolver<ValueType>::GmmxxMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, MinMaxTechniqueSelection preferredTechnique, bool trackScheduler) :
-        MinMaxLinearEquationSolver<ValueType>(A, storm::settings::gmmxxEquationSolverSettings().getPrecision(), storm::settings::gmmxxEquationSolverSettings().getConvergenceCriterion() == storm::settings::modules::GmmxxEquationSolverSettings::ConvergenceCriterion::Relative, storm::settings::gmmxxEquationSolverSettings().getMaximalIterationCount(), trackScheduler, preferredTechnique), gmmxxMatrix(storm::adapters::GmmxxAdapter::toGmmxxSparseMatrix<ValueType>(A)), rowGroupIndices(A.getRowGroupIndices()) {
+        MinMaxLinearEquationSolver<ValueType>(A, storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getConvergenceCriterion() == storm::settings::modules::GmmxxEquationSolverSettings::ConvergenceCriterion::Relative, storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getMaximalIterationCount(), trackScheduler, preferredTechnique), gmmxxMatrix(storm::adapters::GmmxxAdapter::toGmmxxSparseMatrix<ValueType>(A)), rowGroupIndices(A.getRowGroupIndices()) {
                 // Intentionally left empty.
         }
         
diff --git a/src/solver/GurobiLpSolver.cpp b/src/solver/GurobiLpSolver.cpp
index 4108f2bb8..3297d9410 100644
--- a/src/solver/GurobiLpSolver.cpp
+++ b/src/solver/GurobiLpSolver.cpp
@@ -63,13 +63,13 @@ namespace storm {
 			int error = 0;
 
 			// Enable the following line to only print the output of Gurobi if the debug flag is set.
-            toggleOutput(storm::settings::debugSettings().isDebugSet() || storm::settings::gurobiSettings().isOutputSet());
+            toggleOutput(storm::settings::getModule<storm::settings::modules::DebugSettings>().isDebugSet() || storm::settings::getModule<storm::settings::modules::GurobiSettings>().isOutputSet());
             // Enable the following line to restrict Gurobi to one thread only.
-            error = GRBsetintparam(env, "Threads", storm::settings::gurobiSettings().getNumberOfThreads());
+            error = GRBsetintparam(env, "Threads", storm::settings::getModule<storm::settings::modules::GurobisSettings>().getNumberOfThreads());
             STORM_LOG_THROW(error == 0, storm::exceptions::InvalidStateException, "Unable to set Gurobi Parameter Threads (" << GRBgeterrormsg(env) << ", error code " << error << ").");
 
             // Enable the following line to force Gurobi to be as precise about the binary variables as required by the given precision option.
-            error = GRBsetdblparam(env, "IntFeasTol", storm::settings::gurobiSettings().getIntegerTolerance());
+            error = GRBsetdblparam(env, "IntFeasTol", storm::settings::getModule<storm::settings::modules::GurobiSettings>().getIntegerTolerance());
             STORM_LOG_THROW(error == 0, storm::exceptions::InvalidStateException, "Unable to set Gurobi Parameter IntFeasTol (" << GRBgeterrormsg(env) << ", error code " << error << ").");
         }
         
@@ -168,13 +168,13 @@ namespace storm {
             int error = 0;
             switch (constraint.getOperator()) {
                 case storm::expressions::OperatorType::Less:
-                    error = GRBaddconstr(model, variables.size(), variables.data(), coefficients.data(), GRB_LESS_EQUAL, rightCoefficients.getConstantPart() - storm::settings::gurobiSettings().getIntegerTolerance(), name == "" ? nullptr : name.c_str());
+                    error = GRBaddconstr(model, variables.size(), variables.data(), coefficients.data(), GRB_LESS_EQUAL, rightCoefficients.getConstantPart() - storm::settings::getModule<storm::settings::modules::GurobiSettings>().getIntegerTolerance(), name == "" ? nullptr : name.c_str());
                     break;
                 case storm::expressions::OperatorType::LessOrEqual:
                     error = GRBaddconstr(model, variables.size(), variables.data(), coefficients.data(), GRB_LESS_EQUAL, rightCoefficients.getConstantPart(), name == "" ? nullptr : name.c_str());
                     break;
                 case storm::expressions::OperatorType::Greater:
-                    error = GRBaddconstr(model, variables.size(), variables.data(), coefficients.data(), GRB_GREATER_EQUAL, rightCoefficients.getConstantPart() + storm::settings::gurobiSettings().getIntegerTolerance(), name == "" ? nullptr : name.c_str());
+                    error = GRBaddconstr(model, variables.size(), variables.data(), coefficients.data(), GRB_GREATER_EQUAL, rightCoefficients.getConstantPart() + storm::settings::getModule<storm::settings::modules::GurobiSettings>().getIntegerTolerance(), name == "" ? nullptr : name.c_str());
                     break;
                 case storm::expressions::OperatorType::GreaterOrEqual:
                     error = GRBaddconstr(model, variables.size(), variables.data(), coefficients.data(), GRB_GREATER_EQUAL, rightCoefficients.getConstantPart(), name == "" ? nullptr : name.c_str());
@@ -301,7 +301,7 @@ namespace storm {
             double value = 0;
             int error = GRBgetdblattrelement(model, GRB_DBL_ATTR_X, variableIndexPair->second, &value);
             STORM_LOG_THROW(error == 0, storm::exceptions::InvalidStateException, "Unable to get Gurobi solution (" << GRBgeterrormsg(env) << ", error code " << error << ").");
-            STORM_LOG_THROW(std::abs(static_cast<int>(value) - value) <= storm::settings::gurobiSettings().getIntegerTolerance(), storm::exceptions::InvalidStateException, "Illegal value for integer variable in Gurobi solution (" << value << ").");
+            STORM_LOG_THROW(std::abs(static_cast<int>(value) - value) <= storm::settings::getModule<storm::settings::modules::GurobiSettings>().getIntegerTolerance(), storm::exceptions::InvalidStateException, "Illegal value for integer variable in Gurobi solution (" << value << ").");
             
             return static_cast<int_fast64_t>(value);
         }
@@ -321,9 +321,9 @@ namespace storm {
             STORM_LOG_THROW(error == 0, storm::exceptions::InvalidStateException, "Unable to get Gurobi solution (" << GRBgeterrormsg(env) << ", error code " << error << ").");
 
             if (value > 0.5) {
-                STORM_LOG_THROW(std::abs(static_cast<int>(value) - 1) <= storm::settings::gurobiSettings().getIntegerTolerance(), storm::exceptions::InvalidStateException, "Illegal value for integer variable in Gurobi solution (" << value << ").");
+                STORM_LOG_THROW(std::abs(static_cast<int>(value) - 1) <= storm::settings::getModule<storm::settings::modules::GurobiSettings>().getIntegerTolerance(), storm::exceptions::InvalidStateException, "Illegal value for integer variable in Gurobi solution (" << value << ").");
             } else {
-                STORM_LOG_THROW(value <= storm::settings::gurobiSettings().getIntegerTolerance(), storm::exceptions::InvalidStateException, "Illegal value for integer variable in Gurobi solution (" << value << ").");
+                STORM_LOG_THROW(value <= storm::settings::getModule<storm::settings::modules::GurobiSettings>().getIntegerTolerance(), storm::exceptions::InvalidStateException, "Illegal value for integer variable in Gurobi solution (" << value << ").");
             }
             
             return static_cast<bool>(value);
diff --git a/src/solver/MinMaxLinearEquationSolver.cpp b/src/solver/MinMaxLinearEquationSolver.cpp
index 5041469bc..13bec6708 100644
--- a/src/solver/MinMaxLinearEquationSolver.cpp
+++ b/src/solver/MinMaxLinearEquationSolver.cpp
@@ -12,7 +12,7 @@ namespace storm {
         AbstractMinMaxLinearEquationSolver<ValueType>::AbstractMinMaxLinearEquationSolver(double precision, bool relativeError, uint_fast64_t maximalIterations, bool trackScheduler, MinMaxTechniqueSelection prefTech) : precision(precision), relative(relativeError), maximalNumberOfIterations(maximalIterations), trackScheduler(trackScheduler) {
             
             if(prefTech == MinMaxTechniqueSelection::FROMSETTINGS) {
-                useValueIteration = (storm::settings::generalSettings().getMinMaxEquationSolvingTechnique() == storm::solver::MinMaxTechnique::ValueIteration);
+                useValueIteration = (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getMinMaxEquationSolvingTechnique() == storm::solver::MinMaxTechnique::ValueIteration);
             } else {
                 useValueIteration = (prefTech == MinMaxTechniqueSelection::ValueIteration);
             }
diff --git a/src/solver/NativeLinearEquationSolver.cpp b/src/solver/NativeLinearEquationSolver.cpp
index cb59a2253..1d36cc5e5 100644
--- a/src/solver/NativeLinearEquationSolver.cpp
+++ b/src/solver/NativeLinearEquationSolver.cpp
@@ -19,7 +19,7 @@ namespace storm {
         template<typename ValueType>
         NativeLinearEquationSolver<ValueType>::NativeLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, NativeLinearEquationSolverSolutionMethod method) : A(A), method(method) {
             // Get the settings object to customize linear solving.
-            storm::settings::modules::NativeEquationSolverSettings const& settings = storm::settings::nativeEquationSolverSettings();
+            storm::settings::modules::NativeEquationSolverSettings const& settings = storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>();
             
             // Get appropriate settings.
             maximalNumberOfIterations = settings.getMaximalIterationCount();
@@ -31,7 +31,7 @@ namespace storm {
         void NativeLinearEquationSolver<ValueType>::solveEquationSystem(std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult) const {
             if (method == NativeLinearEquationSolverSolutionMethod::SOR || method == NativeLinearEquationSolverSolutionMethod::GaussSeidel) {
                 // Define the omega used for SOR.
-                ValueType omega = method == NativeLinearEquationSolverSolutionMethod::SOR ? storm::settings::nativeEquationSolverSettings().getOmega() : storm::utility::one<ValueType>();
+                ValueType omega = method == NativeLinearEquationSolverSolutionMethod::SOR ? storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getOmega() : storm::utility::one<ValueType>();
                 
                 // To avoid copying the contents of the vector in the loop, we create a temporary x to swap with.
                 bool tmpXProvided = true;
diff --git a/src/solver/NativeMinMaxLinearEquationSolver.cpp b/src/solver/NativeMinMaxLinearEquationSolver.cpp
index ec369ee3e..544840898 100644
--- a/src/solver/NativeMinMaxLinearEquationSolver.cpp
+++ b/src/solver/NativeMinMaxLinearEquationSolver.cpp
@@ -14,7 +14,7 @@ namespace storm {
     namespace solver {
         
         template<typename ValueType>
-        NativeMinMaxLinearEquationSolver<ValueType>::NativeMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, MinMaxTechniqueSelection preferredTechnique, bool trackScheduler) :  MinMaxLinearEquationSolver<ValueType>(A, storm::settings::nativeEquationSolverSettings().getPrecision(), storm::settings::nativeEquationSolverSettings().getConvergenceCriterion() == storm::settings::modules::NativeEquationSolverSettings::ConvergenceCriterion::Relative, storm::settings::nativeEquationSolverSettings().getMaximalIterationCount(), trackScheduler, preferredTechnique) {
+        NativeMinMaxLinearEquationSolver<ValueType>::NativeMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, MinMaxTechniqueSelection preferredTechnique, bool trackScheduler) :  MinMaxLinearEquationSolver<ValueType>(A, storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getConvergenceCriterion() == storm::settings::modules::NativeEquationSolverSettings::ConvergenceCriterion::Relative, storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getMaximalIterationCount(), trackScheduler, preferredTechnique) {
             // Intentionally left empty.
         }
         
diff --git a/src/solver/SymbolicLinearEquationSolver.cpp b/src/solver/SymbolicLinearEquationSolver.cpp
index 01c7d895b..3e8dd0c55 100644
--- a/src/solver/SymbolicLinearEquationSolver.cpp
+++ b/src/solver/SymbolicLinearEquationSolver.cpp
@@ -17,7 +17,7 @@ namespace storm {
         template<storm::dd::DdType DdType, typename ValueType>
         SymbolicLinearEquationSolver<DdType, ValueType>::SymbolicLinearEquationSolver(storm::dd::Add<DdType, ValueType> const& A, storm::dd::Bdd<DdType> const& allRows, std::set<storm::expressions::Variable> const& rowMetaVariables, std::set<storm::expressions::Variable> const& columnMetaVariables, std::vector<std::pair<storm::expressions::Variable, storm::expressions::Variable>> const& rowColumnMetaVariablePairs) : A(A), allRows(allRows), rowMetaVariables(rowMetaVariables), columnMetaVariables(columnMetaVariables), rowColumnMetaVariablePairs(rowColumnMetaVariablePairs) {
             // Get the settings object to customize solving.
-            storm::settings::modules::NativeEquationSolverSettings const& settings = storm::settings::nativeEquationSolverSettings();
+            storm::settings::modules::NativeEquationSolverSettings const& settings = storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>();
             
             // Get appropriate settings.
             maximalNumberOfIterations = settings.getMaximalIterationCount();
diff --git a/src/solver/SymbolicMinMaxLinearEquationSolver.cpp b/src/solver/SymbolicMinMaxLinearEquationSolver.cpp
index 221853a87..d564eddb8 100644
--- a/src/solver/SymbolicMinMaxLinearEquationSolver.cpp
+++ b/src/solver/SymbolicMinMaxLinearEquationSolver.cpp
@@ -21,7 +21,7 @@ namespace storm {
         template<storm::dd::DdType DdType, typename ValueType>
         SymbolicMinMaxLinearEquationSolver<DdType, ValueType>::SymbolicMinMaxLinearEquationSolver(storm::dd::Add<DdType, ValueType> const& A, storm::dd::Bdd<DdType> const& allRows, storm::dd::Bdd<DdType> const& illegalMask, std::set<storm::expressions::Variable> const& rowMetaVariables, std::set<storm::expressions::Variable> const& columnMetaVariables, std::set<storm::expressions::Variable> const& choiceVariables, std::vector<std::pair<storm::expressions::Variable, storm::expressions::Variable>> const& rowColumnMetaVariablePairs) : A(A), allRows(allRows), illegalMaskAdd(illegalMask.ite(A.getDdManager().getConstant(storm::utility::infinity<ValueType>()), A.getDdManager().template getAddZero<ValueType>())), rowMetaVariables(rowMetaVariables), columnMetaVariables(columnMetaVariables), choiceVariables(choiceVariables), rowColumnMetaVariablePairs(rowColumnMetaVariablePairs) {
             // Get the settings object to customize solving.
-            storm::settings::modules::NativeEquationSolverSettings const& settings = storm::settings::nativeEquationSolverSettings();
+            storm::settings::modules::NativeEquationSolverSettings const& settings = storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>();
             
             // Get appropriate settings.
             maximalNumberOfIterations = settings.getMaximalIterationCount();
diff --git a/src/solver/TopologicalMinMaxLinearEquationSolver.cpp b/src/solver/TopologicalMinMaxLinearEquationSolver.cpp
index 793842849..4e34826a1 100644
--- a/src/solver/TopologicalMinMaxLinearEquationSolver.cpp
+++ b/src/solver/TopologicalMinMaxLinearEquationSolver.cpp
@@ -24,13 +24,10 @@ namespace storm {
         
         template<typename ValueType>
         TopologicalMinMaxLinearEquationSolver<ValueType>::TopologicalMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A) : 
-        NativeMinMaxLinearEquationSolver<ValueType>(A, storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision(), \
-                storm::settings::topologicalValueIterationEquationSolverSettings().getMaximalIterationCount(), MinMaxTechniqueSelection::ValueIteration, \
-                storm::settings::topologicalValueIterationEquationSolverSettings().getConvergenceCriterion() == storm::settings::modules::TopologicalValueIterationEquationSolverSettings::ConvergenceCriterion::Relative)
+        NativeMinMaxLinearEquationSolver<ValueType>(A, storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision(), storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getMaximalIterationCount(), MinMaxTechniqueSelection::ValueIteration, storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getConvergenceCriterion() == storm::settings::modules::TopologicalValueIterationEquationSolverSettings::ConvergenceCriterion::Relative)
         {
 			// Get the settings object to customize solving.
-			auto generalSettings = storm::settings::generalSettings();
-			this->enableCuda = generalSettings.isCudaSet();
+			this->enableCuda = storm::settings::getModule<storm::settings::modules::GeneralSettings>().isCudaSet();
 #ifdef STORM_HAVE_CUDA
 			STORM_LOG_INFO_COND(this->enableCuda, "Option CUDA was not set, but the topological value iteration solver will use it anyways.");
 #endif
diff --git a/src/storage/bisimulation/BisimulationDecomposition.cpp b/src/storage/bisimulation/BisimulationDecomposition.cpp
index aedd4a998..048622c26 100644
--- a/src/storage/bisimulation/BisimulationDecomposition.cpp
+++ b/src/storage/bisimulation/BisimulationDecomposition.cpp
@@ -210,7 +210,7 @@ namespace storm {
             
             std::chrono::high_resolution_clock::duration totalTime = std::chrono::high_resolution_clock::now() - totalStart;
             
-            if (storm::settings::generalSettings().isShowStatisticsSet()) {
+            if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isShowStatisticsSet()) {
                 std::chrono::milliseconds initialPartitionTimeInMilliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(initialPartitionTime);
                 std::chrono::milliseconds refinementTimeInMilliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(refinementTime);
                 std::chrono::milliseconds extractionTimeInMilliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(extractionTime);
diff --git a/src/storage/bisimulation/BisimulationDecomposition.h b/src/storage/bisimulation/BisimulationDecomposition.h
index dc1c73261..01fe8307e 100644
--- a/src/storage/bisimulation/BisimulationDecomposition.h
+++ b/src/storage/bisimulation/BisimulationDecomposition.h
@@ -36,7 +36,7 @@ namespace storm {
                 case BisimulationTypeChoice::Weak:
                     return BisimulationType::Weak;
                 case BisimulationTypeChoice::FromSettings:
-                    if (storm::settings::bisimulationSettings().isWeakBisimulationSet()) {
+                    if (storm::settings::getModule<storm::settings::modules::BisimulationSettings>().isWeakBisimulationSet()) {
                         return BisimulationType::Weak;
                     } else {
                         return BisimulationType::Strong;
diff --git a/src/storage/dd/cudd/InternalCuddDdManager.cpp b/src/storage/dd/cudd/InternalCuddDdManager.cpp
index d097b332c..9f33c803d 100644
--- a/src/storage/dd/cudd/InternalCuddDdManager.cpp
+++ b/src/storage/dd/cudd/InternalCuddDdManager.cpp
@@ -7,11 +7,11 @@ namespace storm {
     namespace dd {
         
         InternalDdManager<DdType::CUDD>::InternalDdManager() : cuddManager(), reorderingTechnique(CUDD_REORDER_NONE) {
-            this->cuddManager.SetMaxMemory(static_cast<unsigned long>(storm::settings::cuddSettings().getMaximalMemory() * 1024ul * 1024ul));
-            this->cuddManager.SetEpsilon(storm::settings::cuddSettings().getConstantPrecision());
+            this->cuddManager.SetMaxMemory(static_cast<unsigned long>(storm::settings::getModule<storm::settings::modules::CuddSettings>().getMaximalMemory() * 1024ul * 1024ul));
+            this->cuddManager.SetEpsilon(storm::settings::getModule<storm::settings::modules::CuddSettings>().getConstantPrecision());
             
             // Now set the selected reordering technique.
-            storm::settings::modules::CuddSettings::ReorderingTechnique reorderingTechniqueAsSetting = storm::settings::cuddSettings().getReorderingTechnique();
+            storm::settings::modules::CuddSettings::ReorderingTechnique reorderingTechniqueAsSetting = storm::settings::getModule<storm::settings::modules::CuddSettings>().getReorderingTechnique();
             switch (reorderingTechniqueAsSetting) {
                 case storm::settings::modules::CuddSettings::ReorderingTechnique::None: this->reorderingTechnique = CUDD_REORDER_NONE; break;
                 case storm::settings::modules::CuddSettings::ReorderingTechnique::Random: this->reorderingTechnique = CUDD_REORDER_RANDOM; break;
diff --git a/src/storage/dd/sylvan/InternalSylvanDdManager.cpp b/src/storage/dd/sylvan/InternalSylvanDdManager.cpp
index 9998df121..f79e62277 100644
--- a/src/storage/dd/sylvan/InternalSylvanDdManager.cpp
+++ b/src/storage/dd/sylvan/InternalSylvanDdManager.cpp
@@ -29,11 +29,11 @@ namespace storm {
         InternalDdManager<DdType::Sylvan>::InternalDdManager() {
             if (numberOfInstances == 0) {
                 // Initialize lace: auto-detect number of workers.
-                lace_init(storm::settings::sylvanSettings().getNumberOfThreads(), 1000000);
+                lace_init(storm::settings::getModule<storm::settings::modules::SylvanSettings>().getNumberOfThreads(), 1000000);
                 lace_startup(0, 0, 0);
                 
                 // Each node takes 24 bytes and the maximal memory is specified in megabytes.
-                uint_fast64_t totalNodesToStore = storm::settings::sylvanSettings().getMaximalMemory() * 1024 * 1024 / 24;
+                uint_fast64_t totalNodesToStore = storm::settings::getModule<storm::settings::modules::SylvanSettings>().getMaximalMemory() * 1024 * 1024 / 24;
                 
                 // Compute the power of two that still fits within the total numbers to store.
                 uint_fast64_t powerOfTwo = findLargestPowerOfTwoFitting(totalNodesToStore);
diff --git a/src/storage/prism/Program.cpp b/src/storage/prism/Program.cpp
index 999cf2f30..4137bec09 100644
--- a/src/storage/prism/Program.cpp
+++ b/src/storage/prism/Program.cpp
@@ -56,7 +56,7 @@ namespace storm {
 
                 // If the model is supposed to be a CTMC, but contains probabilistic commands, we transform them to Markovian
                 // commands and issue a warning.
-                if (modelType == storm::prism::Program::ModelType::CTMC && storm::settings::generalSettings().isPrismCompatibilityEnabled()) {
+                if (modelType == storm::prism::Program::ModelType::CTMC && storm::settings::getModule<storm::settings::modules::GeneralSettings>().isPrismCompatibilityEnabled()) {
                     bool hasProbabilisticCommands = false;
                     for (auto& module : this->modules) {
                         for (auto& command : module.getCommands()) {
@@ -829,7 +829,7 @@ namespace storm {
             }
             
             if (hasLabeledMarkovianCommand) {
-                if (storm::settings::generalSettings().isPrismCompatibilityEnabled()) {
+                if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isPrismCompatibilityEnabled()) {
                     STORM_LOG_WARN_COND(false, "The model uses synchronizing Markovian commands. This may lead to unexpected verification results, because of unclear semantics.");
                 } else {
                     STORM_LOG_THROW(false, storm::exceptions::WrongFormatException, "The model uses synchronizing Markovian commands. This may lead to unexpected verification results, because of unclear semantics.");
diff --git a/src/utility/ConstantsComparator.cpp b/src/utility/ConstantsComparator.cpp
index e22efbc5e..37c35898c 100644
--- a/src/utility/ConstantsComparator.cpp
+++ b/src/utility/ConstantsComparator.cpp
@@ -40,7 +40,7 @@ namespace storm {
             return value1 < value2;
         }
         
-        ConstantsComparator<float>::ConstantsComparator() : precision(static_cast<float>(storm::settings::generalSettings().getPrecision())) {
+        ConstantsComparator<float>::ConstantsComparator() : precision(static_cast<float>(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision())) {
             // Intentionally left empty.
         }
         
@@ -72,7 +72,7 @@ namespace storm {
             return std::abs(value1 - value2) < precision;
         }
         
-        ConstantsComparator<double>::ConstantsComparator() : precision(storm::settings::generalSettings().getPrecision()) {
+        ConstantsComparator<double>::ConstantsComparator() : precision(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()) {
             // Intentionally left empty.
         }
         
diff --git a/src/utility/export.h b/src/utility/export.h
index 35386e6a8..4d172bcdc 100644
--- a/src/utility/export.h
+++ b/src/utility/export.h
@@ -19,7 +19,7 @@ namespace utility {
 
 template<typename ValueType>	
 void exportParametricMcResult(const ValueType& mcresult, storm::modelchecker::reachability::CollectConstraints<storm::RationalFunction> const& constraintCollector) {
-	std::string path = storm::settings::parametricSettings().exportResultPath();
+	std::string path = storm::settings::getModule<storm::settings::modules::ParametricSettings>().exportResultPath();
 	std::ofstream filestream;
 	filestream.open(path);
 	// todo add checks.
diff --git a/src/utility/initialize.cpp b/src/utility/initialize.cpp
index e7909d8ef..1fa5927e1 100644
--- a/src/utility/initialize.cpp
+++ b/src/utility/initialize.cpp
@@ -22,7 +22,7 @@ namespace storm {
 
        void initializeLogger() {
 #ifdef STORM_LOGGING_FRAMEWORK
-            auto loglevel = storm::settings::debugSettings().isTraceSet() ? log4cplus::TRACE_LOG_LEVEL : storm::settings::debugSettings().isDebugSet() ? log4cplus::DEBUG_LOG_LEVEL : log4cplus::WARN_LOG_LEVEL;
+            auto loglevel = storm::settings::getModule<storm::settings::modules::DebugSettings>().isTraceSet() ? log4cplus::TRACE_LOG_LEVEL : storm::settings::getModule<storm::settings::modules::DebugSettings>().isDebugSet() ? log4cplus::DEBUG_LOG_LEVEL : log4cplus::WARN_LOG_LEVEL;
             initializeLogger(loglevel);
 #endif
        }
@@ -50,7 +50,7 @@ namespace storm {
 
         void initializeFileLogging() {
 #ifdef STORM_LOGGING_FRAMEWORK
-            log4cplus::SharedAppenderPtr fileLogAppender(new log4cplus::FileAppender(storm::settings::debugSettings().getLogfilename()));
+            log4cplus::SharedAppenderPtr fileLogAppender(new log4cplus::FileAppender(storm::settings::getModule<storm::settings::modules::DebugSettings>().getLogfilename()));
             fileLogAppender->setName("mainFileAppender");
             fileLogAppender->setLayout(std::auto_ptr<log4cplus::Layout>(new log4cplus::PatternLayout("%-5p - %D{%H:%M:%S} (%r ms) - %F:%L: %m%n")));
             logger.addAppender(fileLogAppender);
diff --git a/src/utility/solver.cpp b/src/utility/solver.cpp
index 013a800c4..5709e1f58 100644
--- a/src/utility/solver.cpp
+++ b/src/utility/solver.cpp
@@ -46,7 +46,7 @@ namespace storm {
             
             template<typename ValueType>
             std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> LinearEquationSolverFactory<ValueType>::create(storm::storage::SparseMatrix<ValueType> const& matrix) const {
-                storm::solver::EquationSolverType equationSolver = storm::settings::generalSettings().getEquationSolver();
+                storm::solver::EquationSolverType equationSolver = storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEquationSolver();
                 switch (equationSolver) {
                     case storm::solver::EquationSolverType::Gmmxx: return std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>>(new storm::solver::GmmxxLinearEquationSolver<ValueType>(matrix));
                     case storm::solver::EquationSolverType::Native: return std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>>(new storm::solver::NativeLinearEquationSolver<ValueType>(matrix));
@@ -61,7 +61,7 @@ namespace storm {
             
             template<typename ValueType>
             NativeLinearEquationSolverFactory<ValueType>::NativeLinearEquationSolverFactory() {
-                switch (storm::settings::nativeEquationSolverSettings().getLinearEquationSystemMethod()) {
+                switch (storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getLinearEquationSystemMethod()) {
                     case settings::modules::NativeEquationSolverSettings::LinearEquationMethod::Jacobi:
                     this->method = storm::solver::NativeLinearEquationSolverSolutionMethod::Jacobi;
                     break;
@@ -70,7 +70,7 @@ namespace storm {
                     case settings::modules::NativeEquationSolverSettings::LinearEquationMethod::SOR:
                     this->method = storm::solver::NativeLinearEquationSolverSolutionMethod::SOR;
                 }
-                omega = storm::settings::nativeEquationSolverSettings().getOmega();
+                omega = storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getOmega();
             }
             
             template<typename ValueType>
@@ -93,7 +93,7 @@ namespace storm {
             template<typename ValueType>
             MinMaxLinearEquationSolverFactory<ValueType>& MinMaxLinearEquationSolverFactory<ValueType>::setSolverType(storm::solver::EquationSolverTypeSelection solverTypeSel) {
                 if(solverTypeSel == storm::solver::EquationSolverTypeSelection::FROMSETTINGS) {
-                    this->solverType = storm::settings::generalSettings().getEquationSolver();
+                    this->solverType = storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEquationSolver();
                 } else {
                     this->solverType = storm::solver::convert(solverTypeSel);
                 }
@@ -140,7 +140,7 @@ namespace storm {
             std::unique_ptr<storm::solver::LpSolver> LpSolverFactory::create(std::string const& name, storm::solver::LpSolverTypeSelection solvT) const {
                 storm::solver::LpSolverType t;
                 if(solvT == storm::solver::LpSolverTypeSelection::FROMSETTINGS) {
-                    t = storm::settings::generalSettings().getLpSolver();
+                    t = storm::settings::getModule<storm::settings::modules::GeneralSettings>().getLpSolver();
                 } else {
                     t = convert(solvT);
                 }
@@ -168,7 +168,7 @@ namespace storm {
             }
             
             std::unique_ptr<storm::solver::SmtSolver> SmtSolverFactory::create(storm::expressions::ExpressionManager& manager) const {
-                storm::solver::SmtSolverType smtSolverType = storm::settings::generalSettings().getSmtSolver();
+                storm::solver::SmtSolverType smtSolverType = storm::settings::getModule<storm::settings::modules::GeneralSettings>().getSmtSolver();
                 switch (smtSolverType) {
                     case storm::solver::SmtSolverType::Z3: return std::unique_ptr<storm::solver::SmtSolver>(new storm::solver::Z3SmtSolver(manager));
                     case storm::solver::SmtSolverType::Mathsat: return std::unique_ptr<storm::solver::SmtSolver>(new storm::solver::MathsatSmtSolver(manager));
diff --git a/src/utility/storm.h b/src/utility/storm.h
index ea58705b8..64f43fe0f 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -94,26 +94,24 @@ namespace storm {
         storm::storage::ModelFormulasPair result;
         storm::prism::Program translatedProgram;
 
-        storm::settings::modules::GeneralSettings settings = storm::settings::generalSettings();
-
         // Get the string that assigns values to the unknown currently undefined constants in the model.
-        std::string constants = settings.getConstantDefinitionString();
+        std::string constants = storm::settings::getModule<storm::settings::modules::GeneralSettings>().getConstantDefinitionString();
 
         // Customize and perform model-building.
-        if (settings.getEngine() == storm::settings::modules::GeneralSettings::Engine::Sparse) {
+        if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEngine() == storm::settings::modules::GeneralSettings::Engine::Sparse) {
             typename storm::builder::ExplicitPrismModelBuilder<ValueType, storm::models::sparse::StandardRewardModel<ValueType>>::Options options;
             options = typename storm::builder::ExplicitPrismModelBuilder<ValueType, storm::models::sparse::StandardRewardModel<ValueType>>::Options(formulas);
             options.addConstantDefinitionsFromString(program, constants);
 
             // Generate command labels if we are going to build a counterexample later.
-            if (storm::settings::counterexampleGeneratorSettings().isMinimalCommandSetGenerationSet()) {
+            if (storm::settings::getModule<storm::settings::modules::CounterexampleGeneratorSettings>().isMinimalCommandSetGenerationSet()) {
                 options.buildCommandLabels = true;
             }
 
             storm::builder::ExplicitPrismModelBuilder<ValueType> builder(program, options);
             result.model = builder.translate();
             translatedProgram = builder.getTranslatedProgram();
-        } else if (settings.getEngine() == storm::settings::modules::GeneralSettings::Engine::Dd || settings.getEngine() == storm::settings::modules::GeneralSettings::Engine::Hybrid) {
+        } else if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEngine() == storm::settings::modules::GeneralSettings::Engine::Dd || storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEngine() == storm::settings::modules::GeneralSettings::Engine::Hybrid) {
             typename storm::builder::DdPrismModelBuilder<LibraryType>::Options options;
             options = typename storm::builder::DdPrismModelBuilder<LibraryType>::Options(formulas);
             options.addConstantDefinitionsFromString(program, constants);
@@ -206,9 +204,9 @@ namespace storm {
             } 
         }
         
-        if (model->isSparseModel() && storm::settings::generalSettings().isBisimulationSet()) {
+        if (model->isSparseModel() && storm::settings::getModule<storm::settings::modules::GeneralSettings>().isBisimulationSet()) {
             storm::storage::BisimulationType bisimType = storm::storage::BisimulationType::Strong;
-            if (storm::settings::bisimulationSettings().isWeakBisimulationSet()) {
+            if (storm::settings::getModule<storm::settings::modules::BisimulationSettings>().isWeakBisimulationSet()) {
                 bisimType = storm::storage::BisimulationType::Weak;
             }
             
@@ -222,19 +220,19 @@ namespace storm {
     
     template<typename ValueType>
     void generateCounterexample(storm::prism::Program const& program, std::shared_ptr<storm::models::sparse::Model<ValueType>> model, std::shared_ptr<const storm::logic::Formula> const& formula) {
-        if (storm::settings::counterexampleGeneratorSettings().isMinimalCommandSetGenerationSet()) {
+        if (storm::settings::getModule<storm::settings::modules::CounterexampleGeneratorSettings>().isMinimalCommandSetGenerationSet()) {
             STORM_LOG_THROW(model->getType() == storm::models::ModelType::Mdp, storm::exceptions::InvalidTypeException, "Minimal command set generation is only available for MDPs.");
-            STORM_LOG_THROW(storm::settings::generalSettings().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "Minimal command set generation is only available for symbolic models.");
+            STORM_LOG_THROW(storm::settings::getModule<storm::settings::modules::GeneralSettings>().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "Minimal command set generation is only available for symbolic models.");
 
             std::shared_ptr<storm::models::sparse::Mdp<ValueType>> mdp = model->template as<storm::models::sparse::Mdp<ValueType>>();
 
             // Determine whether we are required to use the MILP-version or the SAT-version.
-            bool useMILP = storm::settings::counterexampleGeneratorSettings().isUseMilpBasedMinimalCommandSetGenerationSet();
+            bool useMILP = storm::settings::getModule<storm::settings::modules::CounterexampleGeneratorSettings>().isUseMilpBasedMinimalCommandSetGenerationSet();
 
             if (useMILP) {
                 storm::counterexamples::MILPMinimalLabelSetGenerator<ValueType>::computeCounterexample(program, *mdp, formula);
             } else {
-                storm::counterexamples::SMTMinimalCommandSetGenerator<ValueType>::computeCounterexample(program, storm::settings::generalSettings().getConstantDefinitionString(), *mdp, formula);
+                storm::counterexamples::SMTMinimalCommandSetGenerator<ValueType>::computeCounterexample(program, storm::settings::getModule<storm::settings::modules::GeneralSettings>().getConstantDefinitionString(), *mdp, formula);
             }
 
         } else {
@@ -251,8 +249,7 @@ namespace storm {
 
     template<typename ValueType, storm::dd::DdType DdType>
     std::unique_ptr<storm::modelchecker::CheckResult> verifyModel(std::shared_ptr<storm::models::ModelBase> model, std::shared_ptr<const storm::logic::Formula> const& formula, bool onlyInitialStatesRelevant) {
-        storm::settings::modules::GeneralSettings const& settings = storm::settings::generalSettings();
-        switch(settings.getEngine()) {
+        switch(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEngine()) {
             case storm::settings::modules::GeneralSettings::Engine::Sparse: {
                 std::shared_ptr<storm::models::sparse::Model<ValueType>> sparseModel = model->template as<storm::models::sparse::Model<ValueType>>();
                 STORM_LOG_THROW(sparseModel != nullptr, storm::exceptions::InvalidArgumentException, "Sparse engine requires a sparse input model");
@@ -295,7 +292,7 @@ namespace storm {
         } else if (model->getType() == storm::models::ModelType::Mdp) {
             std::shared_ptr<storm::models::sparse::Mdp<ValueType>> mdp = model->template as<storm::models::sparse::Mdp<ValueType>>();
 #ifdef STORM_HAVE_CUDA
-            if (settings.isCudaSet()) {
+            if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isCudaSet()) {
                     storm::modelchecker::TopologicalValueIterationMdpPrctlModelChecker<ValueType> modelchecker(*mdp);
                     result = modelchecker.check(task);
                 } else {
diff --git a/test/functional/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp b/test/functional/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp
index dc9512a38..73c16edb1 100644
--- a/test/functional/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp
+++ b/test/functional/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp
@@ -48,56 +48,56 @@ TEST(GmmxxCtmcCslModelCheckerTest, Cluster) {
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,100] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,2000] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult3 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U<=10 \"premium\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult4 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(1, quantitativeCheckResult4[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult4[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"minimum\" U[1,inf] \"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult5 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0, quantitativeCheckResult5[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0, quantitativeCheckResult5[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U[1,inf] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult6 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=100]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult7 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult8 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GmmxxCtmcCslModelCheckerTest, Embedded) {
@@ -131,42 +131,42 @@ TEST(GmmxxCtmcCslModelCheckerTest, Embedded) {
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_actuators\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_io\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult3 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_sensors\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult4 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10000]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult5 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"fail_sensors\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult6 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.93458866427696596, quantitativeCheckResult6[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.93458866427696596, quantitativeCheckResult6[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GmmxxCtmcCslModelCheckerTest, Polling) {
@@ -193,14 +193,14 @@ TEST(GmmxxCtmcCslModelCheckerTest, Polling) {
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(1, quantitativeCheckResult1[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("LRA=?[\"target\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GmmxxCtmcCslModelCheckerTest, Fms) {
@@ -240,47 +240,47 @@ TEST(GmmxxCtmcCslModelCheckerTest, Tandem) {
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"first_queue_full\" ]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult3 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(1, quantitativeCheckResult3[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult3[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [I=10]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult4 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult5 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"first_queue_full\"&\"second_queue_full\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult6 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(262.85103661561755, quantitativeCheckResult6[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(262.85103661561755, quantitativeCheckResult6[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"first_queue_full\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult7 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
diff --git a/test/functional/modelchecker/GmmxxDtmcPrctlModelCheckerTest.cpp b/test/functional/modelchecker/GmmxxDtmcPrctlModelCheckerTest.cpp
index 36a139b9c..8751e3d97 100644
--- a/test/functional/modelchecker/GmmxxDtmcPrctlModelCheckerTest.cpp
+++ b/test/functional/modelchecker/GmmxxDtmcPrctlModelCheckerTest.cpp
@@ -36,28 +36,28 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, Die) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1.0 / 6.0, quantitativeResult1[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0 / 6.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1.0 / 6.0, quantitativeResult2[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0 / 6.0, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1.0 / 6.0, quantitativeResult3[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0 / 6.0, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(11.0 / 3.0, quantitativeResult4[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(11.0 / 3.0, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxDtmcPrctlModelCheckerTest, Crowds) {
@@ -80,21 +80,21 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, Crowds) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.3328800375801578281, quantitativeResult1[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.3328800375801578281, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.1522194965, quantitativeResult2[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.1522194965, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.32153724292835045, quantitativeResult3[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.32153724292835045, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxDtmcPrctlModelCheckerTest, SynchronousLeader) {
@@ -117,21 +117,21 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, SynchronousLeader) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.9999965911265462636, quantitativeResult2[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.9999965911265462636, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1.044879046, quantitativeResult3[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.044879046, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxDtmcPrctlModelCheckerTest, LRASingleBscc) {
@@ -160,8 +160,8 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, LRASingleBscc) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     }
     {
         matrixBuilder = storm::storage::SparseMatrixBuilder<double>(2, 2, 4);
@@ -184,8 +184,8 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, LRASingleBscc) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     }
 
     {
@@ -208,9 +208,9 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, LRASingleBscc) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(1. / 3., quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1. / 3., quantitativeResult1[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1. / 3., quantitativeResult1[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(1. / 3., quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1. / 3., quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1. / 3., quantitativeResult1[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     }
 }
 
@@ -271,13 +271,13 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, LRA) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(0.3 / 3., quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult1[3], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1. / 3., quantitativeResult1[6], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult1[9], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.3 / 3., quantitativeResult1[12], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(.79 / 3., quantitativeResult1[13], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.3 / 3., quantitativeResult1[14], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(0.3 / 3., quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult1[3], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1. / 3., quantitativeResult1[6], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult1[9], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.3 / 3., quantitativeResult1[12], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(.79 / 3., quantitativeResult1[13], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.3 / 3., quantitativeResult1[14], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     }
 }
 
@@ -299,13 +299,13 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, Conditional) {
     
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.5, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"target\" || F \"condition\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(storm::utility::one<double>(), quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(storm::utility::one<double>(), quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"target\"]");
     
@@ -317,5 +317,5 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, Conditional) {
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(storm::utility::one<double>(), quantitativeResult4[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(storm::utility::one<double>(), quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
diff --git a/test/functional/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp b/test/functional/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp
index d5bd19fe2..a128b4802 100644
--- a/test/functional/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp
+++ b/test/functional/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp
@@ -51,8 +51,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,100] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -60,8 +60,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>  quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,2000] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -69,8 +69,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>  quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U<=10 \"premium\"]");
     checkResult = modelchecker.check(*formula);
@@ -78,8 +78,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>  quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(1, quantitativeCheckResult4.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeCheckResult4.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"minimum\" U[1,inf] \"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -87,8 +87,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>  quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0, quantitativeCheckResult5.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0, quantitativeCheckResult5.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U[1,inf] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -96,8 +96,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>  quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=100]");
     checkResult = modelchecker.check(*formula);
@@ -105,16 +105,16 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>  quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult8 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
@@ -148,8 +148,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,100] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -157,8 +157,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>  quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,2000] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -166,8 +166,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>  quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U<=10 \"premium\"]");
     checkResult = modelchecker.check(*formula);
@@ -175,8 +175,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>  quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(1, quantitativeCheckResult4.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeCheckResult4.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"minimum\" U[1,inf] \"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -184,8 +184,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>  quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0, quantitativeCheckResult5.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0, quantitativeCheckResult5.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U[1,inf] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -193,8 +193,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>  quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=100]");
     checkResult = modelchecker.check(*formula);
@@ -202,16 +202,16 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>  quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult8 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
@@ -245,8 +245,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_actuators\"]");
     checkResult = modelchecker.check(*formula);
@@ -254,8 +254,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_io\"]");
     checkResult = modelchecker.check(*formula);
@@ -263,8 +263,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_sensors\"]");
     checkResult = modelchecker.check(*formula);
@@ -272,8 +272,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10000]");
     checkResult = modelchecker.check(*formula);
@@ -281,16 +281,16 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"fail_sensors\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.934586179, quantitativeCheckResult6.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.934586179, quantitativeCheckResult6.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.934586179, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.934586179, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
@@ -324,8 +324,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_actuators\"]");
     checkResult = modelchecker.check(*formula);
@@ -333,8 +333,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_io\"]");
     checkResult = modelchecker.check(*formula);
@@ -342,8 +342,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_sensors\"]");
     checkResult = modelchecker.check(*formula);
@@ -351,8 +351,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10000]");
     checkResult = modelchecker.check(*formula);
@@ -360,16 +360,16 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"fail_sensors\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.934586179, quantitativeCheckResult6.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.934586179, quantitativeCheckResult6.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.934586179, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.934586179, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Cudd) {
@@ -396,16 +396,16 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(1, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"target\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Sylvan) {
@@ -432,16 +432,16 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(1, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"target\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Fms) {
@@ -482,8 +482,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"first_queue_full\" ]");
     checkResult = modelchecker.check(*formula);
@@ -491,8 +491,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]");
     checkResult = modelchecker.check(*formula);
@@ -500,8 +500,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(1, quantitativeCheckResult3.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeCheckResult3.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [I=10]");
     checkResult = modelchecker.check(*formula);
@@ -509,8 +509,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10]");
     checkResult = modelchecker.check(*formula);
@@ -518,8 +518,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"first_queue_full\"&\"second_queue_full\"]");
     checkResult = modelchecker.check(*formula);
@@ -527,16 +527,16 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(262.85103498583413, quantitativeCheckResult6.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(262.85103498583413, quantitativeCheckResult6.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(262.85103498583413, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(262.85103498583413, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"first_queue_full\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
@@ -570,8 +570,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"first_queue_full\" ]");
     checkResult = modelchecker.check(*formula);
@@ -579,8 +579,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]");
     checkResult = modelchecker.check(*formula);
@@ -588,8 +588,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(1, quantitativeCheckResult3.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeCheckResult3.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [I=10]");
     checkResult = modelchecker.check(*formula);
@@ -597,8 +597,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10]");
     checkResult = modelchecker.check(*formula);
@@ -606,8 +606,8 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"first_queue_full\"&\"second_queue_full\"]");
     checkResult = modelchecker.check(*formula);
@@ -615,14 +615,14 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(262.85103498583413, quantitativeCheckResult6.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(262.85103498583413, quantitativeCheckResult6.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(262.85103498583413, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(262.85103498583413, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"first_queue_full\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/functional/modelchecker/GmmxxHybridDtmcPrctlModelCheckerTest.cpp b/test/functional/modelchecker/GmmxxHybridDtmcPrctlModelCheckerTest.cpp
index 6d0eac386..5f62f4e72 100644
--- a/test/functional/modelchecker/GmmxxHybridDtmcPrctlModelCheckerTest.cpp
+++ b/test/functional/modelchecker/GmmxxHybridDtmcPrctlModelCheckerTest.cpp
@@ -48,8 +48,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Die_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]");
     
@@ -57,8 +57,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Die_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]");
     
@@ -66,8 +66,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Die_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]");
     
@@ -75,8 +75,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Die_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(11.0/3.0, quantitativeResult4.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(11.0/3.0, quantitativeResult4.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(11.0/3.0, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(11.0/3.0, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Die_Sylvan) {
@@ -109,8 +109,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Die_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]");
     
@@ -118,8 +118,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Die_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]");
     
@@ -127,8 +127,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Die_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]");
     
@@ -136,8 +136,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Die_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(11.0/3.0, quantitativeResult4.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(11.0/3.0, quantitativeResult4.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(11.0/3.0, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(11.0/3.0, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Crowds_Cudd) {
@@ -162,8 +162,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Crowds_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.3328800375801578281, quantitativeResult1.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.3328800375801578281, quantitativeResult1.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.3328800375801578281, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.3328800375801578281, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]");
     
@@ -171,8 +171,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Crowds_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.1522194965, quantitativeResult2.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.1522194965, quantitativeResult2.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.1522194965, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.1522194965, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]");
     
@@ -180,8 +180,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Crowds_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.32153724292835045, quantitativeResult3.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.32153724292835045, quantitativeResult3.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.32153724292835045, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.32153724292835045, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
@@ -206,8 +206,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.3328800375801578281, quantitativeResult1.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.3328800375801578281, quantitativeResult1.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.3328800375801578281, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.3328800375801578281, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]");
     
@@ -215,8 +215,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.1522194965, quantitativeResult2.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.1522194965, quantitativeResult2.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.1522194965, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.1522194965, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]");
     
@@ -224,8 +224,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.32153724292835045, quantitativeResult3.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.32153724292835045, quantitativeResult3.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.32153724292835045, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.32153724292835045, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
@@ -258,8 +258,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]");
     
@@ -267,8 +267,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]");
     
@@ -276,8 +276,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
@@ -310,8 +310,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]");
     
@@ -319,8 +319,8 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]");
     
@@ -328,6 +328,6 @@ TEST(GmmxxHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
diff --git a/test/functional/modelchecker/GmmxxHybridMdpPrctlModelCheckerTest.cpp b/test/functional/modelchecker/GmmxxHybridMdpPrctlModelCheckerTest.cpp
index 06a236b4d..830b94ef3 100644
--- a/test/functional/modelchecker/GmmxxHybridMdpPrctlModelCheckerTest.cpp
+++ b/test/functional/modelchecker/GmmxxHybridMdpPrctlModelCheckerTest.cpp
@@ -50,8 +50,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"two\"]");
     
@@ -59,8 +59,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"three\"]");
     
@@ -68,8 +68,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"three\"]");
     
@@ -77,8 +77,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"four\"]");
     
@@ -86,8 +86,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult5 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"four\"]");
     
@@ -95,8 +95,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult6 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"done\"]");
     
@@ -104,8 +104,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult7 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
     
@@ -113,8 +113,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult8 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
@@ -147,8 +147,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"two\"]");
     
@@ -156,8 +156,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"three\"]");
     
@@ -165,8 +165,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"three\"]");
     
@@ -174,8 +174,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"four\"]");
     
@@ -183,8 +183,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult5 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"four\"]");
     
@@ -192,8 +192,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult6 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"done\"]");
     
@@ -201,8 +201,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult7 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
     
@@ -210,8 +210,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult8 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
@@ -244,8 +244,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]");
     
@@ -253,8 +253,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
     
@@ -262,8 +262,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0625, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0625, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]");
     
@@ -271,8 +271,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0625, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0625, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
     
@@ -280,8 +280,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult5 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]");
     
@@ -289,8 +289,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult6 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
@@ -323,8 +323,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]");
     
@@ -332,8 +332,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
     
@@ -341,8 +341,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0625, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0625, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]");
     
@@ -350,8 +350,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0625, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0625, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
     
@@ -359,8 +359,8 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult5 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]");
     
@@ -368,7 +368,7 @@ TEST(GmmxxHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult6 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
diff --git a/test/functional/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp b/test/functional/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp
index 93643fd52..319f03066 100644
--- a/test/functional/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp
+++ b/test/functional/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp
@@ -37,56 +37,56 @@ TEST(GmmxxMdpPrctlModelCheckerTest, Dice) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"two\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"three\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"three\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"four\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"four\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult6 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"done\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult7 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(7.333329499, quantitativeResult7[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.333329499, quantitativeResult7[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult8 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(7.333329499, quantitativeResult8[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.333329499, quantitativeResult8[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     abstractModel = storm::parser::AutoParser<>::parseModel(STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.tra", STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.lab", STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.flip.state.rew", "");
 
@@ -101,14 +101,14 @@ TEST(GmmxxMdpPrctlModelCheckerTest, Dice) {
     result = stateRewardModelChecker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult9 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(7.333329499, quantitativeResult9[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.333329499, quantitativeResult9[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
 
     result = stateRewardModelChecker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult10 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(7.333329499, quantitativeResult10[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.333329499, quantitativeResult10[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     abstractModel = storm::parser::AutoParser<>::parseModel(STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.tra", STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.lab", STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.flip.state.rew", STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.flip.trans.rew");
 
@@ -123,14 +123,14 @@ TEST(GmmxxMdpPrctlModelCheckerTest, Dice) {
     result = stateAndTransitionRewardModelChecker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult11 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(14.666658998, quantitativeResult11[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(14.666658998, quantitativeResult11[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
 
     result = stateAndTransitionRewardModelChecker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult12 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(14.666658998, quantitativeResult12[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(14.666658998, quantitativeResult12[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxMdpPrctlModelCheckerTest, AsynchronousLeader) {
@@ -153,42 +153,42 @@ TEST(GmmxxMdpPrctlModelCheckerTest, AsynchronousLeader) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.0625, quantitativeResult3[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.0625, quantitativeResult4[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(4.285689611, quantitativeResult5[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.285689611, quantitativeResult5[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult6 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(4.285689611, quantitativeResult6[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.285689611, quantitativeResult6[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxMdpPrctlModelCheckerTest, SchedulerGeneration) {
diff --git a/test/functional/modelchecker/NativeCtmcCslModelCheckerTest.cpp b/test/functional/modelchecker/NativeCtmcCslModelCheckerTest.cpp
index 0a1d8ee4c..6c94f0007 100644
--- a/test/functional/modelchecker/NativeCtmcCslModelCheckerTest.cpp
+++ b/test/functional/modelchecker/NativeCtmcCslModelCheckerTest.cpp
@@ -46,49 +46,49 @@ TEST(NativeCtmcCslModelCheckerTest, Cluster) {
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,100] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,2000] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult3 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U<=10 \"premium\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult4 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(1, quantitativeCheckResult4[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult4[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"minimum\" U[1,inf] \"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult5 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0, quantitativeCheckResult5[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0, quantitativeCheckResult5[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U[1,inf] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult6 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=100]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult7 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(NativeCtmcCslModelCheckerTest, Embedded) {
@@ -122,35 +122,35 @@ TEST(NativeCtmcCslModelCheckerTest, Embedded) {
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_actuators\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_io\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult3 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_sensors\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult4 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10000]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult5 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(NativeCtmcCslModelCheckerTest, Polling) {
@@ -177,7 +177,7 @@ TEST(NativeCtmcCslModelCheckerTest, Polling) {
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(1, quantitativeCheckResult1[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(NativeCtmcCslModelCheckerTest, Fms) {
@@ -218,40 +218,40 @@ TEST(NativeCtmcCslModelCheckerTest, Tandem) {
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"first_queue_full\" ]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult3 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(1, quantitativeCheckResult3[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult3[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [I=10]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult4 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult5 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"first_queue_full\"&\"second_queue_full\"]");
     checkResult = modelchecker.check(*formula);
     
     ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult());
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult6 = checkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(262.78584491454814, quantitativeCheckResult6[initialState], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(262.78584491454814, quantitativeCheckResult6[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
diff --git a/test/functional/modelchecker/NativeDtmcPrctlModelCheckerTest.cpp b/test/functional/modelchecker/NativeDtmcPrctlModelCheckerTest.cpp
index 6af4c51cc..56b9bc9f2 100644
--- a/test/functional/modelchecker/NativeDtmcPrctlModelCheckerTest.cpp
+++ b/test/functional/modelchecker/NativeDtmcPrctlModelCheckerTest.cpp
@@ -36,28 +36,28 @@ TEST(SparseDtmcPrctlModelCheckerTest, Die) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(3.6666650772094727, quantitativeResult4[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(3.6666650772094727, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SparseDtmcPrctlModelCheckerTest, Crowds) {
@@ -80,21 +80,21 @@ TEST(SparseDtmcPrctlModelCheckerTest, Crowds) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.33288205191646525, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.33288205191646525, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.15222066094730619, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.15222066094730619, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.32153900158185761, quantitativeResult3[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.32153900158185761, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SparseDtmcPrctlModelCheckerTest, SynchronousLeader) {
@@ -117,21 +117,21 @@ TEST(SparseDtmcPrctlModelCheckerTest, SynchronousLeader) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.9999965911265462636, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.9999965911265462636, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(1.0448979589010925, quantitativeResult3[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0448979589010925, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SparseDtmcPrctlModelCheckerTest, LRASingleBscc) {
@@ -160,8 +160,8 @@ TEST(SparseDtmcPrctlModelCheckerTest, LRASingleBscc) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
 		storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-		EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-		EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::nativeEquationSolverSettings().getPrecision());
+		EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+		EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 	}
 	{
 		matrixBuilder = storm::storage::SparseMatrixBuilder<double>(2, 2, 4);
@@ -184,8 +184,8 @@ TEST(SparseDtmcPrctlModelCheckerTest, LRASingleBscc) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
 		storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-		EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-		EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::nativeEquationSolverSettings().getPrecision());
+		EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+		EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 	}
 
 	{
@@ -208,9 +208,9 @@ TEST(SparseDtmcPrctlModelCheckerTest, LRASingleBscc) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
 		storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-		EXPECT_NEAR(1. / 3., quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-		EXPECT_NEAR(1. / 3., quantitativeResult1[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-		EXPECT_NEAR(1. / 3., quantitativeResult1[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+		EXPECT_NEAR(1. / 3., quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+		EXPECT_NEAR(1. / 3., quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+		EXPECT_NEAR(1. / 3., quantitativeResult1[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 	}
 }
 
@@ -271,12 +271,12 @@ TEST(SparseDtmcPrctlModelCheckerTest, LRA) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
 		storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-		EXPECT_NEAR(0.3 / 3., quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-		EXPECT_NEAR(0.0, quantitativeResult1[3], storm::settings::nativeEquationSolverSettings().getPrecision());
-		EXPECT_NEAR(1. / 3., quantitativeResult1[6], storm::settings::nativeEquationSolverSettings().getPrecision());
-		EXPECT_NEAR(0.0, quantitativeResult1[9], storm::settings::nativeEquationSolverSettings().getPrecision());
-		EXPECT_NEAR(0.3/3., quantitativeResult1[12], storm::settings::nativeEquationSolverSettings().getPrecision());
-		EXPECT_NEAR(.79 / 3., quantitativeResult1[13], storm::settings::nativeEquationSolverSettings().getPrecision());
-		EXPECT_NEAR(0.3 / 3., quantitativeResult1[14], storm::settings::nativeEquationSolverSettings().getPrecision());
+		EXPECT_NEAR(0.3 / 3., quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+		EXPECT_NEAR(0.0, quantitativeResult1[3], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+		EXPECT_NEAR(1. / 3., quantitativeResult1[6], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+		EXPECT_NEAR(0.0, quantitativeResult1[9], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+		EXPECT_NEAR(0.3/3., quantitativeResult1[12], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+		EXPECT_NEAR(.79 / 3., quantitativeResult1[13], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+		EXPECT_NEAR(0.3 / 3., quantitativeResult1[14], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 	}
 }
\ No newline at end of file
diff --git a/test/functional/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp b/test/functional/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp
index 6b660acf8..d4b0fb9a5 100644
--- a/test/functional/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp
+++ b/test/functional/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp
@@ -50,8 +50,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,100] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -59,8 +59,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>  quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,2000] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -68,8 +68,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>  quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U<=10 \"premium\"]");
     checkResult = modelchecker.check(*formula);
@@ -77,8 +77,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>  quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(1, quantitativeCheckResult4.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeCheckResult4.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"minimum\" U[1,inf] \"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -86,8 +86,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>  quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0, quantitativeCheckResult5.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0, quantitativeCheckResult5.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U[1,inf] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -95,8 +95,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>  quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=100]");
     checkResult = modelchecker.check(*formula);
@@ -104,16 +104,16 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>  quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult8 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.99979112284455396, quantitativeCheckResult8.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.99979112284455396, quantitativeCheckResult8.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.99979112284455396, quantitativeCheckResult8.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.99979112284455396, quantitativeCheckResult8.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
@@ -147,8 +147,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,100] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -156,8 +156,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>  quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,2000] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -165,8 +165,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>  quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U<=10 \"premium\"]");
     checkResult = modelchecker.check(*formula);
@@ -174,8 +174,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>  quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(1, quantitativeCheckResult4.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeCheckResult4.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"minimum\" U[1,inf] \"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -183,8 +183,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>  quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0, quantitativeCheckResult5.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0, quantitativeCheckResult5.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U[1,inf] !\"minimum\"]");
     checkResult = modelchecker.check(*formula);
@@ -192,8 +192,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>  quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=100]");
     checkResult = modelchecker.check(*formula);
@@ -201,16 +201,16 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>  quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"minimum\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult8 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.99979112284455396, quantitativeCheckResult8.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.99979112284455396, quantitativeCheckResult8.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.99979112284455396, quantitativeCheckResult8.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.99979112284455396, quantitativeCheckResult8.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
@@ -244,8 +244,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_actuators\"]");
     checkResult = modelchecker.check(*formula);
@@ -253,8 +253,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_io\"]");
     checkResult = modelchecker.check(*formula);
@@ -262,8 +262,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_sensors\"]");
     checkResult = modelchecker.check(*formula);
@@ -271,8 +271,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10000]");
     checkResult = modelchecker.check(*formula);
@@ -280,16 +280,16 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"fail_sensors\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.93458777106146362, quantitativeCheckResult6.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.93458777106146362, quantitativeCheckResult6.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.93458777106146362, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.93458777106146362, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
@@ -323,8 +323,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_actuators\"]");
     checkResult = modelchecker.check(*formula);
@@ -332,8 +332,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_io\"]");
     checkResult = modelchecker.check(*formula);
@@ -341,8 +341,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_sensors\"]");
     checkResult = modelchecker.check(*formula);
@@ -350,8 +350,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10000]");
     checkResult = modelchecker.check(*formula);
@@ -359,16 +359,16 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"fail_sensors\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.93458777106146362, quantitativeCheckResult6.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.93458777106146362, quantitativeCheckResult6.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.93458777106146362, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.93458777106146362, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Cudd) {
@@ -395,16 +395,16 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(1, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"target\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Sylvan) {
@@ -431,16 +431,16 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(1, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"target\"]");
     checkResult = modelchecker.check(*formula);
     
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Fms) {
@@ -481,8 +481,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"first_queue_full\" ]");
     checkResult = modelchecker.check(*formula);
@@ -490,8 +490,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]");
     checkResult = modelchecker.check(*formula);
@@ -499,8 +499,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(1, quantitativeCheckResult3.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeCheckResult3.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [I=10]");
     checkResult = modelchecker.check(*formula);
@@ -508,8 +508,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10]");
     checkResult = modelchecker.check(*formula);
@@ -517,8 +517,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"first_queue_full\"&\"second_queue_full\"]");
     checkResult = modelchecker.check(*formula);
@@ -526,8 +526,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
-    EXPECT_NEAR(262.78571505691389, quantitativeCheckResult6.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(262.78571505691389, quantitativeCheckResult6.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(262.78571505691389, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(262.78571505691389, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"first_queue_full\"]");
     checkResult = modelchecker.check(*formula);
@@ -536,8 +536,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
     // FIXME: because of divergence, these results are not correct.
-//    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::generalSettings().getPrecision());
-//    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::generalSettings().getPrecision());
+//    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+//    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
@@ -571,8 +571,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"first_queue_full\" ]");
     checkResult = modelchecker.check(*formula);
@@ -580,8 +580,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]");
     checkResult = modelchecker.check(*formula);
@@ -589,8 +589,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(1, quantitativeCheckResult3.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeCheckResult3.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [I=10]");
     checkResult = modelchecker.check(*formula);
@@ -598,8 +598,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10]");
     checkResult = modelchecker.check(*formula);
@@ -607,8 +607,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"first_queue_full\"&\"second_queue_full\"]");
     checkResult = modelchecker.check(*formula);
@@ -616,8 +616,8 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult());
     checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
-    EXPECT_NEAR(262.78571505691389, quantitativeCheckResult6.getMin(), storm::settings::generalSettings().getPrecision());
-    EXPECT_NEAR(262.78571505691389, quantitativeCheckResult6.getMax(), storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(262.78571505691389, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+    EXPECT_NEAR(262.78571505691389, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"first_queue_full\"]");
     checkResult = modelchecker.check(*formula);
@@ -626,6 +626,6 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
 
     // FIXME: because of divergence, these results are not correct.
-//    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::generalSettings().getPrecision());
-//    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::generalSettings().getPrecision());
+//    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
+//    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/functional/modelchecker/NativeHybridDtmcPrctlModelCheckerTest.cpp b/test/functional/modelchecker/NativeHybridDtmcPrctlModelCheckerTest.cpp
index 13c4f4f85..5e613e1be 100644
--- a/test/functional/modelchecker/NativeHybridDtmcPrctlModelCheckerTest.cpp
+++ b/test/functional/modelchecker/NativeHybridDtmcPrctlModelCheckerTest.cpp
@@ -49,8 +49,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Die_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]");
     
@@ -58,8 +58,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Die_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]");
     
@@ -67,8 +67,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Die_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]");
     
@@ -76,8 +76,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Die_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(NativeHybridDtmcPrctlModelCheckerTest, Die_Sylvan) {
@@ -110,8 +110,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Die_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]");
     
@@ -119,8 +119,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Die_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]");
     
@@ -128,8 +128,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Die_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]");
     
@@ -137,8 +137,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Die_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(NativeHybridDtmcPrctlModelCheckerTest, Crowds_Cudd) {
@@ -163,8 +163,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Crowds_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.33288205191646525, quantitativeResult1.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.33288205191646525, quantitativeResult1.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.33288205191646525, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.33288205191646525, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]");
     
@@ -172,8 +172,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Crowds_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.15222066094730619, quantitativeResult2.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.15222066094730619, quantitativeResult2.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.15222066094730619, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.15222066094730619, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]");
     
@@ -181,8 +181,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Crowds_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.32153900158185761, quantitativeResult3.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.32153900158185761, quantitativeResult3.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.32153900158185761, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.32153900158185761, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(NativeHybridDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
@@ -207,8 +207,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.33288205191646525, quantitativeResult1.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.33288205191646525, quantitativeResult1.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.33288205191646525, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.33288205191646525, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]");
     
@@ -216,8 +216,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.15222066094730619, quantitativeResult2.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.15222066094730619, quantitativeResult2.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.15222066094730619, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.15222066094730619, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]");
     
@@ -225,8 +225,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.32153900158185761, quantitativeResult3.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.32153900158185761, quantitativeResult3.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.32153900158185761, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.32153900158185761, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(NativeHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
@@ -259,8 +259,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]");
     
@@ -268,8 +268,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]");
     
@@ -277,8 +277,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(NativeHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
@@ -311,8 +311,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]");
     
@@ -320,8 +320,8 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]");
     
@@ -329,6 +329,6 @@ TEST(NativeHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/functional/modelchecker/NativeHybridMdpPrctlModelCheckerTest.cpp b/test/functional/modelchecker/NativeHybridMdpPrctlModelCheckerTest.cpp
index 40ce383c5..2c632d4ce 100644
--- a/test/functional/modelchecker/NativeHybridMdpPrctlModelCheckerTest.cpp
+++ b/test/functional/modelchecker/NativeHybridMdpPrctlModelCheckerTest.cpp
@@ -47,8 +47,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"two\"]");
     
@@ -56,8 +56,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"three\"]");
     
@@ -65,8 +65,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"three\"]");
     
@@ -74,8 +74,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"four\"]");
     
@@ -83,8 +83,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult5 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"four\"]");
     
@@ -92,8 +92,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult6 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"done\"]");
     
@@ -101,8 +101,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult7 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
     
@@ -110,8 +110,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult8 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
@@ -143,8 +143,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"two\"]");
     
@@ -152,8 +152,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"three\"]");
     
@@ -161,8 +161,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"three\"]");
     
@@ -170,8 +170,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"four\"]");
     
@@ -179,8 +179,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult5 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"four\"]");
     
@@ -188,8 +188,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult6 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"done\"]");
     
@@ -197,8 +197,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult7 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult7.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
     
@@ -206,8 +206,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult8 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(7.3333294987678528, quantitativeResult8.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
@@ -240,8 +240,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]");
     
@@ -249,8 +249,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
     
@@ -258,8 +258,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0625, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0625, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]");
     
@@ -267,8 +267,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0625, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0625, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
     
@@ -276,8 +276,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult5 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]");
     
@@ -285,8 +285,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult6 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
@@ -319,8 +319,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]");
     
@@ -328,8 +328,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
     
@@ -337,8 +337,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0625, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0625, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]");
     
@@ -346,8 +346,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0625, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0625, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
     
@@ -355,8 +355,8 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult5 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]");
     
@@ -364,6 +364,6 @@ TEST(NativeHybridMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult6 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(4.2856896106114934, quantitativeResult6.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
diff --git a/test/functional/modelchecker/NativeMdpPrctlModelCheckerTest.cpp b/test/functional/modelchecker/NativeMdpPrctlModelCheckerTest.cpp
index da5a2cd34..4406b82cc 100644
--- a/test/functional/modelchecker/NativeMdpPrctlModelCheckerTest.cpp
+++ b/test/functional/modelchecker/NativeMdpPrctlModelCheckerTest.cpp
@@ -34,56 +34,56 @@ TEST(SparseMdpPrctlModelCheckerTest, Dice) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"two\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"three\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"three\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"four\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"four\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult6 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"done\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult7 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(7.333329499, quantitativeResult7[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.333329499, quantitativeResult7[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult8 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(7.333329499, quantitativeResult8[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.333329499, quantitativeResult8[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     abstractModel = storm::parser::AutoParser<>::parseModel(STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.tra", STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.lab", STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.flip.state.rew", "");
 
@@ -98,14 +98,14 @@ TEST(SparseMdpPrctlModelCheckerTest, Dice) {
     result = stateRewardModelChecker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult9 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(7.333329499, quantitativeResult9[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.333329499, quantitativeResult9[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
 
     result = stateRewardModelChecker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult10 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(7.333329499, quantitativeResult10[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.333329499, quantitativeResult10[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     abstractModel = storm::parser::AutoParser<>::parseModel(STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.tra", STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.lab", STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.flip.state.rew", STORM_CPP_BASE_PATH "/examples/mdp/two_dice/two_dice.flip.trans.rew");
 
@@ -120,14 +120,14 @@ TEST(SparseMdpPrctlModelCheckerTest, Dice) {
     result = stateAndTransitionRewardModelChecker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult11 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(14.666658998, quantitativeResult11[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(14.666658998, quantitativeResult11[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
 
     result = stateAndTransitionRewardModelChecker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult12 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(14.666658998, quantitativeResult12[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(14.666658998, quantitativeResult12[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SparseMdpPrctlModelCheckerTest, AsynchronousLeader) {
@@ -150,42 +150,42 @@ TEST(SparseMdpPrctlModelCheckerTest, AsynchronousLeader) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.0625, quantitativeResult3[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.0625, quantitativeResult4[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(4.285689611, quantitativeResult5[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.285689611, quantitativeResult5[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult6 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(4.285689611, quantitativeResult6[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.285689611, quantitativeResult6[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SparseMdpPrctlModelCheckerTest, LRA_SingleMec) {
@@ -214,16 +214,16 @@ TEST(SparseMdpPrctlModelCheckerTest, LRA_SingleMec) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmin=? [\"a\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(.5, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(.5, quantitativeResult2[1], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(.5, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(.5, quantitativeResult2[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     }
     {
         matrixBuilder = storm::storage::SparseMatrixBuilder<double>(2, 2, 4);
@@ -246,16 +246,16 @@ TEST(SparseMdpPrctlModelCheckerTest, LRA_SingleMec) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmin=? [\"a\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(.5, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(.5, quantitativeResult2[1], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(.5, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(.5, quantitativeResult2[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     }
 
     {
@@ -287,54 +287,54 @@ TEST(SparseMdpPrctlModelCheckerTest, LRA_SingleMec) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(1. / 3., quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1. / 3., quantitativeResult1[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1. / 3., quantitativeResult1[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(1. / 3., quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1. / 3., quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1. / 3., quantitativeResult1[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmin=? [\"a\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(0.0, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult2[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult2[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult2[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult2[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmax=? [\"b\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(0.5, quantitativeResult3[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.5, quantitativeResult3[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.5, quantitativeResult3[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(0.5, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.5, quantitativeResult3[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.5, quantitativeResult3[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmin=? [\"b\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(1. / 3., quantitativeResult4[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1. / 3., quantitativeResult4[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1. / 3., quantitativeResult4[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(1. / 3., quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1. / 3., quantitativeResult4[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1. / 3., quantitativeResult4[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmax=? [\"c\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(2. / 3., quantitativeResult5[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(2. / 3., quantitativeResult5[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(2. / 3., quantitativeResult5[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(2. / 3., quantitativeResult5[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(2. / 3., quantitativeResult5[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(2. / 3., quantitativeResult5[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmin=? [\"c\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult6 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(0.5, quantitativeResult6[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.5, quantitativeResult6[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.5, quantitativeResult6[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(0.5, quantitativeResult6[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.5, quantitativeResult6[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.5, quantitativeResult6[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     }
 }
 
@@ -373,54 +373,54 @@ TEST(SparseMdpPrctlModelCheckerTest, LRA) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(0.0, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult1[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult1[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult1[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmin=? [\"a\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(0.0, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult2[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult2[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult2[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult2[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmax=? [\"b\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(1.0, quantitativeResult3[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1.0, quantitativeResult3[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult3[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(1.0, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1.0, quantitativeResult3[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult3[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmin=? [\"b\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(0.0, quantitativeResult4[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult4[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult4[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult4[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult4[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmax=? [\"c\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(1.0, quantitativeResult5[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1.0, quantitativeResult5[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1.0, quantitativeResult5[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(1.0, quantitativeResult5[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1.0, quantitativeResult5[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1.0, quantitativeResult5[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmin=? [\"c\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult6 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(0.0, quantitativeResult6[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult6[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1.0, quantitativeResult6[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult6[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult6[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1.0, quantitativeResult6[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     }
     {
         matrixBuilder = storm::storage::SparseMatrixBuilder<double>(22, 15, 28, true, true, 15);
@@ -495,25 +495,25 @@ TEST(SparseMdpPrctlModelCheckerTest, LRA) {
         std::unique_ptr<storm::modelchecker::CheckResult> result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(37. / 60., quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(2. / 3., quantitativeResult1[3], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.5, quantitativeResult1[6], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1. / 3., quantitativeResult1[9], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(31. / 60., quantitativeResult1[12], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(101. / 200., quantitativeResult1[13], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(31. / 60., quantitativeResult1[14], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(37. / 60., quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(2. / 3., quantitativeResult1[3], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.5, quantitativeResult1[6], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1. / 3., quantitativeResult1[9], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(31. / 60., quantitativeResult1[12], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(101. / 200., quantitativeResult1[13], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(31. / 60., quantitativeResult1[14], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
         formula = formulaParser.parseSingleFormulaFromString("LRAmin=? [\"a\"]");
 
         result = std::move(checker.check(*formula));
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-        EXPECT_NEAR(0.3 / 3., quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult2[3], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(1. / 3., quantitativeResult2[6], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.0, quantitativeResult2[9], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.3 / 3., quantitativeResult2[12], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(.79 / 3., quantitativeResult2[13], storm::settings::nativeEquationSolverSettings().getPrecision());
-        EXPECT_NEAR(0.3 / 3., quantitativeResult2[14], storm::settings::nativeEquationSolverSettings().getPrecision());
+        EXPECT_NEAR(0.3 / 3., quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult2[3], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(1. / 3., quantitativeResult2[6], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.0, quantitativeResult2[9], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.3 / 3., quantitativeResult2[12], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(.79 / 3., quantitativeResult2[13], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+        EXPECT_NEAR(0.3 / 3., quantitativeResult2[14], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     }
 }
\ No newline at end of file
diff --git a/test/functional/modelchecker/SparseDtmcEliminationModelCheckerTest.cpp b/test/functional/modelchecker/SparseDtmcEliminationModelCheckerTest.cpp
index ad4d9ab3d..b5f814f62 100644
--- a/test/functional/modelchecker/SparseDtmcEliminationModelCheckerTest.cpp
+++ b/test/functional/modelchecker/SparseDtmcEliminationModelCheckerTest.cpp
@@ -32,28 +32,28 @@ TEST(SparseDtmcEliminationModelCheckerTest, Die) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1.0 / 6.0, quantitativeResult1[0], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1.0 / 6.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1.0 / 6.0, quantitativeResult2[0], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1.0 / 6.0, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1.0 / 6.0, quantitativeResult3[0], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1.0 / 6.0, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(11.0 / 3.0, quantitativeResult4[0], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(11.0 / 3.0, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(SparseDtmcEliminationModelCheckerTest, Crowds) {
@@ -76,35 +76,35 @@ TEST(SparseDtmcEliminationModelCheckerTest, Crowds) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.3328800375801578281, quantitativeResult1[0], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.3328800375801578281, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.1522194965, quantitativeResult2[0], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.1522194965, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.32153724292835045, quantitativeResult3[0], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.32153724292835045, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observe0Greater1\" || F \"observeIGreater1\"]");
 
     result = checker.check(storm::modelchecker::CheckTask<storm::logic::Formula>(*formula).setOnlyInitialStatesRelevant(true));
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.15330064292476167, quantitativeResult4[0], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.15330064292476167, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\" || F \"observe0Greater1\"]");
 
     result = checker.check(storm::modelchecker::CheckTask<storm::logic::Formula>(*formula).setOnlyInitialStatesRelevant(true));
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.96592521978041668, quantitativeResult5[0], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.96592521978041668, quantitativeResult5[0], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(SparseDtmcEliminationModelCheckerTest, SynchronousLeader) {
@@ -126,12 +126,12 @@ TEST(SparseDtmcEliminationModelCheckerTest, SynchronousLeader) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]");
 
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(1.0448979, quantitativeResult2[0], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(1.0448979, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
diff --git a/test/functional/modelchecker/SymbolicDtmcPrctlModelCheckerTest.cpp b/test/functional/modelchecker/SymbolicDtmcPrctlModelCheckerTest.cpp
index 8f6c9c9e5..6f7ec5d76 100644
--- a/test/functional/modelchecker/SymbolicDtmcPrctlModelCheckerTest.cpp
+++ b/test/functional/modelchecker/SymbolicDtmcPrctlModelCheckerTest.cpp
@@ -47,8 +47,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Die_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]");
     
@@ -56,8 +56,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Die_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]");
     
@@ -65,8 +65,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Die_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]");
     
@@ -74,8 +74,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Die_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult4 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(3.6666622161865234, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(3.6666622161865234, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(3.6666622161865234, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(3.6666622161865234, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicDtmcPrctlModelCheckerTest, Die_Sylvan) {
@@ -108,8 +108,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Die_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]");
     
@@ -117,8 +117,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Die_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]");
     
@@ -126,8 +126,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Die_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]");
     
@@ -136,8 +136,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Die_Sylvan) {
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult4 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
     // FIXME: precision is not optimal.
-    EXPECT_NEAR(3.6666622161865234, quantitativeResult4.getMin(), 10 * storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(3.6666622161865234, quantitativeResult4.getMax(), 10 * storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(3.6666622161865234, quantitativeResult4.getMin(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(3.6666622161865234, quantitativeResult4.getMax(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Cudd) {
@@ -162,8 +162,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.33288236360191303, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.33288236360191303, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.33288236360191303, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.33288236360191303, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]");
     
@@ -171,8 +171,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.15222081144084315, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.15222081144084315, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.15222081144084315, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.15222081144084315, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]");
     
@@ -180,8 +180,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.3215392962289586, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.3215392962289586, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.3215392962289586, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.3215392962289586, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
@@ -207,8 +207,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
     // FIXME: precision not optimal.
-    EXPECT_NEAR(0.33288236360191303, quantitativeResult1.getMin(), 10 * storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.33288236360191303, quantitativeResult1.getMax(), 10 * storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.33288236360191303, quantitativeResult1.getMin(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.33288236360191303, quantitativeResult1.getMax(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]");
     
@@ -217,8 +217,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
     // FIXME: precision not optimal.
-    EXPECT_NEAR(0.15222081144084315, quantitativeResult2.getMin(), 10 * storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.15222081144084315, quantitativeResult2.getMax(), 10 * storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.15222081144084315, quantitativeResult2.getMin(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.15222081144084315, quantitativeResult2.getMax(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]");
     
@@ -227,8 +227,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
     // FIXME: precision not optimal.
-    EXPECT_NEAR(0.3215392962289586, quantitativeResult3.getMin(), 10 * storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.3215392962289586, quantitativeResult3.getMax(), 10 * storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.3215392962289586, quantitativeResult3.getMin(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.3215392962289586, quantitativeResult3.getMax(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
@@ -261,8 +261,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]");
     
@@ -270,8 +270,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]");
     
@@ -279,8 +279,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
@@ -313,8 +313,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]");
     
@@ -322,8 +322,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]");
     
@@ -331,6 +331,6 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/functional/modelchecker/SymbolicMdpPrctlModelCheckerTest.cpp b/test/functional/modelchecker/SymbolicMdpPrctlModelCheckerTest.cpp
index a2486280d..ab64807d8 100644
--- a/test/functional/modelchecker/SymbolicMdpPrctlModelCheckerTest.cpp
+++ b/test/functional/modelchecker/SymbolicMdpPrctlModelCheckerTest.cpp
@@ -47,8 +47,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"two\"]");
     
@@ -56,8 +56,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"three\"]");
     
@@ -65,8 +65,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"three\"]");
     
@@ -74,8 +74,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult4 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"four\"]");
     
@@ -83,8 +83,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult5 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"four\"]");
     
@@ -92,8 +92,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult6 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"done\"]");
     
@@ -101,8 +101,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult7 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(7.3333272933959961, quantitativeResult7.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(7.3333272933959961, quantitativeResult7.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.3333272933959961, quantitativeResult7.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(7.3333272933959961, quantitativeResult7.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
     
@@ -110,8 +110,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult8 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(7.3333272933959961, quantitativeResult8.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(7.3333272933959961, quantitativeResult8.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.3333272933959961, quantitativeResult8.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(7.3333272933959961, quantitativeResult8.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Sylvan) {
@@ -144,8 +144,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"two\"]");
     
@@ -153,8 +153,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0277777612209320068, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"three\"]");
     
@@ -162,8 +162,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"three\"]");
     
@@ -171,8 +171,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult4 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0555555224418640136, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"four\"]");
     
@@ -180,8 +180,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult5 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"four\"]");
     
@@ -189,8 +189,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult6 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.083333283662796020508, quantitativeResult6.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"done\"]");
     
@@ -198,8 +198,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult7 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(7.3333272933959961, quantitativeResult7.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(7.3333272933959961, quantitativeResult7.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.3333272933959961, quantitativeResult7.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(7.3333272933959961, quantitativeResult7.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
     
@@ -207,8 +207,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, Dice_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult8 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(7.3333272933959961, quantitativeResult8.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(7.3333272933959961, quantitativeResult8.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(7.3333272933959961, quantitativeResult8.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(7.3333272933959961, quantitativeResult8.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
@@ -241,8 +241,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]");
     
@@ -250,8 +250,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
     
@@ -259,8 +259,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0625, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0625, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]");
     
@@ -268,8 +268,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult4 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.0625, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0625, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
     
@@ -277,8 +277,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult5 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(4.2856890848060498, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(4.2856890848060498, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.2856890848060498, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(4.2856890848060498, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]");
     
@@ -286,8 +286,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult6 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(4.2856890848060498, quantitativeResult6.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(4.2856890848060498, quantitativeResult6.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.2856890848060498, quantitativeResult6.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(4.2856890848060498, quantitativeResult6.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
@@ -320,8 +320,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]");
     
@@ -329,8 +329,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
     
@@ -338,8 +338,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0625, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0625, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]");
     
@@ -347,8 +347,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult4 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.0625, quantitativeResult4.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.0625, quantitativeResult4.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.0625, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
     
@@ -357,8 +357,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult5 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
     // FIXME: this precision bound is not really good.
-    EXPECT_NEAR(4.2857, quantitativeResult5.getMin(), 100 * storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(4.2857, quantitativeResult5.getMax(), 100 * storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.2857, quantitativeResult5.getMin(), 100 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(4.2857, quantitativeResult5.getMax(), 100 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]");
     
@@ -367,6 +367,6 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult6 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
     // FIXME: this precision bound is not really good.
-    EXPECT_NEAR(4.2857, quantitativeResult6.getMin(), 100 * storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(4.2857, quantitativeResult6.getMax(), 100 * storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(4.2857, quantitativeResult6.getMin(), 100 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(4.2857, quantitativeResult6.getMax(), 100 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/functional/modelchecker/TopologicalValueIterationMdpPrctlModelCheckerTest.cpp b/test/functional/modelchecker/TopologicalValueIterationMdpPrctlModelCheckerTest.cpp
index 17b1a871a..cd3e326e3 100644
--- a/test/functional/modelchecker/TopologicalValueIterationMdpPrctlModelCheckerTest.cpp
+++ b/test/functional/modelchecker/TopologicalValueIterationMdpPrctlModelCheckerTest.cpp
@@ -32,46 +32,46 @@ TEST(TopologicalValueIterationMdpPrctlModelCheckerTest, Dice) {
 
     std::unique_ptr<storm::modelchecker::CheckResult> result = mc.check(*formula);
 
-    ASSERT_NEAR(0.0277777612209320068, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(0.0277777612209320068, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"two\"]");
 
     result = mc.check(*formula);
 
-    ASSERT_NEAR(0.0277777612209320068, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(0.0277777612209320068, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"three\"]");
 
     result = mc.check(*formula);
 
-    ASSERT_NEAR(0.0555555224418640136, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(0.0555555224418640136, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"three\"]");
 
     result = mc.check(*formula);
 
-    ASSERT_NEAR(0.0555555224418640136, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(0.0555555224418640136, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"four\"]");
 
     result = mc.check(*formula);
 
-    ASSERT_NEAR(0.083333283662796020508, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(0.083333283662796020508, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"four\"]");
 
     result = mc.check(*formula);
 
-    ASSERT_NEAR(0.083333283662796020508, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(0.083333283662796020508, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"done\"]");
 
     result = mc.check(*formula);
 
 #ifdef STORM_HAVE_CUDA
-    ASSERT_NEAR(7.333329499, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(7.333329499, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #else
-    ASSERT_NEAR(7.33332904, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(7.33332904, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #endif
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
@@ -79,9 +79,9 @@ TEST(TopologicalValueIterationMdpPrctlModelCheckerTest, Dice) {
     result = mc.check(*formula);
 
 #ifdef STORM_HAVE_CUDA
-    ASSERT_NEAR(7.333329499, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(7.333329499, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #else
-    ASSERT_NEAR(7.33333151, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(7.33333151, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #endif
 
     // ------------- state rewards --------------
@@ -94,9 +94,9 @@ TEST(TopologicalValueIterationMdpPrctlModelCheckerTest, Dice) {
     result = stateRewardModelChecker.check(*formula);
 
 #ifdef STORM_HAVE_CUDA
-    ASSERT_NEAR(7.333329499, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(7.333329499, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #else
-    ASSERT_NEAR(7.33332904, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(7.33332904, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #endif
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
@@ -104,9 +104,9 @@ TEST(TopologicalValueIterationMdpPrctlModelCheckerTest, Dice) {
     result = stateRewardModelChecker.check(*formula);
 
 #ifdef STORM_HAVE_CUDA
-    ASSERT_NEAR(7.333329499, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(7.333329499, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #else
-    ASSERT_NEAR(7.33333151, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(7.33333151, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #endif
 
     // -------------------------------- state and transition reward ------------------------
@@ -119,18 +119,18 @@ TEST(TopologicalValueIterationMdpPrctlModelCheckerTest, Dice) {
     result = stateAndTransitionRewardModelChecker.check(*formula);
 
 #ifdef STORM_HAVE_CUDA
-    ASSERT_NEAR(14.666658998, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(14.666658998, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #else
-    ASSERT_NEAR(14.6666581, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(14.6666581, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #endif
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]");
 
     result = stateAndTransitionRewardModelChecker.check(*formula);
 
 #ifdef STORM_HAVE_CUDA
-    ASSERT_NEAR(14.666658998, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(14.666658998, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #else
-    ASSERT_NEAR(14.666663, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(14.666663, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #endif
 }
 
@@ -150,34 +150,34 @@ TEST(TopologicalValueIterationMdpPrctlModelCheckerTest, AsynchronousLeader) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = mc.check(*formula);
 
     ASSERT_LT(std::abs(result->asExplicitQuantitativeCheckResult<double>()[0] - 1),
-            storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+            storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]");
 
     result = mc.check(*formula);
 
-    ASSERT_NEAR(1, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(1, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]");
 
     result = mc.check(*formula);
 
-    ASSERT_NEAR(0.0625, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(0.0625, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
 
     result = mc.check(*formula);
 
-    ASSERT_NEAR(0.0625, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(0.0625, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
 
     result = mc.check(*formula);
 
 #ifdef STORM_HAVE_CUDA
-    ASSERT_NEAR(4.285689611, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(4.285689611, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #else
-    ASSERT_NEAR(4.285701547, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(4.285701547, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #endif
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]");
@@ -185,8 +185,8 @@ TEST(TopologicalValueIterationMdpPrctlModelCheckerTest, AsynchronousLeader) {
     result = mc.check(*formula);
 
 #ifdef STORM_HAVE_CUDA
-    ASSERT_NEAR(4.285689611, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(4.285689611, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #else
-    ASSERT_NEAR(4.285703591, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(4.285703591, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 #endif
 }
diff --git a/test/functional/solver/FullySymbolicGameSolverTest.cpp b/test/functional/solver/FullySymbolicGameSolverTest.cpp
index 2cf00f1e7..d5098b5f5 100644
--- a/test/functional/solver/FullySymbolicGameSolverTest.cpp
+++ b/test/functional/solver/FullySymbolicGameSolverTest.cpp
@@ -45,25 +45,25 @@ TEST(FullySymbolicGameSolverTest, Solve_Cudd) {
     storm::dd::Add<storm::dd::DdType::CUDD> result = solver->solveGame(storm::OptimizationDirection::Minimize, storm::OptimizationDirection::Minimize, x, b);
     result *= manager->getEncoding(state.first, 1).template toAdd<double>();
     result = result.sumAbstract({state.first});
-    EXPECT_NEAR(0, result.getValue(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0, result.getValue(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     x = manager->getAddZero<double>();
     result = solver->solveGame(storm::OptimizationDirection::Minimize, storm::OptimizationDirection::Maximize, x, b);
     result *= manager->getEncoding(state.first, 1).template toAdd<double>();
     result = result.sumAbstract({state.first});
-    EXPECT_NEAR(0.5, result.getValue(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.5, result.getValue(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     x = manager->getAddZero<double>();
     result = solver->solveGame(storm::OptimizationDirection::Maximize, storm::OptimizationDirection::Minimize, x, b);
     result *= manager->getEncoding(state.first, 1).template toAdd<double>();
     result = result.sumAbstract({state.first});
-    EXPECT_NEAR(0.2, result.getValue(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.2, result.getValue(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     x = manager->getAddZero<double>();
     result = solver->solveGame(storm::OptimizationDirection::Maximize, storm::OptimizationDirection::Maximize, x, b);
     result *= manager->getEncoding(state.first, 1).template toAdd<double>();
     result = result.sumAbstract({state.first});
-    EXPECT_NEAR(0.99999892625817599, result.getValue(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.99999892625817599, result.getValue(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(FullySymbolicGameSolverTest, Solve_Sylvan) {
@@ -103,23 +103,23 @@ TEST(FullySymbolicGameSolverTest, Solve_Sylvan) {
     storm::dd::Add<storm::dd::DdType::Sylvan> result = solver->solveGame(storm::OptimizationDirection::Minimize, storm::OptimizationDirection::Minimize, x, b);
     result *= manager->getEncoding(state.first, 1).template toAdd<double>();
     result = result.sumAbstract({state.first});
-    EXPECT_NEAR(0, result.getValue(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0, result.getValue(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     x = manager->getAddZero<double>();
     result = solver->solveGame(storm::OptimizationDirection::Minimize, storm::OptimizationDirection::Maximize, x, b);
     result *= manager->getEncoding(state.first, 1).template toAdd<double>();
     result = result.sumAbstract({state.first});
-    EXPECT_NEAR(0.5, result.getValue(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.5, result.getValue(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     x = manager->getAddZero<double>();
     result = solver->solveGame(storm::OptimizationDirection::Maximize, storm::OptimizationDirection::Minimize, x, b);
     result *= manager->getEncoding(state.first, 1).template toAdd<double>();
     result = result.sumAbstract({state.first});
-    EXPECT_NEAR(0.2, result.getValue(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.2, result.getValue(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     x = manager->getAddZero<double>();
     result = solver->solveGame(storm::OptimizationDirection::Maximize, storm::OptimizationDirection::Maximize, x, b);
     result *= manager->getEncoding(state.first, 1).template toAdd<double>();
     result = result.sumAbstract({state.first});
-    EXPECT_NEAR(0.99999892625817599, result.getValue(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.99999892625817599, result.getValue(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/functional/solver/GameSolverTest.cpp b/test/functional/solver/GameSolverTest.cpp
index 7c73d90f4..f420c11f3 100644
--- a/test/functional/solver/GameSolverTest.cpp
+++ b/test/functional/solver/GameSolverTest.cpp
@@ -50,20 +50,20 @@ TEST(GameSolverTest, Solve) {
 
     // Now solve the game with different strategies for the players.
     solver->solveGame(storm::OptimizationDirection::Minimize, storm::OptimizationDirection::Minimize, result, b);
-    EXPECT_NEAR(0, result[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0, result[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     result = std::vector<double>(4);
 
     solver->solveGame(storm::OptimizationDirection::Minimize, storm::OptimizationDirection::Maximize, result, b);
-    EXPECT_NEAR(0.5, result[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.5, result[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     result = std::vector<double>(4);
 
     solver->solveGame(storm::OptimizationDirection::Maximize, storm::OptimizationDirection::Minimize, result, b);
-    EXPECT_NEAR(0.2, result[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.2, result[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     result = std::vector<double>(4);
 
     solver->solveGame(storm::OptimizationDirection::Maximize, storm::OptimizationDirection::Maximize, result, b);
-    EXPECT_NEAR(0.99999892625817599, result[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.99999892625817599, result[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/functional/solver/GlpkLpSolverTest.cpp b/test/functional/solver/GlpkLpSolverTest.cpp
index 7e8fcf075..4aea94cf7 100644
--- a/test/functional/solver/GlpkLpSolverTest.cpp
+++ b/test/functional/solver/GlpkLpSolverTest.cpp
@@ -34,16 +34,16 @@ TEST(GlpkLpSolver, LPOptimizeMax) {
     ASSERT_FALSE(solver.isInfeasible());
     double xValue = 0;
     ASSERT_NO_THROW(xValue = solver.getContinuousValue(x));
-    ASSERT_LT(std::abs(xValue - 1), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(xValue - 1), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double yValue = 0;
     ASSERT_NO_THROW(yValue = solver.getContinuousValue(y));
-    ASSERT_LT(std::abs(yValue - 6.5), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(yValue - 6.5), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double zValue = 0;
     ASSERT_NO_THROW(zValue = solver.getContinuousValue(z));
-    ASSERT_LT(std::abs(zValue - 2.75), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(zValue - 2.75), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double objectiveValue = 0;
     ASSERT_NO_THROW(objectiveValue = solver.getObjectiveValue());
-    ASSERT_LT(std::abs(objectiveValue - 14.75), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(objectiveValue - 14.75), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GlpkLpSolver, LPOptimizeMin) {
@@ -67,16 +67,16 @@ TEST(GlpkLpSolver, LPOptimizeMin) {
     ASSERT_FALSE(solver.isInfeasible());
     double xValue = 0;
     ASSERT_NO_THROW(xValue = solver.getContinuousValue(x));
-    ASSERT_LT(std::abs(xValue - 1), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(xValue - 1), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double yValue = 0;
     ASSERT_NO_THROW(yValue = solver.getContinuousValue(y));
-    ASSERT_LT(std::abs(yValue - 0), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(yValue - 0), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double zValue = 0;
     ASSERT_NO_THROW(zValue = solver.getContinuousValue(z));
-    ASSERT_LT(std::abs(zValue - 5.7), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(zValue - 5.7), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double objectiveValue = 0;
     ASSERT_NO_THROW(objectiveValue = solver.getObjectiveValue());
-    ASSERT_LT(std::abs(objectiveValue - (-6.7)), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(objectiveValue - (-6.7)), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GlpkLpSolver, MILPOptimizeMax) {
@@ -106,10 +106,10 @@ TEST(GlpkLpSolver, MILPOptimizeMax) {
     ASSERT_EQ(6, yValue);
     double zValue = 0;
     ASSERT_NO_THROW(zValue = solver.getContinuousValue(z));
-    ASSERT_LT(std::abs(zValue - 3), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(zValue - 3), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double objectiveValue = 0;
     ASSERT_NO_THROW(objectiveValue = solver.getObjectiveValue());
-    ASSERT_LT(std::abs(objectiveValue - 14), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(objectiveValue - 14), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GlpkLpSolver, MILPOptimizeMin) {
@@ -139,10 +139,10 @@ TEST(GlpkLpSolver, MILPOptimizeMin) {
     ASSERT_EQ(0, yValue);
     double zValue = 0;
     ASSERT_NO_THROW(zValue = solver.getContinuousValue(z));
-    ASSERT_LT(std::abs(zValue - 5), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(zValue - 5), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double objectiveValue = 0;
     ASSERT_NO_THROW(objectiveValue = solver.getObjectiveValue());
-    ASSERT_LT(std::abs(objectiveValue - (-6)), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(objectiveValue - (-6)), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GlpkLpSolver, LPInfeasible) {
diff --git a/test/functional/solver/GmmxxLinearEquationSolverTest.cpp b/test/functional/solver/GmmxxLinearEquationSolverTest.cpp
index 5d6ccde26..21e74fe7c 100644
--- a/test/functional/solver/GmmxxLinearEquationSolverTest.cpp
+++ b/test/functional/solver/GmmxxLinearEquationSolverTest.cpp
@@ -29,9 +29,9 @@ TEST(GmmxxLinearEquationSolver, SolveWithStandardOptions) {
     
     storm::solver::GmmxxLinearEquationSolver<double> solver(A);
     ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
-    ASSERT_LT(std::abs(x[0] - 1), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[1] - 3), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxLinearEquationSolver, gmres) {
@@ -57,9 +57,9 @@ TEST(GmmxxLinearEquationSolver, gmres) {
     
     storm::solver::GmmxxLinearEquationSolver<double> solver(A, storm::solver::GmmxxLinearEquationSolver<double>::SolutionMethod::Gmres, 1e-6, 10000, storm::solver::GmmxxLinearEquationSolver<double>::Preconditioner::None, true, 50);
     ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
-    ASSERT_LT(std::abs(x[0] - 1), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[1] - 3), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxLinearEquationSolver, qmr) {
@@ -85,9 +85,9 @@ TEST(GmmxxLinearEquationSolver, qmr) {
     
     storm::solver::GmmxxLinearEquationSolver<double> solver(A, storm::solver::GmmxxLinearEquationSolver<double>::SolutionMethod::Qmr, 1e-6, 10000, storm::solver::GmmxxLinearEquationSolver<double>::Preconditioner::None, true, 50);
     ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
-    ASSERT_LT(std::abs(x[0] - 1), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[1] - 3), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxLinearEquationSolver, bicgstab) {
@@ -113,9 +113,9 @@ TEST(GmmxxLinearEquationSolver, bicgstab) {
     
     storm::solver::GmmxxLinearEquationSolver<double> solver(A, storm::solver::GmmxxLinearEquationSolver<double>::SolutionMethod::Bicgstab, 1e-6, 10000, storm::solver::GmmxxLinearEquationSolver<double>::Preconditioner::None);
     ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
-    ASSERT_LT(std::abs(x[0] - 1), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[1] - 3), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxLinearEquationSolver, jacobi) {
@@ -141,9 +141,9 @@ TEST(GmmxxLinearEquationSolver, jacobi) {
     
     storm::solver::GmmxxLinearEquationSolver<double> solver(A, storm::solver::GmmxxLinearEquationSolver<double>::SolutionMethod::Jacobi, 1e-6, 10000, storm::solver::GmmxxLinearEquationSolver<double>::Preconditioner::None);
     ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
-    ASSERT_LT(std::abs(x[0] - 1), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[1] - 3), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxLinearEquationSolver, gmresilu) {
@@ -169,9 +169,9 @@ TEST(GmmxxLinearEquationSolver, gmresilu) {
     
     storm::solver::GmmxxLinearEquationSolver<double> solver(A, storm::solver::GmmxxLinearEquationSolver<double>::SolutionMethod::Gmres, 1e-6, 10000, storm::solver::GmmxxLinearEquationSolver<double>::Preconditioner::None, true, 50);
     ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
-    ASSERT_LT(std::abs(x[0] - 1), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[1] - 3), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxLinearEquationSolver, gmresdiag) {
@@ -197,9 +197,9 @@ TEST(GmmxxLinearEquationSolver, gmresdiag) {
     
     storm::solver::GmmxxLinearEquationSolver<double> solver(A, storm::solver::GmmxxLinearEquationSolver<double>::SolutionMethod::Gmres, 1e-6, 10000, storm::solver::GmmxxLinearEquationSolver<double>::Preconditioner::None, true, 50);
     ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
-    ASSERT_LT(std::abs(x[0] - 1), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[1] - 3), storm::settings::gmmxxEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxLinearEquationSolver, MatrixVectorMultplication) {
@@ -222,5 +222,5 @@ TEST(GmmxxLinearEquationSolver, MatrixVectorMultplication) {
     
     storm::solver::GmmxxLinearEquationSolver<double> solver(A);
     ASSERT_NO_THROW(solver.performMatrixVectorMultiplication(x, nullptr, 4));
-    ASSERT_LT(std::abs(x[0] - 1), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/functional/solver/GmmxxMinMaxLinearEquationSolverTest.cpp b/test/functional/solver/GmmxxMinMaxLinearEquationSolverTest.cpp
index 1839b1016..d28b84246 100644
--- a/test/functional/solver/GmmxxMinMaxLinearEquationSolverTest.cpp
+++ b/test/functional/solver/GmmxxMinMaxLinearEquationSolverTest.cpp
@@ -19,10 +19,10 @@ TEST(GmmxxMinMaxLinearEquationSolver, SolveWithStandardOptions) {
         
     storm::solver::GmmxxMinMaxLinearEquationSolver<double> solver(A);
     ASSERT_NO_THROW(solver.solveEquationSystem(storm::OptimizationDirection::Minimize, x, b));
-    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     ASSERT_NO_THROW(solver.solveEquationSystem(storm::OptimizationDirection::Maximize, x, b));
-    ASSERT_LT(std::abs(x[0] - 0.989991), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.989991), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 // TODO add better tests here.
@@ -42,16 +42,16 @@ TEST(GmmxxMinMaxLinearEquationSolver, SolveWithStandardOptionsAndEarlyTerminatio
     
     solver.setTerminationCondition(std::make_unique<storm::solver::TerminateIfFilteredExtremumExceedsThreshold<double>>(storm::storage::BitVector(A.getRowGroupCount(), true), bound, false, true));
     ASSERT_NO_THROW(solver.solveEquationSystem(storm::OptimizationDirection::Minimize, x, b));
-    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     ASSERT_NO_THROW(solver.solveEquationSystem(storm::OptimizationDirection::Maximize, x, b));
-    ASSERT_LT(std::abs(x[0] - 0.989991), 0.989991 - bound - storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.989991), 0.989991 - bound - storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     bound = 0.6;
     solver.setTerminationCondition(std::make_unique<storm::solver::TerminateIfFilteredExtremumExceedsThreshold<double>>(storm::storage::BitVector(A.getRowGroupCount(), true), bound, false, true));
     
     ASSERT_NO_THROW(solver.solveEquationSystem(storm::OptimizationDirection::Maximize, x, b));
-    ASSERT_LT(std::abs(x[0] - 0.989991), 0.989991 - bound - storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.989991), 0.989991 - bound - storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxMinMaxLinearEquationSolver, MatrixVectorMultiplication) {
@@ -76,23 +76,23 @@ TEST(GmmxxMinMaxLinearEquationSolver, MatrixVectorMultiplication) {
     
     storm::solver::GmmxxMinMaxLinearEquationSolver<double> solver(A);
     ASSERT_NO_THROW(solver.performMatrixVectorMultiplication(storm::OptimizationDirection::Minimize, x, nullptr, 1));
-    ASSERT_LT(std::abs(x[0] - 0.099), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.099), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     x = {0, 1, 0};
     ASSERT_NO_THROW(solver.performMatrixVectorMultiplication(storm::OptimizationDirection::Minimize, x, nullptr, 2));
-    ASSERT_LT(std::abs(x[0] - 0.1881), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.1881), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     x = {0, 1, 0};
     ASSERT_NO_THROW(solver.performMatrixVectorMultiplication(storm::OptimizationDirection::Minimize, x, nullptr, 20));
-    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     x = {0, 1, 0};
     ASSERT_NO_THROW(solver.performMatrixVectorMultiplication(storm::OptimizationDirection::Maximize, x, nullptr, 1));
-    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     x = {0, 1, 0};
     ASSERT_NO_THROW(solver.performMatrixVectorMultiplication(storm::OptimizationDirection::Maximize, x, nullptr, 20));
-    ASSERT_LT(std::abs(x[0] - 0.9238082658), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.9238082658), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmmxxMinMaxLinearEquationSolver, SolveWithPolicyIteration) {
@@ -106,11 +106,11 @@ TEST(GmmxxMinMaxLinearEquationSolver, SolveWithPolicyIteration) {
 	std::vector<double> x(1);
 	std::vector<double> b = { 0.099, 0.5 };
 
-	storm::settings::modules::GmmxxEquationSolverSettings const& settings = storm::settings::gmmxxEquationSolverSettings();
+	storm::settings::modules::GmmxxEquationSolverSettings const& settings = storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>();
 	storm::solver::GmmxxMinMaxLinearEquationSolver<double> solver(A, settings.getPrecision(), settings.getMaximalIterationCount(), storm::solver::MinMaxTechniqueSelection::PolicyIteration, settings.getConvergenceCriterion() == storm::settings::modules::GmmxxEquationSolverSettings::ConvergenceCriterion::Relative);
 	ASSERT_NO_THROW(solver.solveEquationSystem(storm::OptimizationDirection::Minimize, x, b));
-	ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+	ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 
 	ASSERT_NO_THROW(solver.solveEquationSystem(storm::OptimizationDirection::Maximize, x, b));
-	ASSERT_LT(std::abs(x[0] - 0.99), storm::settings::gmmxxEquationSolverSettings().getPrecision());
+	ASSERT_LT(std::abs(x[0] - 0.99), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/functional/solver/GurobiLpSolverTest.cpp b/test/functional/solver/GurobiLpSolverTest.cpp
index b31070d56..7b21f4fdb 100644
--- a/test/functional/solver/GurobiLpSolverTest.cpp
+++ b/test/functional/solver/GurobiLpSolverTest.cpp
@@ -31,16 +31,16 @@ TEST(GurobiLpSolver, LPOptimizeMax) {
     ASSERT_FALSE(solver.isInfeasible());
     double xValue = 0;
     ASSERT_NO_THROW(xValue = solver.getContinuousValue(x));
-    ASSERT_LT(std::abs(xValue - 1), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(xValue - 1), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double yValue = 0;
     ASSERT_NO_THROW(yValue = solver.getContinuousValue(y));
-    ASSERT_LT(std::abs(yValue - 6.5), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(yValue - 6.5), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double zValue = 0;
     ASSERT_NO_THROW(zValue = solver.getContinuousValue(z));
-    ASSERT_LT(std::abs(zValue - 2.75), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(zValue - 2.75), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double objectiveValue = 0;
     ASSERT_NO_THROW(objectiveValue = solver.getObjectiveValue());
-    ASSERT_LT(std::abs(objectiveValue - 14.75), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(objectiveValue - 14.75), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GurobiLpSolver, LPOptimizeMin) {
@@ -64,16 +64,16 @@ TEST(GurobiLpSolver, LPOptimizeMin) {
     ASSERT_FALSE(solver.isInfeasible());
     double xValue = 0;
     ASSERT_NO_THROW(xValue = solver.getContinuousValue(x));
-    ASSERT_LT(std::abs(xValue - 1), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(xValue - 1), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double yValue = 0;
     ASSERT_NO_THROW(yValue = solver.getContinuousValue(y));
-    ASSERT_LT(std::abs(yValue - 0), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(yValue - 0), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double zValue = 0;
     ASSERT_NO_THROW(zValue = solver.getContinuousValue(z));
-    ASSERT_LT(std::abs(zValue - 5.7), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(zValue - 5.7), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double objectiveValue = 0;
     ASSERT_NO_THROW(objectiveValue = solver.getObjectiveValue());
-    ASSERT_LT(std::abs(objectiveValue - (-6.7)), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(objectiveValue - (-6.7)), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GurobiLpSolver, MILPOptimizeMax) {
@@ -103,10 +103,10 @@ TEST(GurobiLpSolver, MILPOptimizeMax) {
     ASSERT_EQ(6, yValue);
     double zValue = 0;
     ASSERT_NO_THROW(zValue = solver.getContinuousValue(z));
-    ASSERT_LT(std::abs(zValue - 3), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(zValue - 3), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double objectiveValue = 0;
     ASSERT_NO_THROW(objectiveValue = solver.getObjectiveValue());
-    ASSERT_LT(std::abs(objectiveValue - 14), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(objectiveValue - 14), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GurobiLpSolver, MILPOptimizeMin) {
@@ -136,10 +136,10 @@ TEST(GurobiLpSolver, MILPOptimizeMin) {
     ASSERT_EQ(0, yValue);
     double zValue = 0;
     ASSERT_NO_THROW(zValue = solver.getContinuousValue(z));
-    ASSERT_LT(std::abs(zValue - 5), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(zValue - 5), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     double objectiveValue = 0;
     ASSERT_NO_THROW(objectiveValue = solver.getObjectiveValue());
-    ASSERT_LT(std::abs(objectiveValue - (-6)), storm::settings::generalSettings().getPrecision());
+    ASSERT_LT(std::abs(objectiveValue - (-6)), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 TEST(GurobiLpSolver, LPInfeasible) {
diff --git a/test/functional/solver/NativeLinearEquationSolverTest.cpp b/test/functional/solver/NativeLinearEquationSolverTest.cpp
index 844b0c5c9..a1313a797 100644
--- a/test/functional/solver/NativeLinearEquationSolverTest.cpp
+++ b/test/functional/solver/NativeLinearEquationSolverTest.cpp
@@ -29,9 +29,9 @@ TEST(NativeLinearEquationSolver, SolveWithStandardOptions) {
     
     storm::solver::NativeLinearEquationSolver<double> solver(A);
     ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
-    ASSERT_LT(std::abs(x[0] - 1), storm::settings::nativeEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[1] - 3), storm::settings::nativeEquationSolverSettings().getPrecision());
-    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::nativeEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(NativeLinearEquationSolver, MatrixVectorMultplication) {
@@ -54,5 +54,5 @@ TEST(NativeLinearEquationSolver, MatrixVectorMultplication) {
     
     storm::solver::NativeLinearEquationSolver<double> solver(A);
     ASSERT_NO_THROW(solver.performMatrixVectorMultiplication(x, nullptr, 4));
-    ASSERT_LT(std::abs(x[0] - 1), storm::settings::nativeEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/functional/solver/NativeMinMaxLinearEquationSolverTest.cpp b/test/functional/solver/NativeMinMaxLinearEquationSolverTest.cpp
index 6bb0e0335..07fc2a66d 100644
--- a/test/functional/solver/NativeMinMaxLinearEquationSolverTest.cpp
+++ b/test/functional/solver/NativeMinMaxLinearEquationSolverTest.cpp
@@ -20,10 +20,10 @@ TEST(NativeMinMaxLinearEquationSolver, SolveWithStandardOptions) {
         
     storm::solver::NativeMinMaxLinearEquationSolver<double> solver(A);
     ASSERT_NO_THROW(solver.solveEquationSystem(storm::OptimizationDirection::Minimize, x, b));
-    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::nativeEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     ASSERT_NO_THROW(solver.solveEquationSystem(storm::OptimizationDirection::Maximize, x, b));
-    ASSERT_LT(std::abs(x[0] - 0.989991), storm::settings::nativeEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.989991), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(NativeMinMaxLinearEquationSolver, MatrixVectorMultiplication) {
@@ -48,23 +48,23 @@ TEST(NativeMinMaxLinearEquationSolver, MatrixVectorMultiplication) {
     
     storm::solver::NativeMinMaxLinearEquationSolver<double> solver(A);
     ASSERT_NO_THROW(solver.performMatrixVectorMultiplication(storm::OptimizationDirection::Minimize, x, nullptr, 1));
-    ASSERT_LT(std::abs(x[0] - 0.099), storm::settings::nativeEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.099), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     x = {0, 1, 0};
     ASSERT_NO_THROW(solver.performMatrixVectorMultiplication(storm::OptimizationDirection::Minimize, x, nullptr, 2));
-    ASSERT_LT(std::abs(x[0] - 0.1881), storm::settings::nativeEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.1881), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     x = {0, 1, 0};
     ASSERT_NO_THROW(solver.performMatrixVectorMultiplication(storm::OptimizationDirection::Minimize, x, nullptr, 20));
-    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::nativeEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     x = {0, 1, 0};
     ASSERT_NO_THROW(solver.performMatrixVectorMultiplication(storm::OptimizationDirection::Maximize, x, nullptr, 1));
-    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::nativeEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     x = {0, 1, 0};
     ASSERT_NO_THROW(solver.performMatrixVectorMultiplication(storm::OptimizationDirection::Maximize, x, nullptr, 20));
-    ASSERT_LT(std::abs(x[0] - 0.9238082658), storm::settings::nativeEquationSolverSettings().getPrecision());
+    ASSERT_LT(std::abs(x[0] - 0.9238082658), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(NativeMinMaxLinearEquationSolver, SolveWithPolicyIteration) {
@@ -78,12 +78,12 @@ TEST(NativeMinMaxLinearEquationSolver, SolveWithPolicyIteration) {
 	std::vector<double> x(1);
 	std::vector<double> b = { 0.099, 0.5 };
 
-	storm::settings::modules::NativeEquationSolverSettings const& settings = storm::settings::nativeEquationSolverSettings();
+	storm::settings::modules::NativeEquationSolverSettings const& settings = storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>();
 	storm::solver::NativeMinMaxLinearEquationSolver<double> solver(A, settings.getPrecision(), settings.getMaximalIterationCount(), storm::solver::MinMaxTechniqueSelection::PolicyIteration, settings.getConvergenceCriterion() == storm::settings::modules::NativeEquationSolverSettings::ConvergenceCriterion::Relative);
 
 	ASSERT_NO_THROW(solver.solveEquationSystem(storm::OptimizationDirection::Minimize, x, b));
-	ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::nativeEquationSolverSettings().getPrecision());
+	ASSERT_LT(std::abs(x[0] - 0.5), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
 	ASSERT_NO_THROW(solver.solveEquationSystem(storm::OptimizationDirection::Maximize, x, b));
-	ASSERT_LT(std::abs(x[0] - 0.99), storm::settings::nativeEquationSolverSettings().getPrecision());
+	ASSERT_LT(std::abs(x[0] - 0.99), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/functional/utility/ModelInstantiatorTest.cpp b/test/functional/utility/ModelInstantiatorTest.cpp
index 9602a3e86..4bb4057e2 100644
--- a/test/functional/utility/ModelInstantiatorTest.cpp
+++ b/test/functional/utility/ModelInstantiatorTest.cpp
@@ -68,7 +68,7 @@ TEST(ModelInstantiatorTest, BrpProb) {
         storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> modelchecker(instantiated);
         std::unique_ptr<storm::modelchecker::CheckResult> chkResult = modelchecker.check(*formulas[0]);
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeChkResult = chkResult->asExplicitQuantitativeCheckResult<double>();
-        EXPECT_NEAR(0.2989278941, quantitativeChkResult[*instantiated.getInitialStates().begin()], storm::settings::generalSettings().getPrecision());
+        EXPECT_NEAR(0.2989278941, quantitativeChkResult[*instantiated.getInitialStates().begin()], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     }
     
     {
@@ -134,7 +134,7 @@ TEST(ModelInstantiatorTest, BrpProb) {
         storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> modelchecker(instantiated);
         std::unique_ptr<storm::modelchecker::CheckResult> chkResult = modelchecker.check(*formulas[0]);
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeChkResult = chkResult->asExplicitQuantitativeCheckResult<double>();
-        EXPECT_NEAR(0.01588055832, quantitativeChkResult[*instantiated.getInitialStates().begin()], storm::settings::generalSettings().getPrecision());
+        EXPECT_NEAR(0.01588055832, quantitativeChkResult[*instantiated.getInitialStates().begin()], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     }
 }
 
@@ -205,7 +205,7 @@ TEST(ModelInstantiatorTest, Brp_Rew) {
         storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> modelchecker(instantiated);
         std::unique_ptr<storm::modelchecker::CheckResult> chkResult = modelchecker.check(*formulas[0]);
         storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeChkResult = chkResult->asExplicitQuantitativeCheckResult<double>();
-        EXPECT_NEAR(1.308324495, quantitativeChkResult[*instantiated.getInitialStates().begin()], storm::settings::generalSettings().getPrecision());
+        EXPECT_NEAR(1.308324495, quantitativeChkResult[*instantiated.getInitialStates().begin()], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     }
     
 }
@@ -259,7 +259,7 @@ TEST(ModelInstantiatorTest, Consensus) {
     storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<double>> modelchecker(instantiated);
     std::unique_ptr<storm::modelchecker::CheckResult> chkResult = modelchecker.check(*formulas[0]);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeChkResult = chkResult->asExplicitQuantitativeCheckResult<double>();
-    EXPECT_NEAR(0.3526577219, quantitativeChkResult[*instantiated.getInitialStates().begin()], storm::settings::generalSettings().getPrecision());
+    EXPECT_NEAR(0.3526577219, quantitativeChkResult[*instantiated.getInitialStates().begin()], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 }
 
 #endif
\ No newline at end of file
diff --git a/test/performance/modelchecker/GmmxxDtmcPrctModelCheckerTest.cpp b/test/performance/modelchecker/GmmxxDtmcPrctModelCheckerTest.cpp
index b2a39f5dd..ae2c11e37 100644
--- a/test/performance/modelchecker/GmmxxDtmcPrctModelCheckerTest.cpp
+++ b/test/performance/modelchecker/GmmxxDtmcPrctModelCheckerTest.cpp
@@ -28,7 +28,7 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, Crowds) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*eventuallyFormula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
 
-    EXPECT_NEAR(0.2296800237, quantitativeResult1[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.2296800237, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 
     labelFormula = std::make_shared<storm::logic::AtomicLabelFormula>("observeIGreater1");
     eventuallyFormula = std::make_shared<storm::logic::EventuallyFormula>(labelFormula);
@@ -36,7 +36,7 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, Crowds) {
     result = checker.check(*eventuallyFormula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(0.05073232193, quantitativeResult2[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(0.05073232193, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 
     labelFormula = std::make_shared<storm::logic::AtomicLabelFormula>("observeOnlyTrueSender");
     eventuallyFormula = std::make_shared<storm::logic::EventuallyFormula>(labelFormula);
@@ -44,7 +44,7 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, Crowds) {
     result = checker.check(*eventuallyFormula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(0.22742171078, quantitativeResult3[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(0.22742171078, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 
@@ -66,7 +66,7 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, SynchronousLeader) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*eventuallyFormula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 
     labelFormula = std::make_shared<storm::logic::AtomicLabelFormula>("elected");
     auto trueFormula = std::make_shared<storm::logic::BooleanLiteralFormula>(true);
@@ -75,7 +75,7 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, SynchronousLeader) {
     result = checker.check(*boundedUntilFormula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(0.9993949793, quantitativeResult2[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(0.9993949793, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 
     labelFormula = std::make_shared<storm::logic::AtomicLabelFormula>("elected");
     auto reachabilityRewardFormula = std::make_shared<storm::logic::EventuallyFormula>(labelFormula, storm::logic::FormulaContext::Reward);
@@ -83,5 +83,5 @@ TEST(GmmxxDtmcPrctlModelCheckerTest, SynchronousLeader) {
     result = checker.check(*reachabilityRewardFormula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(1.025106273, quantitativeResult3[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(1.025106273, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
diff --git a/test/performance/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp b/test/performance/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp
index daf041ec7..7b712d94c 100644
--- a/test/performance/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp
+++ b/test/performance/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp
@@ -31,42 +31,42 @@ TEST(GmxxMdpPrctlModelCheckerTest, AsynchronousLeader) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.0, quantitativeResult3[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.0, quantitativeResult4[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(6.172433512, quantitativeResult5[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(6.172433512, quantitativeResult5[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult6 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(6.1724344, quantitativeResult6[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(6.1724344, quantitativeResult6[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(GmxxMdpPrctlModelCheckerTest, Consensus) {
@@ -89,54 +89,54 @@ TEST(GmxxMdpPrctlModelCheckerTest, Consensus) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"finished\" & \"all_coins_equal_0\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.4374282832, quantitativeResult2[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.4374282832, quantitativeResult2[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"finished\" & \"all_coins_equal_1\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.5293286369, quantitativeResult3[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.5293286369, quantitativeResult3[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"finished\" & !\"agree\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.10414097, quantitativeResult4[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.10414097, quantitativeResult4[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=50 \"finished\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.0, quantitativeResult5[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0, quantitativeResult5[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=50 \"finished\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult6 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.0, quantitativeResult6[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.0, quantitativeResult6[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"finished\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult7 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(1725.593313, quantitativeResult7[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1725.593313, quantitativeResult7[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"finished\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult8 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(2183.142422, quantitativeResult8[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(2183.142422, quantitativeResult8[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
diff --git a/test/performance/modelchecker/NativeDtmcPrctlModelCheckerTest.cpp b/test/performance/modelchecker/NativeDtmcPrctlModelCheckerTest.cpp
index 23949131a..98c8a501d 100644
--- a/test/performance/modelchecker/NativeDtmcPrctlModelCheckerTest.cpp
+++ b/test/performance/modelchecker/NativeDtmcPrctlModelCheckerTest.cpp
@@ -29,7 +29,7 @@ TEST(NativeDtmcPrctlModelCheckerTest, Crowds) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*eventuallyFormula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.22968140721646868, quantitativeResult1[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.22968140721646868, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     labelFormula = std::make_shared<storm::logic::AtomicLabelFormula>("observeIGreater1");
     eventuallyFormula = std::make_shared<storm::logic::EventuallyFormula>(labelFormula);
@@ -37,7 +37,7 @@ TEST(NativeDtmcPrctlModelCheckerTest, Crowds) {
     result = checker.check(*eventuallyFormula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.05073232193, quantitativeResult2[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.05073232193, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     labelFormula = std::make_shared<storm::logic::AtomicLabelFormula>("observeOnlyTrueSender");
     eventuallyFormula = std::make_shared<storm::logic::EventuallyFormula>(labelFormula);
@@ -45,7 +45,7 @@ TEST(NativeDtmcPrctlModelCheckerTest, Crowds) {
     result = checker.check(*eventuallyFormula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.22742305378217331, quantitativeResult3[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.22742305378217331, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
 
 
@@ -67,7 +67,7 @@ TEST(NativeDtmcPrctlModelCheckerTest, SynchronousLeader) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*eventuallyFormula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     labelFormula = std::make_shared<storm::logic::AtomicLabelFormula>("elected");
     auto trueFormula = std::make_shared<storm::logic::BooleanLiteralFormula>(true);
@@ -76,7 +76,7 @@ TEST(NativeDtmcPrctlModelCheckerTest, SynchronousLeader) {
     result = checker.check(*boundedUntilFormula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(0.9993949793, quantitativeResult2[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.9993949793, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
     
     labelFormula = std::make_shared<storm::logic::AtomicLabelFormula>("elected");
     auto reachabilityRewardFormula = std::make_shared<storm::logic::EventuallyFormula>(labelFormula, storm::logic::FormulaContext::Reward);
@@ -84,5 +84,5 @@ TEST(NativeDtmcPrctlModelCheckerTest, SynchronousLeader) {
     result = checker.check(*reachabilityRewardFormula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(1.0252174454896057, quantitativeResult3[0], storm::settings::gmmxxEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0252174454896057, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision());
 }
diff --git a/test/performance/modelchecker/NativeMdpPrctlModelCheckerTest.cpp b/test/performance/modelchecker/NativeMdpPrctlModelCheckerTest.cpp
index f55a45d07..4c6b9569e 100644
--- a/test/performance/modelchecker/NativeMdpPrctlModelCheckerTest.cpp
+++ b/test/performance/modelchecker/NativeMdpPrctlModelCheckerTest.cpp
@@ -32,42 +32,42 @@ TEST(SparseMdpPrctlModelCheckerTest, AsynchronousLeader) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
 
-	EXPECT_NEAR(1.0, quantitativeResult2[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(1.0, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(0.0, quantitativeResult3[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(0.0, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(0.0, quantitativeResult4[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(0.0, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>();
 
-	EXPECT_NEAR(6.172433512, quantitativeResult5[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(6.172433512, quantitativeResult5[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult6 = result->asExplicitQuantitativeCheckResult<double>();
 
-	EXPECT_NEAR(6.1724344, quantitativeResult6[0], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(6.1724344, quantitativeResult6[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SparseMdpPrctlModelCheckerTest, Consensus) {
@@ -90,54 +90,54 @@ TEST(SparseMdpPrctlModelCheckerTest, Consensus) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(1.0, quantitativeResult1[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(1.0, quantitativeResult1[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"finished\" & \"all_coins_equal_0\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(0.4374282832, quantitativeResult2[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(0.4374282832, quantitativeResult2[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"finished\" & \"all_coins_equal_1\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(0.5293286369, quantitativeResult3[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(0.5293286369, quantitativeResult3[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"finished\" & !\"agree\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(0.10414097, quantitativeResult4[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(0.10414097, quantitativeResult4[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=50 \"finished\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(0.0, quantitativeResult5[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(0.0, quantitativeResult5[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=50 \"finished\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult6 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(0.0, quantitativeResult6[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(0.0, quantitativeResult6[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"finished\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult7 = result->asExplicitQuantitativeCheckResult<double>();
     
-	EXPECT_NEAR(1725.593313, quantitativeResult7[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(1725.593313, quantitativeResult7[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"finished\"]");
     
     result = checker.check(*formula);
     storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeResult8 = result->asExplicitQuantitativeCheckResult<double>();
 
-	EXPECT_NEAR(2183.142422, quantitativeResult8[31168], storm::settings::nativeEquationSolverSettings().getPrecision());
+	EXPECT_NEAR(2183.142422, quantitativeResult8[31168], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
diff --git a/test/performance/modelchecker/SymbolicDtmcPrctlModelCheckerTest.cpp b/test/performance/modelchecker/SymbolicDtmcPrctlModelCheckerTest.cpp
index b9f90f3b8..8674a28b5 100644
--- a/test/performance/modelchecker/SymbolicDtmcPrctlModelCheckerTest.cpp
+++ b/test/performance/modelchecker/SymbolicDtmcPrctlModelCheckerTest.cpp
@@ -47,8 +47,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]");
     
@@ -56,8 +56,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.9999947917094687, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.9999947917094687, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.9999947917094687, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.9999947917094687, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]");
     
@@ -65,8 +65,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1.0176397951004841, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0176397951004841, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0176397951004841, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0176397951004841, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
@@ -99,8 +99,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]");
     
@@ -108,8 +108,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.9999947917094687, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.9999947917094687, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.9999947917094687, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.9999947917094687, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]");
     
@@ -117,8 +117,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1.0176397951004841, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1.0176397951004841, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1.0176397951004841, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1.0176397951004841, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Cudd) {
@@ -143,8 +143,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.24084538502812078, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.24084538502812078, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.24084538502812078, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.24084538502812078, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]");
     
@@ -152,8 +152,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.065569806085001583, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.065569806085001583, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.065569806085001583, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.065569806085001583, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]");
     
@@ -161,8 +161,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.23773283919051694, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.23773283919051694, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.23773283919051694, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.23773283919051694, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
@@ -187,8 +187,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.24084538502812078, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.24084538502812078, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.24084538502812078, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.24084538502812078, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]");
     
@@ -196,8 +196,8 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.065569806085001583, quantitativeResult2.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.065569806085001583, quantitativeResult2.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.065569806085001583, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.065569806085001583, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]");
     
@@ -205,6 +205,6 @@ TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.23773283919051694, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.23773283919051694, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.23773283919051694, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.23773283919051694, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/performance/modelchecker/SymbolicMdpPrctlModelCheckerTest.cpp b/test/performance/modelchecker/SymbolicMdpPrctlModelCheckerTest.cpp
index fec7389c9..2fb68e01a 100644
--- a/test/performance/modelchecker/SymbolicMdpPrctlModelCheckerTest.cpp
+++ b/test/performance/modelchecker/SymbolicMdpPrctlModelCheckerTest.cpp
@@ -47,8 +47,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
     
@@ -56,8 +56,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
     
@@ -65,8 +65,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult5 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(5.0348834996352601, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(5.0348834996352601, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(5.0348834996352601, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(5.0348834996352601, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
@@ -99,8 +99,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
     
@@ -108,8 +108,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
     
@@ -117,8 +117,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, AsynchronousLeader_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult5 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(5.034920501133386, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(5.034920501133386, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(5.034920501133386, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(5.034920501133386, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicMdpPrctlModelCheckerTest, CSMA_Cudd) {
@@ -155,8 +155,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, CSMA_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(0.4349662650631545, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.4349662650631545, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.4349662650631545, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.4349662650631545, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [ F (min_backoff_after_success < 4) ]");
     formula = formula->substitute(translatedProgram.getConstantsSubstitution());
@@ -165,8 +165,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, CSMA_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(1, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [ F \"all_delivered\" ]");
     
@@ -174,8 +174,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, CSMA_Cudd) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult5 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>();
     
-    EXPECT_NEAR(93.624085091252454, quantitativeResult5.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(93.624085091252454, quantitativeResult5.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(93.624085091252454, quantitativeResult5.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(93.624085091252454, quantitativeResult5.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
 
 TEST(SymbolicMdpPrctlModelCheckerTest, CSMA_Sylvan) {
@@ -212,8 +212,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, CSMA_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(0.4349666248753522, quantitativeResult1.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0.4349666248753522, quantitativeResult1.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(0.4349666248753522, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0.4349666248753522, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [ F (min_backoff_after_success < 4) ]");
     formula = formula->substitute(translatedProgram.getConstantsSubstitution());
@@ -222,8 +222,8 @@ TEST(SymbolicMdpPrctlModelCheckerTest, CSMA_Sylvan) {
     result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates()));
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
-    EXPECT_NEAR(1, quantitativeResult3.getMin(), storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1, quantitativeResult3.getMax(), storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [ F \"all_delivered\" ]");
     
@@ -232,6 +232,6 @@ TEST(SymbolicMdpPrctlModelCheckerTest, CSMA_Sylvan) {
     storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult5 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     
     // FIXME: not optimal precision.
-    EXPECT_NEAR(93.624117712294478, quantitativeResult5.getMin(), 100 * storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(93.624117712294478, quantitativeResult5.getMax(), 100 * storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(93.624117712294478, quantitativeResult5.getMin(), 100 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(93.624117712294478, quantitativeResult5.getMax(), 100 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
 }
\ No newline at end of file
diff --git a/test/performance/modelchecker/TopologicalValueIterationMdpPrctlModelCheckerTest.cpp b/test/performance/modelchecker/TopologicalValueIterationMdpPrctlModelCheckerTest.cpp
index 578e04f42..cab5d40d1 100644
--- a/test/performance/modelchecker/TopologicalValueIterationMdpPrctlModelCheckerTest.cpp
+++ b/test/performance/modelchecker/TopologicalValueIterationMdpPrctlModelCheckerTest.cpp
@@ -26,33 +26,33 @@ TEST(DISABLED_TopologicalValueIterationMdpPrctlModelCheckerTest, AsynchronousLea
     
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
 
-	ASSERT_NEAR(1.0, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+	ASSERT_NEAR(1.0, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]");
     
     result = checker.check(*formula);
-    ASSERT_NEAR(1.0, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(1.0, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]");
     
     result = checker.check(*formula);
 
-	ASSERT_NEAR(0.0, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+	ASSERT_NEAR(0.0, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]");
     
     result = checker.check(*formula);
-	ASSERT_NEAR(0.0, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+	ASSERT_NEAR(0.0, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]");
     
     result = checker.check(*formula);
-	ASSERT_NEAR(6.172433512, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+	ASSERT_NEAR(6.172433512, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]");
     
     result = checker.check(*formula);
-	ASSERT_NEAR(6.1724344, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+	ASSERT_NEAR(6.1724344, result->asExplicitQuantitativeCheckResult<double>()[0], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 }
 
 TEST(DISABLED_TopologicalValueIterationMdpPrctlModelCheckerTest, Consensus) {
@@ -73,40 +73,40 @@ TEST(DISABLED_TopologicalValueIterationMdpPrctlModelCheckerTest, Consensus) {
     
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula);
     
-	ASSERT_NEAR(1.0, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+	ASSERT_NEAR(1.0, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"finished\" & \"all_coins_equal_0\"]");
     
     result = checker.check(*formula);
-    ASSERT_NEAR(0.4374282832, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(0.4374282832, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"finished\" & \"all_coins_equal_1\"]");
     
     result = checker.check(*formula);
-	ASSERT_NEAR(0.5293286369, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+	ASSERT_NEAR(0.5293286369, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"finished\" & !\"agree\"]");
     
     result = checker.check(*formula);
-	ASSERT_NEAR(0.10414097, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+	ASSERT_NEAR(0.10414097, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=50 \"finished\"]");
     
     result = checker.check(*formula);    
-	ASSERT_NEAR(0.0, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+	ASSERT_NEAR(0.0, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=50 \"finished\"]");
     
     result = checker.check(*formula);
-    ASSERT_NEAR(0.0, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(0.0, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 
     formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"finished\"]");
     
     result = checker.check(*formula);
-    ASSERT_NEAR(1725.593313, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(1725.593313, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
     
     formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"finished\"\"]");
     
     result = checker.check(*formula);
-    ASSERT_NEAR(2183.142422, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::topologicalValueIterationEquationSolverSettings().getPrecision());
+    ASSERT_NEAR(2183.142422, result->asExplicitQuantitativeCheckResult<double>()[31168], storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision());
 }
\ No newline at end of file

From 8241df3b0bf9f83dfe3794e1795d3f7b43bafc56 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 21 Mar 2016 14:48:59 +0100
Subject: [PATCH 231/246] First step towards settings for multiple binaries

Former-commit-id: 028599d43d10be129ea2f93ec4abd425fb0a96d1
---
 src/CMakeLists.txt               |  2 +-
 src/cli/cli.cpp                  |  6 ++---
 src/cli/cli.h                    | 27 ++++++++++----------
 src/settings/SettingsManager.cpp | 22 +++++-----------
 src/settings/SettingsManager.h   | 10 ++++++++
 src/storm.cpp                    | 44 +++++++++++++++++++++++++++++++-
 6 files changed, 77 insertions(+), 34 deletions(-)

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index bde12ab44..c70bd136f 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -56,7 +56,7 @@ list(REMOVE_ITEM STORM_LIB_SOURCES ${STORM_SOURCES_CLI})
 set(STORM_LIB_HEADERS ${STORM_HEADERS})
 list(REMOVE_ITEM STORM_LIB_HEADERS ${STORM_HEADERS_CLI})
 set(STORM_MAIN_SOURCES ${STORM_SOURCES_CLI} ${STORM_MAIN_FILE})
-set(STORM_DFT_MAIN_SOURCES ${STORM_DFT_MAIN_FILE})
+set(STORM_DFT_MAIN_SOURCES ${STORM_SOURCES_CLI} ${STORM_DFT_MAIN_FILE})
 set(STORM_MAIN_HEADERS ${STORM_HEADERS_CLI})
 
 # Group the headers and sources
diff --git a/src/cli/cli.cpp b/src/cli/cli.cpp
index 08ebd74fc..6b517e410 100644
--- a/src/cli/cli.cpp
+++ b/src/cli/cli.cpp
@@ -41,9 +41,9 @@ namespace storm {
                 return (GetCurrentDir(temp, 512 - 1) ? std::string(temp) : std::string(""));
             }
             
-            void printHeader(const int argc, const char* argv[]) {
-                 std::cout << "StoRM" << std::endl;
-                std::cout << "--------" << std::endl << std::endl;
+            void printHeader(const std::string name, const int argc, const char* argv[]) {
+                std::cout << name << std::endl;
+                std::cout << "---------------" << std::endl << std::endl;
                 
                 
                 std::cout << storm::utility::StormVersion::longVersionString() << std::endl;
diff --git a/src/cli/cli.h b/src/cli/cli.h
index 896b7bee2..db2ab11bf 100644
--- a/src/cli/cli.h
+++ b/src/cli/cli.h
@@ -6,23 +6,22 @@
 namespace storm {
     namespace cli {
             
-            std::string getCurrentWorkingDirectory();
+        std::string getCurrentWorkingDirectory();
             
-            void printHeader(const int argc, const char* argv[]);
+        void printHeader(std::string name, const int argc, const char* argv[]);
             
-            void printUsage();
+        void printUsage();
+        
+        /*!
+         * Parses the given command line arguments.
+         *
+         * @param argc The argc argument of main().
+         * @param argv The argv argument of main().
+         * @return True iff the program should continue to run after parsing the options.
+         */
+        bool parseOptions(const int argc, const char* argv[]);
             
-            /*!
-             * Parses the given command line arguments.
-             *
-             * @param argc The argc argument of main().
-             * @param argv The argv argument of main().
-             * @return True iff the program should continue to run after parsing the options.
-             */
-            bool parseOptions(const int argc, const char* argv[]);
-         
-            
-            void processOptions();
+        void processOptions();
     }
 }
 
diff --git a/src/settings/SettingsManager.cpp b/src/settings/SettingsManager.cpp
index a7dc0d029..97209c43d 100644
--- a/src/settings/SettingsManager.cpp
+++ b/src/settings/SettingsManager.cpp
@@ -34,20 +34,6 @@ namespace storm {
     namespace settings {
         
         SettingsManager::SettingsManager() : modules(), longNameToOptions(), shortNameToOptions(), moduleOptions() {
-            // Register all known settings modules.
-            storm::settings::addModule<storm::settings::modules::GeneralSettings>();
-            storm::settings::addModule<storm::settings::modules::DebugSettings>();
-            storm::settings::addModule<storm::settings::modules::CounterexampleGeneratorSettings>();
-            storm::settings::addModule<storm::settings::modules::CuddSettings>();
-            storm::settings::addModule<storm::settings::modules::SylvanSettings>();
-            storm::settings::addModule<storm::settings::modules::GmmxxEquationSolverSettings>();
-            storm::settings::addModule<storm::settings::modules::NativeEquationSolverSettings>();
-            storm::settings::addModule<storm::settings::modules::BisimulationSettings>();
-            storm::settings::addModule<storm::settings::modules::GlpkSettings>();
-            storm::settings::addModule<storm::settings::modules::GurobiSettings>();
-            storm::settings::addModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>();
-            storm::settings::addModule<storm::settings::modules::ParametricSettings>();
-            storm::settings::addModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>();
         }
         
         SettingsManager::~SettingsManager() {
@@ -59,6 +45,12 @@ namespace storm {
             return settingsManager;
         }
         
+        void SettingsManager::setName(std::string const& name, std::string const& executableName) {
+            this->name = name;
+            this->executableName = executableName;
+        }
+
+        
         void SettingsManager::setFromCommandLine(int const argc, char const * const argv[]) {
             // We convert the arguments to a vector of strings and strip off the first element since it refers to the
             // name of the program.
@@ -169,7 +161,7 @@ namespace storm {
         }
         
         void SettingsManager::printHelp(std::string const& hint) const {
-            STORM_PRINT("usage: storm [options]" << std::endl << std::endl);
+            STORM_PRINT("usage: " << executableName << " [options]" << std::endl << std::endl);
             
             if (hint == "all") {
                 // Find longest option name.
diff --git a/src/settings/SettingsManager.h b/src/settings/SettingsManager.h
index 92dc83cf1..5fe7c82dc 100644
--- a/src/settings/SettingsManager.h
+++ b/src/settings/SettingsManager.h
@@ -102,6 +102,12 @@ namespace storm {
              * @return The only existing instance of a settings manager
              */
             static SettingsManager& manager();
+            /*!
+             * Sets the name of the tool.
+             * @param name Name of the tool.
+             * @param executableName Filename of the executable.
+             */
+            void setName(std::string const& name, std::string const& executableName);
             
             /*!
              * Adds a new module with the given name. If the module could not be successfully added, an exception is
@@ -139,6 +145,10 @@ namespace storm {
 			 */
 			virtual ~SettingsManager();
             
+            // The name of the tool
+            std::string name;
+            std::string executableName;
+            
             // The registered modules.
             std::vector<std::string> moduleNames;
             std::unordered_map<std::string, std::unique_ptr<modules::ModuleSettings>> modules;
diff --git a/src/storm.cpp b/src/storm.cpp
index 3b060120b..b665d48a6 100644
--- a/src/storm.cpp
+++ b/src/storm.cpp
@@ -3,13 +3,55 @@
 #include "src/utility/macros.h"
 #include "src/cli/cli.h"
 #include "src/utility/initialize.h"
+
+#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/DebugSettings.h"
+#include "src/settings/modules/CounterexampleGeneratorSettings.h"
+#include "src/settings/modules/CuddSettings.h"
+#include "src/settings/modules/SylvanSettings.h"
+#include "src/settings/modules/GmmxxEquationSolverSettings.h"
+#include "src/settings/modules/NativeEquationSolverSettings.h"
+#include "src/settings/modules/BisimulationSettings.h"
+#include "src/settings/modules/GlpkSettings.h"
+#include "src/settings/modules/GurobiSettings.h"
+#include "src/settings/modules/TopologicalValueIterationEquationSolverSettings.h"
+#include "src/settings/modules/ParametricSettings.h"
+#include "src/settings/modules/SparseDtmcEliminationModelCheckerSettings.h"
+
+
+/*!
+ * Initialize the settings manager.
+ */
+void initializeSettings() {
+    storm::settings::mutableManager().setName("SToRM", "storm");
+    
+    // Register all known settings modules.
+    storm::settings::addModule<storm::settings::modules::GeneralSettings>();
+    storm::settings::addModule<storm::settings::modules::DebugSettings>();
+    storm::settings::addModule<storm::settings::modules::CounterexampleGeneratorSettings>();
+    storm::settings::addModule<storm::settings::modules::CuddSettings>();
+    storm::settings::addModule<storm::settings::modules::SylvanSettings>();
+    storm::settings::addModule<storm::settings::modules::GmmxxEquationSolverSettings>();
+    storm::settings::addModule<storm::settings::modules::NativeEquationSolverSettings>();
+    storm::settings::addModule<storm::settings::modules::BisimulationSettings>();
+    storm::settings::addModule<storm::settings::modules::GlpkSettings>();
+    storm::settings::addModule<storm::settings::modules::GurobiSettings>();
+    storm::settings::addModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>();
+    storm::settings::addModule<storm::settings::modules::ParametricSettings>();
+    storm::settings::addModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>();
+}
+
+
+
 /*!
  * Main entry point of the executable storm.
  */
 int main(const int argc, const char** argv) {
+
     try {
         storm::utility::setUp();
-        storm::cli::printHeader(argc, argv);
+        storm::cli::printHeader("SToRM", argc, argv);
+        initializeSettings();
         bool optionsCorrect = storm::cli::parseOptions(argc, argv);
         if (!optionsCorrect) {
             return -1;

From f48d8bc6b135099061b77a94211ab8955697b824 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Mon, 21 Mar 2016 15:12:34 +0100
Subject: [PATCH 232/246] Initialize all modules in tests and normal storm

Former-commit-id: 249a702d667f97a6a6776369d6a18d12fb8fd572
---
 src/settings/SettingsManager.cpp             | 19 +++++++++
 src/settings/SettingsManager.h               |  8 ++++
 src/storm.cpp                                | 41 +-------------------
 test/functional/storm-functional-tests.cpp   |  1 +
 test/performance/storm-performance-tests.cpp |  1 +
 5 files changed, 31 insertions(+), 39 deletions(-)

diff --git a/src/settings/SettingsManager.cpp b/src/settings/SettingsManager.cpp
index 97209c43d..bb1883209 100644
--- a/src/settings/SettingsManager.cpp
+++ b/src/settings/SettingsManager.cpp
@@ -488,5 +488,24 @@ namespace storm {
             return dynamic_cast<storm::settings::modules::GeneralSettings&>(mutableManager().getModule(storm::settings::modules::GeneralSettings::moduleName));
         }
         
+        void initializeAll(std::string const& name, std::string const& executableName) {
+            storm::settings::mutableManager().setName(name, executableName);
+            
+            // Register all known settings modules.
+            storm::settings::addModule<storm::settings::modules::GeneralSettings>();
+            storm::settings::addModule<storm::settings::modules::DebugSettings>();
+            storm::settings::addModule<storm::settings::modules::CounterexampleGeneratorSettings>();
+            storm::settings::addModule<storm::settings::modules::CuddSettings>();
+            storm::settings::addModule<storm::settings::modules::SylvanSettings>();
+            storm::settings::addModule<storm::settings::modules::GmmxxEquationSolverSettings>();
+            storm::settings::addModule<storm::settings::modules::NativeEquationSolverSettings>();
+            storm::settings::addModule<storm::settings::modules::BisimulationSettings>();
+            storm::settings::addModule<storm::settings::modules::GlpkSettings>();
+            storm::settings::addModule<storm::settings::modules::GurobiSettings>();
+            storm::settings::addModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>();
+            storm::settings::addModule<storm::settings::modules::ParametricSettings>();
+            storm::settings::addModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>();
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/settings/SettingsManager.h b/src/settings/SettingsManager.h
index 5fe7c82dc..69d91899f 100644
--- a/src/settings/SettingsManager.h
+++ b/src/settings/SettingsManager.h
@@ -102,6 +102,7 @@ namespace storm {
              * @return The only existing instance of a settings manager
              */
             static SettingsManager& manager();
+            
             /*!
              * Sets the name of the tool.
              * @param name Name of the tool.
@@ -257,6 +258,13 @@ namespace storm {
             mutableManager().addModule(std::unique_ptr<modules::ModuleSettings>(new SettingsType()));
         }
         
+        /*!
+         * Initialize the settings manager with all available modules.
+         * @param name Name of the tool.
+         * @param executableName Filename of the executable.
+         */
+        void initializeAll(std::string const& name, std::string const& executableName);
+        
         /*!
          * Get module. The type of the module is given as a template argument.
          *
diff --git a/src/storm.cpp b/src/storm.cpp
index b665d48a6..464dda56f 100644
--- a/src/storm.cpp
+++ b/src/storm.cpp
@@ -4,44 +4,7 @@
 #include "src/cli/cli.h"
 #include "src/utility/initialize.h"
 
-#include "src/settings/modules/GeneralSettings.h"
-#include "src/settings/modules/DebugSettings.h"
-#include "src/settings/modules/CounterexampleGeneratorSettings.h"
-#include "src/settings/modules/CuddSettings.h"
-#include "src/settings/modules/SylvanSettings.h"
-#include "src/settings/modules/GmmxxEquationSolverSettings.h"
-#include "src/settings/modules/NativeEquationSolverSettings.h"
-#include "src/settings/modules/BisimulationSettings.h"
-#include "src/settings/modules/GlpkSettings.h"
-#include "src/settings/modules/GurobiSettings.h"
-#include "src/settings/modules/TopologicalValueIterationEquationSolverSettings.h"
-#include "src/settings/modules/ParametricSettings.h"
-#include "src/settings/modules/SparseDtmcEliminationModelCheckerSettings.h"
-
-
-/*!
- * Initialize the settings manager.
- */
-void initializeSettings() {
-    storm::settings::mutableManager().setName("SToRM", "storm");
-    
-    // Register all known settings modules.
-    storm::settings::addModule<storm::settings::modules::GeneralSettings>();
-    storm::settings::addModule<storm::settings::modules::DebugSettings>();
-    storm::settings::addModule<storm::settings::modules::CounterexampleGeneratorSettings>();
-    storm::settings::addModule<storm::settings::modules::CuddSettings>();
-    storm::settings::addModule<storm::settings::modules::SylvanSettings>();
-    storm::settings::addModule<storm::settings::modules::GmmxxEquationSolverSettings>();
-    storm::settings::addModule<storm::settings::modules::NativeEquationSolverSettings>();
-    storm::settings::addModule<storm::settings::modules::BisimulationSettings>();
-    storm::settings::addModule<storm::settings::modules::GlpkSettings>();
-    storm::settings::addModule<storm::settings::modules::GurobiSettings>();
-    storm::settings::addModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>();
-    storm::settings::addModule<storm::settings::modules::ParametricSettings>();
-    storm::settings::addModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>();
-}
-
-
+#include "src/settings/SettingsManager.h"
 
 /*!
  * Main entry point of the executable storm.
@@ -51,7 +14,7 @@ int main(const int argc, const char** argv) {
     try {
         storm::utility::setUp();
         storm::cli::printHeader("SToRM", argc, argv);
-        initializeSettings();
+        storm::settings::initializeAll("SToRM", "storm");
         bool optionsCorrect = storm::cli::parseOptions(argc, argv);
         if (!optionsCorrect) {
             return -1;
diff --git a/test/functional/storm-functional-tests.cpp b/test/functional/storm-functional-tests.cpp
index e206561e0..47c802bfc 100644
--- a/test/functional/storm-functional-tests.cpp
+++ b/test/functional/storm-functional-tests.cpp
@@ -38,6 +38,7 @@ void setUpLogging() {
 
 int main(int argc, char* argv[]) {
 	setUpLogging();
+	storm::settings::initializeAll("StoRM (Functional) Testing Suite", "storm-functional-tests");
 	std::cout << "StoRM (Functional) Testing Suite" << std::endl;
 	
 	testing::InitGoogleTest(&argc, argv);
diff --git a/test/performance/storm-performance-tests.cpp b/test/performance/storm-performance-tests.cpp
index 3291d6823..36414410b 100644
--- a/test/performance/storm-performance-tests.cpp
+++ b/test/performance/storm-performance-tests.cpp
@@ -36,6 +36,7 @@ void setUpLogging() {
 
 int main(int argc, char* argv[]) {
 	setUpLogging();
+	storm::settings::initializeAll("StoRM (Performance) Testing Suite", "storm-performance-tests");
 	std::cout << "StoRM (Performance) Testing Suite" << std::endl;
 	
 	testing::InitGoogleTest(&argc, argv);

From effadc5cca878beab2cd9749c415a3380396706f Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 22 Mar 2016 13:31:09 +0100
Subject: [PATCH 233/246] Split into general settings and markov chain settings

Former-commit-id: 619a2e36227e957df81b5aeeca911f6dbd307041
---
 src/builder/DdPrismModelBuilder.cpp           |   4 +-
 src/builder/ExplicitPrismModelBuilder.cpp     |  10 +-
 src/cli/cli.cpp                               |   8 +-
 src/cli/entrypoints.h                         |  14 +-
 .../SMTMinimalCommandSetGenerator.h           |   4 +-
 .../SparseDtmcEliminationModelChecker.cpp     |   4 +-
 .../DeterministicSparseTransitionParser.cpp   |   4 +-
 .../MarkovAutomatonSparseTransitionParser.cpp |   6 +-
 ...NondeterministicSparseTransitionParser.cpp |   4 +-
 src/settings/SettingsManager.cpp              |   8 +-
 src/settings/SettingsManager.h                |  22 +-
 .../CounterexampleGeneratorSettings.cpp       |   4 +-
 src/settings/modules/GeneralSettings.cpp      | 270 --------------
 src/settings/modules/GeneralSettings.h        | 295 +---------------
 src/settings/modules/GlpkSettings.cpp         |   6 +-
 .../modules/GmmxxEquationSolverSettings.cpp   |   6 +-
 src/settings/modules/GurobiSettings.cpp       |   6 +-
 src/settings/modules/MarkovChainSettings.cpp  | 302 ++++++++++++++++
 src/settings/modules/MarkovChainSettings.h    | 332 ++++++++++++++++++
 .../modules/NativeEquationSolverSettings.cpp  |   6 +-
 src/solver/MinMaxLinearEquationSolver.cpp     |   4 +-
 .../TopologicalMinMaxLinearEquationSolver.cpp |   4 +-
 .../BisimulationDecomposition.cpp             |   4 +-
 src/storage/prism/Program.cpp                 |   6 +-
 src/utility/solver.cpp                        |  12 +-
 src/utility/storm.h                           |  23 +-
 .../builder/DdPrismModelBuilderTest.cpp       |   8 +-
 .../builder/ExplicitPrismModelBuilderTest.cpp |   6 +-
 .../GmmxxCtmcCslModelCheckerTest.cpp          |  11 +-
 .../GmmxxHybridCtmcCslModelCheckerTest.cpp    |  21 +-
 .../NativeCtmcCslModelCheckerTest.cpp         |  11 +-
 .../NativeHybridCtmcCslModelCheckerTest.cpp   |  21 +-
 ...eterministicSparseTransitionParserTest.cpp |   6 +-
 ...kovAutomatonSparseTransitionParserTest.cpp |   6 +-
 ...eterministicSparseTransitionParserTest.cpp |   6 +-
 35 files changed, 765 insertions(+), 699 deletions(-)
 create mode 100644 src/settings/modules/MarkovChainSettings.cpp
 create mode 100644 src/settings/modules/MarkovChainSettings.h

diff --git a/src/builder/DdPrismModelBuilder.cpp b/src/builder/DdPrismModelBuilder.cpp
index 7fcb209d0..208666bb7 100644
--- a/src/builder/DdPrismModelBuilder.cpp
+++ b/src/builder/DdPrismModelBuilder.cpp
@@ -20,7 +20,7 @@
 #include "src/storage/dd/cudd/CuddAddIterator.h"
 #include "src/storage/dd/Bdd.h"
 
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 
 namespace storm {
     namespace builder {
@@ -1081,7 +1081,7 @@ namespace storm {
 
             if (!deadlockStates.isZero()) {
                 // If we need to fix deadlocks, we do so now.
-                if (!storm::settings::getModule<storm::settings::modules::GeneralSettings>().isDontFixDeadlocksSet()) {
+                if (!storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isDontFixDeadlocksSet()) {
                     STORM_LOG_INFO("Fixing deadlocks in " << deadlockStates.getNonZeroCount() << " states. The first three of these states are: ");
                     
                     uint_fast64_t count = 0;
diff --git a/src/builder/ExplicitPrismModelBuilder.cpp b/src/builder/ExplicitPrismModelBuilder.cpp
index eba19054f..77b37684e 100644
--- a/src/builder/ExplicitPrismModelBuilder.cpp
+++ b/src/builder/ExplicitPrismModelBuilder.cpp
@@ -9,7 +9,7 @@
 
 #include "src/storage/expressions/ExpressionManager.h"
 
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 
 #include "src/generator/PrismNextStateGenerator.h"
 #include "src/generator/PrismStateLabelingGenerator.h"
@@ -84,17 +84,17 @@ namespace storm {
         }
         
         template <typename ValueType, typename RewardModelType, typename StateType>
-        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options() : explorationOrder(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(true), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(true), labelsToBuild(), expressionLabels(), terminalStates(), negatedTerminalStates() {
+        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options() : explorationOrder(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(true), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(true), labelsToBuild(), expressionLabels(), terminalStates(), negatedTerminalStates() {
             // Intentionally left empty.
         }
         
         template <typename ValueType, typename RewardModelType, typename StateType>
-        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options(storm::logic::Formula const& formula) : explorationOrder(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(false), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(false), labelsToBuild(std::set<std::string>()), expressionLabels(std::vector<storm::expressions::Expression>()), terminalStates(), negatedTerminalStates() {
+        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options(storm::logic::Formula const& formula) : explorationOrder(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(false), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(false), labelsToBuild(std::set<std::string>()), expressionLabels(std::vector<storm::expressions::Expression>()), terminalStates(), negatedTerminalStates() {
             this->preserveFormula(formula);
         }
         
         template <typename ValueType, typename RewardModelType, typename StateType>
-        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options(std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas) : explorationOrder(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(false), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(false), labelsToBuild(), expressionLabels(), terminalStates(), negatedTerminalStates() {
+        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options(std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas) : explorationOrder(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(false), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(false), labelsToBuild(), expressionLabels(), terminalStates(), negatedTerminalStates() {
             if (formulas.empty()) {
                 this->buildAllRewardModels = true;
                 this->buildAllLabels = true;
@@ -386,7 +386,7 @@ namespace storm {
                 
                 // If there is no behavior, we might have to introduce a self-loop.
                 if (behavior.empty()) {
-                    if (!storm::settings::getModule<storm::settings::modules::GeneralSettings>().isDontFixDeadlocksSet() || !behavior.wasExpanded()) {
+                    if (!storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isDontFixDeadlocksSet() || !behavior.wasExpanded()) {
                         if (options.buildCommandLabels) {
                             // Insert empty choice labeling for added self-loop transitions.
                             choiceLabels.get().push_back(boost::container::flat_set<uint_fast64_t>());
diff --git a/src/cli/cli.cpp b/src/cli/cli.cpp
index 6b517e410..7ff84ef22 100644
--- a/src/cli/cli.cpp
+++ b/src/cli/cli.cpp
@@ -205,7 +205,7 @@ namespace storm {
                     storm::utility::initializeFileLogging();
                 }
                 
-                storm::settings::modules::GeneralSettings const& settings = storm::settings::getModule<storm::settings::modules::GeneralSettings>();
+                storm::settings::modules::MarkovChainSettings const& settings = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>();
                 
                 // If we have to build the model from a symbolic representation, we need to parse the representation first.
                 boost::optional<storm::prism::Program> program;
@@ -216,8 +216,8 @@ namespace storm {
                 
                 // Then proceed to parsing the property (if given), since the model we are building may depend on the property.
                 std::vector<std::shared_ptr<storm::logic::Formula>> parsedFormulas;
-                if (settings.isPropertySet()) {
-                    std::string properties = settings.getProperty();
+                if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isPropertySet()) {
+                    std::string properties = storm::settings::getModule<storm::settings::modules::GeneralSettings>().getProperty();
                     
                     if(program) {
                         parsedFormulas = storm::parseFormulasForProgram(properties, program.get());
@@ -230,7 +230,7 @@ namespace storm {
                 
                 if (settings.isSymbolicSet()) {
 #ifdef STORM_HAVE_CARL
-                    if (settings.isParametricSet()) {
+                    if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isParametricSet()) {
                         buildAndCheckSymbolicModel<storm::RationalFunction>(program.get(), formulas, true);
                     } else {
 #endif
diff --git a/src/cli/entrypoints.h b/src/cli/entrypoints.h
index 3e2ee0670..f1febc74e 100644
--- a/src/cli/entrypoints.h
+++ b/src/cli/entrypoints.h
@@ -114,7 +114,7 @@ namespace storm {
     
         template<typename ValueType, storm::dd::DdType LibraryType>
         void buildAndCheckSymbolicModel(storm::prism::Program const& program, std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas, bool onlyInitialStatesRelevant = false) {
-            if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEngine() == storm::settings::modules::GeneralSettings::Engine::AbstractionRefinement) {
+            if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getEngine() == storm::settings::modules::MarkovChainSettings::Engine::AbstractionRefinement) {
                 verifySymbolicModelWithAbstractionRefinementEngine<LibraryType>(program, formulas, onlyInitialStatesRelevant);
             } else {
                 storm::storage::ModelFormulasPair modelFormulasPair = buildSymbolicModel<ValueType, LibraryType>(program, formulas);
@@ -130,7 +130,7 @@ namespace storm {
                 // Verify the model, if a formula was given.
                 if (!formulas.empty()) {
                     if (modelFormulasPair.model->isSparseModel()) {
-                        if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isCounterexampleSet()) {
+                        if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isCounterexampleSet()) {
                             // If we were requested to generate a counterexample, we now do so for each formula.
                             for (auto const &formula : modelFormulasPair.formulas) {
                                 generateCounterexample<ValueType>(program, modelFormulasPair.model->as<storm::models::sparse::Model<ValueType>>(), formula);
@@ -139,7 +139,7 @@ namespace storm {
                             verifySparseModel<ValueType>(modelFormulasPair.model->as<storm::models::sparse::Model<ValueType>>(), modelFormulasPair.formulas, onlyInitialStatesRelevant);
                         }
                     } else if (modelFormulasPair.model->isSymbolicModel()) {
-                        if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEngine() == storm::settings::modules::GeneralSettings::Engine::Hybrid) {
+                        if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getEngine() == storm::settings::modules::MarkovChainSettings::Engine::Hybrid) {
                             verifySymbolicModelWithHybridEngine(modelFormulasPair.model->as<storm::models::symbolic::Model<LibraryType>>(),
                                                                 modelFormulasPair.formulas, onlyInitialStatesRelevant);
                         } else {
@@ -155,18 +155,18 @@ namespace storm {
         
         template<typename ValueType>
         void buildAndCheckSymbolicModel(storm::prism::Program const& program, std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas, bool onlyInitialStatesRelevant = false) {
-            if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getDdLibraryType() == storm::dd::DdType::CUDD) {
+            if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getDdLibraryType() == storm::dd::DdType::CUDD) {
                 buildAndCheckSymbolicModel<ValueType, storm::dd::DdType::CUDD>(program, formulas, onlyInitialStatesRelevant);
-            } else if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getDdLibraryType() == storm::dd::DdType::Sylvan) {
+            } else if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getDdLibraryType() == storm::dd::DdType::Sylvan) {
                 buildAndCheckSymbolicModel<ValueType, storm::dd::DdType::Sylvan>(program, formulas, onlyInitialStatesRelevant);
             }
         }
 
         template<typename ValueType>
         void buildAndCheckExplicitModel(std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas, bool onlyInitialStatesRelevant = false) {
-            storm::settings::modules::GeneralSettings const& settings = storm::settings::getModule<storm::settings::modules::GeneralSettings>();
+            storm::settings::modules::MarkovChainSettings const& settings = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>();
 
-            STORM_LOG_THROW(storm::settings::getModule<storm::settings::modules::GeneralSettings>().isExplicitSet(), storm::exceptions::InvalidStateException, "Unable to build explicit model without model files.");
+            STORM_LOG_THROW(settings.isExplicitSet(), storm::exceptions::InvalidStateException, "Unable to build explicit model without model files.");
             std::shared_ptr<storm::models::ModelBase> model = buildExplicitModel<ValueType>(settings.getTransitionFilename(), settings.getLabelingFilename(), settings.isStateRewardsSet() ? boost::optional<std::string>(settings.getStateRewardsFilename()) : boost::none, settings.isTransitionRewardsSet() ? boost::optional<std::string>(settings.getTransitionRewardsFilename()) : boost::none, settings.isChoiceLabelingSet() ? boost::optional<std::string>(settings.getChoiceLabelingFilename()) : boost::none);
             
             // Preprocess the model if needed.
diff --git a/src/counterexamples/SMTMinimalCommandSetGenerator.h b/src/counterexamples/SMTMinimalCommandSetGenerator.h
index ed84d7b10..048808763 100644
--- a/src/counterexamples/SMTMinimalCommandSetGenerator.h
+++ b/src/counterexamples/SMTMinimalCommandSetGenerator.h
@@ -12,7 +12,7 @@
 #include "src/modelchecker/results/ExplicitQuantitativeCheckResult.h"
 #include "src/solver/GmmxxMinMaxLinearEquationSolver.h"
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 
 #include "src/utility/counterexamples.h"
 #include "src/utility/prism.h"
@@ -1729,7 +1729,7 @@ namespace storm {
 
                 // Compute and emit the time measurements if the corresponding flag was set.
                 totalTime = std::chrono::high_resolution_clock::now() - totalClock;
-                if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isShowStatisticsSet()) {
+                if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isShowStatisticsSet()) {
                     std::cout << std::endl;
                     std::cout << "Time breakdown:" << std::endl;
                     std::cout << "    * time for setup: " << std::chrono::duration_cast<std::chrono::milliseconds>(totalSetupTime).count() << "ms" << std::endl;
diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
index 1b6cbda98..ac3254dd4 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
@@ -7,7 +7,7 @@
 #include "src/adapters/CarlAdapter.h"
 
 #include "src/settings/modules/SparseDtmcEliminationModelCheckerSettings.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/settings/SettingsManager.h"
 
 #include "src/storage/StronglyConnectedComponentDecomposition.h"
@@ -330,7 +330,7 @@ namespace storm {
             std::chrono::high_resolution_clock::time_point modelCheckingEnd = std::chrono::high_resolution_clock::now();
             std::chrono::high_resolution_clock::time_point totalTimeEnd = std::chrono::high_resolution_clock::now();
             
-            if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isShowStatisticsSet()) {
+            if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isShowStatisticsSet()) {
                 std::chrono::high_resolution_clock::duration sccDecompositionTime = sccDecompositionEnd - sccDecompositionStart;
                 std::chrono::milliseconds sccDecompositionTimeInMilliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(sccDecompositionTime);
                 std::chrono::high_resolution_clock::duration conversionTime = conversionEnd - conversionStart;
diff --git a/src/parser/DeterministicSparseTransitionParser.cpp b/src/parser/DeterministicSparseTransitionParser.cpp
index efc91643a..db63f509f 100644
--- a/src/parser/DeterministicSparseTransitionParser.cpp
+++ b/src/parser/DeterministicSparseTransitionParser.cpp
@@ -14,7 +14,7 @@
 #include "src/exceptions/WrongFormatException.h"
 #include "src/exceptions/InvalidArgumentException.h"
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 
 #include "src/adapters/CarlAdapter.h"
 #include "src/utility/macros.h"
@@ -88,7 +88,7 @@ namespace storm {
 
             uint_fast64_t row, col, lastRow = 0;
             double val;
-            bool dontFixDeadlocks = storm::settings::getModule<storm::settings::modules::GeneralSettings>().isDontFixDeadlocksSet();
+            bool dontFixDeadlocks = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isDontFixDeadlocksSet();
             bool hadDeadlocks = false;
             bool rowHadDiagonalEntry = false;
 
diff --git a/src/parser/MarkovAutomatonSparseTransitionParser.cpp b/src/parser/MarkovAutomatonSparseTransitionParser.cpp
index 7ea2dd611..5a9fcfb84 100644
--- a/src/parser/MarkovAutomatonSparseTransitionParser.cpp
+++ b/src/parser/MarkovAutomatonSparseTransitionParser.cpp
@@ -1,7 +1,7 @@
 #include "MarkovAutomatonSparseTransitionParser.h"
 
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/exceptions/WrongFormatException.h"
 #include "src/exceptions/FileIoException.h"
 #include "src/parser/MappedFile.h"
@@ -17,7 +17,7 @@ namespace storm {
         typename MarkovAutomatonSparseTransitionParser<ValueType>::FirstPassResult MarkovAutomatonSparseTransitionParser<ValueType>::firstPass(char const* buf) {
             MarkovAutomatonSparseTransitionParser::FirstPassResult result;
 
-            bool dontFixDeadlocks = storm::settings::getModule<storm::settings::modules::GeneralSettings>().isDontFixDeadlocksSet();
+            bool dontFixDeadlocks = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isDontFixDeadlocksSet();
 
             // Skip the format hint if it is there.
             buf = trimWhitespaces(buf);
@@ -160,7 +160,7 @@ namespace storm {
         typename MarkovAutomatonSparseTransitionParser<ValueType>::Result MarkovAutomatonSparseTransitionParser<ValueType>::secondPass(char const* buf, FirstPassResult const& firstPassResult) {
             Result result(firstPassResult);
 
-            bool dontFixDeadlocks = storm::settings::getModule<storm::settings::modules::GeneralSettings>().isDontFixDeadlocksSet();
+            bool dontFixDeadlocks = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isDontFixDeadlocksSet();
 
             // Skip the format hint if it is there.
             buf = trimWhitespaces(buf);
diff --git a/src/parser/NondeterministicSparseTransitionParser.cpp b/src/parser/NondeterministicSparseTransitionParser.cpp
index 2f40a7425..2186b4929 100644
--- a/src/parser/NondeterministicSparseTransitionParser.cpp
+++ b/src/parser/NondeterministicSparseTransitionParser.cpp
@@ -4,7 +4,7 @@
 
 #include "src/parser/MappedFile.h"
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/exceptions/FileIoException.h"
 #include "src/exceptions/OutOfRangeException.h"
 
@@ -96,7 +96,7 @@ namespace storm {
             // Initialize variables for the parsing run.
             uint_fast64_t source = 0, target = 0, lastSource = 0, choice = 0, lastChoice = 0, curRow = 0;
             double val = 0.0;
-            bool dontFixDeadlocks = storm::settings::getModule<storm::settings::modules::GeneralSettings>().isDontFixDeadlocksSet();
+            bool dontFixDeadlocks = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isDontFixDeadlocksSet();
             bool hadDeadlocks = false;
 
             // The first state already starts a new row group of the matrix.
diff --git a/src/settings/SettingsManager.cpp b/src/settings/SettingsManager.cpp
index bb1883209..853b5c3e1 100644
--- a/src/settings/SettingsManager.cpp
+++ b/src/settings/SettingsManager.cpp
@@ -14,6 +14,7 @@
 #include "src/exceptions/OptionParserException.h"
 #include "src/utility/storm-version.h"
 #include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/settings/modules/DebugSettings.h"
 #include "src/settings/modules/CounterexampleGeneratorSettings.h"
 #include "src/settings/modules/CuddSettings.h"
@@ -484,8 +485,8 @@ namespace storm {
             return SettingsManager::manager();
         }
         
-        storm::settings::modules::GeneralSettings& mutableGeneralSettings() {
-            return dynamic_cast<storm::settings::modules::GeneralSettings&>(mutableManager().getModule(storm::settings::modules::GeneralSettings::moduleName));
+        storm::settings::modules::MarkovChainSettings& mutableMarkovChainSettings() {
+            return dynamic_cast<storm::settings::modules::MarkovChainSettings&>(mutableManager().getModule(storm::settings::modules::MarkovChainSettings::moduleName));
         }
         
         void initializeAll(std::string const& name, std::string const& executableName) {
@@ -493,6 +494,7 @@ namespace storm {
             
             // Register all known settings modules.
             storm::settings::addModule<storm::settings::modules::GeneralSettings>();
+            storm::settings::addModule<storm::settings::modules::MarkovChainSettings>();
             storm::settings::addModule<storm::settings::modules::DebugSettings>();
             storm::settings::addModule<storm::settings::modules::CounterexampleGeneratorSettings>();
             storm::settings::addModule<storm::settings::modules::CuddSettings>();
@@ -508,4 +510,4 @@ namespace storm {
         }
 
     }
-}
\ No newline at end of file
+}
diff --git a/src/settings/SettingsManager.h b/src/settings/SettingsManager.h
index 69d91899f..5b0141045 100644
--- a/src/settings/SettingsManager.h
+++ b/src/settings/SettingsManager.h
@@ -12,19 +12,7 @@
 namespace storm {
     namespace settings {
         namespace modules {
-            class GeneralSettings;
-            class DebugSettings;
-            class CounterexampleGeneratorSettings;
-            class CuddSettings;
-            class SylvanSettings;
-            class GmmxxEquationSolverSettings;
-            class NativeEquationSolverSettings;
-            class BisimulationSettings;
-            class GlpkSettings;
-            class GurobiSettings;
-            class TopologicalValueIterationEquationSolverSettings;
-            class ParametricSettings;
-            class SparseDtmcEliminationModelCheckerSettings;
+            class MarkovChainSettings;
             class ModuleSettings;
         }
         class Option;
@@ -277,14 +265,14 @@ namespace storm {
         }
         
         /*!
-         * Retrieves the general settings in a mutable form. This is only meant to be used for debug purposes or very
+         * Retrieves the markov chain settings in a mutable form. This is only meant to be used for debug purposes or very
          * rare cases where it is necessary.
          *
-         * @return An object that allows accessing and modifying the general settings.
+         * @return An object that allows accessing and modifying the markov chain settings.
          */
-        storm::settings::modules::GeneralSettings& mutableGeneralSettings();
+        storm::settings::modules::MarkovChainSettings& mutableMarkovChainSettings();
         
     } // namespace settings
 } // namespace storm
 
-#endif /* STORM_SETTINGS_SETTINGSMANAGER_H_ */
\ No newline at end of file
+#endif /* STORM_SETTINGS_SETTINGSMANAGER_H_ */
diff --git a/src/settings/modules/CounterexampleGeneratorSettings.cpp b/src/settings/modules/CounterexampleGeneratorSettings.cpp
index 79b57e756..6c245d3b2 100644
--- a/src/settings/modules/CounterexampleGeneratorSettings.cpp
+++ b/src/settings/modules/CounterexampleGeneratorSettings.cpp
@@ -6,7 +6,7 @@
 #include "src/settings/OptionBuilder.h"
 #include "src/settings/ArgumentBuilder.h"
 #include "src/settings/Argument.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 
 namespace storm {
     namespace settings {
@@ -48,7 +48,7 @@ namespace storm {
             
             bool CounterexampleGeneratorSettings::check() const {
                 // Ensure that the model was given either symbolically or explicitly.
-                STORM_LOG_THROW(!isMinimalCommandSetGenerationSet() || storm::settings::getModule<storm::settings::modules::GeneralSettings>().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "For the generation of a minimal command set, the model has to be specified symbolically.");
+                STORM_LOG_THROW(!isMinimalCommandSetGenerationSet() || storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "For the generation of a minimal command set, the model has to be specified symbolically.");
                 
                 if (isMinimalCommandSetGenerationSet()) {
                     STORM_LOG_WARN_COND(isUseMaxSatBasedMinimalCommandSetGenerationSet() || !isEncodeReachabilitySet(), "Encoding reachability is only available for the MaxSat-based minimal command set generation, so selecting it has no effect.");
diff --git a/src/settings/modules/GeneralSettings.cpp b/src/settings/modules/GeneralSettings.cpp
index 0b477d667..778c2a705 100644
--- a/src/settings/modules/GeneralSettings.cpp
+++ b/src/settings/modules/GeneralSettings.cpp
@@ -24,43 +24,14 @@ namespace storm {
             const std::string GeneralSettings::verboseOptionShortName = "v";
             const std::string GeneralSettings::precisionOptionName = "precision";
             const std::string GeneralSettings::precisionOptionShortName = "eps";
-            const std::string GeneralSettings::exportDotOptionName = "exportdot";
-            const std::string GeneralSettings::exportMatOptionName = "exportmat";
             const std::string GeneralSettings::configOptionName = "config";
             const std::string GeneralSettings::configOptionShortName = "c";
-            const std::string GeneralSettings::explicitOptionName = "explicit";
-            const std::string GeneralSettings::explicitOptionShortName = "exp";
-            const std::string GeneralSettings::symbolicOptionName = "symbolic";
-            const std::string GeneralSettings::symbolicOptionShortName = "s";
-            const std::string GeneralSettings::explorationOrderOptionName = "explorder";
-            const std::string GeneralSettings::explorationOrderOptionShortName = "eo";
             const std::string GeneralSettings::propertyOptionName = "prop";
             const std::string GeneralSettings::propertyOptionShortName = "prop";
-            const std::string GeneralSettings::transitionRewardsOptionName = "transrew";
-            const std::string GeneralSettings::stateRewardsOptionName = "staterew";
-            const std::string GeneralSettings::choiceLabelingOptionName = "choicelab";
-            const std::string GeneralSettings::counterexampleOptionName = "counterexample";
-            const std::string GeneralSettings::counterexampleOptionShortName = "cex";
-            const std::string GeneralSettings::dontFixDeadlockOptionName = "nofixdl";
-            const std::string GeneralSettings::dontFixDeadlockOptionShortName = "ndl";
             const std::string GeneralSettings::timeoutOptionName = "timeout";
             const std::string GeneralSettings::timeoutOptionShortName = "t";
-            const std::string GeneralSettings::eqSolverOptionName = "eqsolver";
-            const std::string GeneralSettings::lpSolverOptionName = "lpsolver";
-            const std::string GeneralSettings::smtSolverOptionName = "smtsolver";
-            const std::string GeneralSettings::constantsOptionName = "constants";
-            const std::string GeneralSettings::constantsOptionShortName = "const";
-            const std::string GeneralSettings::statisticsOptionName = "statistics";
-            const std::string GeneralSettings::statisticsOptionShortName = "stats";
             const std::string GeneralSettings::bisimulationOptionName = "bisimulation";
             const std::string GeneralSettings::bisimulationOptionShortName = "bisim";
-            const std::string GeneralSettings::engineOptionName = "engine";
-            const std::string GeneralSettings::engineOptionShortName = "e";
-            const std::string GeneralSettings::ddLibraryOptionName = "ddlib";
-            const std::string GeneralSettings::cudaOptionName = "cuda";
-            const std::string GeneralSettings::prismCompatibilityOptionName = "prismcompat";
-            const std::string GeneralSettings::prismCompatibilityOptionShortName = "pc";
-			const std::string GeneralSettings::minMaxEquationSolvingTechniqueOptionName = "minMaxEquationSolvingTechnique";
             
 #ifdef STORM_HAVE_CARL
             const std::string GeneralSettings::parametricOptionName = "parametric";
@@ -69,69 +40,17 @@ namespace storm {
             GeneralSettings::GeneralSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, helpOptionName, false, "Shows all available options, arguments and descriptions.").setShortName(helpOptionShortName)
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("hint", "A regular expression to show help for all matching entities or 'all' for the complete help.").setDefaultValueString("all").build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, prismCompatibilityOptionName, false, "Enables PRISM compatibility. This may be necessary to process some PRISM models.").setShortName(prismCompatibilityOptionShortName).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, versionOptionName, false, "Prints the version information.").build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, verboseOptionName, false, "Enables more verbose output.").setShortName(verboseOptionShortName).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, precisionOptionName, false, "The internally used precision.").setShortName(precisionOptionShortName)
                                 .addArgument(storm::settings::ArgumentBuilder::createDoubleArgument("value", "The precision to use.").setDefaultValueDouble(1e-06).addValidationFunctionDouble(storm::settings::ArgumentValidators::doubleRangeValidatorExcluding(0.0, 1.0)).build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, exportDotOptionName, "", "If given, the loaded model will be written to the specified file in the dot format.")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file to which the model is to be written.").build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, exportMatOptionName, "", "If given, the loaded model will be written to the specified file in the mat format.")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "the name of the file to which the model is to be writen.").build()).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, configOptionName, false, "If given, this file will be read and parsed for additional configuration settings.").setShortName(configOptionShortName)
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file from which to read the configuration.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, explicitOptionName, false, "Parses the model given in an explicit (sparse) representation.").setShortName(explicitOptionShortName)
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("transition filename", "The name of the file from which to read the transitions.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build())
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("labeling filename", "The name of the file from which to read the state labeling.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, symbolicOptionName, false, "Parses the model given in a symbolic representation.").setShortName(symbolicOptionShortName)
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file from which to read the symbolic model.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
-
-                std::vector<std::string> explorationOrders = {"dfs", "bfs"};
-                this->addOption(storm::settings::OptionBuilder(moduleName, explorationOrderOptionName, false, "Sets which exploration order to use.").setShortName(explorationOrderOptionShortName)
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the exploration order to choose. Available are: dfs and bfs.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(explorationOrders)).setDefaultValueString("bfs").build()).build());
 
                 this->addOption(storm::settings::OptionBuilder(moduleName, propertyOptionName, false, "Specifies the formulas to be checked on the model.").setShortName(propertyOptionShortName)
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("formula or filename", "The formula or the file containing the formulas.").build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, counterexampleOptionName, false, "Generates a counterexample for the given PRCTL formulas if not satisfied by the model")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file to which the counterexample is to be written.").setDefaultValueString("-").setIsOptional(true).build()).setShortName(counterexampleOptionShortName).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, bisimulationOptionName, false, "Sets whether to perform bisimulation minimization.").setShortName(bisimulationOptionShortName).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, transitionRewardsOptionName, false, "If given, the transition rewards are read from this file and added to the explicit model. Note that this requires the model to be given as an explicit model (i.e., via --" + explicitOptionName + ").")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The file from which to read the transition rewards.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, stateRewardsOptionName, false, "If given, the state rewards are read from this file and added to the explicit model. Note that this requires the model to be given as an explicit model (i.e., via --" + explicitOptionName + ").")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The file from which to read the state rewards.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, choiceLabelingOptionName, false, "If given, the choice labels are read from this file and added to the explicit model. Note that this requires the model to be given as an explicit model (i.e., via --" + explicitOptionName + ").")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The file from which to read the choice labels.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, dontFixDeadlockOptionName, false, "If the model contains deadlock states, they need to be fixed by setting this option.").setShortName(dontFixDeadlockOptionShortName).build());
-                
-                std::vector<std::string> engines = {"sparse", "hybrid", "dd", "abs"};
-                this->addOption(storm::settings::OptionBuilder(moduleName, engineOptionName, false, "Sets which engine is used for model building and model checking.").setShortName(engineOptionShortName)
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the engine to use. Available are {sparse, hybrid, dd, ar}.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(engines)).setDefaultValueString("sparse").build()).build());
-                
-                std::vector<std::string> linearEquationSolver = {"gmm++", "native"};
-                this->addOption(storm::settings::OptionBuilder(moduleName, eqSolverOptionName, false, "Sets which solver is preferred for solving systems of linear equations.")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the solver to prefer. Available are: gmm++ and native.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(linearEquationSolver)).setDefaultValueString("gmm++").build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, timeoutOptionName, false, "If given, computation will abort after the timeout has been reached.").setShortName(timeoutOptionShortName)
-                                .addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("time", "The number of seconds after which to timeout.").setDefaultValueUnsignedInteger(0).build()).build());
                 
-                std::vector<std::string> ddLibraries = {"cudd", "sylvan"};
-                this->addOption(storm::settings::OptionBuilder(moduleName, ddLibraryOptionName, false, "Sets which library is preferred for decision-diagram operations.")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the library to prefer. Available are: cudd and sylvan.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(ddLibraries)).setDefaultValueString("cudd").build()).build());
-                
-                std::vector<std::string> lpSolvers = {"gurobi", "glpk"};
-                this->addOption(storm::settings::OptionBuilder(moduleName, lpSolverOptionName, false, "Sets which LP solver is preferred.")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of an LP solver. Available are: gurobi and glpk.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(lpSolvers)).setDefaultValueString("glpk").build()).build());
-                std::vector<std::string> smtSolvers = {"z3", "mathsat"};
-                this->addOption(storm::settings::OptionBuilder(moduleName, smtSolverOptionName, false, "Sets which SMT solver is preferred.")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of an SMT solver. Available are: z3 and mathsat.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(smtSolvers)).setDefaultValueString("z3").build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, constantsOptionName, false, "Specifies the constant replacements to use in symbolic models. Note that Note that this requires the model to be given as an symbolic model (i.e., via --" + symbolicOptionName + ").").setShortName(constantsOptionShortName)
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("values", "A comma separated list of constants and their value, e.g. a=1,b=2,c=3.").setDefaultValueString("").build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, statisticsOptionName, false, "Sets whether to display statistics if available.").setShortName(statisticsOptionShortName).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, cudaOptionName, false, "Sets whether to use CUDA to speed up computation time.").build());
-
-				std::vector<std::string> minMaxSolvingTechniques = {"policyIteration", "valueIteration"};
-				this->addOption(storm::settings::OptionBuilder(moduleName, minMaxEquationSolvingTechniqueOptionName, false, "Sets which min/max linear equation solving technique is preferred.")
-					.addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of a min/max linear equation solving technique. Available are: valueIteration and policyIteration.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(minMaxSolvingTechniques)).setDefaultValueString("valueIteration").build()).build());
-
 #ifdef STORM_HAVE_CARL
                 this->addOption(storm::settings::OptionBuilder(moduleName, parametricOptionName, false, "Sets whether to use the parametric engine.").build());
 #endif
@@ -157,14 +76,6 @@ namespace storm {
                 return this->getOption(precisionOptionName).getArgumentByName("value").getValueAsDouble();
             }
             
-            bool GeneralSettings::isExportDotSet() const {
-                return this->getOption(exportDotOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string GeneralSettings::getExportDotFilename() const {
-                return this->getOption(exportDotOptionName).getArgumentByName("filename").getValueAsString();
-            }
-            
             bool GeneralSettings::isConfigSet() const {
                 return this->getOption(configOptionName).getHasOptionBeenSet();
             }
@@ -173,40 +84,6 @@ namespace storm {
                 return this->getOption(configOptionName).getArgumentByName("filename").getValueAsString();
             }
             
-            bool GeneralSettings::isExplicitSet() const {
-                return this->getOption(explicitOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string GeneralSettings::getTransitionFilename() const {
-                return this->getOption(explicitOptionName).getArgumentByName("transition filename").getValueAsString();
-            }
-                        
-            std::string GeneralSettings::getLabelingFilename() const {
-                return this->getOption(explicitOptionName).getArgumentByName("labeling filename").getValueAsString();
-            }
-            
-            bool GeneralSettings::isSymbolicSet() const {
-                return this->getOption(symbolicOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string GeneralSettings::getSymbolicModelFilename() const {
-                return this->getOption(symbolicOptionName).getArgumentByName("filename").getValueAsString();
-            }
-            
-            bool GeneralSettings::isExplorationOrderSet() const {
-                return this->getOption(explorationOrderOptionName).getHasOptionBeenSet();
-            }
-            
-            storm::builder::ExplorationOrder GeneralSettings::getExplorationOrder() const {
-                std::string explorationOrderAsString = this->getOption(explorationOrderOptionName).getArgumentByName("name").getValueAsString();
-                if (explorationOrderAsString == "dfs") {
-                    return storm::builder::ExplorationOrder::Dfs;
-                } else if (explorationOrderAsString == "bfs") {
-                    return storm::builder::ExplorationOrder::Bfs;
-                }
-                STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown exploration order '" << explorationOrderAsString << "'.");
-            }
-            
             bool GeneralSettings::isPropertySet() const {
                 return this->getOption(propertyOptionName).getHasOptionBeenSet();
             }
@@ -215,50 +92,6 @@ namespace storm {
                 return this->getOption(propertyOptionName).getArgumentByName("formula or filename").getValueAsString();
             }
             
-            bool GeneralSettings::isTransitionRewardsSet() const {
-                return this->getOption(transitionRewardsOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string GeneralSettings::getTransitionRewardsFilename() const {
-                return this->getOption(transitionRewardsOptionName).getArgumentByName("filename").getValueAsString();
-            }
-            
-            bool GeneralSettings::isStateRewardsSet() const {
-                return this->getOption(stateRewardsOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string GeneralSettings::getStateRewardsFilename() const {
-                return this->getOption(stateRewardsOptionName).getArgumentByName("filename").getValueAsString();
-            }
-            
-            bool GeneralSettings::isChoiceLabelingSet() const {
-                return this->getOption(choiceLabelingOptionName).getHasOptionBeenSet();
-            }
-                
-            std::string GeneralSettings::getChoiceLabelingFilename() const {
-                return this->getOption(choiceLabelingOptionName).getArgumentByName("filename").getValueAsString();
-            }
-            
-            bool GeneralSettings::isCounterexampleSet() const {
-                return this->getOption(counterexampleOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string GeneralSettings::getCounterexampleFilename() const {
-                return this->getOption(counterexampleOptionName).getArgumentByName("filename").getValueAsString();
-            }
-            
-            bool GeneralSettings::isDontFixDeadlocksSet() const {
-                return this->getOption(dontFixDeadlockOptionName).getHasOptionBeenSet();
-            }
-            
-            std::unique_ptr<storm::settings::SettingMemento> GeneralSettings::overrideDontFixDeadlocksSet(bool stateToSet) {
-                return this->overrideOption(dontFixDeadlockOptionName, stateToSet);
-            }
-            
-            std::unique_ptr<storm::settings::SettingMemento> GeneralSettings::overridePrismCompatibilityMode(bool stateToSet) {
-                return this->overrideOption(prismCompatibilityOptionName, stateToSet);
-            }
-            
             bool GeneralSettings::isTimeoutSet() const {
                 return this->getOption(timeoutOptionName).getHasOptionBeenSet();
             }
@@ -267,91 +100,10 @@ namespace storm {
                 return this->getOption(timeoutOptionName).getArgumentByName("time").getValueAsUnsignedInteger();
             }
             
-            storm::solver::EquationSolverType  GeneralSettings::getEquationSolver() const {
-                std::string equationSolverName = this->getOption(eqSolverOptionName).getArgumentByName("name").getValueAsString();
-                if (equationSolverName == "gmm++") {
-                    return storm::solver::EquationSolverType::Gmmxx;
-                } else if (equationSolverName == "native") {
-                    return storm::solver::EquationSolverType::Native;
-                }
-                STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown equation solver '" << equationSolverName << "'.");
-            }
-            
-            bool GeneralSettings::isEquationSolverSet() const {
-                return this->getOption(eqSolverOptionName).getHasOptionBeenSet();
-            }
-            
-            storm::solver::LpSolverType GeneralSettings::getLpSolver() const {
-                std::string lpSolverName = this->getOption(lpSolverOptionName).getArgumentByName("name").getValueAsString();
-                if (lpSolverName == "gurobi") {
-                    return storm::solver::LpSolverType::Gurobi;
-                } else if (lpSolverName == "glpk") {
-                    return storm::solver::LpSolverType::Glpk;
-                }
-                STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown LP solver '" << lpSolverName << "'.");
-            }
-            
-            storm::solver::SmtSolverType GeneralSettings::getSmtSolver() const {
-                std::string smtSolverName = this->getOption(smtSolverOptionName).getArgumentByName("name").getValueAsString();
-                if (smtSolverName == "z3") {
-                    return storm::solver::SmtSolverType::Z3;
-                } else if (smtSolverName == "mathsat") {
-                    return storm::solver::SmtSolverType::Mathsat;
-                }
-                STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown SMT solver '" << smtSolverName << "'.");
-            }
-            
-            storm::dd::DdType GeneralSettings::getDdLibraryType() const {
-                std::string ddLibraryAsString = this->getOption(ddLibraryOptionName).getArgumentByName("name").getValueAsString();
-                if (ddLibraryAsString == "sylvan") {
-                    return storm::dd::DdType::Sylvan;
-                } else {
-                    return storm::dd::DdType::CUDD;
-                }
-            }
-            
-            bool GeneralSettings::isConstantsSet() const {
-                return this->getOption(constantsOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string GeneralSettings::getConstantDefinitionString() const {
-                return this->getOption(constantsOptionName).getArgumentByName("values").getValueAsString();
-            }
-            
-            bool GeneralSettings::isShowStatisticsSet() const {
-                return this->getOption(statisticsOptionName).getHasOptionBeenSet();
-            }
-            
             bool GeneralSettings::isBisimulationSet() const {
                 return this->getOption(bisimulationOptionName).getHasOptionBeenSet();
             }
             
-            GeneralSettings::Engine GeneralSettings::getEngine() const {
-                return engine;
-            }
-
-            void GeneralSettings::setEngine(Engine newEngine) {
-                this->engine = newEngine;
-            }
-            
-            bool GeneralSettings::isPrismCompatibilityEnabled() const {
-                return this->getOption(prismCompatibilityOptionName).getHasOptionBeenSet();
-            }
-
-			storm::solver::MinMaxTechnique GeneralSettings::getMinMaxEquationSolvingTechnique() const {
-				std::string minMaxEquationSolvingTechnique = this->getOption(minMaxEquationSolvingTechniqueOptionName).getArgumentByName("name").getValueAsString();
-				if (minMaxEquationSolvingTechnique == "valueIteration") {
-					return storm::solver::MinMaxTechnique::ValueIteration;
-				} else if (minMaxEquationSolvingTechnique == "policyIteration") {
-					return storm::solver::MinMaxTechnique::PolicyIteration;
-				}
-				STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown min/max equation solving technique '" << minMaxEquationSolvingTechnique << "'.");
-			}
-
-			bool GeneralSettings::isMinMaxEquationSolvingTechniqueSet() const {
-				return this->getOption(minMaxEquationSolvingTechniqueOptionName).getHasOptionBeenSet();
-			}
-            
 #ifdef STORM_HAVE_CARL
             bool GeneralSettings::isParametricSet() const {
                 return this->getOption(parametricOptionName).getHasOptionBeenSet();
@@ -359,33 +111,11 @@ namespace storm {
 #endif
 
             void GeneralSettings::finalize() {
-                // Finalize engine.
-                std::string engineStr = this->getOption(engineOptionName).getArgumentByName("name").getValueAsString();
-                if (engineStr == "sparse") {
-                    engine =  GeneralSettings::Engine::Sparse;
-                } else if (engineStr == "hybrid") {
-                    engine = GeneralSettings::Engine::Hybrid;
-                } else if (engineStr == "dd") {
-                    engine = GeneralSettings::Engine::Dd;
-                } else if (engineStr == "abs") {
-                    engine = GeneralSettings::Engine::AbstractionRefinement;
-                } else {
-                    STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown engine '" << engineStr << "'.");
-                }
             }
 
             bool GeneralSettings::check() const {
-                // Ensure that the model was given either symbolically or explicitly.
-                STORM_LOG_THROW(!isSymbolicSet() || !isExplicitSet(), storm::exceptions::InvalidSettingsException, "The model may be either given in an explicit or a symbolic format, but not both.");
-                
-                STORM_LOG_THROW(this->getEngine() == Engine::Sparse || !isExplicitSet(), storm::exceptions::InvalidSettingsException, "Cannot use explicit input models with this engine.");
-                
                 return true;
             }
-
-            bool GeneralSettings::isCudaSet() const {
-                return this->getOption(cudaOptionName).getHasOptionBeenSet();
-            }
             
         } // namespace modules
     } // namespace settings
diff --git a/src/settings/modules/GeneralSettings.h b/src/settings/modules/GeneralSettings.h
index cf8a9318e..1f7bf3445 100644
--- a/src/settings/modules/GeneralSettings.h
+++ b/src/settings/modules/GeneralSettings.h
@@ -7,17 +7,6 @@
 #include "src/builder/ExplorationOrder.h"
 
 namespace storm {
-    namespace solver {
-        enum class EquationSolverType;
-        enum class LpSolverType;
-        enum class MinMaxTechnique;
-        enum class SmtSolverType;
-    }
-    
-    namespace dd {
-        enum class DdType;
-    }
-
     namespace settings {
         namespace modules {
 
@@ -26,10 +15,6 @@ namespace storm {
              */
             class GeneralSettings : public ModuleSettings {
             public:
-                // An enumeration of all engines.
-                enum class Engine {
-                    Sparse, Hybrid, Dd, AbstractionRefinement
-                };
 
                 /*!
                  * Creates a new set of general settings.
@@ -72,20 +57,6 @@ namespace storm {
                  */
                 double getPrecision() const;
 
-                /*!
-                 * Retrieves whether the export-to-dot option was set.
-                 *
-                 * @return True if the export-to-dot option was set.
-                 */
-                bool isExportDotSet() const;
-
-                /*!
-                 * Retrieves the name in which to write the model in dot format, if the export-to-dot option was set.
-                 *
-                 * @return The name of the file in which to write the exported model.
-                 */
-                std::string getExportDotFilename() const;
-
                 /*!
                  * Retrieves whether the config option was set.
                  *
@@ -100,58 +71,6 @@ namespace storm {
                  */
                 std::string getConfigFilename() const;
 
-                /*!
-                 * Retrieves whether the explicit option was set.
-                 *
-                 * @return True if the explicit option was set.
-                 */
-                bool isExplicitSet() const;
-
-                /*!
-                 * Retrieves the name of the file that contains the transitions if the model was given using the explicit
-                 * option.
-                 *
-                 * @return The name of the file that contains the transitions.
-                 */
-                std::string getTransitionFilename() const;
-
-                /*!
-                 * Retrieves the name of the file that contains the state labeling if the model was given using the
-                 * explicit option.
-                 *
-                 * @return The name of the file that contains the state labeling.
-                 */
-                std::string getLabelingFilename() const;
-
-                /*!
-                 * Retrieves whether the symbolic option was set.
-                 *
-                 * @return True if the symbolic option was set.
-                 */
-                bool isSymbolicSet() const;
-
-                /*!
-                 * Retrieves the name of the file that contains the symbolic model specification if the model was given
-                 * using the symbolic option.
-                 *
-                 * @return The name of the file that contains the symbolic model specification.
-                 */
-                std::string getSymbolicModelFilename() const;
-                
-                /*!
-                 * Retrieves whether the model exploration order was set.
-                 *
-                 * @return True if the model exploration option was set.
-                 */
-                bool isExplorationOrderSet() const;
-                
-                /*!
-                 * Retrieves the exploration order if it was set.
-                 *
-                 * @return The chosen exploration order.
-                 */
-                storm::builder::ExplorationOrder getExplorationOrder() const;
-
                 /*!
                  * Retrieves whether the property option was set.
                  *
@@ -166,91 +85,6 @@ namespace storm {
                  */
                 std::string getProperty() const;
 
-                /*!
-                 * Retrieves whether the transition reward option was set.
-                 *
-                 * @return True if the transition reward option was set.
-                 */
-                bool isTransitionRewardsSet() const;
-
-                /*!
-                 * Retrieves the name of the file that contains the transition rewards if the model was given using the
-                 * explicit option.
-                 *
-                 * @return The name of the file that contains the transition rewards.
-                 */
-                std::string getTransitionRewardsFilename() const;
-
-                /*!
-                 * Retrieves whether the state reward option was set.
-                 *
-                 * @return True if the state reward option was set.
-                 */
-                bool isStateRewardsSet() const;
-
-                /*!
-                 * Retrieves the name of the file that contains the state rewards if the model was given using the
-                 * explicit option.
-                 *
-                 * @return The name of the file that contains the state rewards.
-                 */
-                std::string getStateRewardsFilename() const;
-
-                /*!
-                 * Retrieves whether the choice labeling option was set.
-                 * 
-                 * @return True iff the choice labeling option was set.
-                 */
-                bool isChoiceLabelingSet() const;
-
-                /*!
-                 * Retrieves the name of the file that contains the choice labeling
-                 * if the model was given using the explicit option.
-                 *
-                 * @return The name of the file that contains the choice labeling.
-                 */
-                std::string getChoiceLabelingFilename() const;
-
-                /*!
-                 * Retrieves whether the counterexample option was set.
-                 *
-                 * @return True if the counterexample option was set.
-                 */
-                bool isCounterexampleSet() const;
-
-                /*!
-                 * Retrieves the name of the file to which the counterexample is to be written if the counterexample
-                 * option was set.
-                 *
-                 * @return The name of the file to which the counterexample is to be written.
-                 */
-                std::string getCounterexampleFilename() const;
-
-                /*!
-                 * Retrieves whether the dont-fix-deadlocks option was set.
-                 *
-                 * @return True if the dont-fix-deadlocks option was set.
-                 */
-                bool isDontFixDeadlocksSet() const;
-
-                /*!
-                 * Overrides the option to not fix deadlocks by setting it to the specified value. As soon as the
-                 * returned memento goes out of scope, the original value is restored.
-                 *
-                 * @param stateToSet The value that is to be set for the fix-deadlocks option.
-                 * @return The memento that will eventually restore the original value.
-                 */
-                std::unique_ptr<storm::settings::SettingMemento> overrideDontFixDeadlocksSet(bool stateToSet);
-
-                /*!
-                 * Overrides the option to enable the PRISM compatibility mode by setting it to the specified value. As
-                 * soon as the returned memento goes out of scope, the original value is restored.
-                 *
-                 * @param stateToSet The value that is to be set for the option.
-                 * @return The memento that will eventually restore the original value.
-                 */
-                std::unique_ptr<storm::settings::SettingMemento> overridePrismCompatibilityMode(bool stateToSet);
-
                 /*!
                  * Retrieves whether the timeout option was set.
                  *
@@ -265,62 +99,6 @@ namespace storm {
                  */
                 uint_fast64_t getTimeoutInSeconds() const;
 
-                /*!
-                 * Retrieves the selected equation solver.
-                 *
-                 * @return The selected convergence criterion.
-                 */
-                storm::solver::EquationSolverType getEquationSolver() const;
-
-                /*!
-                 * Retrieves whether a equation solver has been set.
-                 *
-                 * @return True iff an equation solver has been set.
-                 */
-                bool isEquationSolverSet() const;
-
-                /*!
-                 * Retrieves the selected LP solver.
-                 *
-                 * @return The selected LP solver.
-                 */
-                storm::solver::LpSolverType getLpSolver() const;
-
-                /*!
-                 * Retrieves the selected SMT solver.
-                 *
-                 * @return The selected SMT solver.
-                 */
-                storm::solver::SmtSolverType getSmtSolver() const;
-                
-                /*!
-                 * Retrieves the selected library for DD-related operations.
-                 *
-                 * @return The selected library.
-                 */
-                storm::dd::DdType getDdLibraryType() const;
-                
-                /*!
-                 * Retrieves whether the export-to-dot option was set.
-                 *
-                 * @return True if the export-to-dot option was set.
-                 */
-                bool isConstantsSet() const;
-
-                /*!
-                 * Retrieves the string that defines the constants of a symbolic model (given via the symbolic option).
-                 *
-                 * @return The string that defines the constants of a symbolic model.
-                 */
-                std::string getConstantDefinitionString() const;
-
-                /*!
-                 * Retrieves whether statistics are to be shown for counterexample generation.
-                 *
-                 * @return True iff statistics are to be shown for counterexample generation.
-                 */
-                bool isShowStatisticsSet() const;
-
                 /*!
                  * Retrieves whether the option to perform bisimulation minimization is set.
                  *
@@ -328,32 +106,6 @@ namespace storm {
                  */
                 bool isBisimulationSet() const;
 
-                /*!
-                 * Retrieves whether the option to use CUDA is set.
-                 *
-                 * @return True iff the option was set.
-                 */
-                bool isCudaSet() const;
-
-                /*!
-                 * Retrieves the selected engine.
-                 *
-                 * @return The selected engine.
-                 */
-                Engine getEngine() const;
-
-                /*!
-                 * Sets the engine for further usage.
-                 */
-                void setEngine(Engine);
-
-                /*!
-                 * Retrieves whether the PRISM compatibility mode was enabled.
-                 *
-                 * @return True iff the PRISM compatibility mode was enabled.
-                 */
-                bool isPrismCompatibilityEnabled() const;
-
 #ifdef STORM_HAVE_CARL
                 /*!
                  * Retrieves whether the option enabling parametric model checking is set.
@@ -362,21 +114,7 @@ namespace storm {
                  */
                 bool isParametricSet() const;
 #endif
-                /*!
-                 * Retrieves whether a min/max equation solving technique has been set.
-                 *
-                 * @return True iff an equation solving technique has been set.
-                 */
-                bool isMinMaxEquationSolvingTechniqueSet() const;
-
-                /*!
-                 * Retrieves the selected min/max equation solving technique.
-                 *
-                 * @return The selected min/max equation solving technique.
-                 */
-                storm::solver::MinMaxTechnique getMinMaxEquationSolvingTechnique() const;
-
-
+                
                 bool check() const override;
                 void finalize() override;
 
@@ -384,8 +122,6 @@ namespace storm {
                 static const std::string moduleName;
 
             private:
-                Engine engine;
-
                 // Define the string names of the options as constants.
                 static const std::string helpOptionName;
                 static const std::string helpOptionShortName;
@@ -394,43 +130,14 @@ namespace storm {
                 static const std::string verboseOptionShortName;
                 static const std::string precisionOptionName;
                 static const std::string precisionOptionShortName;
-                static const std::string exportDotOptionName;
-                static const std::string exportMatOptionName;
                 static const std::string configOptionName;
                 static const std::string configOptionShortName;
-                static const std::string explicitOptionName;
-                static const std::string explicitOptionShortName;
-                static const std::string symbolicOptionName;
-                static const std::string symbolicOptionShortName;
-                static const std::string explorationOrderOptionName;
-                static const std::string explorationOrderOptionShortName;
                 static const std::string propertyOptionName;
                 static const std::string propertyOptionShortName;
-                static const std::string transitionRewardsOptionName;
-                static const std::string stateRewardsOptionName;
-                static const std::string choiceLabelingOptionName;
-                static const std::string counterexampleOptionName;
-                static const std::string counterexampleOptionShortName;
-                static const std::string dontFixDeadlockOptionName;
-                static const std::string dontFixDeadlockOptionShortName;
                 static const std::string timeoutOptionName;
                 static const std::string timeoutOptionShortName;
-                static const std::string eqSolverOptionName;
-                static const std::string lpSolverOptionName;
-                static const std::string smtSolverOptionName;
-                static const std::string constantsOptionName;
-                static const std::string constantsOptionShortName;
-                static const std::string statisticsOptionName;
-                static const std::string statisticsOptionShortName;
                 static const std::string bisimulationOptionName;
                 static const std::string bisimulationOptionShortName;
-                static const std::string engineOptionName;
-                static const std::string engineOptionShortName;
-                static const std::string ddLibraryOptionName;
-                static const std::string cudaOptionName;
-                static const std::string prismCompatibilityOptionName;
-                static const std::string prismCompatibilityOptionShortName;
-                static const std::string minMaxEquationSolvingTechniqueOptionName;
 
 #ifdef STORM_HAVE_CARL
                 static const std::string parametricOptionName;
diff --git a/src/settings/modules/GlpkSettings.cpp b/src/settings/modules/GlpkSettings.cpp
index 824f855ed..188c196eb 100644
--- a/src/settings/modules/GlpkSettings.cpp
+++ b/src/settings/modules/GlpkSettings.cpp
@@ -5,7 +5,7 @@
 #include "src/settings/Argument.h"
 
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/solver/SolverSelectionOptions.h"
 
 namespace storm {
@@ -35,7 +35,7 @@ namespace storm {
             
             bool GlpkSettings::check() const {
                 if (isOutputSet() || isIntegerToleranceSet()) {
-                    STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getLpSolver() == storm::solver::LpSolverType::Glpk, "glpk is not selected as the preferred LP solver, so setting options for glpk might have no effect.");
+                    STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getLpSolver() == storm::solver::LpSolverType::Glpk, "glpk is not selected as the preferred LP solver, so setting options for glpk might have no effect.");
                 }
                 
                 return true;
@@ -43,4 +43,4 @@ namespace storm {
             
         } // namespace modules
     } // namespace settings
-} // namespace storm
\ No newline at end of file
+} // namespace storm
diff --git a/src/settings/modules/GmmxxEquationSolverSettings.cpp b/src/settings/modules/GmmxxEquationSolverSettings.cpp
index bfc4770f1..cc81fb6f5 100644
--- a/src/settings/modules/GmmxxEquationSolverSettings.cpp
+++ b/src/settings/modules/GmmxxEquationSolverSettings.cpp
@@ -6,7 +6,7 @@
 #include "src/settings/Argument.h"
 
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/solver/SolverSelectionOptions.h"
 
 namespace storm {
@@ -109,11 +109,11 @@ namespace storm {
                 // This list does not include the precision, because this option is shared with other modules.
                 bool optionsSet = isLinearEquationSystemMethodSet() || isPreconditioningMethodSet() || isRestartIterationCountSet() | isMaximalIterationCountSet() || isConvergenceCriterionSet();
                 
-                STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEquationSolver() == storm::solver::EquationSolverType::Gmmxx || !optionsSet, "gmm++ is not selected as the preferred equation solver, so setting options for gmm++ might have no effect.");
+                STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getEquationSolver() == storm::solver::EquationSolverType::Gmmxx || !optionsSet, "gmm++ is not selected as the preferred equation solver, so setting options for gmm++ might have no effect.");
                 
                 return true;
             }
             
         } // namespace modules
     } // namespace settings
-} // namespace storm
\ No newline at end of file
+} // namespace storm
diff --git a/src/settings/modules/GurobiSettings.cpp b/src/settings/modules/GurobiSettings.cpp
index d27a6c8a0..412578fe0 100644
--- a/src/settings/modules/GurobiSettings.cpp
+++ b/src/settings/modules/GurobiSettings.cpp
@@ -5,7 +5,7 @@
 #include "src/settings/ArgumentBuilder.h"
 #include "src/settings/Argument.h"
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/solver/SolverSelectionOptions.h"
 namespace storm {
     namespace settings {
@@ -46,7 +46,7 @@ namespace storm {
             
             bool GurobiSettings::check() const {
                 if (isOutputSet() || isIntegerToleranceSet() || isNumberOfThreadsSet()) {
-                    STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getLpSolver() == storm::solver::LpSolverType::Gurobi, "Gurobi is not selected as the preferred LP solver, so setting options for Gurobi might have no effect.");
+                    STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getLpSolver() == storm::solver::LpSolverType::Gurobi, "Gurobi is not selected as the preferred LP solver, so setting options for Gurobi might have no effect.");
                 }
                 
                 return true;
@@ -54,4 +54,4 @@ namespace storm {
             
         } // namespace modules
     } // namespace settings
-} // namespace storm
\ No newline at end of file
+} // namespace storm
diff --git a/src/settings/modules/MarkovChainSettings.cpp b/src/settings/modules/MarkovChainSettings.cpp
new file mode 100644
index 000000000..389ef664b
--- /dev/null
+++ b/src/settings/modules/MarkovChainSettings.cpp
@@ -0,0 +1,302 @@
+#include "src/settings/modules/MarkovChainSettings.h"
+
+#include "src/settings/SettingsManager.h"
+#include "src/settings/SettingMemento.h"
+#include "src/settings/Option.h"
+#include "src/settings/OptionBuilder.h"
+#include "src/settings/ArgumentBuilder.h"
+#include "src/settings/Argument.h"
+#include "src/solver/SolverSelectionOptions.h"
+
+#include "src/storage/dd/DdType.h"
+
+#include "src/exceptions/InvalidSettingsException.h"
+
+namespace storm {
+    namespace settings {
+        namespace modules {
+            
+            const std::string MarkovChainSettings::moduleName = "markovchain";
+            const std::string MarkovChainSettings::exportDotOptionName = "exportdot";
+            const std::string MarkovChainSettings::exportMatOptionName = "exportmat";
+            const std::string MarkovChainSettings::explicitOptionName = "explicit";
+            const std::string MarkovChainSettings::explicitOptionShortName = "exp";
+            const std::string MarkovChainSettings::symbolicOptionName = "symbolic";
+            const std::string MarkovChainSettings::symbolicOptionShortName = "s";
+            const std::string MarkovChainSettings::explorationOrderOptionName = "explorder";
+            const std::string MarkovChainSettings::explorationOrderOptionShortName = "eo";
+            const std::string MarkovChainSettings::transitionRewardsOptionName = "transrew";
+            const std::string MarkovChainSettings::stateRewardsOptionName = "staterew";
+            const std::string MarkovChainSettings::choiceLabelingOptionName = "choicelab";
+            const std::string MarkovChainSettings::counterexampleOptionName = "counterexample";
+            const std::string MarkovChainSettings::counterexampleOptionShortName = "cex";
+            const std::string MarkovChainSettings::dontFixDeadlockOptionName = "nofixdl";
+            const std::string MarkovChainSettings::dontFixDeadlockOptionShortName = "ndl";
+            const std::string MarkovChainSettings::eqSolverOptionName = "eqsolver";
+            const std::string MarkovChainSettings::lpSolverOptionName = "lpsolver";
+            const std::string MarkovChainSettings::smtSolverOptionName = "smtsolver";
+            const std::string MarkovChainSettings::constantsOptionName = "constants";
+            const std::string MarkovChainSettings::constantsOptionShortName = "const";
+            const std::string MarkovChainSettings::statisticsOptionName = "statistics";
+            const std::string MarkovChainSettings::statisticsOptionShortName = "stats";
+            const std::string MarkovChainSettings::engineOptionName = "engine";
+            const std::string MarkovChainSettings::engineOptionShortName = "e";
+            const std::string MarkovChainSettings::ddLibraryOptionName = "ddlib";
+            const std::string MarkovChainSettings::cudaOptionName = "cuda";
+            const std::string MarkovChainSettings::prismCompatibilityOptionName = "prismcompat";
+            const std::string MarkovChainSettings::prismCompatibilityOptionShortName = "pc";
+			const std::string MarkovChainSettings::minMaxEquationSolvingTechniqueOptionName = "minMaxEquationSolvingTechnique";
+            
+            MarkovChainSettings::MarkovChainSettings() : ModuleSettings(moduleName) {
+                this->addOption(storm::settings::OptionBuilder(moduleName, prismCompatibilityOptionName, false, "Enables PRISM compatibility. This may be necessary to process some PRISM models.").setShortName(prismCompatibilityOptionShortName).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, exportDotOptionName, "", "If given, the loaded model will be written to the specified file in the dot format.")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file to which the model is to be written.").build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, exportMatOptionName, "", "If given, the loaded model will be written to the specified file in the mat format.")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "the name of the file to which the model is to be writen.").build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, explicitOptionName, false, "Parses the model given in an explicit (sparse) representation.").setShortName(explicitOptionShortName)
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("transition filename", "The name of the file from which to read the transitions.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build())
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("labeling filename", "The name of the file from which to read the state labeling.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, symbolicOptionName, false, "Parses the model given in a symbolic representation.").setShortName(symbolicOptionShortName)
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file from which to read the symbolic model.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
+
+                std::vector<std::string> explorationOrders = {"dfs", "bfs"};
+                this->addOption(storm::settings::OptionBuilder(moduleName, explorationOrderOptionName, false, "Sets which exploration order to use.").setShortName(explorationOrderOptionShortName)
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the exploration order to choose. Available are: dfs and bfs.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(explorationOrders)).setDefaultValueString("bfs").build()).build());
+
+                this->addOption(storm::settings::OptionBuilder(moduleName, counterexampleOptionName, false, "Generates a counterexample for the given PRCTL formulas if not satisfied by the model")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file to which the counterexample is to be written.").setDefaultValueString("-").setIsOptional(true).build()).setShortName(counterexampleOptionShortName).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, transitionRewardsOptionName, false, "If given, the transition rewards are read from this file and added to the explicit model. Note that this requires the model to be given as an explicit model (i.e., via --" + explicitOptionName + ").")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The file from which to read the transition rewards.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, stateRewardsOptionName, false, "If given, the state rewards are read from this file and added to the explicit model. Note that this requires the model to be given as an explicit model (i.e., via --" + explicitOptionName + ").")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The file from which to read the state rewards.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, choiceLabelingOptionName, false, "If given, the choice labels are read from this file and added to the explicit model. Note that this requires the model to be given as an explicit model (i.e., via --" + explicitOptionName + ").")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The file from which to read the choice labels.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, dontFixDeadlockOptionName, false, "If the model contains deadlock states, they need to be fixed by setting this option.").setShortName(dontFixDeadlockOptionShortName).build());
+                
+                std::vector<std::string> engines = {"sparse", "hybrid", "dd", "abs"};
+                this->addOption(storm::settings::OptionBuilder(moduleName, engineOptionName, false, "Sets which engine is used for model building and model checking.").setShortName(engineOptionShortName)
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the engine to use. Available are {sparse, hybrid, dd, ar}.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(engines)).setDefaultValueString("sparse").build()).build());
+                
+                std::vector<std::string> linearEquationSolver = {"gmm++", "native"};
+                this->addOption(storm::settings::OptionBuilder(moduleName, eqSolverOptionName, false, "Sets which solver is preferred for solving systems of linear equations.")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the solver to prefer. Available are: gmm++ and native.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(linearEquationSolver)).setDefaultValueString("gmm++").build()).build());
+                
+                std::vector<std::string> ddLibraries = {"cudd", "sylvan"};
+                this->addOption(storm::settings::OptionBuilder(moduleName, ddLibraryOptionName, false, "Sets which library is preferred for decision-diagram operations.")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the library to prefer. Available are: cudd and sylvan.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(ddLibraries)).setDefaultValueString("cudd").build()).build());
+                
+                std::vector<std::string> lpSolvers = {"gurobi", "glpk"};
+                this->addOption(storm::settings::OptionBuilder(moduleName, lpSolverOptionName, false, "Sets which LP solver is preferred.")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of an LP solver. Available are: gurobi and glpk.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(lpSolvers)).setDefaultValueString("glpk").build()).build());
+                std::vector<std::string> smtSolvers = {"z3", "mathsat"};
+                this->addOption(storm::settings::OptionBuilder(moduleName, smtSolverOptionName, false, "Sets which SMT solver is preferred.")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of an SMT solver. Available are: z3 and mathsat.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(smtSolvers)).setDefaultValueString("z3").build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, constantsOptionName, false, "Specifies the constant replacements to use in symbolic models. Note that Note that this requires the model to be given as an symbolic model (i.e., via --" + symbolicOptionName + ").").setShortName(constantsOptionShortName)
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("values", "A comma separated list of constants and their value, e.g. a=1,b=2,c=3.").setDefaultValueString("").build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, statisticsOptionName, false, "Sets whether to display statistics if available.").setShortName(statisticsOptionShortName).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, cudaOptionName, false, "Sets whether to use CUDA to speed up computation time.").build());
+
+				std::vector<std::string> minMaxSolvingTechniques = {"policyIteration", "valueIteration"};
+				this->addOption(storm::settings::OptionBuilder(moduleName, minMaxEquationSolvingTechniqueOptionName, false, "Sets which min/max linear equation solving technique is preferred.")
+					.addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of a min/max linear equation solving technique. Available are: valueIteration and policyIteration.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(minMaxSolvingTechniques)).setDefaultValueString("valueIteration").build()).build());
+            }
+
+            bool MarkovChainSettings::isExportDotSet() const {
+                return this->getOption(exportDotOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string MarkovChainSettings::getExportDotFilename() const {
+                return this->getOption(exportDotOptionName).getArgumentByName("filename").getValueAsString();
+            }
+
+            bool MarkovChainSettings::isExplicitSet() const {
+                return this->getOption(explicitOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string MarkovChainSettings::getTransitionFilename() const {
+                return this->getOption(explicitOptionName).getArgumentByName("transition filename").getValueAsString();
+            }
+                        
+            std::string MarkovChainSettings::getLabelingFilename() const {
+                return this->getOption(explicitOptionName).getArgumentByName("labeling filename").getValueAsString();
+            }
+            
+            bool MarkovChainSettings::isSymbolicSet() const {
+                return this->getOption(symbolicOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string MarkovChainSettings::getSymbolicModelFilename() const {
+                return this->getOption(symbolicOptionName).getArgumentByName("filename").getValueAsString();
+            }
+            
+            bool MarkovChainSettings::isExplorationOrderSet() const {
+                return this->getOption(explorationOrderOptionName).getHasOptionBeenSet();
+            }
+            
+            storm::builder::ExplorationOrder MarkovChainSettings::getExplorationOrder() const {
+                std::string explorationOrderAsString = this->getOption(explorationOrderOptionName).getArgumentByName("name").getValueAsString();
+                if (explorationOrderAsString == "dfs") {
+                    return storm::builder::ExplorationOrder::Dfs;
+                } else if (explorationOrderAsString == "bfs") {
+                    return storm::builder::ExplorationOrder::Bfs;
+                }
+                STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown exploration order '" << explorationOrderAsString << "'.");
+            }
+            
+            bool MarkovChainSettings::isTransitionRewardsSet() const {
+                return this->getOption(transitionRewardsOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string MarkovChainSettings::getTransitionRewardsFilename() const {
+                return this->getOption(transitionRewardsOptionName).getArgumentByName("filename").getValueAsString();
+            }
+            
+            bool MarkovChainSettings::isStateRewardsSet() const {
+                return this->getOption(stateRewardsOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string MarkovChainSettings::getStateRewardsFilename() const {
+                return this->getOption(stateRewardsOptionName).getArgumentByName("filename").getValueAsString();
+            }
+            
+            bool MarkovChainSettings::isChoiceLabelingSet() const {
+                return this->getOption(choiceLabelingOptionName).getHasOptionBeenSet();
+            }
+                
+            std::string MarkovChainSettings::getChoiceLabelingFilename() const {
+                return this->getOption(choiceLabelingOptionName).getArgumentByName("filename").getValueAsString();
+            }
+            
+            bool MarkovChainSettings::isCounterexampleSet() const {
+                return this->getOption(counterexampleOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string MarkovChainSettings::getCounterexampleFilename() const {
+                return this->getOption(counterexampleOptionName).getArgumentByName("filename").getValueAsString();
+            }
+            
+            bool MarkovChainSettings::isDontFixDeadlocksSet() const {
+                return this->getOption(dontFixDeadlockOptionName).getHasOptionBeenSet();
+            }
+            
+            std::unique_ptr<storm::settings::SettingMemento> MarkovChainSettings::overrideDontFixDeadlocksSet(bool stateToSet) {
+                return this->overrideOption(dontFixDeadlockOptionName, stateToSet);
+            }
+            
+            std::unique_ptr<storm::settings::SettingMemento> MarkovChainSettings::overridePrismCompatibilityMode(bool stateToSet) {
+                return this->overrideOption(prismCompatibilityOptionName, stateToSet);
+            }
+            
+            storm::solver::EquationSolverType  MarkovChainSettings::getEquationSolver() const {
+                std::string equationSolverName = this->getOption(eqSolverOptionName).getArgumentByName("name").getValueAsString();
+                if (equationSolverName == "gmm++") {
+                    return storm::solver::EquationSolverType::Gmmxx;
+                } else if (equationSolverName == "native") {
+                    return storm::solver::EquationSolverType::Native;
+                }
+                STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown equation solver '" << equationSolverName << "'.");
+            }
+            
+            bool MarkovChainSettings::isEquationSolverSet() const {
+                return this->getOption(eqSolverOptionName).getHasOptionBeenSet();
+            }
+            
+            storm::solver::LpSolverType MarkovChainSettings::getLpSolver() const {
+                std::string lpSolverName = this->getOption(lpSolverOptionName).getArgumentByName("name").getValueAsString();
+                if (lpSolverName == "gurobi") {
+                    return storm::solver::LpSolverType::Gurobi;
+                } else if (lpSolverName == "glpk") {
+                    return storm::solver::LpSolverType::Glpk;
+                }
+                STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown LP solver '" << lpSolverName << "'.");
+            }
+            
+            storm::solver::SmtSolverType MarkovChainSettings::getSmtSolver() const {
+                std::string smtSolverName = this->getOption(smtSolverOptionName).getArgumentByName("name").getValueAsString();
+                if (smtSolverName == "z3") {
+                    return storm::solver::SmtSolverType::Z3;
+                } else if (smtSolverName == "mathsat") {
+                    return storm::solver::SmtSolverType::Mathsat;
+                }
+                STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown SMT solver '" << smtSolverName << "'.");
+            }
+            
+            storm::dd::DdType MarkovChainSettings::getDdLibraryType() const {
+                std::string ddLibraryAsString = this->getOption(ddLibraryOptionName).getArgumentByName("name").getValueAsString();
+                if (ddLibraryAsString == "sylvan") {
+                    return storm::dd::DdType::Sylvan;
+                } else {
+                    return storm::dd::DdType::CUDD;
+                }
+            }
+            
+            bool MarkovChainSettings::isConstantsSet() const {
+                return this->getOption(constantsOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string MarkovChainSettings::getConstantDefinitionString() const {
+                return this->getOption(constantsOptionName).getArgumentByName("values").getValueAsString();
+            }
+            
+            bool MarkovChainSettings::isShowStatisticsSet() const {
+                return this->getOption(statisticsOptionName).getHasOptionBeenSet();
+            }
+            
+            bool MarkovChainSettings::isCudaSet() const {
+                return this->getOption(cudaOptionName).getHasOptionBeenSet();
+            }
+            
+            MarkovChainSettings::Engine MarkovChainSettings::getEngine() const {
+                return engine;
+            }
+
+            void MarkovChainSettings::setEngine(Engine newEngine) {
+                this->engine = newEngine;
+            }
+            
+            bool MarkovChainSettings::isPrismCompatibilityEnabled() const {
+                return this->getOption(prismCompatibilityOptionName).getHasOptionBeenSet();
+            }
+
+			storm::solver::MinMaxTechnique MarkovChainSettings::getMinMaxEquationSolvingTechnique() const {
+				std::string minMaxEquationSolvingTechnique = this->getOption(minMaxEquationSolvingTechniqueOptionName).getArgumentByName("name").getValueAsString();
+				if (minMaxEquationSolvingTechnique == "valueIteration") {
+					return storm::solver::MinMaxTechnique::ValueIteration;
+				} else if (minMaxEquationSolvingTechnique == "policyIteration") {
+					return storm::solver::MinMaxTechnique::PolicyIteration;
+				}
+				STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown min/max equation solving technique '" << minMaxEquationSolvingTechnique << "'.");
+			}
+
+			bool MarkovChainSettings::isMinMaxEquationSolvingTechniqueSet() const {
+				return this->getOption(minMaxEquationSolvingTechniqueOptionName).getHasOptionBeenSet();
+			}
+            
+            void MarkovChainSettings::finalize() {
+                // Finalize engine.
+                std::string engineStr = this->getOption(engineOptionName).getArgumentByName("name").getValueAsString();
+                if (engineStr == "sparse") {
+                    engine =  MarkovChainSettings::Engine::Sparse;
+                } else if (engineStr == "hybrid") {
+                    engine = MarkovChainSettings::Engine::Hybrid;
+                } else if (engineStr == "dd") {
+                    engine = MarkovChainSettings::Engine::Dd;
+                } else if (engineStr == "abs") {
+                    engine = MarkovChainSettings::Engine::AbstractionRefinement;
+                } else {
+                    STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown engine '" << engineStr << "'.");
+                }
+            }
+
+            bool MarkovChainSettings::check() const {
+                // Ensure that the model was given either symbolically or explicitly.
+                STORM_LOG_THROW(!isSymbolicSet() || !isExplicitSet(), storm::exceptions::InvalidSettingsException, "The model may be either given in an explicit or a symbolic format, but not both.");
+                
+                STORM_LOG_THROW(this->getEngine() == Engine::Sparse || !isExplicitSet(), storm::exceptions::InvalidSettingsException, "Cannot use explicit input models with this engine.");
+                
+                return true;
+            }
+
+        } // namespace modules
+    } // namespace settings
+} // namespace storm
\ No newline at end of file
diff --git a/src/settings/modules/MarkovChainSettings.h b/src/settings/modules/MarkovChainSettings.h
new file mode 100644
index 000000000..193b47c44
--- /dev/null
+++ b/src/settings/modules/MarkovChainSettings.h
@@ -0,0 +1,332 @@
+#ifndef STORM_SETTINGS_MODULES_MARKOVCHAINSETTINGS_H_
+#define STORM_SETTINGS_MODULES_MARKOVCHAINSETTINGS_H_
+
+#include "storm-config.h"
+#include "src/settings/modules/ModuleSettings.h"
+
+#include "src/builder/ExplorationOrder.h"
+
+namespace storm {
+    namespace solver {
+        enum class EquationSolverType;
+        enum class LpSolverType;
+        enum class MinMaxTechnique;
+        enum class SmtSolverType;
+    }
+    
+    namespace dd {
+        enum class DdType;
+    }
+
+    namespace settings {
+        namespace modules {
+
+            /*!
+             * This class represents the markov chain settings.
+             */
+            class MarkovChainSettings : public ModuleSettings {
+            public:
+                // An enumeration of all engines.
+                enum class Engine {
+                    Sparse, Hybrid, Dd, AbstractionRefinement
+                };
+
+                /*!
+                 * Creates a new set of markov chain settings.
+                 */
+                MarkovChainSettings();
+
+                /*!
+                 * Retrieves whether the export-to-dot option was set.
+                 *
+                 * @return True if the export-to-dot option was set.
+                 */
+                bool isExportDotSet() const;
+
+                /*!
+                 * Retrieves the name in which to write the model in dot format, if the export-to-dot option was set.
+                 *
+                 * @return The name of the file in which to write the exported model.
+                 */
+                std::string getExportDotFilename() const;
+
+                /*!
+                 * Retrieves whether the explicit option was set.
+                 *
+                 * @return True if the explicit option was set.
+                 */
+                bool isExplicitSet() const;
+
+                /*!
+                 * Retrieves the name of the file that contains the transitions if the model was given using the explicit
+                 * option.
+                 *
+                 * @return The name of the file that contains the transitions.
+                 */
+                std::string getTransitionFilename() const;
+
+                /*!
+                 * Retrieves the name of the file that contains the state labeling if the model was given using the
+                 * explicit option.
+                 *
+                 * @return The name of the file that contains the state labeling.
+                 */
+                std::string getLabelingFilename() const;
+
+                /*!
+                 * Retrieves whether the symbolic option was set.
+                 *
+                 * @return True if the symbolic option was set.
+                 */
+                bool isSymbolicSet() const;
+
+                /*!
+                 * Retrieves the name of the file that contains the symbolic model specification if the model was given
+                 * using the symbolic option.
+                 *
+                 * @return The name of the file that contains the symbolic model specification.
+                 */
+                std::string getSymbolicModelFilename() const;
+                
+                /*!
+                 * Retrieves whether the model exploration order was set.
+                 *
+                 * @return True if the model exploration option was set.
+                 */
+                bool isExplorationOrderSet() const;
+                
+                /*!
+                 * Retrieves the exploration order if it was set.
+                 *
+                 * @return The chosen exploration order.
+                 */
+                storm::builder::ExplorationOrder getExplorationOrder() const;
+
+                /*!
+                 * Retrieves whether the transition reward option was set.
+                 *
+                 * @return True if the transition reward option was set.
+                 */
+                bool isTransitionRewardsSet() const;
+
+                /*!
+                 * Retrieves the name of the file that contains the transition rewards if the model was given using the
+                 * explicit option.
+                 *
+                 * @return The name of the file that contains the transition rewards.
+                 */
+                std::string getTransitionRewardsFilename() const;
+
+                /*!
+                 * Retrieves whether the state reward option was set.
+                 *
+                 * @return True if the state reward option was set.
+                 */
+                bool isStateRewardsSet() const;
+
+                /*!
+                 * Retrieves the name of the file that contains the state rewards if the model was given using the
+                 * explicit option.
+                 *
+                 * @return The name of the file that contains the state rewards.
+                 */
+                std::string getStateRewardsFilename() const;
+
+                /*!
+                 * Retrieves whether the choice labeling option was set.
+                 * 
+                 * @return True iff the choice labeling option was set.
+                 */
+                bool isChoiceLabelingSet() const;
+
+                /*!
+                 * Retrieves the name of the file that contains the choice labeling
+                 * if the model was given using the explicit option.
+                 *
+                 * @return The name of the file that contains the choice labeling.
+                 */
+                std::string getChoiceLabelingFilename() const;
+
+                /*!
+                 * Retrieves whether the counterexample option was set.
+                 *
+                 * @return True if the counterexample option was set.
+                 */
+                bool isCounterexampleSet() const;
+
+                /*!
+                 * Retrieves the name of the file to which the counterexample is to be written if the counterexample
+                 * option was set.
+                 *
+                 * @return The name of the file to which the counterexample is to be written.
+                 */
+                std::string getCounterexampleFilename() const;
+
+                /*!
+                 * Retrieves whether the dont-fix-deadlocks option was set.
+                 *
+                 * @return True if the dont-fix-deadlocks option was set.
+                 */
+                bool isDontFixDeadlocksSet() const;
+
+                /*!
+                 * Overrides the option to not fix deadlocks by setting it to the specified value. As soon as the
+                 * returned memento goes out of scope, the original value is restored.
+                 *
+                 * @param stateToSet The value that is to be set for the fix-deadlocks option.
+                 * @return The memento that will eventually restore the original value.
+                 */
+                std::unique_ptr<storm::settings::SettingMemento> overrideDontFixDeadlocksSet(bool stateToSet);
+
+                /*!
+                 * Overrides the option to enable the PRISM compatibility mode by setting it to the specified value. As
+                 * soon as the returned memento goes out of scope, the original value is restored.
+                 *
+                 * @param stateToSet The value that is to be set for the option.
+                 * @return The memento that will eventually restore the original value.
+                 */
+                std::unique_ptr<storm::settings::SettingMemento> overridePrismCompatibilityMode(bool stateToSet);
+
+                /*!
+                 * Retrieves the selected equation solver.
+                 *
+                 * @return The selected convergence criterion.
+                 */
+                storm::solver::EquationSolverType getEquationSolver() const;
+
+                /*!
+                 * Retrieves whether a equation solver has been set.
+                 *
+                 * @return True iff an equation solver has been set.
+                 */
+                bool isEquationSolverSet() const;
+
+                /*!
+                 * Retrieves the selected LP solver.
+                 *
+                 * @return The selected LP solver.
+                 */
+                storm::solver::LpSolverType getLpSolver() const;
+
+                /*!
+                 * Retrieves the selected SMT solver.
+                 *
+                 * @return The selected SMT solver.
+                 */
+                storm::solver::SmtSolverType getSmtSolver() const;
+                
+                /*!
+                 * Retrieves the selected library for DD-related operations.
+                 *
+                 * @return The selected library.
+                 */
+                storm::dd::DdType getDdLibraryType() const;
+                
+                /*!
+                 * Retrieves whether the export-to-dot option was set.
+                 *
+                 * @return True if the export-to-dot option was set.
+                 */
+                bool isConstantsSet() const;
+
+                /*!
+                 * Retrieves the string that defines the constants of a symbolic model (given via the symbolic option).
+                 *
+                 * @return The string that defines the constants of a symbolic model.
+                 */
+                std::string getConstantDefinitionString() const;
+
+                /*!
+                 * Retrieves whether statistics are to be shown for counterexample generation.
+                 *
+                 * @return True iff statistics are to be shown for counterexample generation.
+                 */
+                bool isShowStatisticsSet() const;
+
+                /*!
+                 * Retrieves whether the option to use CUDA is set.
+                 *
+                 * @return True iff the option was set.
+                 */
+                bool isCudaSet() const;
+
+                /*!
+                 * Retrieves the selected engine.
+                 *
+                 * @return The selected engine.
+                 */
+                Engine getEngine() const;
+
+                /*!
+                 * Sets the engine for further usage.
+                 */
+                void setEngine(Engine);
+
+                /*!
+                 * Retrieves whether the PRISM compatibility mode was enabled.
+                 *
+                 * @return True iff the PRISM compatibility mode was enabled.
+                 */
+                bool isPrismCompatibilityEnabled() const;
+
+                /*!
+                 * Retrieves whether a min/max equation solving technique has been set.
+                 *
+                 * @return True iff an equation solving technique has been set.
+                 */
+                bool isMinMaxEquationSolvingTechniqueSet() const;
+
+                /*!
+                 * Retrieves the selected min/max equation solving technique.
+                 *
+                 * @return The selected min/max equation solving technique.
+                 */
+                storm::solver::MinMaxTechnique getMinMaxEquationSolvingTechnique() const;
+
+
+                bool check() const override;
+                void finalize() override;
+
+                // The name of the module.
+                static const std::string moduleName;
+
+            private:
+                Engine engine;
+
+                // Define the string names of the options as constants.
+                static const std::string exportDotOptionName;
+                static const std::string exportMatOptionName;
+                static const std::string explicitOptionName;
+                static const std::string explicitOptionShortName;
+                static const std::string symbolicOptionName;
+                static const std::string symbolicOptionShortName;
+                static const std::string explorationOrderOptionName;
+                static const std::string explorationOrderOptionShortName;
+                static const std::string transitionRewardsOptionName;
+                static const std::string stateRewardsOptionName;
+                static const std::string choiceLabelingOptionName;
+                static const std::string counterexampleOptionName;
+                static const std::string counterexampleOptionShortName;
+                static const std::string dontFixDeadlockOptionName;
+                static const std::string dontFixDeadlockOptionShortName;
+                static const std::string eqSolverOptionName;
+                static const std::string lpSolverOptionName;
+                static const std::string smtSolverOptionName;
+                static const std::string constantsOptionName;
+                static const std::string constantsOptionShortName;
+                static const std::string statisticsOptionName;
+                static const std::string statisticsOptionShortName;
+                static const std::string engineOptionName;
+                static const std::string engineOptionShortName;
+                static const std::string ddLibraryOptionName;
+                static const std::string cudaOptionName;
+                static const std::string prismCompatibilityOptionName;
+                static const std::string prismCompatibilityOptionShortName;
+                static const std::string minMaxEquationSolvingTechniqueOptionName;
+            };
+
+        } // namespace modules
+    } // namespace settings
+} // namespace storm
+
+#endif /* STORM_SETTINGS_MODULES_MARKOVCHAINSETTINGS_H_ */
diff --git a/src/settings/modules/NativeEquationSolverSettings.cpp b/src/settings/modules/NativeEquationSolverSettings.cpp
index abc1860ee..251e7f1aa 100644
--- a/src/settings/modules/NativeEquationSolverSettings.cpp
+++ b/src/settings/modules/NativeEquationSolverSettings.cpp
@@ -1,7 +1,7 @@
 #include "src/settings/modules/NativeEquationSolverSettings.h"
 
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/settings/Option.h"
 #include "src/settings/OptionBuilder.h"
 #include "src/settings/ArgumentBuilder.h"
@@ -81,11 +81,11 @@ namespace storm {
                 // This list does not include the precision, because this option is shared with other modules.
                 bool optionSet = isLinearEquationSystemTechniqueSet() || isMaximalIterationCountSet() || isConvergenceCriterionSet();
                 
-                STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEquationSolver() == storm::solver::EquationSolverType::Native || !optionSet, "Native is not selected as the preferred equation solver, so setting options for native might have no effect.");
+                STORM_LOG_WARN_COND(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getEquationSolver() == storm::solver::EquationSolverType::Native || !optionSet, "Native is not selected as the preferred equation solver, so setting options for native might have no effect.");
                 
                 return true;
             }
             
         } // namespace modules
     } // namespace settings
-} // namespace storm
\ No newline at end of file
+} // namespace storm
diff --git a/src/solver/MinMaxLinearEquationSolver.cpp b/src/solver/MinMaxLinearEquationSolver.cpp
index 13bec6708..dea71fe58 100644
--- a/src/solver/MinMaxLinearEquationSolver.cpp
+++ b/src/solver/MinMaxLinearEquationSolver.cpp
@@ -1,6 +1,6 @@
 #include "MinMaxLinearEquationSolver.h"
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 
 #include "src/utility/macros.h"
 #include "src/exceptions/NotImplementedException.h"
@@ -12,7 +12,7 @@ namespace storm {
         AbstractMinMaxLinearEquationSolver<ValueType>::AbstractMinMaxLinearEquationSolver(double precision, bool relativeError, uint_fast64_t maximalIterations, bool trackScheduler, MinMaxTechniqueSelection prefTech) : precision(precision), relative(relativeError), maximalNumberOfIterations(maximalIterations), trackScheduler(trackScheduler) {
             
             if(prefTech == MinMaxTechniqueSelection::FROMSETTINGS) {
-                useValueIteration = (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getMinMaxEquationSolvingTechnique() == storm::solver::MinMaxTechnique::ValueIteration);
+                useValueIteration = (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getMinMaxEquationSolvingTechnique() == storm::solver::MinMaxTechnique::ValueIteration);
             } else {
                 useValueIteration = (prefTech == MinMaxTechniqueSelection::ValueIteration);
             }
diff --git a/src/solver/TopologicalMinMaxLinearEquationSolver.cpp b/src/solver/TopologicalMinMaxLinearEquationSolver.cpp
index 4e34826a1..0140fec1d 100644
--- a/src/solver/TopologicalMinMaxLinearEquationSolver.cpp
+++ b/src/solver/TopologicalMinMaxLinearEquationSolver.cpp
@@ -9,7 +9,7 @@
 
 
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/settings/modules/NativeEquationSolverSettings.h"
 #include "src/settings/modules/TopologicalValueIterationEquationSolverSettings.h"
 
@@ -27,7 +27,7 @@ namespace storm {
         NativeMinMaxLinearEquationSolver<ValueType>(A, storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getPrecision(), storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getMaximalIterationCount(), MinMaxTechniqueSelection::ValueIteration, storm::settings::getModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>().getConvergenceCriterion() == storm::settings::modules::TopologicalValueIterationEquationSolverSettings::ConvergenceCriterion::Relative)
         {
 			// Get the settings object to customize solving.
-			this->enableCuda = storm::settings::getModule<storm::settings::modules::GeneralSettings>().isCudaSet();
+			this->enableCuda = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isCudaSet();
 #ifdef STORM_HAVE_CUDA
 			STORM_LOG_INFO_COND(this->enableCuda, "Option CUDA was not set, but the topological value iteration solver will use it anyways.");
 #endif
diff --git a/src/storage/bisimulation/BisimulationDecomposition.cpp b/src/storage/bisimulation/BisimulationDecomposition.cpp
index 048622c26..fb6a6c759 100644
--- a/src/storage/bisimulation/BisimulationDecomposition.cpp
+++ b/src/storage/bisimulation/BisimulationDecomposition.cpp
@@ -13,7 +13,7 @@
 #include "src/modelchecker/results/ExplicitQualitativeCheckResult.h"
 
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 
 #include "src/logic/FormulaInformation.h"
 #include "src/logic/FragmentSpecification.h"
@@ -210,7 +210,7 @@ namespace storm {
             
             std::chrono::high_resolution_clock::duration totalTime = std::chrono::high_resolution_clock::now() - totalStart;
             
-            if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isShowStatisticsSet()) {
+            if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isShowStatisticsSet()) {
                 std::chrono::milliseconds initialPartitionTimeInMilliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(initialPartitionTime);
                 std::chrono::milliseconds refinementTimeInMilliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(refinementTime);
                 std::chrono::milliseconds extractionTimeInMilliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(extractionTime);
diff --git a/src/storage/prism/Program.cpp b/src/storage/prism/Program.cpp
index 4137bec09..229f205f5 100644
--- a/src/storage/prism/Program.cpp
+++ b/src/storage/prism/Program.cpp
@@ -6,7 +6,7 @@
 
 #include "src/storage/expressions/ExpressionManager.h"
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/utility/macros.h"
 #include "src/utility/solver.h"
 #include "src/exceptions/InvalidArgumentException.h"
@@ -56,7 +56,7 @@ namespace storm {
 
                 // If the model is supposed to be a CTMC, but contains probabilistic commands, we transform them to Markovian
                 // commands and issue a warning.
-                if (modelType == storm::prism::Program::ModelType::CTMC && storm::settings::getModule<storm::settings::modules::GeneralSettings>().isPrismCompatibilityEnabled()) {
+                if (modelType == storm::prism::Program::ModelType::CTMC && storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isPrismCompatibilityEnabled()) {
                     bool hasProbabilisticCommands = false;
                     for (auto& module : this->modules) {
                         for (auto& command : module.getCommands()) {
@@ -829,7 +829,7 @@ namespace storm {
             }
             
             if (hasLabeledMarkovianCommand) {
-                if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isPrismCompatibilityEnabled()) {
+                if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isPrismCompatibilityEnabled()) {
                     STORM_LOG_WARN_COND(false, "The model uses synchronizing Markovian commands. This may lead to unexpected verification results, because of unclear semantics.");
                 } else {
                     STORM_LOG_THROW(false, storm::exceptions::WrongFormatException, "The model uses synchronizing Markovian commands. This may lead to unexpected verification results, because of unclear semantics.");
diff --git a/src/utility/solver.cpp b/src/utility/solver.cpp
index 5709e1f58..77f644949 100644
--- a/src/utility/solver.cpp
+++ b/src/utility/solver.cpp
@@ -19,7 +19,7 @@
 #include "src/solver/Z3SmtSolver.h"
 #include "src/solver/MathsatSmtSolver.h"
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/settings/modules/NativeEquationSolverSettings.h"
 
 #include "src/exceptions/InvalidSettingsException.h"
@@ -46,7 +46,7 @@ namespace storm {
             
             template<typename ValueType>
             std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> LinearEquationSolverFactory<ValueType>::create(storm::storage::SparseMatrix<ValueType> const& matrix) const {
-                storm::solver::EquationSolverType equationSolver = storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEquationSolver();
+                storm::solver::EquationSolverType equationSolver = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getEquationSolver();
                 switch (equationSolver) {
                     case storm::solver::EquationSolverType::Gmmxx: return std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>>(new storm::solver::GmmxxLinearEquationSolver<ValueType>(matrix));
                     case storm::solver::EquationSolverType::Native: return std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>>(new storm::solver::NativeLinearEquationSolver<ValueType>(matrix));
@@ -93,7 +93,7 @@ namespace storm {
             template<typename ValueType>
             MinMaxLinearEquationSolverFactory<ValueType>& MinMaxLinearEquationSolverFactory<ValueType>::setSolverType(storm::solver::EquationSolverTypeSelection solverTypeSel) {
                 if(solverTypeSel == storm::solver::EquationSolverTypeSelection::FROMSETTINGS) {
-                    this->solverType = storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEquationSolver();
+                    this->solverType = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getEquationSolver();
                 } else {
                     this->solverType = storm::solver::convert(solverTypeSel);
                 }
@@ -140,7 +140,7 @@ namespace storm {
             std::unique_ptr<storm::solver::LpSolver> LpSolverFactory::create(std::string const& name, storm::solver::LpSolverTypeSelection solvT) const {
                 storm::solver::LpSolverType t;
                 if(solvT == storm::solver::LpSolverTypeSelection::FROMSETTINGS) {
-                    t = storm::settings::getModule<storm::settings::modules::GeneralSettings>().getLpSolver();
+                    t = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getLpSolver();
                 } else {
                     t = convert(solvT);
                 }
@@ -168,7 +168,7 @@ namespace storm {
             }
             
             std::unique_ptr<storm::solver::SmtSolver> SmtSolverFactory::create(storm::expressions::ExpressionManager& manager) const {
-                storm::solver::SmtSolverType smtSolverType = storm::settings::getModule<storm::settings::modules::GeneralSettings>().getSmtSolver();
+                storm::solver::SmtSolverType smtSolverType = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getSmtSolver();
                 switch (smtSolverType) {
                     case storm::solver::SmtSolverType::Z3: return std::unique_ptr<storm::solver::SmtSolver>(new storm::solver::Z3SmtSolver(manager));
                     case storm::solver::SmtSolverType::Mathsat: return std::unique_ptr<storm::solver::SmtSolver>(new storm::solver::MathsatSmtSolver(manager));
@@ -201,4 +201,4 @@ namespace storm {
             template class GameSolverFactory<double>;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/utility/storm.h b/src/utility/storm.h
index 64f43fe0f..59f640bdf 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -20,6 +20,7 @@
 #include "src/settings/SettingsManager.h"
 
 
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/settings/modules/BisimulationSettings.h"
 #include "src/settings/modules/ParametricSettings.h"
 
@@ -95,10 +96,10 @@ namespace storm {
         storm::prism::Program translatedProgram;
 
         // Get the string that assigns values to the unknown currently undefined constants in the model.
-        std::string constants = storm::settings::getModule<storm::settings::modules::GeneralSettings>().getConstantDefinitionString();
+        std::string constants = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getConstantDefinitionString();
 
         // Customize and perform model-building.
-        if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEngine() == storm::settings::modules::GeneralSettings::Engine::Sparse) {
+        if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getEngine() == storm::settings::modules::MarkovChainSettings::Engine::Sparse) {
             typename storm::builder::ExplicitPrismModelBuilder<ValueType, storm::models::sparse::StandardRewardModel<ValueType>>::Options options;
             options = typename storm::builder::ExplicitPrismModelBuilder<ValueType, storm::models::sparse::StandardRewardModel<ValueType>>::Options(formulas);
             options.addConstantDefinitionsFromString(program, constants);
@@ -111,7 +112,7 @@ namespace storm {
             storm::builder::ExplicitPrismModelBuilder<ValueType> builder(program, options);
             result.model = builder.translate();
             translatedProgram = builder.getTranslatedProgram();
-        } else if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEngine() == storm::settings::modules::GeneralSettings::Engine::Dd || storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEngine() == storm::settings::modules::GeneralSettings::Engine::Hybrid) {
+        } else if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getEngine() == storm::settings::modules::MarkovChainSettings::Engine::Dd || storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getEngine() == storm::settings::modules::MarkovChainSettings::Engine::Hybrid) {
             typename storm::builder::DdPrismModelBuilder<LibraryType>::Options options;
             options = typename storm::builder::DdPrismModelBuilder<LibraryType>::Options(formulas);
             options.addConstantDefinitionsFromString(program, constants);
@@ -222,7 +223,7 @@ namespace storm {
     void generateCounterexample(storm::prism::Program const& program, std::shared_ptr<storm::models::sparse::Model<ValueType>> model, std::shared_ptr<const storm::logic::Formula> const& formula) {
         if (storm::settings::getModule<storm::settings::modules::CounterexampleGeneratorSettings>().isMinimalCommandSetGenerationSet()) {
             STORM_LOG_THROW(model->getType() == storm::models::ModelType::Mdp, storm::exceptions::InvalidTypeException, "Minimal command set generation is only available for MDPs.");
-            STORM_LOG_THROW(storm::settings::getModule<storm::settings::modules::GeneralSettings>().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "Minimal command set generation is only available for symbolic models.");
+            STORM_LOG_THROW(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "Minimal command set generation is only available for symbolic models.");
 
             std::shared_ptr<storm::models::sparse::Mdp<ValueType>> mdp = model->template as<storm::models::sparse::Mdp<ValueType>>();
 
@@ -232,7 +233,7 @@ namespace storm {
             if (useMILP) {
                 storm::counterexamples::MILPMinimalLabelSetGenerator<ValueType>::computeCounterexample(program, *mdp, formula);
             } else {
-                storm::counterexamples::SMTMinimalCommandSetGenerator<ValueType>::computeCounterexample(program, storm::settings::getModule<storm::settings::modules::GeneralSettings>().getConstantDefinitionString(), *mdp, formula);
+                storm::counterexamples::SMTMinimalCommandSetGenerator<ValueType>::computeCounterexample(program, storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getConstantDefinitionString(), *mdp, formula);
             }
 
         } else {
@@ -249,23 +250,23 @@ namespace storm {
 
     template<typename ValueType, storm::dd::DdType DdType>
     std::unique_ptr<storm::modelchecker::CheckResult> verifyModel(std::shared_ptr<storm::models::ModelBase> model, std::shared_ptr<const storm::logic::Formula> const& formula, bool onlyInitialStatesRelevant) {
-        switch(storm::settings::getModule<storm::settings::modules::GeneralSettings>().getEngine()) {
-            case storm::settings::modules::GeneralSettings::Engine::Sparse: {
+        switch(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getEngine()) {
+            case storm::settings::modules::MarkovChainSettings::Engine::Sparse: {
                 std::shared_ptr<storm::models::sparse::Model<ValueType>> sparseModel = model->template as<storm::models::sparse::Model<ValueType>>();
                 STORM_LOG_THROW(sparseModel != nullptr, storm::exceptions::InvalidArgumentException, "Sparse engine requires a sparse input model");
                 return verifySparseModel(sparseModel, formula, onlyInitialStatesRelevant);
             }
-            case storm::settings::modules::GeneralSettings::Engine::Hybrid: {
+            case storm::settings::modules::MarkovChainSettings::Engine::Hybrid: {
                 std::shared_ptr<storm::models::symbolic::Model<DdType>> ddModel = model->template as<storm::models::symbolic::Model<DdType>>();
                 STORM_LOG_THROW(ddModel != nullptr, storm::exceptions::InvalidArgumentException, "Hybrid engine requires a dd input model");
                 return verifySymbolicModelWithHybridEngine(ddModel, formula, onlyInitialStatesRelevant);
             }
-            case storm::settings::modules::GeneralSettings::Engine::Dd: {
+            case storm::settings::modules::MarkovChainSettings::Engine::Dd: {
                 std::shared_ptr<storm::models::symbolic::Model<DdType>> ddModel = model->template as<storm::models::symbolic::Model<DdType>>();
                 STORM_LOG_THROW(ddModel != nullptr, storm::exceptions::InvalidArgumentException, "Dd engine requires a dd input model");
                 return verifySymbolicModelWithDdEngine(ddModel, formula, onlyInitialStatesRelevant);
             }
-            case storm::settings::modules::GeneralSettings::Engine::AbstractionRefinement: {
+            case storm::settings::modules::MarkovChainSettings::Engine::AbstractionRefinement: {
                 STORM_LOG_ASSERT(false, "This position should not be reached, as at this point no model has been built.");
             }
         }
@@ -292,7 +293,7 @@ namespace storm {
         } else if (model->getType() == storm::models::ModelType::Mdp) {
             std::shared_ptr<storm::models::sparse::Mdp<ValueType>> mdp = model->template as<storm::models::sparse::Mdp<ValueType>>();
 #ifdef STORM_HAVE_CUDA
-            if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isCudaSet()) {
+            if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isCudaSet()) {
                     storm::modelchecker::TopologicalValueIterationMdpPrctlModelChecker<ValueType> modelchecker(*mdp);
                     result = modelchecker.check(task);
                 } else {
diff --git a/test/functional/builder/DdPrismModelBuilderTest.cpp b/test/functional/builder/DdPrismModelBuilderTest.cpp
index 102b7fb2a..9f1f66cf2 100644
--- a/test/functional/builder/DdPrismModelBuilderTest.cpp
+++ b/test/functional/builder/DdPrismModelBuilderTest.cpp
@@ -2,7 +2,7 @@
 #include "storm-config.h"
 #include "src/settings/SettingMemento.h"
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/models/symbolic/Dtmc.h"
 #include "src/models/symbolic/Ctmc.h"
 #include "src/models/symbolic/Mdp.h"
@@ -68,7 +68,7 @@ TEST(DdPrismModelBuilderTest_Cudd, Dtmc) {
 
 TEST(DdPrismModelBuilderTest_Sylvan, Ctmc) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
     
@@ -99,7 +99,7 @@ TEST(DdPrismModelBuilderTest_Sylvan, Ctmc) {
 
 TEST(DdPrismModelBuilderTest_Cudd, Ctmc) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
 
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
     
@@ -250,4 +250,4 @@ TEST(DdPrismModelBuilderTest_Cudd, Mdp) {
     EXPECT_EQ(37ul, mdp->getNumberOfStates());
     EXPECT_EQ(59ul, mdp->getNumberOfTransitions());
     EXPECT_EQ(59ul, mdp->getNumberOfChoices());
-}
\ No newline at end of file
+}
diff --git a/test/functional/builder/ExplicitPrismModelBuilderTest.cpp b/test/functional/builder/ExplicitPrismModelBuilderTest.cpp
index c2151c74c..634c106ee 100644
--- a/test/functional/builder/ExplicitPrismModelBuilderTest.cpp
+++ b/test/functional/builder/ExplicitPrismModelBuilderTest.cpp
@@ -5,7 +5,7 @@
 #include "src/parser/PrismParser.h"
 #include "src/builder/ExplicitPrismModelBuilder.h"
 
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 
 TEST(ExplicitPrismModelBuilderTest, Dtmc) {
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/die.pm");
@@ -37,7 +37,7 @@ TEST(ExplicitPrismModelBuilderTest, Dtmc) {
 
 TEST(ExplicitPrismModelBuilderTest, Ctmc) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
 
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
 
@@ -97,4 +97,4 @@ TEST(ExplicitPrismModelBuilderTest, Mdp) {
     model = storm::builder::ExplicitPrismModelBuilder<double>(program).translate();
     EXPECT_EQ(37ul, model->getNumberOfStates());
     EXPECT_EQ(59ul, model->getNumberOfTransitions());
-}
\ No newline at end of file
+}
diff --git a/test/functional/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp b/test/functional/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp
index 73c16edb1..7a28ad892 100644
--- a/test/functional/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp
+++ b/test/functional/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp
@@ -13,13 +13,14 @@
 
 #include "src/settings/SettingsManager.h"
 #include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 
 #include "src/settings/modules/NativeEquationSolverSettings.h"
 #include "src/settings/modules/GmmxxEquationSolverSettings.h"
 
 TEST(GmmxxCtmcCslModelCheckerTest, Cluster) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
@@ -102,7 +103,7 @@ TEST(GmmxxCtmcCslModelCheckerTest, Cluster) {
 
 TEST(GmmxxCtmcCslModelCheckerTest, Embedded) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/embedded2.sm");
@@ -171,7 +172,7 @@ TEST(GmmxxCtmcCslModelCheckerTest, Embedded) {
 
 TEST(GmmxxCtmcCslModelCheckerTest, Polling) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/polling2.sm");
@@ -205,14 +206,14 @@ TEST(GmmxxCtmcCslModelCheckerTest, Polling) {
 
 TEST(GmmxxCtmcCslModelCheckerTest, Fms) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // No properties to check at this point.
 }
 
 TEST(GmmxxCtmcCslModelCheckerTest, Tandem) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/tandem5.sm");
diff --git a/test/functional/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp b/test/functional/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp
index a128b4802..51a3a7bc9 100644
--- a/test/functional/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp
+++ b/test/functional/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp
@@ -16,13 +16,14 @@
 
 #include "src/settings/SettingsManager.h"
 #include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/settings/modules/GmmxxEquationSolverSettings.h"
 
 #include "src/settings/modules/NativeEquationSolverSettings.h"
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
@@ -119,7 +120,7 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
@@ -216,7 +217,7 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/embedded2.sm");
@@ -295,7 +296,7 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/embedded2.sm");
@@ -374,7 +375,7 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/polling2.sm");
@@ -410,7 +411,7 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Cudd) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/polling2.sm");
@@ -446,14 +447,14 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Sylvan) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Fms) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // No properties to check at this point.
 }
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/tandem5.sm");
@@ -541,7 +542,7 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/tandem5.sm");
@@ -625,4 +626,4 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>();
     EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
     EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
-}
\ No newline at end of file
+}
diff --git a/test/functional/modelchecker/NativeCtmcCslModelCheckerTest.cpp b/test/functional/modelchecker/NativeCtmcCslModelCheckerTest.cpp
index 6c94f0007..afa0e7e25 100644
--- a/test/functional/modelchecker/NativeCtmcCslModelCheckerTest.cpp
+++ b/test/functional/modelchecker/NativeCtmcCslModelCheckerTest.cpp
@@ -14,10 +14,11 @@
 #include "src/settings/modules/NativeEquationSolverSettings.h"
 
 #include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 
 TEST(NativeCtmcCslModelCheckerTest, Cluster) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
@@ -93,7 +94,7 @@ TEST(NativeCtmcCslModelCheckerTest, Cluster) {
 
 TEST(NativeCtmcCslModelCheckerTest, Embedded) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/embedded2.sm");
@@ -155,7 +156,7 @@ TEST(NativeCtmcCslModelCheckerTest, Embedded) {
 
 TEST(NativeCtmcCslModelCheckerTest, Polling) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/polling2.sm");
@@ -182,14 +183,14 @@ TEST(NativeCtmcCslModelCheckerTest, Polling) {
 
 TEST(NativeCtmcCslModelCheckerTest, Fms) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // No properties to check at this point.
 }
 
 TEST(NativeCtmcCslModelCheckerTest, Tandem) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/tandem5.sm");
diff --git a/test/functional/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp b/test/functional/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp
index d4b0fb9a5..3bfa011cb 100644
--- a/test/functional/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp
+++ b/test/functional/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp
@@ -16,12 +16,13 @@
 
 #include "src/settings/SettingsManager.h"
 #include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 
 #include "src/settings/modules/NativeEquationSolverSettings.h"
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
@@ -118,7 +119,7 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
@@ -215,7 +216,7 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/embedded2.sm");
@@ -294,7 +295,7 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/embedded2.sm");
@@ -373,7 +374,7 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/polling2.sm");
@@ -409,7 +410,7 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Cudd) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/polling2.sm");
@@ -445,14 +446,14 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Sylvan) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Fms) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // No properties to check at this point.
 }
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/tandem5.sm");
@@ -542,7 +543,7 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableGeneralSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/tandem5.sm");
@@ -628,4 +629,4 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     // FIXME: because of divergence, these results are not correct.
 //    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
 //    EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision());
-}
\ No newline at end of file
+}
diff --git a/test/functional/parser/DeterministicSparseTransitionParserTest.cpp b/test/functional/parser/DeterministicSparseTransitionParserTest.cpp
index 50b545d25..3f40c1edb 100644
--- a/test/functional/parser/DeterministicSparseTransitionParserTest.cpp
+++ b/test/functional/parser/DeterministicSparseTransitionParserTest.cpp
@@ -11,7 +11,7 @@
 #include "src/parser/DeterministicSparseTransitionParser.h"
 #include "src/storage/SparseMatrix.h"
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/settings/SettingMemento.h"
 #include "src/exceptions/FileIoException.h"
 #include "src/exceptions/WrongFormatException.h"
@@ -193,7 +193,7 @@ TEST(DeterministicSparseTransitionParserTest, MixedTransitionOrder) {
 
 TEST(DeterministicSparseTransitionParserTest, FixDeadlocks) {
     // Set the fixDeadlocks flag temporarily. It is set to its old value once the deadlockOption object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> fixDeadlocks = storm::settings::mutableGeneralSettings().overrideDontFixDeadlocksSet(false);
+    std::unique_ptr<storm::settings::SettingMemento> fixDeadlocks = storm::settings::mutableMarkovChainSettings().overrideDontFixDeadlocksSet(false);
 
     // Parse a transitions file with the fixDeadlocks Flag set and test if it works.
     storm::storage::SparseMatrix<double> transitionMatrix = storm::parser::DeterministicSparseTransitionParser<>::parseDeterministicTransitions(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/dtmc_deadlock.tra");
@@ -217,7 +217,7 @@ TEST(DeterministicSparseTransitionParserTest, FixDeadlocks) {
 
 TEST(DeterministicSparseTransitionParserTest, DontFixDeadlocks) {
     // Try to parse a transitions file containing a deadlock state with the fixDeadlocksFlag unset. This should throw an exception.
-    std::unique_ptr<storm::settings::SettingMemento> dontFixDeadlocks = storm::settings::mutableGeneralSettings().overrideDontFixDeadlocksSet(true);
+    std::unique_ptr<storm::settings::SettingMemento> dontFixDeadlocks = storm::settings::mutableMarkovChainSettings().overrideDontFixDeadlocksSet(true);
 
     ASSERT_THROW(storm::parser::DeterministicSparseTransitionParser<>::parseDeterministicTransitions(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/dtmc_deadlock.tra"), storm::exceptions::WrongFormatException);
 }
diff --git a/test/functional/parser/MarkovAutomatonSparseTransitionParserTest.cpp b/test/functional/parser/MarkovAutomatonSparseTransitionParserTest.cpp
index 4246c5b3d..e6cb09e54 100644
--- a/test/functional/parser/MarkovAutomatonSparseTransitionParserTest.cpp
+++ b/test/functional/parser/MarkovAutomatonSparseTransitionParserTest.cpp
@@ -8,7 +8,7 @@
 #include "gtest/gtest.h"
 #include "storm-config.h"
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 
 #include <vector>
 
@@ -187,7 +187,7 @@ TEST(MarkovAutomatonSparseTransitionParserTest, Whitespaces) {
 
 TEST(MarkovAutomatonSparseTransitionParserTest, FixDeadlocks) {
     // Set the fixDeadlocks flag temporarily. It is set to its old value once the deadlockOption object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> fixDeadlocks = storm::settings::mutableGeneralSettings().overrideDontFixDeadlocksSet(false);
+    std::unique_ptr<storm::settings::SettingMemento> fixDeadlocks = storm::settings::mutableMarkovChainSettings().overrideDontFixDeadlocksSet(false);
 
     // Parse a Markov Automaton transition file with the fixDeadlocks Flag set and test if it works.
     typename storm::parser::MarkovAutomatonSparseTransitionParser<>::Result result = storm::parser::MarkovAutomatonSparseTransitionParser<>::parseMarkovAutomatonTransitions(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/ma_deadlock.tra");
@@ -206,7 +206,7 @@ TEST(MarkovAutomatonSparseTransitionParserTest, FixDeadlocks) {
 
 TEST(MarkovAutomatonSparseTransitionParserTest, DontFixDeadlocks) {
     // Try to parse a Markov Automaton transition file containing a deadlock state with the fixDeadlocksFlag unset. This should throw an exception.
-    std::unique_ptr<storm::settings::SettingMemento> dontFixDeadlocks = storm::settings::mutableGeneralSettings().overrideDontFixDeadlocksSet(true);
+    std::unique_ptr<storm::settings::SettingMemento> dontFixDeadlocks = storm::settings::mutableMarkovChainSettings().overrideDontFixDeadlocksSet(true);
 
     ASSERT_THROW(storm::parser::MarkovAutomatonSparseTransitionParser<>::parseMarkovAutomatonTransitions(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/ma_deadlock.tra"), storm::exceptions::WrongFormatException);
 }
diff --git a/test/functional/parser/NondeterministicSparseTransitionParserTest.cpp b/test/functional/parser/NondeterministicSparseTransitionParserTest.cpp
index c5c0807bc..f177eaf40 100644
--- a/test/functional/parser/NondeterministicSparseTransitionParserTest.cpp
+++ b/test/functional/parser/NondeterministicSparseTransitionParserTest.cpp
@@ -13,7 +13,7 @@
 #include "src/settings/SettingMemento.h"
 
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/exceptions/FileIoException.h"
 #include "src/exceptions/WrongFormatException.h"
 
@@ -212,7 +212,7 @@ TEST(NondeterministicSparseTransitionParserTest, MixedTransitionOrder) {
 
 TEST(NondeterministicSparseTransitionParserTest, FixDeadlocks) {
 	// Set the fixDeadlocks flag temporarily. It is set to its old value once the deadlockOption object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> fixDeadlocks = storm::settings::mutableGeneralSettings().overrideDontFixDeadlocksSet(false);
+    std::unique_ptr<storm::settings::SettingMemento> fixDeadlocks = storm::settings::mutableMarkovChainSettings().overrideDontFixDeadlocksSet(false);
 
 	// Parse a transitions file with the fixDeadlocks Flag set and test if it works.
 	storm::storage::SparseMatrix<double> result(storm::parser::NondeterministicSparseTransitionParser<>::parseNondeterministicTransitions(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/mdp_deadlock.tra"));
@@ -253,7 +253,7 @@ TEST(NondeterministicSparseTransitionParserTest, FixDeadlocks) {
 
 TEST(NondeterministicSparseTransitionParserTest, DontFixDeadlocks) {
 	// Try to parse a transitions file containing a deadlock state with the fixDeadlocksFlag unset. This should throw an exception.
-    std::unique_ptr<storm::settings::SettingMemento> dontFixDeadlocks = storm::settings::mutableGeneralSettings().overrideDontFixDeadlocksSet(true);
+    std::unique_ptr<storm::settings::SettingMemento> dontFixDeadlocks = storm::settings::mutableMarkovChainSettings().overrideDontFixDeadlocksSet(true);
 
 	ASSERT_THROW(storm::parser::NondeterministicSparseTransitionParser<>::parseNondeterministicTransitions(STORM_CPP_TESTS_BASE_PATH "/functional/parser/tra_files/mdp_deadlock.tra"), storm::exceptions::WrongFormatException);
 }

From c9f04ecc0bf8255c084ded46eee9b4818a8791ca Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 23 Mar 2016 15:42:22 +0100
Subject: [PATCH 234/246] Added IOSettings

Former-commit-id: 95946a76660687e19c04d12631d8366c90143e27
---
 src/builder/ExplicitPrismModelBuilder.cpp     |   7 +-
 src/cli/cli.cpp                               |  13 +-
 src/cli/entrypoints.h                         |   2 +-
 src/settings/SettingsManager.cpp              |   6 +
 src/settings/SettingsManager.h                |   9 +
 .../CounterexampleGeneratorSettings.cpp       |   4 +-
 src/settings/modules/IOSettings.cpp           | 151 ++++++++++++++
 src/settings/modules/IOSettings.h             | 194 ++++++++++++++++++
 src/settings/modules/MarkovChainSettings.cpp  | 127 +-----------
 src/settings/modules/MarkovChainSettings.h    | 156 --------------
 src/storage/prism/Program.cpp                 |   6 +-
 src/utility/storm.h                           |   7 +-
 .../builder/DdPrismModelBuilderTest.cpp       |   6 +-
 .../builder/ExplicitPrismModelBuilderTest.cpp |   4 +-
 .../GmmxxCtmcCslModelCheckerTest.cpp          |  12 +-
 .../GmmxxHybridCtmcCslModelCheckerTest.cpp    |  20 +-
 .../NativeCtmcCslModelCheckerTest.cpp         |  12 +-
 .../NativeHybridCtmcCslModelCheckerTest.cpp   |  20 +-
 18 files changed, 419 insertions(+), 337 deletions(-)
 create mode 100644 src/settings/modules/IOSettings.cpp
 create mode 100644 src/settings/modules/IOSettings.h

diff --git a/src/builder/ExplicitPrismModelBuilder.cpp b/src/builder/ExplicitPrismModelBuilder.cpp
index 77b37684e..fc1170cd9 100644
--- a/src/builder/ExplicitPrismModelBuilder.cpp
+++ b/src/builder/ExplicitPrismModelBuilder.cpp
@@ -10,6 +10,7 @@
 #include "src/storage/expressions/ExpressionManager.h"
 
 #include "src/settings/modules/MarkovChainSettings.h"
+#include "src/settings/modules/IOSettings.h"
 
 #include "src/generator/PrismNextStateGenerator.h"
 #include "src/generator/PrismStateLabelingGenerator.h"
@@ -84,17 +85,17 @@ namespace storm {
         }
         
         template <typename ValueType, typename RewardModelType, typename StateType>
-        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options() : explorationOrder(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(true), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(true), labelsToBuild(), expressionLabels(), terminalStates(), negatedTerminalStates() {
+        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options() : explorationOrder(storm::settings::getModule<storm::settings::modules::IOSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(true), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(true), labelsToBuild(), expressionLabels(), terminalStates(), negatedTerminalStates() {
             // Intentionally left empty.
         }
         
         template <typename ValueType, typename RewardModelType, typename StateType>
-        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options(storm::logic::Formula const& formula) : explorationOrder(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(false), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(false), labelsToBuild(std::set<std::string>()), expressionLabels(std::vector<storm::expressions::Expression>()), terminalStates(), negatedTerminalStates() {
+        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options(storm::logic::Formula const& formula) : explorationOrder(storm::settings::getModule<storm::settings::modules::IOSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(false), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(false), labelsToBuild(std::set<std::string>()), expressionLabels(std::vector<storm::expressions::Expression>()), terminalStates(), negatedTerminalStates() {
             this->preserveFormula(formula);
         }
         
         template <typename ValueType, typename RewardModelType, typename StateType>
-        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options(std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas) : explorationOrder(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(false), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(false), labelsToBuild(), expressionLabels(), terminalStates(), negatedTerminalStates() {
+        ExplicitPrismModelBuilder<ValueType, RewardModelType, StateType>::Options::Options(std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas) : explorationOrder(storm::settings::getModule<storm::settings::modules::IOSettings>().getExplorationOrder()), buildCommandLabels(false), buildAllRewardModels(false), buildStateInformation(false), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(false), labelsToBuild(), expressionLabels(), terminalStates(), negatedTerminalStates() {
             if (formulas.empty()) {
                 this->buildAllRewardModels = true;
                 this->buildAllLabels = true;
diff --git a/src/cli/cli.cpp b/src/cli/cli.cpp
index 7ff84ef22..944a7c3f9 100644
--- a/src/cli/cli.cpp
+++ b/src/cli/cli.cpp
@@ -4,6 +4,8 @@
 #include "../utility/storm.h"
 
 #include "src/settings/modules/DebugSettings.h"
+#include "src/settings/modules/IOSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
 #include "src/exceptions/OptionParserException.h"
 
 #include "src/utility/storm-version.h"
@@ -205,12 +207,10 @@ namespace storm {
                     storm::utility::initializeFileLogging();
                 }
                 
-                storm::settings::modules::MarkovChainSettings const& settings = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>();
-                
                 // If we have to build the model from a symbolic representation, we need to parse the representation first.
                 boost::optional<storm::prism::Program> program;
-                if (settings.isSymbolicSet()) {
-                    std::string const& programFile = settings.getSymbolicModelFilename();
+                if (storm::settings::getModule<storm::settings::modules::IOSettings>().isSymbolicSet()) {
+                    std::string const& programFile = storm::settings::getModule<storm::settings::modules::IOSettings>().getSymbolicModelFilename();
                     program = storm::parseProgram(programFile);
                 }
                 
@@ -228,7 +228,7 @@ namespace storm {
                 }
                 std::vector<std::shared_ptr<const storm::logic::Formula>> formulas(parsedFormulas.begin(), parsedFormulas.end());
                 
-                if (settings.isSymbolicSet()) {
+                if (storm::settings::getModule<storm::settings::modules::IOSettings>().isSymbolicSet()) {
 #ifdef STORM_HAVE_CARL
                     if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isParametricSet()) {
                         buildAndCheckSymbolicModel<storm::RationalFunction>(program.get(), formulas, true);
@@ -238,7 +238,8 @@ namespace storm {
 #ifdef STORM_HAVE_CARL
                     }
 #endif
-                } else if (settings.isExplicitSet()) {
+                } else if (storm::settings::getModule<storm::settings::modules::IOSettings>().isExplicitSet()) {
+                    STORM_LOG_THROW(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getEngine() == storm::settings::modules::MarkovChainSettings::Engine::Sparse, storm::exceptions::InvalidSettingsException, "Cannot use explicit input models with this engine.");
                     buildAndCheckExplicitModel<double>(formulas, true);
                 } else {
                     STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "No input model.");
diff --git a/src/cli/entrypoints.h b/src/cli/entrypoints.h
index f1febc74e..5745caa62 100644
--- a/src/cli/entrypoints.h
+++ b/src/cli/entrypoints.h
@@ -164,7 +164,7 @@ namespace storm {
 
         template<typename ValueType>
         void buildAndCheckExplicitModel(std::vector<std::shared_ptr<const storm::logic::Formula>> const& formulas, bool onlyInitialStatesRelevant = false) {
-            storm::settings::modules::MarkovChainSettings const& settings = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>();
+            storm::settings::modules::IOSettings const& settings = storm::settings::getModule<storm::settings::modules::IOSettings>();
 
             STORM_LOG_THROW(settings.isExplicitSet(), storm::exceptions::InvalidStateException, "Unable to build explicit model without model files.");
             std::shared_ptr<storm::models::ModelBase> model = buildExplicitModel<ValueType>(settings.getTransitionFilename(), settings.getLabelingFilename(), settings.isStateRewardsSet() ? boost::optional<std::string>(settings.getStateRewardsFilename()) : boost::none, settings.isTransitionRewardsSet() ? boost::optional<std::string>(settings.getTransitionRewardsFilename()) : boost::none, settings.isChoiceLabelingSet() ? boost::optional<std::string>(settings.getChoiceLabelingFilename()) : boost::none);
diff --git a/src/settings/SettingsManager.cpp b/src/settings/SettingsManager.cpp
index 853b5c3e1..2f2cb33d1 100644
--- a/src/settings/SettingsManager.cpp
+++ b/src/settings/SettingsManager.cpp
@@ -15,6 +15,7 @@
 #include "src/utility/storm-version.h"
 #include "src/settings/modules/GeneralSettings.h"
 #include "src/settings/modules/MarkovChainSettings.h"
+#include "src/settings/modules/IOSettings.h"
 #include "src/settings/modules/DebugSettings.h"
 #include "src/settings/modules/CounterexampleGeneratorSettings.h"
 #include "src/settings/modules/CuddSettings.h"
@@ -489,12 +490,17 @@ namespace storm {
             return dynamic_cast<storm::settings::modules::MarkovChainSettings&>(mutableManager().getModule(storm::settings::modules::MarkovChainSettings::moduleName));
         }
         
+        storm::settings::modules::IOSettings& mutableIOSettings() {
+            return dynamic_cast<storm::settings::modules::IOSettings&>(mutableManager().getModule(storm::settings::modules::IOSettings::moduleName));
+        }
+        
         void initializeAll(std::string const& name, std::string const& executableName) {
             storm::settings::mutableManager().setName(name, executableName);
             
             // Register all known settings modules.
             storm::settings::addModule<storm::settings::modules::GeneralSettings>();
             storm::settings::addModule<storm::settings::modules::MarkovChainSettings>();
+            storm::settings::addModule<storm::settings::modules::IOSettings>();
             storm::settings::addModule<storm::settings::modules::DebugSettings>();
             storm::settings::addModule<storm::settings::modules::CounterexampleGeneratorSettings>();
             storm::settings::addModule<storm::settings::modules::CuddSettings>();
diff --git a/src/settings/SettingsManager.h b/src/settings/SettingsManager.h
index 5b0141045..0efdcd2fd 100644
--- a/src/settings/SettingsManager.h
+++ b/src/settings/SettingsManager.h
@@ -13,6 +13,7 @@ namespace storm {
     namespace settings {
         namespace modules {
             class MarkovChainSettings;
+            class IOSettings;
             class ModuleSettings;
         }
         class Option;
@@ -272,6 +273,14 @@ namespace storm {
          */
         storm::settings::modules::MarkovChainSettings& mutableMarkovChainSettings();
         
+        /*!
+         * Retrieves the IO settings in a mutable form. This is only meant to be used for debug purposes or very
+         * rare cases where it is necessary.
+         *
+         * @return An object that allows accessing and modifying the IO settings.
+         */
+        storm::settings::modules::IOSettings& mutableIOSettings();
+        
     } // namespace settings
 } // namespace storm
 
diff --git a/src/settings/modules/CounterexampleGeneratorSettings.cpp b/src/settings/modules/CounterexampleGeneratorSettings.cpp
index 6c245d3b2..b2dbb0ddc 100644
--- a/src/settings/modules/CounterexampleGeneratorSettings.cpp
+++ b/src/settings/modules/CounterexampleGeneratorSettings.cpp
@@ -6,7 +6,7 @@
 #include "src/settings/OptionBuilder.h"
 #include "src/settings/ArgumentBuilder.h"
 #include "src/settings/Argument.h"
-#include "src/settings/modules/MarkovChainSettings.h"
+#include "src/settings/modules/IOSettings.h"
 
 namespace storm {
     namespace settings {
@@ -48,7 +48,7 @@ namespace storm {
             
             bool CounterexampleGeneratorSettings::check() const {
                 // Ensure that the model was given either symbolically or explicitly.
-                STORM_LOG_THROW(!isMinimalCommandSetGenerationSet() || storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "For the generation of a minimal command set, the model has to be specified symbolically.");
+                STORM_LOG_THROW(!isMinimalCommandSetGenerationSet() || storm::settings::getModule<storm::settings::modules::IOSettings>().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "For the generation of a minimal command set, the model has to be specified symbolically.");
                 
                 if (isMinimalCommandSetGenerationSet()) {
                     STORM_LOG_WARN_COND(isUseMaxSatBasedMinimalCommandSetGenerationSet() || !isEncodeReachabilitySet(), "Encoding reachability is only available for the MaxSat-based minimal command set generation, so selecting it has no effect.");
diff --git a/src/settings/modules/IOSettings.cpp b/src/settings/modules/IOSettings.cpp
new file mode 100644
index 000000000..ae11caa7b
--- /dev/null
+++ b/src/settings/modules/IOSettings.cpp
@@ -0,0 +1,151 @@
+#include "src/settings/modules/IOSettings.h"
+
+#include "src/settings/SettingsManager.h"
+#include "src/settings/SettingMemento.h"
+#include "src/settings/Option.h"
+#include "src/settings/OptionBuilder.h"
+#include "src/settings/ArgumentBuilder.h"
+#include "src/settings/Argument.h"
+#include "src/exceptions/InvalidSettingsException.h"
+
+namespace storm {
+    namespace settings {
+        namespace modules {
+            
+            const std::string IOSettings::moduleName = "io";
+            const std::string IOSettings::exportDotOptionName = "exportdot";
+            const std::string IOSettings::exportMatOptionName = "exportmat";
+            const std::string IOSettings::explicitOptionName = "explicit";
+            const std::string IOSettings::explicitOptionShortName = "exp";
+            const std::string IOSettings::symbolicOptionName = "symbolic";
+            const std::string IOSettings::symbolicOptionShortName = "s";
+            const std::string IOSettings::explorationOrderOptionName = "explorder";
+            const std::string IOSettings::explorationOrderOptionShortName = "eo";
+            const std::string IOSettings::transitionRewardsOptionName = "transrew";
+            const std::string IOSettings::stateRewardsOptionName = "staterew";
+            const std::string IOSettings::choiceLabelingOptionName = "choicelab";
+            const std::string IOSettings::constantsOptionName = "constants";
+            const std::string IOSettings::constantsOptionShortName = "const";
+            const std::string IOSettings::prismCompatibilityOptionName = "prismcompat";
+            const std::string IOSettings::prismCompatibilityOptionShortName = "pc";
+            
+            IOSettings::IOSettings() : ModuleSettings(moduleName) {
+                this->addOption(storm::settings::OptionBuilder(moduleName, prismCompatibilityOptionName, false, "Enables PRISM compatibility. This may be necessary to process some PRISM models.").setShortName(prismCompatibilityOptionShortName).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, exportDotOptionName, "", "If given, the loaded model will be written to the specified file in the dot format.")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file to which the model is to be written.").build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, exportMatOptionName, "", "If given, the loaded model will be written to the specified file in the mat format.")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "the name of the file to which the model is to be writen.").build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, explicitOptionName, false, "Parses the model given in an explicit (sparse) representation.").setShortName(explicitOptionShortName)
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("transition filename", "The name of the file from which to read the transitions.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build())
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("labeling filename", "The name of the file from which to read the state labeling.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, symbolicOptionName, false, "Parses the model given in a symbolic representation.").setShortName(symbolicOptionShortName)
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file from which to read the symbolic model.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
+
+                std::vector<std::string> explorationOrders = {"dfs", "bfs"};
+                this->addOption(storm::settings::OptionBuilder(moduleName, explorationOrderOptionName, false, "Sets which exploration order to use.").setShortName(explorationOrderOptionShortName)
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the exploration order to choose. Available are: dfs and bfs.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(explorationOrders)).setDefaultValueString("bfs").build()).build());
+
+                this->addOption(storm::settings::OptionBuilder(moduleName, transitionRewardsOptionName, false, "If given, the transition rewards are read from this file and added to the explicit model. Note that this requires the model to be given as an explicit model (i.e., via --" + explicitOptionName + ").")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The file from which to read the transition rewards.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, stateRewardsOptionName, false, "If given, the state rewards are read from this file and added to the explicit model. Note that this requires the model to be given as an explicit model (i.e., via --" + explicitOptionName + ").")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The file from which to read the state rewards.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, choiceLabelingOptionName, false, "If given, the choice labels are read from this file and added to the explicit model. Note that this requires the model to be given as an explicit model (i.e., via --" + explicitOptionName + ").")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The file from which to read the choice labels.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, constantsOptionName, false, "Specifies the constant replacements to use in symbolic models. Note that Note that this requires the model to be given as an symbolic model (i.e., via --" + symbolicOptionName + ").").setShortName(constantsOptionShortName)
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("values", "A comma separated list of constants and their value, e.g. a=1,b=2,c=3.").setDefaultValueString("").build()).build());
+            }
+
+            bool IOSettings::isExportDotSet() const {
+                return this->getOption(exportDotOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string IOSettings::getExportDotFilename() const {
+                return this->getOption(exportDotOptionName).getArgumentByName("filename").getValueAsString();
+            }
+
+            bool IOSettings::isExplicitSet() const {
+                return this->getOption(explicitOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string IOSettings::getTransitionFilename() const {
+                return this->getOption(explicitOptionName).getArgumentByName("transition filename").getValueAsString();
+            }
+                        
+            std::string IOSettings::getLabelingFilename() const {
+                return this->getOption(explicitOptionName).getArgumentByName("labeling filename").getValueAsString();
+            }
+            
+            bool IOSettings::isSymbolicSet() const {
+                return this->getOption(symbolicOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string IOSettings::getSymbolicModelFilename() const {
+                return this->getOption(symbolicOptionName).getArgumentByName("filename").getValueAsString();
+            }
+            
+            bool IOSettings::isExplorationOrderSet() const {
+                return this->getOption(explorationOrderOptionName).getHasOptionBeenSet();
+            }
+            
+            storm::builder::ExplorationOrder IOSettings::getExplorationOrder() const {
+                std::string explorationOrderAsString = this->getOption(explorationOrderOptionName).getArgumentByName("name").getValueAsString();
+                if (explorationOrderAsString == "dfs") {
+                    return storm::builder::ExplorationOrder::Dfs;
+                } else if (explorationOrderAsString == "bfs") {
+                    return storm::builder::ExplorationOrder::Bfs;
+                }
+                STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown exploration order '" << explorationOrderAsString << "'.");
+            }
+            
+            bool IOSettings::isTransitionRewardsSet() const {
+                return this->getOption(transitionRewardsOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string IOSettings::getTransitionRewardsFilename() const {
+                return this->getOption(transitionRewardsOptionName).getArgumentByName("filename").getValueAsString();
+            }
+            
+            bool IOSettings::isStateRewardsSet() const {
+                return this->getOption(stateRewardsOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string IOSettings::getStateRewardsFilename() const {
+                return this->getOption(stateRewardsOptionName).getArgumentByName("filename").getValueAsString();
+            }
+            
+            bool IOSettings::isChoiceLabelingSet() const {
+                return this->getOption(choiceLabelingOptionName).getHasOptionBeenSet();
+            }
+                
+            std::string IOSettings::getChoiceLabelingFilename() const {
+                return this->getOption(choiceLabelingOptionName).getArgumentByName("filename").getValueAsString();
+            }
+            
+            std::unique_ptr<storm::settings::SettingMemento> IOSettings::overridePrismCompatibilityMode(bool stateToSet) {
+                return this->overrideOption(prismCompatibilityOptionName, stateToSet);
+            }
+            
+            bool IOSettings::isConstantsSet() const {
+                return this->getOption(constantsOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string IOSettings::getConstantDefinitionString() const {
+                return this->getOption(constantsOptionName).getArgumentByName("values").getValueAsString();
+            }
+            
+            bool IOSettings::isPrismCompatibilityEnabled() const {
+                return this->getOption(prismCompatibilityOptionName).getHasOptionBeenSet();
+            }
+
+			void IOSettings::finalize() {
+            }
+
+            bool IOSettings::check() const {
+                // Ensure that the model was given either symbolically or explicitly.
+                STORM_LOG_THROW(!isSymbolicSet() || !isExplicitSet(), storm::exceptions::InvalidSettingsException, "The model may be either given in an explicit or a symbolic format, but not both.");
+                return true;
+            }
+
+        } // namespace modules
+    } // namespace settings
+} // namespace storm
\ No newline at end of file
diff --git a/src/settings/modules/IOSettings.h b/src/settings/modules/IOSettings.h
new file mode 100644
index 000000000..eb1ced407
--- /dev/null
+++ b/src/settings/modules/IOSettings.h
@@ -0,0 +1,194 @@
+#ifndef STORM_SETTINGS_MODULES_IOSETTINGS_H_
+#define STORM_SETTINGS_MODULES_IOSETTINGS_H_
+
+#include "storm-config.h"
+#include "src/settings/modules/ModuleSettings.h"
+
+#include "src/builder/ExplorationOrder.h"
+
+namespace storm {
+    namespace settings {
+        namespace modules {
+
+            /*!
+             * This class represents the markov chain settings.
+             */
+            class IOSettings : public ModuleSettings {
+            public:
+
+                /*!
+                 * Creates a new set of IO settings.
+                 */
+                IOSettings();
+
+                /*!
+                 * Retrieves whether the export-to-dot option was set.
+                 *
+                 * @return True if the export-to-dot option was set.
+                 */
+                bool isExportDotSet() const;
+
+                /*!
+                 * Retrieves the name in which to write the model in dot format, if the export-to-dot option was set.
+                 *
+                 * @return The name of the file in which to write the exported model.
+                 */
+                std::string getExportDotFilename() const;
+
+                /*!
+                 * Retrieves whether the explicit option was set.
+                 *
+                 * @return True if the explicit option was set.
+                 */
+                bool isExplicitSet() const;
+
+                /*!
+                 * Retrieves the name of the file that contains the transitions if the model was given using the explicit
+                 * option.
+                 *
+                 * @return The name of the file that contains the transitions.
+                 */
+                std::string getTransitionFilename() const;
+
+                /*!
+                 * Retrieves the name of the file that contains the state labeling if the model was given using the
+                 * explicit option.
+                 *
+                 * @return The name of the file that contains the state labeling.
+                 */
+                std::string getLabelingFilename() const;
+
+                /*!
+                 * Retrieves whether the symbolic option was set.
+                 *
+                 * @return True if the symbolic option was set.
+                 */
+                bool isSymbolicSet() const;
+
+                /*!
+                 * Retrieves the name of the file that contains the symbolic model specification if the model was given
+                 * using the symbolic option.
+                 *
+                 * @return The name of the file that contains the symbolic model specification.
+                 */
+                std::string getSymbolicModelFilename() const;
+                
+                /*!
+                 * Retrieves whether the model exploration order was set.
+                 *
+                 * @return True if the model exploration option was set.
+                 */
+                bool isExplorationOrderSet() const;
+                
+                /*!
+                 * Retrieves the exploration order if it was set.
+                 *
+                 * @return The chosen exploration order.
+                 */
+                storm::builder::ExplorationOrder getExplorationOrder() const;
+
+                /*!
+                 * Retrieves whether the transition reward option was set.
+                 *
+                 * @return True if the transition reward option was set.
+                 */
+                bool isTransitionRewardsSet() const;
+
+                /*!
+                 * Retrieves the name of the file that contains the transition rewards if the model was given using the
+                 * explicit option.
+                 *
+                 * @return The name of the file that contains the transition rewards.
+                 */
+                std::string getTransitionRewardsFilename() const;
+
+                /*!
+                 * Retrieves whether the state reward option was set.
+                 *
+                 * @return True if the state reward option was set.
+                 */
+                bool isStateRewardsSet() const;
+
+                /*!
+                 * Retrieves the name of the file that contains the state rewards if the model was given using the
+                 * explicit option.
+                 *
+                 * @return The name of the file that contains the state rewards.
+                 */
+                std::string getStateRewardsFilename() const;
+
+                /*!
+                 * Retrieves whether the choice labeling option was set.
+                 * 
+                 * @return True iff the choice labeling option was set.
+                 */
+                bool isChoiceLabelingSet() const;
+
+                /*!
+                 * Retrieves the name of the file that contains the choice labeling
+                 * if the model was given using the explicit option.
+                 *
+                 * @return The name of the file that contains the choice labeling.
+                 */
+                std::string getChoiceLabelingFilename() const;
+
+                /*!
+                 * Overrides the option to enable the PRISM compatibility mode by setting it to the specified value. As
+                 * soon as the returned memento goes out of scope, the original value is restored.
+                 *
+                 * @param stateToSet The value that is to be set for the option.
+                 * @return The memento that will eventually restore the original value.
+                 */
+                std::unique_ptr<storm::settings::SettingMemento> overridePrismCompatibilityMode(bool stateToSet);
+                
+                /*!
+                 * Retrieves whether the export-to-dot option was set.
+                 *
+                 * @return True if the export-to-dot option was set.
+                 */
+                bool isConstantsSet() const;
+
+                /*!
+                 * Retrieves the string that defines the constants of a symbolic model (given via the symbolic option).
+                 *
+                 * @return The string that defines the constants of a symbolic model.
+                 */
+                std::string getConstantDefinitionString() const;
+
+                /*!
+                 * Retrieves whether the PRISM compatibility mode was enabled.
+                 *
+                 * @return True iff the PRISM compatibility mode was enabled.
+                 */
+                bool isPrismCompatibilityEnabled() const;
+
+                bool check() const override;
+                void finalize() override;
+
+                // The name of the module.
+                static const std::string moduleName;
+
+            private:
+                // Define the string names of the options as constants.
+                static const std::string exportDotOptionName;
+                static const std::string exportMatOptionName;
+                static const std::string explicitOptionName;
+                static const std::string explicitOptionShortName;
+                static const std::string symbolicOptionName;
+                static const std::string symbolicOptionShortName;
+                static const std::string explorationOrderOptionName;
+                static const std::string explorationOrderOptionShortName;
+                static const std::string transitionRewardsOptionName;
+                static const std::string stateRewardsOptionName;
+                static const std::string choiceLabelingOptionName;
+                static const std::string constantsOptionName;
+                static const std::string constantsOptionShortName;
+                static const std::string prismCompatibilityOptionName;
+                static const std::string prismCompatibilityOptionShortName;
+            };
+
+        } // namespace modules
+    } // namespace settings
+} // namespace storm
+
+#endif /* STORM_SETTINGS_MODULES_IOSETTINGS_H_ */
diff --git a/src/settings/modules/MarkovChainSettings.cpp b/src/settings/modules/MarkovChainSettings.cpp
index 389ef664b..dc8a700d6 100644
--- a/src/settings/modules/MarkovChainSettings.cpp
+++ b/src/settings/modules/MarkovChainSettings.cpp
@@ -17,17 +17,6 @@ namespace storm {
         namespace modules {
             
             const std::string MarkovChainSettings::moduleName = "markovchain";
-            const std::string MarkovChainSettings::exportDotOptionName = "exportdot";
-            const std::string MarkovChainSettings::exportMatOptionName = "exportmat";
-            const std::string MarkovChainSettings::explicitOptionName = "explicit";
-            const std::string MarkovChainSettings::explicitOptionShortName = "exp";
-            const std::string MarkovChainSettings::symbolicOptionName = "symbolic";
-            const std::string MarkovChainSettings::symbolicOptionShortName = "s";
-            const std::string MarkovChainSettings::explorationOrderOptionName = "explorder";
-            const std::string MarkovChainSettings::explorationOrderOptionShortName = "eo";
-            const std::string MarkovChainSettings::transitionRewardsOptionName = "transrew";
-            const std::string MarkovChainSettings::stateRewardsOptionName = "staterew";
-            const std::string MarkovChainSettings::choiceLabelingOptionName = "choicelab";
             const std::string MarkovChainSettings::counterexampleOptionName = "counterexample";
             const std::string MarkovChainSettings::counterexampleOptionShortName = "cex";
             const std::string MarkovChainSettings::dontFixDeadlockOptionName = "nofixdl";
@@ -35,42 +24,17 @@ namespace storm {
             const std::string MarkovChainSettings::eqSolverOptionName = "eqsolver";
             const std::string MarkovChainSettings::lpSolverOptionName = "lpsolver";
             const std::string MarkovChainSettings::smtSolverOptionName = "smtsolver";
-            const std::string MarkovChainSettings::constantsOptionName = "constants";
-            const std::string MarkovChainSettings::constantsOptionShortName = "const";
             const std::string MarkovChainSettings::statisticsOptionName = "statistics";
             const std::string MarkovChainSettings::statisticsOptionShortName = "stats";
             const std::string MarkovChainSettings::engineOptionName = "engine";
             const std::string MarkovChainSettings::engineOptionShortName = "e";
             const std::string MarkovChainSettings::ddLibraryOptionName = "ddlib";
             const std::string MarkovChainSettings::cudaOptionName = "cuda";
-            const std::string MarkovChainSettings::prismCompatibilityOptionName = "prismcompat";
-            const std::string MarkovChainSettings::prismCompatibilityOptionShortName = "pc";
 			const std::string MarkovChainSettings::minMaxEquationSolvingTechniqueOptionName = "minMaxEquationSolvingTechnique";
             
             MarkovChainSettings::MarkovChainSettings() : ModuleSettings(moduleName) {
-                this->addOption(storm::settings::OptionBuilder(moduleName, prismCompatibilityOptionName, false, "Enables PRISM compatibility. This may be necessary to process some PRISM models.").setShortName(prismCompatibilityOptionShortName).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, exportDotOptionName, "", "If given, the loaded model will be written to the specified file in the dot format.")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file to which the model is to be written.").build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, exportMatOptionName, "", "If given, the loaded model will be written to the specified file in the mat format.")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "the name of the file to which the model is to be writen.").build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, explicitOptionName, false, "Parses the model given in an explicit (sparse) representation.").setShortName(explicitOptionShortName)
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("transition filename", "The name of the file from which to read the transitions.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build())
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("labeling filename", "The name of the file from which to read the state labeling.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, symbolicOptionName, false, "Parses the model given in a symbolic representation.").setShortName(symbolicOptionShortName)
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file from which to read the symbolic model.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
-
-                std::vector<std::string> explorationOrders = {"dfs", "bfs"};
-                this->addOption(storm::settings::OptionBuilder(moduleName, explorationOrderOptionName, false, "Sets which exploration order to use.").setShortName(explorationOrderOptionShortName)
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the exploration order to choose. Available are: dfs and bfs.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(explorationOrders)).setDefaultValueString("bfs").build()).build());
-
                 this->addOption(storm::settings::OptionBuilder(moduleName, counterexampleOptionName, false, "Generates a counterexample for the given PRCTL formulas if not satisfied by the model")
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file to which the counterexample is to be written.").setDefaultValueString("-").setIsOptional(true).build()).setShortName(counterexampleOptionShortName).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, transitionRewardsOptionName, false, "If given, the transition rewards are read from this file and added to the explicit model. Note that this requires the model to be given as an explicit model (i.e., via --" + explicitOptionName + ").")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The file from which to read the transition rewards.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, stateRewardsOptionName, false, "If given, the state rewards are read from this file and added to the explicit model. Note that this requires the model to be given as an explicit model (i.e., via --" + explicitOptionName + ").")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The file from which to read the state rewards.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, choiceLabelingOptionName, false, "If given, the choice labels are read from this file and added to the explicit model. Note that this requires the model to be given as an explicit model (i.e., via --" + explicitOptionName + ").")
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The file from which to read the choice labels.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, dontFixDeadlockOptionName, false, "If the model contains deadlock states, they need to be fixed by setting this option.").setShortName(dontFixDeadlockOptionShortName).build());
                 
                 std::vector<std::string> engines = {"sparse", "hybrid", "dd", "abs"};
@@ -91,8 +55,6 @@ namespace storm {
                 std::vector<std::string> smtSolvers = {"z3", "mathsat"};
                 this->addOption(storm::settings::OptionBuilder(moduleName, smtSolverOptionName, false, "Sets which SMT solver is preferred.")
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of an SMT solver. Available are: z3 and mathsat.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(smtSolvers)).setDefaultValueString("z3").build()).build());
-                this->addOption(storm::settings::OptionBuilder(moduleName, constantsOptionName, false, "Specifies the constant replacements to use in symbolic models. Note that Note that this requires the model to be given as an symbolic model (i.e., via --" + symbolicOptionName + ").").setShortName(constantsOptionShortName)
-                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("values", "A comma separated list of constants and their value, e.g. a=1,b=2,c=3.").setDefaultValueString("").build()).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, statisticsOptionName, false, "Sets whether to display statistics if available.").setShortName(statisticsOptionShortName).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, cudaOptionName, false, "Sets whether to use CUDA to speed up computation time.").build());
 
@@ -101,72 +63,6 @@ namespace storm {
 					.addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of a min/max linear equation solving technique. Available are: valueIteration and policyIteration.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(minMaxSolvingTechniques)).setDefaultValueString("valueIteration").build()).build());
             }
 
-            bool MarkovChainSettings::isExportDotSet() const {
-                return this->getOption(exportDotOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string MarkovChainSettings::getExportDotFilename() const {
-                return this->getOption(exportDotOptionName).getArgumentByName("filename").getValueAsString();
-            }
-
-            bool MarkovChainSettings::isExplicitSet() const {
-                return this->getOption(explicitOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string MarkovChainSettings::getTransitionFilename() const {
-                return this->getOption(explicitOptionName).getArgumentByName("transition filename").getValueAsString();
-            }
-                        
-            std::string MarkovChainSettings::getLabelingFilename() const {
-                return this->getOption(explicitOptionName).getArgumentByName("labeling filename").getValueAsString();
-            }
-            
-            bool MarkovChainSettings::isSymbolicSet() const {
-                return this->getOption(symbolicOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string MarkovChainSettings::getSymbolicModelFilename() const {
-                return this->getOption(symbolicOptionName).getArgumentByName("filename").getValueAsString();
-            }
-            
-            bool MarkovChainSettings::isExplorationOrderSet() const {
-                return this->getOption(explorationOrderOptionName).getHasOptionBeenSet();
-            }
-            
-            storm::builder::ExplorationOrder MarkovChainSettings::getExplorationOrder() const {
-                std::string explorationOrderAsString = this->getOption(explorationOrderOptionName).getArgumentByName("name").getValueAsString();
-                if (explorationOrderAsString == "dfs") {
-                    return storm::builder::ExplorationOrder::Dfs;
-                } else if (explorationOrderAsString == "bfs") {
-                    return storm::builder::ExplorationOrder::Bfs;
-                }
-                STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown exploration order '" << explorationOrderAsString << "'.");
-            }
-            
-            bool MarkovChainSettings::isTransitionRewardsSet() const {
-                return this->getOption(transitionRewardsOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string MarkovChainSettings::getTransitionRewardsFilename() const {
-                return this->getOption(transitionRewardsOptionName).getArgumentByName("filename").getValueAsString();
-            }
-            
-            bool MarkovChainSettings::isStateRewardsSet() const {
-                return this->getOption(stateRewardsOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string MarkovChainSettings::getStateRewardsFilename() const {
-                return this->getOption(stateRewardsOptionName).getArgumentByName("filename").getValueAsString();
-            }
-            
-            bool MarkovChainSettings::isChoiceLabelingSet() const {
-                return this->getOption(choiceLabelingOptionName).getHasOptionBeenSet();
-            }
-                
-            std::string MarkovChainSettings::getChoiceLabelingFilename() const {
-                return this->getOption(choiceLabelingOptionName).getArgumentByName("filename").getValueAsString();
-            }
-            
             bool MarkovChainSettings::isCounterexampleSet() const {
                 return this->getOption(counterexampleOptionName).getHasOptionBeenSet();
             }
@@ -183,10 +79,6 @@ namespace storm {
                 return this->overrideOption(dontFixDeadlockOptionName, stateToSet);
             }
             
-            std::unique_ptr<storm::settings::SettingMemento> MarkovChainSettings::overridePrismCompatibilityMode(bool stateToSet) {
-                return this->overrideOption(prismCompatibilityOptionName, stateToSet);
-            }
-            
             storm::solver::EquationSolverType  MarkovChainSettings::getEquationSolver() const {
                 std::string equationSolverName = this->getOption(eqSolverOptionName).getArgumentByName("name").getValueAsString();
                 if (equationSolverName == "gmm++") {
@@ -230,14 +122,6 @@ namespace storm {
                 }
             }
             
-            bool MarkovChainSettings::isConstantsSet() const {
-                return this->getOption(constantsOptionName).getHasOptionBeenSet();
-            }
-            
-            std::string MarkovChainSettings::getConstantDefinitionString() const {
-                return this->getOption(constantsOptionName).getArgumentByName("values").getValueAsString();
-            }
-            
             bool MarkovChainSettings::isShowStatisticsSet() const {
                 return this->getOption(statisticsOptionName).getHasOptionBeenSet();
             }
@@ -254,11 +138,7 @@ namespace storm {
                 this->engine = newEngine;
             }
             
-            bool MarkovChainSettings::isPrismCompatibilityEnabled() const {
-                return this->getOption(prismCompatibilityOptionName).getHasOptionBeenSet();
-            }
-
-			storm::solver::MinMaxTechnique MarkovChainSettings::getMinMaxEquationSolvingTechnique() const {
+            storm::solver::MinMaxTechnique MarkovChainSettings::getMinMaxEquationSolvingTechnique() const {
 				std::string minMaxEquationSolvingTechnique = this->getOption(minMaxEquationSolvingTechniqueOptionName).getArgumentByName("name").getValueAsString();
 				if (minMaxEquationSolvingTechnique == "valueIteration") {
 					return storm::solver::MinMaxTechnique::ValueIteration;
@@ -289,11 +169,6 @@ namespace storm {
             }
 
             bool MarkovChainSettings::check() const {
-                // Ensure that the model was given either symbolically or explicitly.
-                STORM_LOG_THROW(!isSymbolicSet() || !isExplicitSet(), storm::exceptions::InvalidSettingsException, "The model may be either given in an explicit or a symbolic format, but not both.");
-                
-                STORM_LOG_THROW(this->getEngine() == Engine::Sparse || !isExplicitSet(), storm::exceptions::InvalidSettingsException, "Cannot use explicit input models with this engine.");
-                
                 return true;
             }
 
diff --git a/src/settings/modules/MarkovChainSettings.h b/src/settings/modules/MarkovChainSettings.h
index 193b47c44..f37ea2050 100644
--- a/src/settings/modules/MarkovChainSettings.h
+++ b/src/settings/modules/MarkovChainSettings.h
@@ -36,117 +36,6 @@ namespace storm {
                  */
                 MarkovChainSettings();
 
-                /*!
-                 * Retrieves whether the export-to-dot option was set.
-                 *
-                 * @return True if the export-to-dot option was set.
-                 */
-                bool isExportDotSet() const;
-
-                /*!
-                 * Retrieves the name in which to write the model in dot format, if the export-to-dot option was set.
-                 *
-                 * @return The name of the file in which to write the exported model.
-                 */
-                std::string getExportDotFilename() const;
-
-                /*!
-                 * Retrieves whether the explicit option was set.
-                 *
-                 * @return True if the explicit option was set.
-                 */
-                bool isExplicitSet() const;
-
-                /*!
-                 * Retrieves the name of the file that contains the transitions if the model was given using the explicit
-                 * option.
-                 *
-                 * @return The name of the file that contains the transitions.
-                 */
-                std::string getTransitionFilename() const;
-
-                /*!
-                 * Retrieves the name of the file that contains the state labeling if the model was given using the
-                 * explicit option.
-                 *
-                 * @return The name of the file that contains the state labeling.
-                 */
-                std::string getLabelingFilename() const;
-
-                /*!
-                 * Retrieves whether the symbolic option was set.
-                 *
-                 * @return True if the symbolic option was set.
-                 */
-                bool isSymbolicSet() const;
-
-                /*!
-                 * Retrieves the name of the file that contains the symbolic model specification if the model was given
-                 * using the symbolic option.
-                 *
-                 * @return The name of the file that contains the symbolic model specification.
-                 */
-                std::string getSymbolicModelFilename() const;
-                
-                /*!
-                 * Retrieves whether the model exploration order was set.
-                 *
-                 * @return True if the model exploration option was set.
-                 */
-                bool isExplorationOrderSet() const;
-                
-                /*!
-                 * Retrieves the exploration order if it was set.
-                 *
-                 * @return The chosen exploration order.
-                 */
-                storm::builder::ExplorationOrder getExplorationOrder() const;
-
-                /*!
-                 * Retrieves whether the transition reward option was set.
-                 *
-                 * @return True if the transition reward option was set.
-                 */
-                bool isTransitionRewardsSet() const;
-
-                /*!
-                 * Retrieves the name of the file that contains the transition rewards if the model was given using the
-                 * explicit option.
-                 *
-                 * @return The name of the file that contains the transition rewards.
-                 */
-                std::string getTransitionRewardsFilename() const;
-
-                /*!
-                 * Retrieves whether the state reward option was set.
-                 *
-                 * @return True if the state reward option was set.
-                 */
-                bool isStateRewardsSet() const;
-
-                /*!
-                 * Retrieves the name of the file that contains the state rewards if the model was given using the
-                 * explicit option.
-                 *
-                 * @return The name of the file that contains the state rewards.
-                 */
-                std::string getStateRewardsFilename() const;
-
-                /*!
-                 * Retrieves whether the choice labeling option was set.
-                 * 
-                 * @return True iff the choice labeling option was set.
-                 */
-                bool isChoiceLabelingSet() const;
-
-                /*!
-                 * Retrieves the name of the file that contains the choice labeling
-                 * if the model was given using the explicit option.
-                 *
-                 * @return The name of the file that contains the choice labeling.
-                 */
-                std::string getChoiceLabelingFilename() const;
-
                 /*!
                  * Retrieves whether the counterexample option was set.
                  *
@@ -178,15 +67,6 @@ namespace storm {
                  */
                 std::unique_ptr<storm::settings::SettingMemento> overrideDontFixDeadlocksSet(bool stateToSet);
 
-                /*!
-                 * Overrides the option to enable the PRISM compatibility mode by setting it to the specified value. As
-                 * soon as the returned memento goes out of scope, the original value is restored.
-                 *
-                 * @param stateToSet The value that is to be set for the option.
-                 * @return The memento that will eventually restore the original value.
-                 */
-                std::unique_ptr<storm::settings::SettingMemento> overridePrismCompatibilityMode(bool stateToSet);
-
                 /*!
                  * Retrieves the selected equation solver.
                  *
@@ -222,20 +102,6 @@ namespace storm {
                  */
                 storm::dd::DdType getDdLibraryType() const;
                 
-                /*!
-                 * Retrieves whether the export-to-dot option was set.
-                 *
-                 * @return True if the export-to-dot option was set.
-                 */
-                bool isConstantsSet() const;
-
-                /*!
-                 * Retrieves the string that defines the constants of a symbolic model (given via the symbolic option).
-                 *
-                 * @return The string that defines the constants of a symbolic model.
-                 */
-                std::string getConstantDefinitionString() const;
-
                 /*!
                  * Retrieves whether statistics are to be shown for counterexample generation.
                  *
@@ -262,13 +128,6 @@ namespace storm {
                  */
                 void setEngine(Engine);
 
-                /*!
-                 * Retrieves whether the PRISM compatibility mode was enabled.
-                 *
-                 * @return True iff the PRISM compatibility mode was enabled.
-                 */
-                bool isPrismCompatibilityEnabled() const;
-
                 /*!
                  * Retrieves whether a min/max equation solving technique has been set.
                  *
@@ -294,17 +153,6 @@ namespace storm {
                 Engine engine;
 
                 // Define the string names of the options as constants.
-                static const std::string exportDotOptionName;
-                static const std::string exportMatOptionName;
-                static const std::string explicitOptionName;
-                static const std::string explicitOptionShortName;
-                static const std::string symbolicOptionName;
-                static const std::string symbolicOptionShortName;
-                static const std::string explorationOrderOptionName;
-                static const std::string explorationOrderOptionShortName;
-                static const std::string transitionRewardsOptionName;
-                static const std::string stateRewardsOptionName;
-                static const std::string choiceLabelingOptionName;
                 static const std::string counterexampleOptionName;
                 static const std::string counterexampleOptionShortName;
                 static const std::string dontFixDeadlockOptionName;
@@ -312,16 +160,12 @@ namespace storm {
                 static const std::string eqSolverOptionName;
                 static const std::string lpSolverOptionName;
                 static const std::string smtSolverOptionName;
-                static const std::string constantsOptionName;
-                static const std::string constantsOptionShortName;
                 static const std::string statisticsOptionName;
                 static const std::string statisticsOptionShortName;
                 static const std::string engineOptionName;
                 static const std::string engineOptionShortName;
                 static const std::string ddLibraryOptionName;
                 static const std::string cudaOptionName;
-                static const std::string prismCompatibilityOptionName;
-                static const std::string prismCompatibilityOptionShortName;
                 static const std::string minMaxEquationSolvingTechniqueOptionName;
             };
 
diff --git a/src/storage/prism/Program.cpp b/src/storage/prism/Program.cpp
index 229f205f5..ce3662610 100644
--- a/src/storage/prism/Program.cpp
+++ b/src/storage/prism/Program.cpp
@@ -6,7 +6,7 @@
 
 #include "src/storage/expressions/ExpressionManager.h"
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/MarkovChainSettings.h"
+#include "src/settings/modules/IOSettings.h"
 #include "src/utility/macros.h"
 #include "src/utility/solver.h"
 #include "src/exceptions/InvalidArgumentException.h"
@@ -56,7 +56,7 @@ namespace storm {
 
                 // If the model is supposed to be a CTMC, but contains probabilistic commands, we transform them to Markovian
                 // commands and issue a warning.
-                if (modelType == storm::prism::Program::ModelType::CTMC && storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isPrismCompatibilityEnabled()) {
+                if (modelType == storm::prism::Program::ModelType::CTMC && storm::settings::getModule<storm::settings::modules::IOSettings>().isPrismCompatibilityEnabled()) {
                     bool hasProbabilisticCommands = false;
                     for (auto& module : this->modules) {
                         for (auto& command : module.getCommands()) {
@@ -829,7 +829,7 @@ namespace storm {
             }
             
             if (hasLabeledMarkovianCommand) {
-                if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isPrismCompatibilityEnabled()) {
+                if (storm::settings::getModule<storm::settings::modules::IOSettings>().isPrismCompatibilityEnabled()) {
                     STORM_LOG_WARN_COND(false, "The model uses synchronizing Markovian commands. This may lead to unexpected verification results, because of unclear semantics.");
                 } else {
                     STORM_LOG_THROW(false, storm::exceptions::WrongFormatException, "The model uses synchronizing Markovian commands. This may lead to unexpected verification results, because of unclear semantics.");
diff --git a/src/utility/storm.h b/src/utility/storm.h
index 59f640bdf..df84e79d6 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -21,6 +21,7 @@
 
 
 #include "src/settings/modules/MarkovChainSettings.h"
+#include "src/settings/modules/IOSettings.h"
 #include "src/settings/modules/BisimulationSettings.h"
 #include "src/settings/modules/ParametricSettings.h"
 
@@ -96,7 +97,7 @@ namespace storm {
         storm::prism::Program translatedProgram;
 
         // Get the string that assigns values to the unknown currently undefined constants in the model.
-        std::string constants = storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getConstantDefinitionString();
+        std::string constants = storm::settings::getModule<storm::settings::modules::IOSettings>().getConstantDefinitionString();
 
         // Customize and perform model-building.
         if (storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getEngine() == storm::settings::modules::MarkovChainSettings::Engine::Sparse) {
@@ -223,7 +224,7 @@ namespace storm {
     void generateCounterexample(storm::prism::Program const& program, std::shared_ptr<storm::models::sparse::Model<ValueType>> model, std::shared_ptr<const storm::logic::Formula> const& formula) {
         if (storm::settings::getModule<storm::settings::modules::CounterexampleGeneratorSettings>().isMinimalCommandSetGenerationSet()) {
             STORM_LOG_THROW(model->getType() == storm::models::ModelType::Mdp, storm::exceptions::InvalidTypeException, "Minimal command set generation is only available for MDPs.");
-            STORM_LOG_THROW(storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "Minimal command set generation is only available for symbolic models.");
+            STORM_LOG_THROW(storm::settings::getModule<storm::settings::modules::IOSettings>().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "Minimal command set generation is only available for symbolic models.");
 
             std::shared_ptr<storm::models::sparse::Mdp<ValueType>> mdp = model->template as<storm::models::sparse::Mdp<ValueType>>();
 
@@ -233,7 +234,7 @@ namespace storm {
             if (useMILP) {
                 storm::counterexamples::MILPMinimalLabelSetGenerator<ValueType>::computeCounterexample(program, *mdp, formula);
             } else {
-                storm::counterexamples::SMTMinimalCommandSetGenerator<ValueType>::computeCounterexample(program, storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().getConstantDefinitionString(), *mdp, formula);
+                storm::counterexamples::SMTMinimalCommandSetGenerator<ValueType>::computeCounterexample(program, storm::settings::getModule<storm::settings::modules::IOSettings>().getConstantDefinitionString(), *mdp, formula);
             }
 
         } else {
diff --git a/test/functional/builder/DdPrismModelBuilderTest.cpp b/test/functional/builder/DdPrismModelBuilderTest.cpp
index 9f1f66cf2..9e5607761 100644
--- a/test/functional/builder/DdPrismModelBuilderTest.cpp
+++ b/test/functional/builder/DdPrismModelBuilderTest.cpp
@@ -2,7 +2,7 @@
 #include "storm-config.h"
 #include "src/settings/SettingMemento.h"
 #include "src/settings/SettingsManager.h"
-#include "src/settings/modules/MarkovChainSettings.h"
+#include "src/settings/modules/IOSettings.h"
 #include "src/models/symbolic/Dtmc.h"
 #include "src/models/symbolic/Ctmc.h"
 #include "src/models/symbolic/Mdp.h"
@@ -68,7 +68,7 @@ TEST(DdPrismModelBuilderTest_Cudd, Dtmc) {
 
 TEST(DdPrismModelBuilderTest_Sylvan, Ctmc) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
     
@@ -99,7 +99,7 @@ TEST(DdPrismModelBuilderTest_Sylvan, Ctmc) {
 
 TEST(DdPrismModelBuilderTest_Cudd, Ctmc) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
 
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
     
diff --git a/test/functional/builder/ExplicitPrismModelBuilderTest.cpp b/test/functional/builder/ExplicitPrismModelBuilderTest.cpp
index 634c106ee..73675a25c 100644
--- a/test/functional/builder/ExplicitPrismModelBuilderTest.cpp
+++ b/test/functional/builder/ExplicitPrismModelBuilderTest.cpp
@@ -5,7 +5,7 @@
 #include "src/parser/PrismParser.h"
 #include "src/builder/ExplicitPrismModelBuilder.h"
 
-#include "src/settings/modules/MarkovChainSettings.h"
+#include "src/settings/modules/IOSettings.h"
 
 TEST(ExplicitPrismModelBuilderTest, Dtmc) {
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/die.pm");
@@ -37,7 +37,7 @@ TEST(ExplicitPrismModelBuilderTest, Dtmc) {
 
 TEST(ExplicitPrismModelBuilderTest, Ctmc) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
 
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
 
diff --git a/test/functional/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp b/test/functional/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp
index 7a28ad892..628662788 100644
--- a/test/functional/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp
+++ b/test/functional/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp
@@ -13,14 +13,14 @@
 
 #include "src/settings/SettingsManager.h"
 #include "src/settings/modules/GeneralSettings.h"
-#include "src/settings/modules/MarkovChainSettings.h"
+#include "src/settings/modules/IOSettings.h"
 
 #include "src/settings/modules/NativeEquationSolverSettings.h"
 #include "src/settings/modules/GmmxxEquationSolverSettings.h"
 
 TEST(GmmxxCtmcCslModelCheckerTest, Cluster) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
@@ -103,7 +103,7 @@ TEST(GmmxxCtmcCslModelCheckerTest, Cluster) {
 
 TEST(GmmxxCtmcCslModelCheckerTest, Embedded) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/embedded2.sm");
@@ -172,7 +172,7 @@ TEST(GmmxxCtmcCslModelCheckerTest, Embedded) {
 
 TEST(GmmxxCtmcCslModelCheckerTest, Polling) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/polling2.sm");
@@ -206,14 +206,14 @@ TEST(GmmxxCtmcCslModelCheckerTest, Polling) {
 
 TEST(GmmxxCtmcCslModelCheckerTest, Fms) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // No properties to check at this point.
 }
 
 TEST(GmmxxCtmcCslModelCheckerTest, Tandem) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/tandem5.sm");
diff --git a/test/functional/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp b/test/functional/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp
index 51a3a7bc9..2be79d79f 100644
--- a/test/functional/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp
+++ b/test/functional/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp
@@ -16,14 +16,14 @@
 
 #include "src/settings/SettingsManager.h"
 #include "src/settings/modules/GeneralSettings.h"
-#include "src/settings/modules/MarkovChainSettings.h"
+#include "src/settings/modules/IOSettings.h"
 #include "src/settings/modules/GmmxxEquationSolverSettings.h"
 
 #include "src/settings/modules/NativeEquationSolverSettings.h"
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
@@ -120,7 +120,7 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
@@ -217,7 +217,7 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/embedded2.sm");
@@ -296,7 +296,7 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/embedded2.sm");
@@ -375,7 +375,7 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/polling2.sm");
@@ -411,7 +411,7 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Cudd) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/polling2.sm");
@@ -447,14 +447,14 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Sylvan) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Fms) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // No properties to check at this point.
 }
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/tandem5.sm");
@@ -542,7 +542,7 @@ TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
 
 TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/tandem5.sm");
diff --git a/test/functional/modelchecker/NativeCtmcCslModelCheckerTest.cpp b/test/functional/modelchecker/NativeCtmcCslModelCheckerTest.cpp
index afa0e7e25..640c904c5 100644
--- a/test/functional/modelchecker/NativeCtmcCslModelCheckerTest.cpp
+++ b/test/functional/modelchecker/NativeCtmcCslModelCheckerTest.cpp
@@ -14,11 +14,11 @@
 #include "src/settings/modules/NativeEquationSolverSettings.h"
 
 #include "src/settings/modules/GeneralSettings.h"
-#include "src/settings/modules/MarkovChainSettings.h"
+#include "src/settings/modules/IOSettings.h"
 
 TEST(NativeCtmcCslModelCheckerTest, Cluster) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
@@ -94,7 +94,7 @@ TEST(NativeCtmcCslModelCheckerTest, Cluster) {
 
 TEST(NativeCtmcCslModelCheckerTest, Embedded) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/embedded2.sm");
@@ -156,7 +156,7 @@ TEST(NativeCtmcCslModelCheckerTest, Embedded) {
 
 TEST(NativeCtmcCslModelCheckerTest, Polling) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/polling2.sm");
@@ -183,14 +183,14 @@ TEST(NativeCtmcCslModelCheckerTest, Polling) {
 
 TEST(NativeCtmcCslModelCheckerTest, Fms) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // No properties to check at this point.
 }
 
 TEST(NativeCtmcCslModelCheckerTest, Tandem) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/tandem5.sm");
diff --git a/test/functional/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp b/test/functional/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp
index 3bfa011cb..7b7fd6030 100644
--- a/test/functional/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp
+++ b/test/functional/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp
@@ -16,13 +16,13 @@
 
 #include "src/settings/SettingsManager.h"
 #include "src/settings/modules/GeneralSettings.h"
-#include "src/settings/modules/MarkovChainSettings.h"
+#include "src/settings/modules/IOSettings.h"
 
 #include "src/settings/modules/NativeEquationSolverSettings.h"
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
@@ -119,7 +119,7 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Cudd) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/cluster2.sm");
@@ -216,7 +216,7 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/embedded2.sm");
@@ -295,7 +295,7 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Cudd) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/embedded2.sm");
@@ -374,7 +374,7 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Sylvan) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/polling2.sm");
@@ -410,7 +410,7 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Cudd) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/polling2.sm");
@@ -446,14 +446,14 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Sylvan) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Fms) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // No properties to check at this point.
 }
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/tandem5.sm");
@@ -543,7 +543,7 @@ TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Cudd) {
 
 TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Sylvan) {
     // Set the PRISM compatibility mode temporarily. It is set to its old value once the returned object is destructed.
-    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableMarkovChainSettings().overridePrismCompatibilityMode(true);
+    std::unique_ptr<storm::settings::SettingMemento> enablePrismCompatibility = storm::settings::mutableIOSettings().overridePrismCompatibilityMode(true);
     
     // Parse the model description.
     storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/tandem5.sm");

From a63d004fb80bc0857f974572dce186be8a40cb0d Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 23 Mar 2016 17:57:50 +0100
Subject: [PATCH 235/246] storm-dft is using settings now

Former-commit-id: 65a1456651ef032022b1892bf3862f2e2e2060eb
---
 src/modelchecker/DFTAnalyser.h       |   2 +-
 src/settings/ArgumentValidators.h    |  92 ++++++++++++-
 src/settings/SettingsManager.cpp     |   2 +-
 src/settings/modules/DFTSettings.cpp | 107 +++++++++++++++
 src/settings/modules/DFTSettings.h   | 129 +++++++++++++++++++
 src/storm-dyftee.cpp                 | 186 ++++++++++++++++-----------
 6 files changed, 437 insertions(+), 81 deletions(-)
 create mode 100644 src/settings/modules/DFTSettings.cpp
 create mode 100644 src/settings/modules/DFTSettings.h

diff --git a/src/modelchecker/DFTAnalyser.h b/src/modelchecker/DFTAnalyser.h
index 519b8090a..189338b70 100644
--- a/src/modelchecker/DFTAnalyser.h
+++ b/src/modelchecker/DFTAnalyser.h
@@ -159,7 +159,7 @@ private:
             explorationTime += explorationEnd -buildingEnd;
 
             // Bisimulation
-            if (model->isOfType(storm::models::ModelType::Ctmc)) {
+            if (model->isOfType(storm::models::ModelType::Ctmc) && storm::settings::getModule<storm::settings::modules::GeneralSettings>().isBisimulationSet()) {
                 std::cout << "Bisimulation..." << std::endl;
                 model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), {formula}, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
                 //model->printModelInformationToStream(std::cout);
diff --git a/src/settings/ArgumentValidators.h b/src/settings/ArgumentValidators.h
index 6e1b4aa02..60a36b55b 100644
--- a/src/settings/ArgumentValidators.h
+++ b/src/settings/ArgumentValidators.h
@@ -46,6 +46,26 @@ namespace storm {
 				return rangeValidatorExcluding<int_fast64_t>(lowerBound, upperBound);
 			}
 
+            /*!
+             * Creates a validation function that checks whether an integer is greater than or equal to the given threshold.
+             *
+             * @param threshold The threshold.
+             * @return The resulting validation function.
+             */
+            static std::function<bool (int_fast64_t const&)> integerGreaterValidatorIncluding(int_fast64_t threshold) {
+                return greaterValidatorIncluding<int_fast64_t>(threshold);
+            }
+            
+            /*!
+             * Creates a validation function that checks whether an integer is greater than the given threshold.
+             *
+             * @param threshold The threshold.
+             * @return The resulting validation function.
+             */
+            static std::function<bool (int_fast64_t const&)> integerGreaterValidatorExcluding(int_fast64_t threshold) {
+                return greaterValidatorExcluding<int_fast64_t>(threshold);
+            }
+            
 			/*!
              * Creates a validation function that checks whether an unsigned integer is in the given range (including the bounds).
              *
@@ -67,6 +87,26 @@ namespace storm {
 			static std::function<bool (uint_fast64_t const&)> unsignedIntegerRangeValidatorExcluding(uint_fast64_t lowerBound, uint_fast64_t upperBound) {
 				return rangeValidatorExcluding<uint_fast64_t>(lowerBound, upperBound);
 			}
+            
+            /*!
+             * Creates a validation function that checks whether an unsigned integer is greater than or equal to the given threshold.
+             *
+             * @param threshold The threshold.
+             * @return The resulting validation function.
+             */
+            static std::function<bool (uint_fast64_t const&)> unsignedIntegerGreaterValidatorIncluding(uint_fast64_t threshold) {
+                return greaterValidatorIncluding<uint_fast64_t>(threshold);
+            }
+            
+            /*!
+             * Creates a validation function that checks whether an unsigned integer is greater than the given threshold.
+             *
+             * @param threshold The threshold.
+             * @return The resulting validation function.
+             */
+            static std::function<bool (uint_fast64_t const&)> unsignedIntegerGreaterValidatorExcluding(uint_fast64_t threshold) {
+                return greaterValidatorExcluding<uint_fast64_t>(threshold);
+            }
 
 			/*!
              * Creates a validation function that checks whether a double is in the given range (including the bounds).
@@ -89,6 +129,26 @@ namespace storm {
 			static std::function<bool (double const&)> doubleRangeValidatorExcluding(double lowerBound, double upperBound) {
 				return rangeValidatorExcluding<double>(lowerBound, upperBound);
 			}
+            
+            /*!
+             * Creates a validation function that checks whether a double is greater than or equal to the given threshold.
+             *
+             * @param threshold The threshold.
+             * @return The resulting validation function.
+             */
+            static std::function<bool (double const&)> doubleGreaterValidatorIncluding(double threshold) {
+                return greaterValidatorIncluding<double>(threshold);
+            }
+            
+            /*!
+             * Creates a validation function that checks whether a double is greater than the given threshold.
+             *
+             * @param threshold The threshold.
+             * @return The resulting validation function.
+             */
+            static std::function<bool (double const&)> doubleGreaterValidatorExcluding(double threshold) {
+                return greaterValidatorExcluding<double>(threshold);
+            }
 
             /*!
              * Creates a validation function that checks whether a given string corresponds to an existing and readable
@@ -141,7 +201,7 @@ namespace storm {
 			template<typename T>
 			static std::function<bool (T const&)> rangeValidatorIncluding(T lowerBound, T upperBound) {
 				return std::bind([](T lowerBound, T upperBound, T value) -> bool {
-                    STORM_LOG_THROW(lowerBound <= value && value <= upperBound, storm::exceptions::InvalidArgumentException, "Value " << value << " is out range.");
+                    STORM_LOG_THROW(lowerBound <= value && value <= upperBound, storm::exceptions::InvalidArgumentException, "Value " << value << " is out of range.");
                     return true;
                 }, lowerBound, upperBound, std::placeholders::_1);
 			}
@@ -156,10 +216,38 @@ namespace storm {
 			template<typename T>
 			static std::function<bool (T const&)> rangeValidatorExcluding(T lowerBound, T upperBound) {
 				return std::bind([](T lowerBound, T upperBound, T value) -> bool {
-                    STORM_LOG_THROW(lowerBound < value && value < upperBound, storm::exceptions::InvalidArgumentException, "Value " << value << " is out range.");
+                    STORM_LOG_THROW(lowerBound < value && value < upperBound, storm::exceptions::InvalidArgumentException, "Value " << value << " is out of range.");
                     return true;
 				}, lowerBound, upperBound, std::placeholders::_1);
 			}
+            
+            /*!
+             * Creates a validation function that checks whether its argument is greater than the given threshold.
+             *
+             * @param threshold The threshold.
+             * @return The resulting validation function.
+             */
+            template<typename T>
+            static std::function<bool (T const&)> greaterValidatorExcluding(T threshold) {
+                return std::bind([](T threshold, T value) -> bool {
+                    STORM_LOG_THROW(threshold < value, storm::exceptions::InvalidArgumentException, "Value " << value << " is out of range.");
+                    return true;
+                }, threshold, std::placeholders::_1);
+            }
+            
+            /*!
+             * Creates a validation function that checks whether its argument is greater than or equal to the given threshold.
+             *
+             * @param threshold The threshold.
+             * @return The resulting validation function.
+             */
+            template<typename T>
+            static std::function<bool (T const&)> greaterValidatorIncluding(T threshold) {
+                return std::bind([](T threshold, T value) -> bool {
+                    STORM_LOG_THROW(threshold <= value, storm::exceptions::InvalidArgumentException, "Value " << value << " is out of range.");
+                    return true;
+                }, threshold, std::placeholders::_1);
+            }
 		};
 	}
 }
diff --git a/src/settings/SettingsManager.cpp b/src/settings/SettingsManager.cpp
index 2f2cb33d1..b3987f776 100644
--- a/src/settings/SettingsManager.cpp
+++ b/src/settings/SettingsManager.cpp
@@ -499,8 +499,8 @@ namespace storm {
             
             // Register all known settings modules.
             storm::settings::addModule<storm::settings::modules::GeneralSettings>();
-            storm::settings::addModule<storm::settings::modules::MarkovChainSettings>();
             storm::settings::addModule<storm::settings::modules::IOSettings>();
+            storm::settings::addModule<storm::settings::modules::MarkovChainSettings>();
             storm::settings::addModule<storm::settings::modules::DebugSettings>();
             storm::settings::addModule<storm::settings::modules::CounterexampleGeneratorSettings>();
             storm::settings::addModule<storm::settings::modules::CuddSettings>();
diff --git a/src/settings/modules/DFTSettings.cpp b/src/settings/modules/DFTSettings.cpp
new file mode 100644
index 000000000..365ba0271
--- /dev/null
+++ b/src/settings/modules/DFTSettings.cpp
@@ -0,0 +1,107 @@
+#include "src/settings/modules/DFTSettings.h"
+
+#include "src/settings/SettingsManager.h"
+#include "src/settings/SettingMemento.h"
+#include "src/settings/Option.h"
+#include "src/settings/OptionBuilder.h"
+#include "src/settings/ArgumentBuilder.h"
+#include "src/settings/Argument.h"
+
+#include "src/exceptions/InvalidSettingsException.h"
+
+
+namespace storm {
+    namespace settings {
+        namespace modules {
+            
+            const std::string DFTSettings::moduleName = "dft";
+            const std::string DFTSettings::dftFileOptionName = "dftfile";
+            const std::string DFTSettings::dftFileOptionShortName = "dft";
+            const std::string DFTSettings::symmetryReductionOptionName = "symmetryreduction";
+            const std::string DFTSettings::symmetryReductionOptionShortName = "symred";
+            const std::string DFTSettings::modularisationOptionName = "modularisation";
+            const std::string DFTSettings::disableDCOptionName = "disabledc";
+            const std::string DFTSettings::propExpectedTimeOptionName = "expectedtime";
+            const std::string DFTSettings::propExpectedTimeOptionShortName = "mttf";
+            const std::string DFTSettings::propProbabilityOptionName = "probability";
+            const std::string DFTSettings::propTimeBoundOptionName = "timebound";
+            const std::string DFTSettings::minValueOptionName = "min";
+            const std::string DFTSettings::maxValueOptionName = "max";
+
+            DFTSettings::DFTSettings() : ModuleSettings(moduleName) {
+                this->addOption(storm::settings::OptionBuilder(moduleName, dftFileOptionName, false, "Parses the model given in the Galileo format.").setShortName(dftFileOptionShortName)
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file from which to read the DFT model.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, symmetryReductionOptionName, false, "Exploit symmetric structure of model.").setShortName(symmetryReductionOptionShortName).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, modularisationOptionName, false, "Use modularisation (not applicable for expected time).").build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, disableDCOptionName, false, "Disable Dont Care propagation.").build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, propExpectedTimeOptionName, false, "Compute expected time of system failure.").setShortName(propExpectedTimeOptionShortName).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, propProbabilityOptionName, false, "Compute probability of system failure.").build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, propTimeBoundOptionName, false, "Compute probability of system failure up to given timebound.").addArgument(storm::settings::ArgumentBuilder::createDoubleArgument("time", "The timebound to use.").addValidationFunctionDouble(storm::settings::ArgumentValidators::doubleGreaterValidatorExcluding(0.0)).build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, minValueOptionName, false, "Compute minimal value in case of non-determinism.").build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, maxValueOptionName, false, "Compute maximal value in case of non-determinism.").build());
+            }
+            
+            bool DFTSettings::isDftFileSet() const {
+                return this->getOption(dftFileOptionName).getHasOptionBeenSet();
+            }
+            
+            std::string DFTSettings::getDftFilename() const {
+                return this->getOption(dftFileOptionName).getArgumentByName("filename").getValueAsString();
+            }
+            
+            bool DFTSettings::useSymmetryReduction() const {
+                return this->getOption(symmetryReductionOptionName).getHasOptionBeenSet();
+            }
+            
+            bool DFTSettings::useModularisation() const {
+                return this->getOption(modularisationOptionName).getHasOptionBeenSet();
+            }
+            
+            bool DFTSettings::isDisableDC() const {
+                return this->getOption(disableDCOptionName).getHasOptionBeenSet();
+            }
+            
+            bool DFTSettings::usePropExpectedTime() const {
+                return this->getOption(propExpectedTimeOptionName).getHasOptionBeenSet();
+            }
+            
+            bool DFTSettings::usePropProbability() const {
+                return this->getOption(propProbabilityOptionName).getHasOptionBeenSet();
+            }
+            
+            bool DFTSettings::usePropTimebound() const {
+                return this->getOption(propTimeBoundOptionName).getHasOptionBeenSet();
+            }
+            
+            double DFTSettings::getPropTimebound() const {
+                return this->getOption(propTimeBoundOptionName).getArgumentByName("time").getValueAsDouble();
+            }
+            
+            bool DFTSettings::isComputeMinimalValue() const {
+                return this->getOption(minValueOptionName).getHasOptionBeenSet();
+            }
+            
+            bool DFTSettings::isComputeMaximalValue() const {
+                return this->getOption(maxValueOptionName).getHasOptionBeenSet();
+            }
+            
+            void DFTSettings::finalize() {
+                
+            }
+
+            bool DFTSettings::check() const {
+                // Ensure that only one property is given.
+                if (usePropExpectedTime()) {
+                    STORM_LOG_THROW(!usePropProbability() && !usePropTimebound(), storm::exceptions::InvalidSettingsException, "More than one property given.");
+                } else if (usePropProbability()) {
+                    STORM_LOG_THROW(!usePropTimebound(), storm::exceptions::InvalidSettingsException, "More than one property given.");
+                }
+                
+                // Ensure that at most one of min or max is set
+                STORM_LOG_THROW(!isComputeMinimalValue() || !isComputeMaximalValue(), storm::exceptions::InvalidSettingsException, "Min and max can not both be set.");
+                return true;
+            }
+            
+        } // namespace modules
+    } // namespace settings
+} // namespace storm
\ No newline at end of file
diff --git a/src/settings/modules/DFTSettings.h b/src/settings/modules/DFTSettings.h
new file mode 100644
index 000000000..844953c2c
--- /dev/null
+++ b/src/settings/modules/DFTSettings.h
@@ -0,0 +1,129 @@
+#ifndef STORM_SETTINGS_MODULES_DFTSETTINGS_H_
+#define STORM_SETTINGS_MODULES_DFTSETTINGS_H_
+
+#include "storm-config.h"
+#include "src/settings/modules/ModuleSettings.h"
+
+namespace storm {
+    namespace settings {
+        namespace modules {
+
+            /*!
+             * This class represents the settings for DFT model checking.
+             */
+            class DFTSettings : public ModuleSettings {
+            public:
+
+                /*!
+                 * Creates a new set of DFT settings.
+                 */
+                DFTSettings();
+                
+                /*!
+                 * Retrieves whether the dft file option was set.
+                 *
+                 * @return True if the dft file option was set.
+                 */
+                bool isDftFileSet() const;
+                
+                /*!
+                 * Retrieves the name of the file that contains the dft specification.
+                 *
+                 * @return The name of the file that contains the dft specification.
+                 */
+                std::string getDftFilename() const;
+                
+                //expectedtime, probability, timebound, prob
+                //min, max
+                
+                /*!
+                 * Retrieves whether the option to use symmetry reduction is set.
+                 *
+                 * @return True iff the option was set.
+                 */
+                bool useSymmetryReduction() const;
+                
+                /*!
+                 * Retrieves whether the option to use modularisation is set.
+                 *
+                 * @return True iff the option was set.
+                 */
+                bool useModularisation() const;
+                
+                /*!
+                 * Retrieves whether the option to disable Dont Care propagation is set.
+                 *
+                 * @return True iff the option was set.
+                 */
+                bool isDisableDC() const;
+
+                /*!
+                 * Retrieves whether the property expected time should be used.
+                 *
+                 * @return True iff the option was set.
+                 */
+                bool usePropExpectedTime() const;
+                
+                /*!
+                 * Retrieves whether the property probability should be used.
+                 *
+                 * @return True iff the option was set.
+                 */
+                bool usePropProbability() const;
+                
+                /*!
+                 * Retrieves whether the property timebound should be used.
+                 *
+                 * @return True iff the option was set.
+                 */
+                bool usePropTimebound() const;
+                
+                /*!
+                 * Retrieves whether the minimal value should be computed for non-determinism.
+                 *
+                 * @return True iff the option was set.
+                 */
+                bool isComputeMinimalValue() const;
+
+                /*!
+                 * Retrieves whether the maximal value should be computed for non-determinism.
+                 *
+                 * @return True iff the option was set.
+                 */
+                bool isComputeMaximalValue() const;
+                
+                /*!
+                 * Retrieves the timebound for the timebound property.
+                 *
+                 * @return The timebound.
+                 */
+                double getPropTimebound() const;
+                
+                bool check() const override;
+                void finalize() override;
+
+                // The name of the module.
+                static const std::string moduleName;
+
+            private:
+               // Define the string names of the options as constants.
+                static const std::string dftFileOptionName;
+                static const std::string dftFileOptionShortName;
+                static const std::string symmetryReductionOptionName;
+                static const std::string symmetryReductionOptionShortName;
+                static const std::string modularisationOptionName;
+                static const std::string disableDCOptionName;
+                static const std::string propExpectedTimeOptionName;
+                static const std::string propExpectedTimeOptionShortName;
+                static const std::string propProbabilityOptionName;
+                static const std::string propTimeBoundOptionName;
+                static const std::string minValueOptionName;
+                static const std::string maxValueOptionName;
+                
+            };
+
+        } // namespace modules
+    } // namespace settings
+} // namespace storm
+
+#endif /* STORM_SETTINGS_MODULES_DFTSETTINGS_H_ */
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index 4f6c1f7e0..b71ff44e7 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -2,8 +2,27 @@
 #include "utility/initialize.h"
 #include "utility/storm.h"
 #include "modelchecker/DFTAnalyser.h"
+#include "src/cli/cli.h"
+#include "src/exceptions/BaseException.h"
+#include "src/utility/macros.h"
 #include <boost/lexical_cast.hpp>
 
+#include "src/settings/modules/GeneralSettings.h"
+#include "src/settings/modules/DFTSettings.h"
+#include "src/settings/modules/MarkovChainSettings.h"
+#include "src/settings/modules/DebugSettings.h"
+//#include "src/settings/modules/CounterexampleGeneratorSettings.h"
+//#include "src/settings/modules/CuddSettings.h"
+//#include "src/settings/modules/SylvanSettings.h"
+#include "src/settings/modules/GmmxxEquationSolverSettings.h"
+#include "src/settings/modules/NativeEquationSolverSettings.h"
+//#include "src/settings/modules/BisimulationSettings.h"
+//#include "src/settings/modules/GlpkSettings.h"
+//#include "src/settings/modules/GurobiSettings.h"
+//#include "src/settings/modules/TopologicalValueIterationEquationSolverSettings.h"
+//#include "src/settings/modules/ParametricSettings.h"
+#include "src/settings/modules/SparseDtmcEliminationModelCheckerSettings.h"
+
 /*!
  * Load DFT from filename, build corresponding Model and check against given property.
  *
@@ -12,8 +31,7 @@
  */
 template <typename ValueType>
 void analyzeDFT(std::string filename, std::string property, bool symred = false, bool allowModularisation = false, bool enableDC = true) {
-    storm::settings::SettingsManager& manager = storm::settings::mutableManager();
-    manager.setFromString("");
+    std::cout << "Running DFT analysis on file " << filename << " with property " << property << std::endl;
 
     storm::parser::DFTGalileoParser<ValueType> parser;
     storm::storage::DFT<ValueType> dft = parser.parseDFT(filename);
@@ -27,6 +45,30 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false,
     analyser.printResult();
 }
 
+/*!
+ * Initialize the settings manager.
+ */
+void initializeSettings() {
+    storm::settings::mutableManager().setName("StoRM-DyFTeE", "storm-dft");
+    
+    // Register all known settings modules.
+    storm::settings::addModule<storm::settings::modules::GeneralSettings>();
+    storm::settings::addModule<storm::settings::modules::DFTSettings>();
+    storm::settings::addModule<storm::settings::modules::MarkovChainSettings>();
+    storm::settings::addModule<storm::settings::modules::DebugSettings>();
+    //storm::settings::addModule<storm::settings::modules::CounterexampleGeneratorSettings>();
+    //storm::settings::addModule<storm::settings::modules::CuddSettings>();
+    //storm::settings::addModule<storm::settings::modules::SylvanSettings>();
+    storm::settings::addModule<storm::settings::modules::GmmxxEquationSolverSettings>();
+    storm::settings::addModule<storm::settings::modules::NativeEquationSolverSettings>();
+    //storm::settings::addModule<storm::settings::modules::BisimulationSettings>();
+    //storm::settings::addModule<storm::settings::modules::GlpkSettings>();
+    //storm::settings::addModule<storm::settings::modules::GurobiSettings>();
+    //storm::settings::addModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>();
+    //storm::settings::addModule<storm::settings::modules::ParametricSettings>();
+    storm::settings::addModule<storm::settings::modules::SparseDtmcEliminationModelCheckerSettings>();
+}
+
 /*!
  * Entry point for the DyFTeE backend.
  *
@@ -34,91 +76,81 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false,
  * @param argv The argv argument of main().
  * @return Return code, 0 if successfull, not 0 otherwise.
  */
-int main(int argc, char** argv) {
-    if(argc < 2) {
-        std::cout << "Storm-DyFTeE should be called with a filename as argument." << std::endl;
-        std::cout << "./storm-dft <filename> <--prop pctl-formula> <--parametric>" << std::endl;
-        return 1;
-    }
-
-    // Parse cli arguments
-    bool parametric = false;
-    bool symred = false;
-    bool minimal = true;
-    bool allowModular = true;
-    bool enableModularisation = false;
-    bool disableDC = false;
-    std::string filename = argv[1];
-    std::string operatorType = "";
-    std::string targetFormula = "";
-    std::string pctlFormula = "";
-    for (int i = 2; i < argc; ++i) {
-        std::string option = argv[i];
-        if (option == "--parametric") {
-            parametric = true;
-        } else if (option == "--expectedtime") {
-            assert(targetFormula.empty());
+int main(const int argc, const char** argv) {
+    try {
+        storm::utility::setUp();
+        storm::cli::printHeader("StoRM-DyFTeE", argc, argv);
+        initializeSettings();
+        
+        bool optionsCorrect = storm::cli::parseOptions(argc, argv);
+        if (!optionsCorrect) {
+            return -1;
+        }
+        
+        storm::settings::modules::DFTSettings const& dftSettings = storm::settings::getModule<storm::settings::modules::DFTSettings>();
+        storm::settings::modules::GeneralSettings const& generalSettings = storm::settings::getModule<storm::settings::modules::GeneralSettings>();
+        if (!dftSettings.isDftFileSet()) {
+            STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "No input model.");
+        }
+        
+        // Set min or max
+        bool minimal = true;
+        if (dftSettings.isComputeMaximalValue()) {
+            assert(!dftSettings.isComputeMinimalValue());
+            minimal = false;
+        }
+        
+        // Construct pctlFormula
+        std::string pctlFormula = "";
+        bool allowModular = true;
+        std::string operatorType = "";
+        std::string targetFormula = "";
+        
+        if (generalSettings.isPropertySet()) {
+            STORM_LOG_THROW(!dftSettings.usePropExpectedTime() && !dftSettings.usePropProbability() && !dftSettings.usePropTimebound(), storm::exceptions::InvalidSettingsException, "More than one property given.");
+            pctlFormula = generalSettings.getProperty();
+        } else if (dftSettings.usePropExpectedTime()) {
+            STORM_LOG_THROW(!dftSettings.usePropProbability() && !dftSettings.usePropTimebound(), storm::exceptions::InvalidSettingsException, "More than one property given.");
             operatorType = "T";
             targetFormula = "F \"failed\"";
             allowModular = false;
-        } else if (option == "--probability") {
-            assert(targetFormula.empty());
+        } else if (dftSettings.usePropProbability()) {
+            STORM_LOG_THROW(!dftSettings.usePropTimebound(), storm::exceptions::InvalidSettingsException, "More than one property given.");
             operatorType = "P";;
             targetFormula = "F \"failed\"";
-        } else if (option == "--timebound") {
-            assert(targetFormula.empty());
-            ++i;
-            assert(i < argc);
-            double timeBound;
-            try {
-                timeBound = boost::lexical_cast<double>(argv[i]);
-            } catch (boost::bad_lexical_cast e) {
-                std::cerr << "The time bound '" << argv[i] << "' is not valid." << std::endl;
-                return 2;
-            }
+        } else {
+            STORM_LOG_THROW(dftSettings.usePropTimebound(), storm::exceptions::InvalidSettingsException, "No property given.");
             std::stringstream stream;
-            stream << "F<=" << timeBound << " \"failed\"";
+            stream << "F<=" << dftSettings.getPropTimebound() << " \"failed\"";
             operatorType = "P";
             targetFormula = stream.str();
-        } else if (option == "--trace") {
-            STORM_GLOBAL_LOGLEVEL_TRACE();
-        } else if (option == "--debug") {
-            STORM_GLOBAL_LOGLEVEL_DEBUG();
-        } else if (option == "--prop") {
+        }
+        
+        if (!targetFormula.empty()) {
             assert(pctlFormula.empty());
-            ++i;
-            assert(i < argc);
-            pctlFormula = argv[i];
-        } else if (option == "--symred") {
-            symred = true;
-        } else if (option == "--modularisation") {
-            enableModularisation = true;
-        } else if (option == "--disabledc") {
-            disableDC = true;
-        } else if (option == "--min") {
-            minimal = true;
-        } else if (option == "--max") {
-            minimal = false;
-        } else {
-            std::cout << "Option '" << option << "' not recognized." << std::endl;
-            return 1;
+            pctlFormula = operatorType + (minimal ? "min" : "max") + "=?[" + targetFormula + "]";
         }
-    }
-    
-    // Construct pctlFormula
-    if (!targetFormula.empty()) {
-        assert(pctlFormula.empty());
-        pctlFormula = operatorType + (minimal ? "min" : "max") + "=?[" + targetFormula + "]";
-    }
-    
-    assert(!pctlFormula.empty());
-
-    storm::utility::setUp();
-    std::cout << "Running " << (parametric ? "parametric " : "") << "DFT analysis on file " << filename << " with property " << pctlFormula << std::endl;
+        
+        assert(!pctlFormula.empty());
 
-    if (parametric) {
-        analyzeDFT<storm::RationalFunction>(filename, pctlFormula, symred, allowModular && enableModularisation, !disableDC );
-    } else {
-        analyzeDFT<double>(filename, pctlFormula, symred, allowModular && enableModularisation, !disableDC);
+        bool parametric = false;
+#ifdef STORM_HAVE_CARL
+        parametric = generalSettings.isParametricSet();
+#endif
+        
+        // From this point on we are ready to carry out the actual computations.
+        if (parametric) {
+            analyzeDFT<storm::RationalFunction>(dftSettings.getDftFilename(), pctlFormula, dftSettings.useSymmetryReduction(), allowModular && dftSettings.useModularisation(), !dftSettings.isDisableDC() );
+        } else {
+            analyzeDFT<double>(dftSettings.getDftFilename(), pctlFormula, dftSettings.useSymmetryReduction(), allowModular && dftSettings.useModularisation(), !dftSettings.isDisableDC());
+        }
+        
+        // All operations have now been performed, so we clean up everything and terminate.
+        storm::utility::cleanUp();
+        return 0;
+    } catch (storm::exceptions::BaseException const& exception) {
+        STORM_LOG_ERROR("An exception caused StoRM-DyFTeE to terminate. The message of the exception is: " << exception.what());
+    } catch (std::exception const& exception) {
+        STORM_LOG_ERROR("An unexpected exception occurred and caused StoRM-DyFTeE to terminate. The message of this exception is: " << exception.what());
     }
 }

From 7688d7ef42d00d35a26e9b9adca12aee9fc292d2 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 5 Apr 2016 11:39:30 +0200
Subject: [PATCH 236/246] Fixed test

Former-commit-id: 9e1094a5a0c36377fa34c922fde839324706ee73
---
 .../modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp          | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/functional/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp b/test/functional/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp
index 6220276ba..ee2a1b5e5 100644
--- a/test/functional/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp
+++ b/test/functional/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp
@@ -268,8 +268,8 @@ TEST(GmmxxMdpPrctlModelCheckerTest, tiny_rewards) {
     std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(checkTask);
     
     ASSERT_TRUE(result->isExplicitQuantitativeCheckResult());
-    EXPECT_NEAR(1,result->asExplicitQuantitativeCheckResult<double>().getValueVector()[0], storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(1,result->asExplicitQuantitativeCheckResult<double>().getValueVector()[1], storm::settings::nativeEquationSolverSettings().getPrecision());
-    EXPECT_NEAR(0,result->asExplicitQuantitativeCheckResult<double>().getValueVector()[2], storm::settings::nativeEquationSolverSettings().getPrecision());
+    EXPECT_NEAR(1,result->asExplicitQuantitativeCheckResult<double>().getValueVector()[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(1,result->asExplicitQuantitativeCheckResult<double>().getValueVector()[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
+    EXPECT_NEAR(0,result->asExplicitQuantitativeCheckResult<double>().getValueVector()[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision());
     
 }

From 380d3f18979721bcb8f925596f599b3447ad4dcf Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 5 Apr 2016 16:31:12 +0200
Subject: [PATCH 237/246] CTMC constructor with exitRates

Former-commit-id: 2f1afe1d5b9a0842f8994b4516f68fac3208f769
---
 src/builder/ExplicitDFTModelBuilder.cpp |  2 +-
 src/models/sparse/Ctmc.cpp              |  7 +++++++
 src/models/sparse/Ctmc.h                | 14 ++++++++++++++
 3 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index fa8be6e1a..820dee6a4 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -120,7 +120,7 @@ namespace storm {
                         }
                     }
                 }
-                model = std::make_shared<storm::models::sparse::Ctmc<ValueType>>(std::move(rateMatrix), std::move(modelComponents.stateLabeling));
+                model = std::make_shared<storm::models::sparse::Ctmc<ValueType>>(std::move(rateMatrix), std::move(modelComponents.exitRates), std::move(modelComponents.stateLabeling));
             } else {
                 std::shared_ptr<storm::models::sparse::MarkovAutomaton<ValueType>> ma = std::make_shared<storm::models::sparse::MarkovAutomaton<ValueType>>(std::move(modelComponents.transitionMatrix), std::move(modelComponents.stateLabeling), std::move(modelComponents.markovianStates), std::move(modelComponents.exitRates), true);
                 if (ma->hasOnlyTrivialNondeterminism()) {
diff --git a/src/models/sparse/Ctmc.cpp b/src/models/sparse/Ctmc.cpp
index 62347c81b..1d07c48a9 100644
--- a/src/models/sparse/Ctmc.cpp
+++ b/src/models/sparse/Ctmc.cpp
@@ -24,6 +24,13 @@ namespace storm {
                 exitRates = createExitRateVector(this->getTransitionMatrix());
             }
             
+            template <typename ValueType, typename RewardModelType>
+            Ctmc<ValueType, RewardModelType>::Ctmc(storm::storage::SparseMatrix<ValueType> const& rateMatrix, std::vector<ValueType> const& exitRates, storm::models::sparse::StateLabeling const& stateLabeling,
+                                std::unordered_map<std::string, RewardModelType> const& rewardModels,
+                                boost::optional<std::vector<LabelSet>> const& optionalChoiceLabeling)
+            : DeterministicModel<ValueType, RewardModelType>(storm::models::ModelType::Ctmc, std::move(rateMatrix), std::move(stateLabeling), std::move(rewardModels), std::move(optionalChoiceLabeling)), exitRates(exitRates) {
+            }
+            
             template <typename ValueType, typename RewardModelType>
             std::vector<ValueType> const& Ctmc<ValueType, RewardModelType>::getExitRateVector() const {
                 return exitRates;
diff --git a/src/models/sparse/Ctmc.h b/src/models/sparse/Ctmc.h
index 716b80373..fc933ae7d 100644
--- a/src/models/sparse/Ctmc.h
+++ b/src/models/sparse/Ctmc.h
@@ -38,6 +38,20 @@ namespace storm {
                      std::unordered_map<std::string, RewardModelType>&& rewardModels = std::unordered_map<std::string, RewardModelType>(),
                      boost::optional<std::vector<LabelSet>>&& optionalChoiceLabeling = boost::optional<std::vector<LabelSet>>());
                 
+                /*!
+                 * Constructs a model from the given data.
+                 *
+                 * @param rateMatrix The matrix representing the transitions in the model.
+                 * @param exitRates The exit rates of all states.
+                 * @param stateLabeling The labeling of the states.
+                 * @param rewardModels A mapping of reward model names to reward models.
+                 * @param optionalChoiceLabeling A vector that represents the labels associated with the choices of each state.
+                 */
+                Ctmc(storm::storage::SparseMatrix<ValueType> const& rateMatrix, std::vector<ValueType> const& exitRates, storm::models::sparse::StateLabeling const& stateLabeling,
+                     std::unordered_map<std::string, RewardModelType> const& rewardModels = std::unordered_map<std::string, RewardModelType>(),
+                     boost::optional<std::vector<LabelSet>> const& optionalChoiceLabeling = boost::optional<std::vector<LabelSet>>());
+
+                
                 Ctmc(Ctmc<ValueType, RewardModelType> const& ctmc) = default;
                 Ctmc& operator=(Ctmc<ValueType, RewardModelType> const& ctmc) = default;
                 

From 3f06a518694162c3fb2a47afed477b5f0fea0b4a Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 5 Apr 2016 16:31:57 +0200
Subject: [PATCH 238/246] Added test setting for quick activation/deactivation
 of test feature

Former-commit-id: a7bbfabcbe0b11be629209e18b40ec003b62cf67
---
 src/settings/modules/DebugSettings.cpp | 6 ++++++
 src/settings/modules/DebugSettings.h   | 9 +++++++++
 2 files changed, 15 insertions(+)

diff --git a/src/settings/modules/DebugSettings.cpp b/src/settings/modules/DebugSettings.cpp
index 16d035015..0f37e7ce7 100644
--- a/src/settings/modules/DebugSettings.cpp
+++ b/src/settings/modules/DebugSettings.cpp
@@ -15,12 +15,14 @@ namespace storm {
             const std::string DebugSettings::traceOptionName = "trace";
             const std::string DebugSettings::logfileOptionName = "logfile";
             const std::string DebugSettings::logfileOptionShortName = "l";
+            const std::string DebugSettings::testOptionName = "test";
  
             DebugSettings::DebugSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, debugOptionName, false, "Print debug output.").build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, traceOptionName, false, "Print even more debug output.").build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, logfileOptionName, false, "If specified, the log output will also be written to this file.").setShortName(logfileOptionShortName)
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file to write the log.").build()).build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, testOptionName, false, "Activate a test setting.").build());
             }
             
             bool DebugSettings::isDebugSet() const {
@@ -39,6 +41,10 @@ namespace storm {
                 return this->getOption(traceOptionName).getArgumentByName("filename").getValueAsString();
             }
             
+            bool DebugSettings::isTestSet() const {
+                return this->getOption(testOptionName).getHasOptionBeenSet();
+            }
+            
         } // namespace modules
     } // namespace settings
 } // namespace storm
\ No newline at end of file
diff --git a/src/settings/modules/DebugSettings.h b/src/settings/modules/DebugSettings.h
index f78a4e3a8..438017307 100644
--- a/src/settings/modules/DebugSettings.h
+++ b/src/settings/modules/DebugSettings.h
@@ -45,6 +45,14 @@ namespace storm {
                  */
                 std::string getLogfilename() const;
                 
+                /*!
+                 * Retrieves whether the test option was set. This is a general option which can be
+                 * used for quick testing purposes to activate/decactivate a certain setting.
+                 *
+                 * @return True iff the test option was set.
+                 */
+                bool isTestSet() const;
+                
                 // The name of the module.
                 static const std::string moduleName;
                 
@@ -54,6 +62,7 @@ namespace storm {
                 static const std::string traceOptionName;
                 static const std::string logfileOptionName;
                 static const std::string logfileOptionShortName;
+                static const std::string testOptionName;
             };
             
         } // namespace modules

From 10e94d7104748722afed3dfb643c93ca00155ca5 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 7 Apr 2016 12:58:39 +0200
Subject: [PATCH 239/246] Typo

Former-commit-id: c5f7a6c6033aa4c98228b5266606da78f68eb4cc
---
 .../reachability/SparseDtmcEliminationModelChecker.cpp          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
index ac3254dd4..0f67cca4a 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
@@ -882,7 +882,7 @@ namespace storm {
                     }
                 }
             }
-            STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "Illlegal elimination order selected.");
+            STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "Illegal elimination order selected.");
         }
         
         template<typename SparseDtmcModelType>

From a41e5df39f1d04c2009c257d97ebf3cadbf29eb7 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 7 Apr 2016 17:06:13 +0200
Subject: [PATCH 240/246] Changed BFS to DFS in Exploration

Former-commit-id: b55e18123c1cb54aad099d1eddef0004e9993f51
---
 src/builder/ExplicitDFTModelBuilder.cpp  | 494 +++++++++++++----------
 src/builder/ExplicitDFTModelBuilder.h    |  19 +-
 src/storage/dft/DFTStateGenerationInfo.h |   4 +
 3 files changed, 296 insertions(+), 221 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 820dee6a4..5e17e2f52 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -26,29 +26,53 @@ namespace storm {
         std::shared_ptr<storm::models::sparse::Model<ValueType>> ExplicitDFTModelBuilder<ValueType>::buildModel(LabelOptions const& labelOpts) {
             // Initialize
             bool deterministicModel = false;
+            size_t rowOffset = 0;
             ModelComponents modelComponents;
             std::vector<uint_fast64_t> tmpMarkovianStates;
             storm::storage::SparseMatrixBuilder<ValueType> transitionMatrixBuilder(0, 0, 0, false, !deterministicModel, 0);
-            
 
             if(mergeFailedStates) {
+                // Introduce explicit fail state
+                failedIndex = newIndex;
                 newIndex++;
-                
                 transitionMatrixBuilder.newRowGroup(failedIndex);
                 transitionMatrixBuilder.addNextValue(failedIndex, failedIndex, storm::utility::one<ValueType>());
-                STORM_LOG_TRACE("Added self loop for " << failedIndex);
+                STORM_LOG_TRACE("Introduce fail state with id: " << failedIndex);
                 modelComponents.exitRates.push_back(storm::utility::one<ValueType>());
                 tmpMarkovianStates.push_back(failedIndex);        
             }
             
-            DFTStatePointer state = std::make_shared<storm::storage::DFTState<ValueType>>(mDft, *mStateGenerationInfo, newIndex++);
-            mStates.findOrAdd(state->status(), state->getId());
-            initialStateIndex = state->getId();
-            std::queue<DFTStatePointer> stateQueue;
-            stateQueue.push(state);
+            // Explore state space
+            DFTStatePointer state = std::make_shared<storm::storage::DFTState<ValueType>>(mDft, *mStateGenerationInfo, newIndex);
+            auto exploreResult = exploreStates(state, rowOffset, transitionMatrixBuilder, tmpMarkovianStates, modelComponents.exitRates);
+            initialStateIndex = exploreResult.first;
+            bool deterministic = exploreResult.second;
+        
+            // Before ending the exploration check for pseudo states which are no be initialized yet
+            for (auto & pseudoStatePair : mPseudoStatesMapping) {
+                if (pseudoStatePair.first == 0) {
+                    // Create state from pseudo state and explore
+                    assert(mStates.contains(pseudoStatePair.second));
+                    assert(mStates.getValue(pseudoStatePair.second) >= OFFSET_PSEUDO_STATE);
+                    STORM_LOG_TRACE("Create pseudo state from bit vector " << pseudoStatePair.second);
+                    DFTStatePointer pseudoState = std::make_shared<storm::storage::DFTState<ValueType>>(pseudoStatePair.second, mDft, *mStateGenerationInfo, newIndex);
+                    assert(pseudoStatePair.second == pseudoState->status());
+                    STORM_LOG_TRACE("Explore pseudo state " << mDft.getStateString(pseudoState) << " with id " << pseudoState->getId());
+                    auto exploreResult = exploreStates(pseudoState, rowOffset, transitionMatrixBuilder, tmpMarkovianStates, modelComponents.exitRates);
+                    deterministic &= exploreResult.second;
+                    assert(pseudoStatePair.first == pseudoState->getId());
+                    assert(pseudoState->getId() == exploreResult.first);
+                }
+            }
+            
+            // Replace pseudo states in matrix
+            std::vector<uint_fast64_t> pseudoStatesVector;
+            for (auto const& pseudoStatePair : mPseudoStatesMapping) {
+                pseudoStatesVector.push_back(pseudoStatePair.first);
+            }
+            assert(std::find(pseudoStatesVector.begin(), pseudoStatesVector.end(), 0) == pseudoStatesVector.end());
+            transitionMatrixBuilder.replaceColumns(pseudoStatesVector, OFFSET_PSEUDO_STATE);
             
-            // Begin model generation
-            bool deterministic = exploreStates(stateQueue, transitionMatrixBuilder, tmpMarkovianStates, modelComponents.exitRates);
             STORM_LOG_DEBUG("Generated " << mStates.size() + (mergeFailedStates ? 1 : 0) << " states");
             STORM_LOG_DEBUG("Model is " << (deterministic ? "deterministic" : "non-deterministic"));
 
@@ -135,238 +159,274 @@ namespace storm {
         }
 
         template <typename ValueType>
-        bool ExplicitDFTModelBuilder<ValueType>::exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates) {
+        std::pair<uint_fast64_t, bool> ExplicitDFTModelBuilder<ValueType>::exploreStates(DFTStatePointer const& state, size_t& rowOffset, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates) {
+            STORM_LOG_TRACE("Explore state: " << mDft.getStateString(state));
+
+            auto explorePair = checkForExploration(state);
+            if (!explorePair.first) {
+                // State does not need any exploration
+                return std::make_pair(explorePair.second, true);
+            }
 
-            // TODO Matthias: set Markovian states directly as bitvector?
-            std::map<uint_fast64_t, ValueType> outgoingTransitions;
-            size_t rowOffset = 0; // Captures number of non-deterministic choices
-            bool deterministic = true;
-            
             
-            while (!stateQueue.empty()) {
-                // Initialization
-                outgoingTransitions.clear();
-                ValueType exitRate = storm::utility::zero<ValueType>();
+            // Initialization
+            // TODO Matthias: set Markovian states directly as bitvector?
+            std::map<uint_fast64_t, ValueType> outgoingRates;
+            std::vector<std::map<uint_fast64_t, ValueType>> outgoingProbabilities;
+            bool hasDependencies = state->nrFailableDependencies() > 0;
+            size_t failableCount = hasDependencies ? state->nrFailableDependencies() : state->nrFailableBEs();
+            size_t smallest = 0;
+            ValueType exitRate = storm::utility::zero<ValueType>();
+            bool deterministic = !hasDependencies;
+
+            // Absorbing state
+            if (mDft.hasFailed(state) || mDft.isFailsafe(state) || state->nrFailableBEs() == 0) {
+                uint_fast64_t stateId = addState(state);
+                assert(stateId == state->getId());
+
+                // Add self loop
+                transitionMatrixBuilder.newRowGroup(stateId + rowOffset);
+                transitionMatrixBuilder.addNextValue(stateId + rowOffset, stateId, storm::utility::one<ValueType>());
+                STORM_LOG_TRACE("Added self loop for " << stateId);
+                exitRates.push_back(storm::utility::one<ValueType>());
+                assert(exitRates.size()-1 == stateId);
+                markovianStates.push_back(stateId);
+                // No further exploration required
+                return std::make_pair(stateId, true);
+            }
 
-                // Consider next state
-                DFTStatePointer state = stateQueue.front();
-                stateQueue.pop();
+            // Let BE fail
+            while (smallest < failableCount) {
+                assert(!mDft.hasFailed(state));
 
-                bool hasDependencies = state->nrFailableDependencies() > 0;
-                deterministic &= !hasDependencies;
-                size_t failableCount = hasDependencies ? state->nrFailableDependencies() : state->nrFailableBEs();
-                size_t smallest = 0;
+                // Construct new state as copy from original one
+                DFTStatePointer newState = std::make_shared<storm::storage::DFTState<ValueType>>(*state);
+                std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType> const>, bool> nextBEPair = newState->letNextBEFail(smallest++);
+                std::shared_ptr<storm::storage::DFTBE<ValueType> const>& nextBE = nextBEPair.first;
+                assert(nextBE);
+                assert(nextBEPair.second == hasDependencies);
+                STORM_LOG_TRACE("With the failure of: " << nextBE->name() << " [" << nextBE->id() << "] in " << mDft.getStateString(state));
 
-                transitionMatrixBuilder.newRowGroup(state->getId() + rowOffset);
+                // Propagate failures
+                storm::storage::DFTStateSpaceGenerationQueues<ValueType> queues;
 
-                // Add self loop for target states
-                if (mDft.hasFailed(state) || mDft.isFailsafe(state) || state->nrFailableBEs() == 0) {
-                    transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, state->getId(), storm::utility::one<ValueType>());
-                    STORM_LOG_TRACE("Added self loop for " << state->getId());
-                    exitRates.push_back(storm::utility::one<ValueType>());
-                    assert(exitRates.size()-1 == state->getId());
-                    markovianStates.push_back(state->getId());
-                    // No further exploration required
-                    continue;
+                for (DFTGatePointer parent : nextBE->parents()) {
+                    if (newState->isOperational(parent->id())) {
+                        queues.propagateFailure(parent);
+                    }
+                }
+                for (DFTRestrictionPointer restr : nextBE->restrictions()) {
+                    queues.checkRestrictionLater(restr);
                 }
 
-                // Let BE fail
-                while (smallest < failableCount) {
-                    assert(!mDft.hasFailed(state));
-                    STORM_LOG_TRACE("exploring from: " << mDft.getStateString(state));
-
-                    // Construct new state as copy from original one
-                    DFTStatePointer newState = std::make_shared<storm::storage::DFTState<ValueType>>(*state);
-                    std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType> const>, bool> nextBEPair = newState->letNextBEFail(smallest++);
-                    std::shared_ptr<storm::storage::DFTBE<ValueType> const>& nextBE = nextBEPair.first;
-                    assert(nextBE);
-                    assert(nextBEPair.second == hasDependencies);
-                    STORM_LOG_TRACE("with the failure of: " << nextBE->name() << " [" << nextBE->id() << "]");
-
-                    // Propagate failures
-                    storm::storage::DFTStateSpaceGenerationQueues<ValueType> queues;
-
-                    for (DFTGatePointer parent : nextBE->parents()) {
-                        if (newState->isOperational(parent->id())) {
-                            queues.propagateFailure(parent);
-                        }
-                    }
-                    for (DFTRestrictionPointer restr : nextBE->restrictions()) {
-                        queues.checkRestrictionLater(restr);
-                    }
+                while (!queues.failurePropagationDone()) {
+                    DFTGatePointer next = queues.nextFailurePropagation();
+                    next->checkFails(*newState, queues);
+                    newState->updateFailableDependencies(next->id());
+                }
+                
+                while(!queues.restrictionChecksDone()) {
+                    DFTRestrictionPointer next = queues.nextRestrictionCheck();
+                    next->checkFails(*newState, queues);
+                    newState->updateFailableDependencies(next->id());
+                }
+                
+                if(newState->isInvalid()) {
+                    continue;
+                }
+                bool dftFailed = newState->hasFailed(mDft.getTopLevelIndex());
+                
+                while (!dftFailed && !queues.failsafePropagationDone()) {
+                    DFTGatePointer next = queues.nextFailsafePropagation();
+                    next->checkFailsafe(*newState, queues);
+                }
 
-                    while (!queues.failurePropagationDone()) {
-                        DFTGatePointer next = queues.nextFailurePropagation();
-                        next->checkFails(*newState, queues);
-                        newState->updateFailableDependencies(next->id());
-                    }
-                    
-                    while(!queues.restrictionChecksDone()) {
-                        DFTRestrictionPointer next = queues.nextRestrictionCheck();
-                        next->checkFails(*newState, queues);
-                        newState->updateFailableDependencies(next->id());
-                    }
-                    
-                    if(newState->isInvalid()) {
-                        continue;
-                    }
-                    bool dftFailed = newState->hasFailed(mDft.getTopLevelIndex());
-                    
-                    while (!dftFailed && !queues.failsafePropagationDone()) {
-                        DFTGatePointer next = queues.nextFailsafePropagation();
-                        next->checkFailsafe(*newState, queues);
-                    }
+                while (!dftFailed && enableDC && !queues.dontCarePropagationDone()) {
+                    DFTElementPointer next = queues.nextDontCarePropagation();
+                    next->checkDontCareAnymore(*newState, queues);
+                }
+                
+                // Update failable dependencies
+                if (!dftFailed) {
+                    newState->updateFailableDependencies(nextBE->id());
+                    newState->updateDontCareDependencies(nextBE->id());
+                }
+                
+                uint_fast64_t newStateId;
+                if(dftFailed && mergeFailedStates) {
+                    newStateId = failedIndex;
+                } else {
+                    // Explore new state recursively
+                    auto explorePair = exploreStates(newState, rowOffset, transitionMatrixBuilder, markovianStates, exitRates);
+                    newStateId = explorePair.first;
+                    deterministic &= explorePair.second;
+                }
 
-                    while (!dftFailed && enableDC && !queues.dontCarePropagationDone()) {
-                        DFTElementPointer next = queues.nextDontCarePropagation();
-                        next->checkDontCareAnymore(*newState, queues);
+                // Set transitions
+                if (hasDependencies) {
+                    // Failure is due to dependency -> add non-deterministic choice
+                    std::map<uint_fast64_t, ValueType> choiceProbabilities;
+                    std::shared_ptr<storm::storage::DFTDependency<ValueType> const> dependency = mDft.getDependency(state->getDependencyId(smallest-1));
+                    choiceProbabilities.insert(std::make_pair(newStateId, dependency->probability()));
+                    STORM_LOG_TRACE("Added transition to " << newStateId << " with probability " << dependency->probability());
+
+                    if (!storm::utility::isOne(dependency->probability())) {
+                        // Add transition to state where dependency was unsuccessful
+                        DFTStatePointer unsuccessfulState = std::make_shared<storm::storage::DFTState<ValueType>>(*state);
+                        unsuccessfulState->letDependencyBeUnsuccessful(smallest-1);
+                        auto explorePair = exploreStates(unsuccessfulState, rowOffset, transitionMatrixBuilder, markovianStates, exitRates);
+                        uint_fast64_t unsuccessfulStateId = explorePair.first;
+                        deterministic &= explorePair.second;
+                        ValueType remainingProbability = storm::utility::one<ValueType>() - dependency->probability();
+                        choiceProbabilities.insert(std::make_pair(unsuccessfulStateId, remainingProbability));
+                        STORM_LOG_TRACE("Added transition to " << unsuccessfulStateId << " with remaining probability " << remainingProbability);
                     }
-                    
-                    // Update failable dependencies
-                    if (!dftFailed) {
-                        newState->updateFailableDependencies(nextBE->id());
-                        newState->updateDontCareDependencies(nextBE->id());
+                    outgoingProbabilities.push_back(choiceProbabilities);
+                } else {
+                    // Set failure rate according to activation
+                    bool isActive = true;
+                    if (mDft.hasRepresentant(nextBE->id())) {
+                        // Active must be checked for the state we are coming from as this state is responsible for the
+                        // rate and not the new state we are going to
+                        isActive = state->isActive(mDft.getRepresentant(nextBE->id())->id());
                     }
-                    
-                    uint_fast64_t newStateId;
-                    if(dftFailed && mergeFailedStates) {
-                        newStateId = failedIndex;
+                    ValueType rate = isActive ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
+                    assert(!storm::utility::isZero(rate));
+                    auto resultFind = outgoingRates.find(newStateId);
+                    if (resultFind != outgoingRates.end()) {
+                        // Add to existing transition
+                        resultFind->second += rate;
+                        STORM_LOG_TRACE("Updated transition to " << resultFind->first << " with " << (isActive ? "active" : "passive") << " rate " << rate << " to new rate " << resultFind->second);
                     } else {
-                        newStateId = addState(newState, stateQueue);
+                        // Insert new transition
+                        outgoingRates.insert(std::make_pair(newStateId, rate));
+                        STORM_LOG_TRACE("Added transition to " << newStateId << " with " << (isActive ? "active" : "passive") << " rate " << rate);
                     }
+                    exitRate += rate;
+                }
 
-                    // Set transitions
-                    if (hasDependencies) {
-                        // Failure is due to dependency -> add non-deterministic choice
-                        std::shared_ptr<storm::storage::DFTDependency<ValueType> const> dependency = mDft.getDependency(state->getDependencyId(smallest-1));
-                        transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, newStateId, dependency->probability());
-                        STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newStateId << " with probability " << dependency->probability());
-
-                        if (!storm::utility::isOne(dependency->probability())) {
-                            // Add transition to state where dependency was unsuccessful
-                            DFTStatePointer unsuccessfulState = std::make_shared<storm::storage::DFTState<ValueType>>(*state);
-                            unsuccessfulState->letDependencyBeUnsuccessful(smallest-1);
-                            uint_fast64_t unsuccessfulStateId = addState(unsuccessfulState, stateQueue);
-                            ValueType remainingProbability = storm::utility::one<ValueType>() - dependency->probability();
-                            transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, unsuccessfulStateId, remainingProbability);
-                            STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << unsuccessfulStateId << " with probability " << remainingProbability);
-                        } else {
-                            // Self-loop with probability one cannot be eliminated later one.
-                            assert(state->getId() != newStateId);
-                        }
-                        ++rowOffset;
-
-                    } else {
-                        // Set failure rate according to activation
-                        bool isActive = true;
-                        if (mDft.hasRepresentant(nextBE->id())) {
-                            // Active must be checked for the state we are coming from as this state is responsible for the
-                            // rate and not the new state we are going to
-                            isActive = state->isActive(mDft.getRepresentant(nextBE->id())->id());
-                        }
-                        ValueType rate = isActive ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
-                        assert(!storm::utility::isZero(rate));
-                        auto resultFind = outgoingTransitions.find(newStateId);
-                        if (resultFind != outgoingTransitions.end()) {
-                            // Add to existing transition
-                            resultFind->second += rate;
-                            STORM_LOG_TRACE("Updated transition from " << state->getId() << " to " << resultFind->first << " with " << (isActive ? "active" : "passive") << " rate " << rate << " to new rate " << resultFind->second);
-                        } else {
-                            // Insert new transition
-                            outgoingTransitions.insert(std::make_pair(newStateId, rate));
-                            STORM_LOG_TRACE("Added transition from " << state->getId() << " to " << newStateId << " with " << (isActive ? "active" : "passive") << " rate " << rate);
-                        }
-                        exitRate += rate;
+            } // end while failing BE
+            
+            // Add state
+            uint_fast64_t stateId = addState(state);
+            assert(stateId == state->getId());
+            assert(stateId == newIndex-1);
+            
+            if (hasDependencies) {
+                // Add all probability transitions
+                assert(outgoingRates.empty());
+                transitionMatrixBuilder.newRowGroup(stateId + rowOffset);
+                for (size_t i = 0; i < outgoingProbabilities.size(); ++i, ++rowOffset) {
+                    assert(outgoingProbabilities[i].size() == 1 || outgoingProbabilities[i].size() == 2);
+                    for (auto it = outgoingProbabilities[i].begin(); it != outgoingProbabilities[i].end(); ++it)
+                    {
+                        STORM_LOG_TRACE("Set transition from " << stateId << " to " << it->first << " with probability " << it->second);
+                        transitionMatrixBuilder.addNextValue(stateId + rowOffset, it->first, it->second);
                     }
-
-                } // end while failing BE
-
-                if (hasDependencies) {
-                    rowOffset--; // One increment to many
-                } else {
-                    // Try to merge pseudo states with their instantiation
-                    // TODO Matthias: improve?
-                    for (auto it = outgoingTransitions.begin(); it != outgoingTransitions.end(); ) {
-                        if (it->first >= OFFSET_PSEUDO_STATE) {
-                            uint_fast64_t newId = it->first - OFFSET_PSEUDO_STATE;
-                            assert(newId < mPseudoStatesMapping.size());
-                            if (mPseudoStatesMapping[newId].first > 0) {
-                                // State exists already
-                                newId = mPseudoStatesMapping[newId].first;
-                                auto itFind = outgoingTransitions.find(newId);
-                                if (itFind != outgoingTransitions.end()) {
-                                    // Add probability from pseudo state to instantiation
-                                    itFind->second += it->second;
-                                    STORM_LOG_TRACE("Merged pseudo state " << newId << " adding rate " << it->second << " to total rate of " << itFind->second);
-                                } else {
-                                    // Only change id
-                                    outgoingTransitions.emplace(newId, it->second);
-                                    STORM_LOG_TRACE("Instantiated pseudo state " << newId << " with rate " << it->second);
-                                }
-                                // Remove pseudo state
-                                it = outgoingTransitions.erase(it);
+                }
+                rowOffset--; // One increment too many
+            } else {
+                // Try to merge pseudo states with their instantiation
+                // TODO Matthias: improve?
+                for (auto it = outgoingRates.begin(); it != outgoingRates.end(); ) {
+                    if (it->first >= OFFSET_PSEUDO_STATE) {
+                        uint_fast64_t newId = it->first - OFFSET_PSEUDO_STATE;
+                        assert(newId < mPseudoStatesMapping.size());
+                        if (mPseudoStatesMapping[newId].first > 0) {
+                            // State exists already
+                            newId = mPseudoStatesMapping[newId].first;
+                            auto itFind = outgoingRates.find(newId);
+                            if (itFind != outgoingRates.end()) {
+                                // Add probability from pseudo state to instantiation
+                                itFind->second += it->second;
+                                STORM_LOG_TRACE("Merged pseudo state " << newId << " adding rate " << it->second << " to total rate of " << itFind->second);
                             } else {
-                                ++it;
+                                // Only change id
+                                outgoingRates.emplace(newId, it->second);
+                                STORM_LOG_TRACE("Instantiated pseudo state " << newId << " with rate " << it->second);
                             }
+                            // Remove pseudo state
+                            it = outgoingRates.erase(it);
                         } else {
                             ++it;
                         }
-                    }
-                    
-                    // Add all probability transitions
-                    for (auto it = outgoingTransitions.begin(); it != outgoingTransitions.end(); ++it)
-                    {
-                        ValueType probability = it->second / exitRate; // Transform rate to probability
-                        transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, it->first, probability);
-                    }
-
-                    markovianStates.push_back(state->getId());
-                }
-                exitRates.push_back(exitRate);
-                assert(exitRates.size()-1 == state->getId());
-
-                if (stateQueue.empty()) {
-                    // Before ending the exploration check for pseudo states which are no be initialized yet
-                    for (auto & pseudoStatePair : mPseudoStatesMapping) {
-                        if (pseudoStatePair.first == 0) {
-                            // Create state from pseudo state and explore
-                            assert(mStates.contains(pseudoStatePair.second));
-                            assert(mStates.getValue(pseudoStatePair.second) >= OFFSET_PSEUDO_STATE);
-                            STORM_LOG_TRACE("Create pseudo state from bit vector " << pseudoStatePair.second);
-                            DFTStatePointer pseudoState = std::make_shared<storm::storage::DFTState<ValueType>>(pseudoStatePair.second, mDft, *mStateGenerationInfo, newIndex++);
-                            assert(pseudoStatePair.second == pseudoState->status());
-                            pseudoStatePair.first = pseudoState->getId();
-                            mStates.setOrAdd(pseudoState->status(), pseudoState->getId());
-                            stateQueue.push(pseudoState);
-                            STORM_LOG_TRACE("Explore pseudo state " << mDft.getStateString(pseudoState) << " with id " << pseudoState->getId());
-                            break;
-                        }
+                    } else {
+                        ++it;
                     }
                 }
                 
-            } // end while queue
-            
-            std::vector<uint_fast64_t> pseudoStatesVector;
-            for (auto const& pseudoStatePair : mPseudoStatesMapping) {
-                pseudoStatesVector.push_back(pseudoStatePair.first);
+                // Add all rate transitions
+                assert(outgoingProbabilities.empty());
+                transitionMatrixBuilder.newRowGroup(state->getId() + rowOffset);
+                STORM_LOG_TRACE("Exit rate for " << state->getId() << ": " << exitRate);
+                for (auto it = outgoingRates.begin(); it != outgoingRates.end(); ++it)
+                {
+                    ValueType probability = it->second / exitRate; // Transform rate to probability
+                    STORM_LOG_TRACE("Set transition from " << state->getId() << " to " << it->first << " with rate " << it->second);
+                    transitionMatrixBuilder.addNextValue(state->getId() + rowOffset, it->first, probability);
+                }
+
+                markovianStates.push_back(state->getId());
             }
-            assert(std::find(pseudoStatesVector.begin(), pseudoStatesVector.end(), 0) == pseudoStatesVector.end());
             
-            // Replace pseudo states in matrix
-            transitionMatrixBuilder.replaceColumns(pseudoStatesVector, OFFSET_PSEUDO_STATE);
+            STORM_LOG_TRACE("Finished exploring state: " << mDft.getStateString(state));
+            exitRates.push_back(exitRate);
+            assert(exitRates.size()-1 == state->getId());
+            return std::make_pair(state->getId(), deterministic);
+        }
+        
+        template <typename ValueType>
+        std::pair<bool, uint_fast64_t> ExplicitDFTModelBuilder<ValueType>::checkForExploration(DFTStatePointer const& state) {
+            bool changed = false;
+            if (mStateGenerationInfo->hasSymmetries()) {
+                // Order state by symmetry
+                STORM_LOG_TRACE("Check for symmetry: " << mDft.getStateString(state));
+                changed = state->orderBySymmetry();
+                STORM_LOG_TRACE("State " << (changed ? "changed to " : "did not change") << (changed ? mDft.getStateString(state) : ""));
+            }
             
-            assert(!deterministic || rowOffset == 0);
-            return deterministic;
+            if (mStates.contains(state->status())) {
+                // State already exists
+                uint_fast64_t stateId = mStates.getValue(state->status());
+                STORM_LOG_TRACE("State " << mDft.getStateString(state) << " with id " << stateId << " already exists");
+                
+                if (changed || stateId < OFFSET_PSEUDO_STATE) {
+                    // State is changed or an explored "normal" state
+                    return std::make_pair(false, stateId);
+                }
+                
+                stateId -= OFFSET_PSEUDO_STATE;
+                assert(stateId < mPseudoStatesMapping.size());
+                if (mPseudoStatesMapping[stateId].first > 0) {
+                    // Pseudo state already explored
+                    return std::make_pair(false, mPseudoStatesMapping[stateId].first);
+                }
+                
+                assert(mPseudoStatesMapping[stateId].second == state->status());
+                STORM_LOG_TRACE("Pseudo state " << mDft.getStateString(state) << " can be explored now");
+                return std::make_pair(true, stateId);
+            } else {
+                // State does not exists
+                if (changed) {
+                    // Remember state for later creation
+                    state->setId(mPseudoStatesMapping.size() + OFFSET_PSEUDO_STATE);
+                    mPseudoStatesMapping.push_back(std::make_pair(0, state->status()));
+                    mStates.findOrAdd(state->status(), state->getId());
+                    STORM_LOG_TRACE("Remember state for later creation: " << mDft.getStateString(state));
+                    return std::make_pair(false, state->getId());
+                } else {
+                    // State needs exploration
+                    return std::make_pair(true, 0);
+                }
+            }
         }
 
         template <typename ValueType>
-        uint_fast64_t ExplicitDFTModelBuilder<ValueType>::addState(DFTStatePointer state, std::queue<DFTStatePointer>& stateQueue) {
-            // Order state by symmetry
-            STORM_LOG_TRACE("Check for symmetry: " << mDft.getStateString(state));
-            bool changed = state->orderBySymmetry();
-            STORM_LOG_TRACE("State " << (changed ? "changed to " : "did not change") << (changed ? mDft.getStateString(state) : ""));
-            
+        uint_fast64_t ExplicitDFTModelBuilder<ValueType>::addState(DFTStatePointer const& state) {
             uint_fast64_t stateId;
+            // TODO remove
+            bool changed = state->orderBySymmetry();
+            assert(!changed);
             
             // Check if state already exists
             if (mStates.contains(state->status())) {
@@ -385,27 +445,23 @@ namespace storm {
                         mPseudoStatesMapping[stateId].first = state->getId();
                         stateId = state->getId();
                         mStates.setOrAdd(state->status(), stateId);
-                        stateQueue.push(state);
                         STORM_LOG_TRACE("Now create state " << mDft.getStateString(state) << " with id " << stateId);
+                        return stateId;
                     }
                 }
+                assert(false);
             } else {
                 // New state
                 if (changed) {
-                    // Remember to create state later on
-                    state->setId(mPseudoStatesMapping.size() + OFFSET_PSEUDO_STATE);
-                    mPseudoStatesMapping.push_back(std::make_pair(0, state->status()));
-                    stateId = mStates.findOrAdd(state->status(), state->getId());
-                    STORM_LOG_TRACE("New state for later creation: " << mDft.getStateString(state));
+                    assert(false);
                 } else {
                     // Create new state
                     state->setId(newIndex++);
                     stateId = mStates.findOrAdd(state->status(), state->getId());
                     STORM_LOG_TRACE("New state: " << mDft.getStateString(state));
-                    stateQueue.push(state);
+                    return stateId;
                 }
             }
-            return stateId;
         }
 
 
diff --git a/src/builder/ExplicitDFTModelBuilder.h b/src/builder/ExplicitDFTModelBuilder.h
index 2f197255e..3e78180d1 100644
--- a/src/builder/ExplicitDFTModelBuilder.h
+++ b/src/builder/ExplicitDFTModelBuilder.h
@@ -71,9 +71,24 @@ namespace storm {
             std::shared_ptr<storm::models::sparse::Model<ValueType>> buildModel(LabelOptions const& labelOpts);
 
         private:
-            bool exploreStates(std::queue<DFTStatePointer>& stateQueue, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates);
+            std::pair<uint_fast64_t, bool> exploreStates(DFTStatePointer const& state, size_t& rowOffset, storm::storage::SparseMatrixBuilder<ValueType>& transitionMatrixBuilder, std::vector<uint_fast64_t>& markovianStates, std::vector<ValueType>& exitRates);
             
-            uint_fast64_t addState(DFTStatePointer state, std::queue<DFTStatePointer>& stateQueue);
+            /*!
+             * Adds a state to the explored states and handles pseudo states.
+             *
+             * @param state The state to add.
+             * @return Id of added state.
+             */
+            uint_fast64_t addState(DFTStatePointer const& state);
+            
+            /*!
+             * Check if state needs an exploration and remember pseudo states for later creation.
+             *
+             * @param state State which might need exploration.
+             * @return Pair of flag indicating whether the state needs exploration now and the state id if the state already
+             * exists.
+             */
+            std::pair<bool, uint_fast64_t> checkForExploration(DFTStatePointer const& state);
 
         };
     }
diff --git a/src/storage/dft/DFTStateGenerationInfo.h b/src/storage/dft/DFTStateGenerationInfo.h
index 513a6a7a0..84680979a 100644
--- a/src/storage/dft/DFTStateGenerationInfo.h
+++ b/src/storage/dft/DFTStateGenerationInfo.h
@@ -108,6 +108,10 @@ namespace storm {
             size_t getSymmetrySize() const {
                 return mSymmetries.size();
             }
+            
+            bool hasSymmetries() const {
+                return !mSymmetries.empty();
+            }
 
             size_t getSymmetryLength(size_t pos) const {
                 assert(pos < mSymmetries.size());

From 19a1c99fd3b41bfdbe50854d58a095d4b54df6c9 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Thu, 7 Apr 2016 17:47:38 +0200
Subject: [PATCH 241/246] Sort failable BEs according to active failure rate

Former-commit-id: c4622e9dc80ccb921899a016199fc5a705a5a664
---
 src/storage/dft/DFTState.cpp | 15 ++++++++++++++-
 src/storage/dft/DFTState.h   |  5 +++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/storage/dft/DFTState.cpp b/src/storage/dft/DFTState.cpp
index b1c9a4fc1..25edf1d38 100644
--- a/src/storage/dft/DFTState.cpp
+++ b/src/storage/dft/DFTState.cpp
@@ -21,6 +21,7 @@ namespace storm {
 
             std::vector<size_t> alwaysActiveBEs = dft.nonColdBEs();
             mIsCurrentlyFailableBE.insert(mIsCurrentlyFailableBE.end(), alwaysActiveBEs.begin(), alwaysActiveBEs.end());
+            sortFailableBEs();
         }
         
         template<typename ValueType>
@@ -41,6 +42,7 @@ namespace storm {
                     STORM_LOG_TRACE("Spare " << index << " uses " << useId);
                 }
             }
+            sortFailableBEs();
             
             // Initialize failable dependencies
             for (size_t dependencyId : mDft.getDependencies()) {
@@ -208,7 +210,7 @@ namespace storm {
             if (nrFailableDependencies() > 0) {
                 // Consider failure due to dependency
                 assert(index < nrFailableDependencies());
-                std::shared_ptr<DFTDependency<ValueType> const> dependency = mDft.getDependency(getDependencyId(index));
+                std::shared_ptr<DFTDependency<ValueType> const> dependency = mDft.getDependency(mFailableDependencies[index]);
                 std::pair<std::shared_ptr<DFTBE<ValueType> const>,bool> res(mDft.getBasicElement(dependency->dependentEvent()->id()), true);
                 mFailableDependencies.erase(mFailableDependencies.begin() + index);
                 setFailed(res.first->id());
@@ -260,6 +262,7 @@ namespace storm {
                     propagateActivation(uses(elem));
                 }
             }
+            sortFailableBEs();
         }
 
         template<typename ValueType>
@@ -354,6 +357,16 @@ namespace storm {
             }
             return changed;
         }
+        
+        template<typename ValueType>
+        void DFTState<ValueType>::sortFailableBEs() {
+            std::sort( mIsCurrentlyFailableBE.begin( ), mIsCurrentlyFailableBE.end( ), [&](size_t const& lhs, size_t const& rhs) {
+                ValueType leftRate = mDft.getBasicElement(lhs)->activeFailureRate();
+                ValueType rightRate = mDft.getBasicElement(rhs)->activeFailureRate();
+                // Sort decreasing
+                return rightRate < leftRate;
+            });
+        }
 
 
         // Explicitly instantiate the class.
diff --git a/src/storage/dft/DFTState.h b/src/storage/dft/DFTState.h
index 5b68d46ae..f647aae17 100644
--- a/src/storage/dft/DFTState.h
+++ b/src/storage/dft/DFTState.h
@@ -235,6 +235,11 @@ namespace storm {
             
         private:
             void propagateActivation(size_t representativeId);
+            
+            /*!
+             * Sort failable BEs in decreasing order of their active failure rate.
+             */
+            void sortFailableBEs();
 
         };
 

From 1b6137cc5d1b441132206cdb55e1c470db4cbd58 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 17 May 2016 17:04:14 +0200
Subject: [PATCH 242/246] Changed some assert to STORM_LOG_ASSERT

Former-commit-id: 04c320dac92a9328e4590d3f98d6b54131134318
---
 src/builder/ExplicitDFTModelBuilder.cpp       | 90 +++++++++----------
 .../ConditionalEliminator.cpp                 |  5 +-
 .../LongRunAverageEliminator.cpp              |  3 +-
 src/solver/stateelimination/MAEliminator.cpp  |  3 +-
 .../PrioritizedEliminator.cpp                 |  3 +-
 src/solver/stateelimination/StateEliminator.h |  1 +
 src/storage/dft/DFT.cpp                       | 13 +--
 src/storage/dft/DFTBuilder.cpp                |  4 +-
 src/storage/dft/DFTElementType.h              | 14 +--
 9 files changed, 71 insertions(+), 65 deletions(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 5e17e2f52..74b460e8c 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -48,20 +48,20 @@ namespace storm {
             initialStateIndex = exploreResult.first;
             bool deterministic = exploreResult.second;
         
-            // Before ending the exploration check for pseudo states which are no be initialized yet
+            // Before ending the exploration check for pseudo states which are not initialized yet
             for (auto & pseudoStatePair : mPseudoStatesMapping) {
                 if (pseudoStatePair.first == 0) {
                     // Create state from pseudo state and explore
-                    assert(mStates.contains(pseudoStatePair.second));
-                    assert(mStates.getValue(pseudoStatePair.second) >= OFFSET_PSEUDO_STATE);
+                    STORM_LOG_ASSERT(mStates.contains(pseudoStatePair.second), "Pseudo state not contained.");
+                    STORM_LOG_ASSERT(mStates.getValue(pseudoStatePair.second) >= OFFSET_PSEUDO_STATE, "State is no pseudo state.");
                     STORM_LOG_TRACE("Create pseudo state from bit vector " << pseudoStatePair.second);
                     DFTStatePointer pseudoState = std::make_shared<storm::storage::DFTState<ValueType>>(pseudoStatePair.second, mDft, *mStateGenerationInfo, newIndex);
-                    assert(pseudoStatePair.second == pseudoState->status());
+                    STORM_LOG_ASSERT(pseudoStatePair.second == pseudoState->status(), "Pseudo states do not coincide.");
                     STORM_LOG_TRACE("Explore pseudo state " << mDft.getStateString(pseudoState) << " with id " << pseudoState->getId());
                     auto exploreResult = exploreStates(pseudoState, rowOffset, transitionMatrixBuilder, tmpMarkovianStates, modelComponents.exitRates);
                     deterministic &= exploreResult.second;
-                    assert(pseudoStatePair.first == pseudoState->getId());
-                    assert(pseudoState->getId() == exploreResult.first);
+                    STORM_LOG_ASSERT(pseudoStatePair.first == pseudoState->getId(), "Pseudo state ids do not coincide");
+                    STORM_LOG_ASSERT(pseudoState->getId() == exploreResult.first, "Pseudo state ids do not coincide.");
                 }
             }
             
@@ -70,7 +70,7 @@ namespace storm {
             for (auto const& pseudoStatePair : mPseudoStatesMapping) {
                 pseudoStatesVector.push_back(pseudoStatePair.first);
             }
-            assert(std::find(pseudoStatesVector.begin(), pseudoStatesVector.end(), 0) == pseudoStatesVector.end());
+            STORM_LOG_ASSERT(std::find(pseudoStatesVector.begin(), pseudoStatesVector.end(), 0) == pseudoStatesVector.end(), "Unexplored pseudo state still contained.");
             transitionMatrixBuilder.replaceColumns(pseudoStatesVector, OFFSET_PSEUDO_STATE);
             
             STORM_LOG_DEBUG("Generated " << mStates.size() + (mergeFailedStates ? 1 : 0) << " states");
@@ -137,7 +137,7 @@ namespace storm {
                 // TODO Matthias: avoid transforming back and forth
                 storm::storage::SparseMatrix<ValueType> rateMatrix(modelComponents.transitionMatrix);
                 for (uint_fast64_t row = 0; row < rateMatrix.getRowCount(); ++row) {
-                    assert(row < modelComponents.markovianStates.size());
+                    STORM_LOG_ASSERT(row < modelComponents.markovianStates.size(), "Row exceeds no. of markovian states.");
                     if (modelComponents.markovianStates.get(row)) {
                         for (auto& entry : rateMatrix.getRow(row)) {
                             entry.setValue(entry.getValue() * modelComponents.exitRates[row]);
@@ -182,14 +182,14 @@ namespace storm {
             // Absorbing state
             if (mDft.hasFailed(state) || mDft.isFailsafe(state) || state->nrFailableBEs() == 0) {
                 uint_fast64_t stateId = addState(state);
-                assert(stateId == state->getId());
+                STORM_LOG_ASSERT(stateId == state->getId(), "Ids do not coincide.");
 
                 // Add self loop
                 transitionMatrixBuilder.newRowGroup(stateId + rowOffset);
                 transitionMatrixBuilder.addNextValue(stateId + rowOffset, stateId, storm::utility::one<ValueType>());
                 STORM_LOG_TRACE("Added self loop for " << stateId);
                 exitRates.push_back(storm::utility::one<ValueType>());
-                assert(exitRates.size()-1 == stateId);
+                STORM_LOG_ASSERT(exitRates.size()-1 == stateId, "No. of considered states does not match state id.");
                 markovianStates.push_back(stateId);
                 // No further exploration required
                 return std::make_pair(stateId, true);
@@ -197,14 +197,14 @@ namespace storm {
 
             // Let BE fail
             while (smallest < failableCount) {
-                assert(!mDft.hasFailed(state));
+                STORM_LOG_ASSERT(!mDft.hasFailed(state), "Dft has failed.");
 
                 // Construct new state as copy from original one
                 DFTStatePointer newState = std::make_shared<storm::storage::DFTState<ValueType>>(*state);
                 std::pair<std::shared_ptr<storm::storage::DFTBE<ValueType> const>, bool> nextBEPair = newState->letNextBEFail(smallest++);
                 std::shared_ptr<storm::storage::DFTBE<ValueType> const>& nextBE = nextBEPair.first;
-                assert(nextBE);
-                assert(nextBEPair.second == hasDependencies);
+                STORM_LOG_ASSERT(nextBE, "NextBE is null.");
+                STORM_LOG_ASSERT(nextBEPair.second == hasDependencies, "Failure due to dependencies does not match.");
                 STORM_LOG_TRACE("With the failure of: " << nextBE->name() << " [" << nextBE->id() << "] in " << mDft.getStateString(state));
 
                 // Propagate failures
@@ -291,7 +291,7 @@ namespace storm {
                         isActive = state->isActive(mDft.getRepresentant(nextBE->id())->id());
                     }
                     ValueType rate = isActive ? nextBE->activeFailureRate() : nextBE->passiveFailureRate();
-                    assert(!storm::utility::isZero(rate));
+                    STORM_LOG_ASSERT(!storm::utility::isZero(rate), "Rate is 0.");
                     auto resultFind = outgoingRates.find(newStateId);
                     if (resultFind != outgoingRates.end()) {
                         // Add to existing transition
@@ -309,15 +309,15 @@ namespace storm {
             
             // Add state
             uint_fast64_t stateId = addState(state);
-            assert(stateId == state->getId());
-            assert(stateId == newIndex-1);
+            STORM_LOG_ASSERT(stateId == state->getId(), "Ids do not match.");
+            STORM_LOG_ASSERT(stateId == newIndex-1, "Id does not match no. of states.");
             
             if (hasDependencies) {
                 // Add all probability transitions
-                assert(outgoingRates.empty());
+                STORM_LOG_ASSERT(outgoingRates.empty(), "Outgoing transitions not empty.");
                 transitionMatrixBuilder.newRowGroup(stateId + rowOffset);
                 for (size_t i = 0; i < outgoingProbabilities.size(); ++i, ++rowOffset) {
-                    assert(outgoingProbabilities[i].size() == 1 || outgoingProbabilities[i].size() == 2);
+                    STORM_LOG_ASSERT(outgoingProbabilities[i].size() == 1 || outgoingProbabilities[i].size() == 2, "No. of outgoing transitions is not valid.");
                     for (auto it = outgoingProbabilities[i].begin(); it != outgoingProbabilities[i].end(); ++it)
                     {
                         STORM_LOG_TRACE("Set transition from " << stateId << " to " << it->first << " with probability " << it->second);
@@ -331,7 +331,7 @@ namespace storm {
                 for (auto it = outgoingRates.begin(); it != outgoingRates.end(); ) {
                     if (it->first >= OFFSET_PSEUDO_STATE) {
                         uint_fast64_t newId = it->first - OFFSET_PSEUDO_STATE;
-                        assert(newId < mPseudoStatesMapping.size());
+                        STORM_LOG_ASSERT(newId < mPseudoStatesMapping.size(), "Id is not valid.");
                         if (mPseudoStatesMapping[newId].first > 0) {
                             // State exists already
                             newId = mPseudoStatesMapping[newId].first;
@@ -356,7 +356,7 @@ namespace storm {
                 }
                 
                 // Add all rate transitions
-                assert(outgoingProbabilities.empty());
+                STORM_LOG_ASSERT(outgoingProbabilities.empty(), "Outgoing probabilities not empty.");
                 transitionMatrixBuilder.newRowGroup(state->getId() + rowOffset);
                 STORM_LOG_TRACE("Exit rate for " << state->getId() << ": " << exitRate);
                 for (auto it = outgoingRates.begin(); it != outgoingRates.end(); ++it)
@@ -371,7 +371,7 @@ namespace storm {
             
             STORM_LOG_TRACE("Finished exploring state: " << mDft.getStateString(state));
             exitRates.push_back(exitRate);
-            assert(exitRates.size()-1 == state->getId());
+            STORM_LOG_ASSERT(exitRates.size()-1 == state->getId(), "Id does not match no. of states.");
             return std::make_pair(state->getId(), deterministic);
         }
         
@@ -396,13 +396,13 @@ namespace storm {
                 }
                 
                 stateId -= OFFSET_PSEUDO_STATE;
-                assert(stateId < mPseudoStatesMapping.size());
+                STORM_LOG_ASSERT(stateId < mPseudoStatesMapping.size(), "Id not valid.");
                 if (mPseudoStatesMapping[stateId].first > 0) {
                     // Pseudo state already explored
                     return std::make_pair(false, mPseudoStatesMapping[stateId].first);
                 }
                 
-                assert(mPseudoStatesMapping[stateId].second == state->status());
+                STORM_LOG_ASSERT(mPseudoStatesMapping[stateId].second == state->status(), "States do not coincide.");
                 STORM_LOG_TRACE("Pseudo state " << mDft.getStateString(state) << " can be explored now");
                 return std::make_pair(true, stateId);
             } else {
@@ -426,7 +426,7 @@ namespace storm {
             uint_fast64_t stateId;
             // TODO remove
             bool changed = state->orderBySymmetry();
-            assert(!changed);
+            STORM_LOG_ASSERT(!changed, "State to add has changed by applying symmetry.");
             
             // Check if state already exists
             if (mStates.contains(state->status())) {
@@ -435,32 +435,28 @@ namespace storm {
                 STORM_LOG_TRACE("State " << mDft.getStateString(state) << " with id " << stateId << " already exists");
                 
                 // Check if possible pseudo state can be created now
-                if (!changed && stateId >= OFFSET_PSEUDO_STATE) {
-                    stateId -= OFFSET_PSEUDO_STATE;
-                    assert(stateId < mPseudoStatesMapping.size());
-                    if (mPseudoStatesMapping[stateId].first == 0) {
-                        // Create pseudo state now
-                        assert(mPseudoStatesMapping[stateId].second == state->status());
-                        state->setId(newIndex++);
-                        mPseudoStatesMapping[stateId].first = state->getId();
-                        stateId = state->getId();
-                        mStates.setOrAdd(state->status(), stateId);
-                        STORM_LOG_TRACE("Now create state " << mDft.getStateString(state) << " with id " << stateId);
-                        return stateId;
-                    }
-                }
-                assert(false);
-            } else {
-                // New state
-                if (changed) {
-                    assert(false);
-                } else {
-                    // Create new state
+                STORM_LOG_ASSERT(stateID >= OFFSET_PSEUDO_STATE, "State is no pseudo state.");
+                stateId -= OFFSET_PSEUDO_STATE;
+                STORM_LOG_ASSERT(stateId < mPseudoStatesMapping.size(), "Pseudo state not known.");
+                if (mPseudoStatesMapping[stateId].first == 0) {
+                    // Create pseudo state now
+                    STORM_LOG_ASSERT(mPseudoStatesMapping[stateId].second == state->status(), "Pseudo states do not coincide.");
                     state->setId(newIndex++);
-                    stateId = mStates.findOrAdd(state->status(), state->getId());
-                    STORM_LOG_TRACE("New state: " << mDft.getStateString(state));
+                    mPseudoStatesMapping[stateId].first = state->getId();
+                    stateId = state->getId();
+                    mStates.setOrAdd(state->status(), stateId);
+                    STORM_LOG_TRACE("Now create state " << mDft.getStateString(state) << " with id " << stateId);
                     return stateId;
+                } else {
+                    STORM_LOG_ASSERT(false, "Pseudo state already created.");
+                    return 0;
                 }
+            } else {
+                // Create new state
+                state->setId(newIndex++);
+                stateId = mStates.findOrAdd(state->status(), state->getId());
+                STORM_LOG_TRACE("New state: " << mDft.getStateString(state));
+                return stateId;
             }
         }
 
diff --git a/src/solver/stateelimination/ConditionalEliminator.cpp b/src/solver/stateelimination/ConditionalEliminator.cpp
index bba964596..f1e1c5df6 100644
--- a/src/solver/stateelimination/ConditionalEliminator.cpp
+++ b/src/solver/stateelimination/ConditionalEliminator.cpp
@@ -31,8 +31,9 @@ namespace storm {
                         return phiStates.get(state);
                     case PSI:
                         return psiStates.get(state);
-                    case NONE:
-                        assert(false);
+                    default:
+                        STORM_LOG_ASSERT(false, "Specific state not set.");
+                        return false;
                 }
             }
             
diff --git a/src/solver/stateelimination/LongRunAverageEliminator.cpp b/src/solver/stateelimination/LongRunAverageEliminator.cpp
index ec59dd1b1..1757b87fa 100644
--- a/src/solver/stateelimination/LongRunAverageEliminator.cpp
+++ b/src/solver/stateelimination/LongRunAverageEliminator.cpp
@@ -27,7 +27,8 @@ namespace storm {
             
             template<typename SparseModelType>
             bool LongRunAverageEliminator<SparseModelType>::filterPredecessor(storm::storage::sparse::state_type const& state) {
-                assert(false);
+                STORM_LOG_ASSERT(false, "Filter should not be applied.");
+                return false;
             }
             
             template<typename SparseModelType>
diff --git a/src/solver/stateelimination/MAEliminator.cpp b/src/solver/stateelimination/MAEliminator.cpp
index 7a26e995c..911364ac7 100644
--- a/src/solver/stateelimination/MAEliminator.cpp
+++ b/src/solver/stateelimination/MAEliminator.cpp
@@ -25,7 +25,8 @@ namespace storm {
             
             template<typename SparseModelType>
             bool MAEliminator<SparseModelType>::filterPredecessor(storm::storage::sparse::state_type const& state) {
-                assert(false);
+                STORM_LOG_ASSERT(false, "Filter should not be applied.");
+                return false;
             }
             
             template<typename SparseModelType>
diff --git a/src/solver/stateelimination/PrioritizedEliminator.cpp b/src/solver/stateelimination/PrioritizedEliminator.cpp
index 567d07df9..17a9c0825 100644
--- a/src/solver/stateelimination/PrioritizedEliminator.cpp
+++ b/src/solver/stateelimination/PrioritizedEliminator.cpp
@@ -25,7 +25,8 @@ namespace storm {
             
             template<typename SparseModelType>
             bool PrioritizedEliminator<SparseModelType>::filterPredecessor(storm::storage::sparse::state_type const& state) {
-                assert(false);
+                STORM_LOG_ASSERT(false, "Filter should not be applied.");
+                return false;
             }
             
             template<typename SparseModelType>
diff --git a/src/solver/stateelimination/StateEliminator.h b/src/solver/stateelimination/StateEliminator.h
index a0bf04a98..35c7b0521 100644
--- a/src/solver/stateelimination/StateEliminator.h
+++ b/src/solver/stateelimination/StateEliminator.h
@@ -8,6 +8,7 @@
 #include "src/models/sparse/StandardRewardModel.h"
 #include "src/adapters/CarlAdapter.h"
 #include "src/modelchecker/reachability/SparseDtmcEliminationModelChecker.h"
+#include "src/utility/macros.h"
 
 namespace storm {
     namespace solver {
diff --git a/src/storage/dft/DFT.cpp b/src/storage/dft/DFT.cpp
index ea4417915..5c70c475d 100644
--- a/src/storage/dft/DFT.cpp
+++ b/src/storage/dft/DFT.cpp
@@ -341,10 +341,9 @@ namespace storm {
                     case DFTElementType::SEQ:
                     case DFTElementType::MUTEX:
                         // Other elements are not supported
-                        assert(false);
-                        break;
                     default:
-                        assert(false);
+                        STORM_LOG_ASSERT(false, "Dft type can not be rewritten.");
+                        break;
                 }
                 
                 // Add parent with the new child newParent and all its remaining children
@@ -508,7 +507,8 @@ namespace storm {
                     return nrChild;
                 }
             }
-            assert(false);
+            STORM_LOG_ASSERT(false, "Child not found.");
+            return 0;
         }
         
         template <typename ValueType>
@@ -520,8 +520,9 @@ namespace storm {
 
         template<typename ValueType>
         std::vector<size_t> DFT<ValueType>::immediateFailureCauses(size_t index) const {
-            if(isGate(index)) {
-
+            if (isGate(index)) {
+                STORM_LOG_ASSERT(false, "Is gate.");
+                return {};
             } else {
                 return {index};
             }
diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index 6998529f8..e6e4ef1ae 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -32,8 +32,8 @@ namespace storm {
                         // Child not found -> find first dependent event to assure that child is dependency
                         // TODO: Not sure whether this is the intended behaviour?
                         auto itFind = mElements.find(child + "_1");
-                        assert(itFind != mElements.end());
-                        assert(itFind->second->isDependency());
+                        STORM_LOG_ASSERT(itFind != mElements.end(), "Child not found.");
+                        STORM_LOG_ASSERT(itFind->second->isDependency(), "Child is no dependency.");
                         STORM_LOG_TRACE("Ignore functional dependency " << child << " in gate " << gate->name());
                     }
                 }
diff --git a/src/storage/dft/DFTElementType.h b/src/storage/dft/DFTElementType.h
index 8b8035d45..272b56182 100644
--- a/src/storage/dft/DFTElementType.h
+++ b/src/storage/dft/DFTElementType.h
@@ -1,6 +1,8 @@
-#pragma once
+#ifndef DFTELEMENTTYPE_H
+#define DFTELEMENTTYPE_H
+
+#include "src/utility/macros.h"
 
-#include <cassert>
 namespace storm {
     namespace storage {
 
@@ -23,7 +25,7 @@ namespace storm {
                 case DFTElementType::PDEP:
                     return false;
                 default:
-                    assert(false);
+                    STORM_LOG_ASSERT(false, "Dft type not known.");
                     return false;
             }
         }
@@ -40,7 +42,7 @@ namespace storm {
                 case DFTElementType::PAND:
                     return false;
                 default:
-                    assert(false);
+                    STORM_LOG_ASSERT(false, "Dft gate type not known.");
                     return false;
             }
         }
@@ -68,7 +70,8 @@ namespace storm {
                 case DFTElementType::PDEP:
                     return "PDEP";
                 default:
-                    assert(false);
+                    STORM_LOG_ASSERT(false, "Dft type not known.");
+                    return "";
             }
         }
 
@@ -81,3 +84,4 @@ namespace storm {
     }
 }
 
+#endif	/* DFTELEMENTTYPE_H */

From 5eaa46c7de42ab73ad748af80dfe196c452b3d5b Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 17 May 2016 18:05:03 +0200
Subject: [PATCH 243/246] More refactoring

Former-commit-id: 26f95239bd77362eacb975bef05246cbc296e47b
---
 src/modelchecker/DFTAnalyser.h  | 26 +++++------
 src/parser/DFTGalileoParser.cpp |  3 +-
 src/storage/BitVector.cpp       | 76 +++++++++++++++++++--------------
 src/storm-dyftee.cpp            |  8 ++--
 src/utility/bitoperations.h     |  8 ++--
 src/utility/math.h              |  4 +-
 src/utility/storm.h             |  2 +-
 src/utility/vector.h            |  4 +-
 8 files changed, 71 insertions(+), 60 deletions(-)

diff --git a/src/modelchecker/DFTAnalyser.h b/src/modelchecker/DFTAnalyser.h
index 189338b70..24c1068ba 100644
--- a/src/modelchecker/DFTAnalyser.h
+++ b/src/modelchecker/DFTAnalyser.h
@@ -38,7 +38,7 @@ public:
     
 private:
     ValueType checkHelper(storm::storage::DFT<ValueType> const& dft , std::shared_ptr<const storm::logic::Formula> const& formula, bool symred = true, bool allowModularisation = true, bool enableDC = true)  {
-        std::cout << "check helper called" << std::endl;
+        STORM_LOG_TRACE("Check helper called");
         bool invResults = false;
         std::vector<storm::storage::DFT<ValueType>> dfts = {dft};
         std::vector<ValueType> res;
@@ -86,11 +86,11 @@ private:
 
             for (auto const& model : models) {
                 // Model checking
-                std::cout << "Model checking..." << std::endl;
+                STORM_LOG_INFO("Model checking...");
                 std::chrono::high_resolution_clock::time_point modelCheckingStart = std::chrono::high_resolution_clock::now();
                 std::unique_ptr<storm::modelchecker::CheckResult> result(storm::verifySparseModel(model, formula));
-                std::cout << "done." << std::endl;
-                assert(result);
+                STORM_LOG_INFO("Model checking done.");
+                STORM_LOG_ASSERT(result, "Result does not exist.");
                 result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
                 modelCheckingTime += std::chrono::high_resolution_clock::now() -  modelCheckingStart;
                 res.push_back(result->asExplicitQuantitativeCheckResult<ValueType>().getValueMap().begin()->second);
@@ -98,7 +98,7 @@ private:
         }
         if(nrM <= 1) {
             // No modularisation done.
-            assert(res.size()==1);
+            STORM_LOG_ASSERT(res.size()==1, "Result size not 1.");
             return res[0];
         }
         
@@ -107,7 +107,7 @@ private:
         int limK = invResults ? -1 : nrM+1;
         int chK = invResults ? -1 : 1;
         for(int cK = nrK; cK != limK; cK += chK ) {
-            assert(cK >= 0);
+            STORM_LOG_ASSERT(cK >= 0, "ck negative.");
             size_t permutation = smallestIntWithNBitsSet(static_cast<size_t>(cK));
             do {
                 STORM_LOG_TRACE("Permutation="<<permutation);
@@ -141,31 +141,31 @@ private:
             if(symred) {
                 auto colouring = dft.colourDFT();
                 symmetries = dft.findSymmetries(colouring);
-                std::cout << "Found " << symmetries.groups.size() << " symmetries." << std::endl;
+                STORM_LOG_INFO("Found " << symmetries.groups.size() << " symmetries.");
                 STORM_LOG_TRACE("Symmetries: " << std::endl << symmetries);
             }
             std::chrono::high_resolution_clock::time_point buildingEnd = std::chrono::high_resolution_clock::now();
             buildingTime += buildingEnd - buildingStart;
             
             // Building Markov Automaton
-            std::cout << "Building Model..." << std::endl;
+            STORM_LOG_INFO("Building Model...");
             storm::builder::ExplicitDFTModelBuilder<ValueType> builder(dft, symmetries, enableDC);
             typename storm::builder::ExplicitDFTModelBuilder<ValueType>::LabelOptions labeloptions; // TODO initialize this with the formula
             std::shared_ptr<storm::models::sparse::Model<ValueType>> model = builder.buildModel(labeloptions);
             //model->printModelInformationToStream(std::cout);
-            std::cout << "No. states (Explored): " << model->getNumberOfStates() << std::endl;
-            std::cout << "No. transitions (Explored): " << model->getNumberOfTransitions() << std::endl;
+            STORM_LOG_INFO("No. states (Explored): " << model->getNumberOfStates());
+            STORM_LOG_INFO("No. transitions (Explored): " << model->getNumberOfTransitions());
             std::chrono::high_resolution_clock::time_point explorationEnd = std::chrono::high_resolution_clock::now();
             explorationTime += explorationEnd -buildingEnd;
 
             // Bisimulation
             if (model->isOfType(storm::models::ModelType::Ctmc) && storm::settings::getModule<storm::settings::modules::GeneralSettings>().isBisimulationSet()) {
-                std::cout << "Bisimulation..." << std::endl;
+                STORM_LOG_INFO("Bisimulation...");
                 model =  storm::performDeterministicSparseBisimulationMinimization<storm::models::sparse::Ctmc<ValueType>>(model->template as<storm::models::sparse::Ctmc<ValueType>>(), {formula}, storm::storage::BisimulationType::Weak)->template as<storm::models::sparse::Ctmc<ValueType>>();
                 //model->printModelInformationToStream(std::cout);
             }
-            std::cout << "No. states (Bisimulation): " << model->getNumberOfStates() << std::endl;
-            std::cout << "No. transitions (Bisimulation): " << model->getNumberOfTransitions() << std::endl;
+            STORM_LOG_INFO("No. states (Bisimulation): " << model->getNumberOfStates());
+            STORM_LOG_INFO("No. transitions (Bisimulation): " << model->getNumberOfTransitions());
             bisimulationTime += std::chrono::high_resolution_clock::now() - explorationEnd;
             models.push_back(model);
         }
diff --git a/src/parser/DFTGalileoParser.cpp b/src/parser/DFTGalileoParser.cpp
index 0a0aa5b32..2cdda4929 100644
--- a/src/parser/DFTGalileoParser.cpp
+++ b/src/parser/DFTGalileoParser.cpp
@@ -130,7 +130,8 @@ namespace storm {
 
         template<typename ValueType>
         ValueType DFTGalileoParser<ValueType>::parseRationalExpression(std::string const& expr) {
-            assert(false);
+            STORM_LOG_ASSERT(false, "Specialized method should be called.");
+            return 0;
         }
 
         template<>
diff --git a/src/storage/BitVector.cpp b/src/storage/BitVector.cpp
index 28f6bdcff..fcbceca7b 100644
--- a/src/storage/BitVector.cpp
+++ b/src/storage/BitVector.cpp
@@ -454,7 +454,7 @@ namespace storm {
         
         uint_fast64_t BitVector::getTwoBitsAligned(uint_fast64_t bitIndex) const {
             // Check whether it is aligned.
-            assert(bitIndex % 64 != 63);
+            STORM_LOG_ASSERT(bitIndex % 64 != 63, "Bits not aligned.");
             uint64_t bucket = bitIndex >> 6;
             uint64_t bitIndexInBucket = bitIndex & mod64mask;
             
@@ -662,7 +662,7 @@ namespace storm {
         }
         
         storm::storage::BitVector BitVector::getAsBitVector(uint_fast64_t start, uint_fast64_t length) const {
-            assert(start + length <= bitCount);
+            STORM_LOG_ASSERT(start + length <= bitCount, "Invalid range.");
 #ifdef ASSERT_BITVECTOR
             BitVector original(*this);
 #endif
@@ -699,12 +699,12 @@ namespace storm {
             
             // Write last bits
             uint_fast64_t remainingBits = length - noBits;
-            assert(getBucket != buckets + bucketCount());
+            STORM_LOG_ASSERT(getBucket != buckets + bucketCount(), "Bucket index incorrect.");
             // Get remaining bits
             getValue = (*getBucket >> (64-remainingBits)) << (64-remainingBits);
-            assert(remainingBits < 64);
+            STORM_LOG_ASSERT(remainingBits < 64, "Too many remaining bits.");
             // Write bucket
-            assert(insertBucket != result.buckets + result.bucketCount());
+            STORM_LOG_ASSERT(insertBucket != result.buckets + result.bucketCount(), "Bucket index incorrect.");
             if (offset == 0) {
                 *insertBucket = getValue;
             } else {
@@ -714,7 +714,7 @@ namespace storm {
                     // Write last bits in new value
                     writeValue = (getValue << offset);
                     ++insertBucket;
-                    assert(insertBucket != result.buckets + result.bucketCount());
+                    STORM_LOG_ASSERT(insertBucket != result.buckets + result.bucketCount(), "Bucket index incorrect.");
                     *insertBucket = writeValue;
                 }
             }
@@ -723,21 +723,27 @@ namespace storm {
             // Check correctness of getter
             for (uint_fast64_t i = 0; i < length; ++i) {
                 if (result.get(i) != get(start + i)) {
-                    std::cout << "Getting of bits not correct for index " << i << std::endl;
-                    std::cout << "Getting from " << start << " with length " << length << std::endl;
-                    printBits(std::cout);
-                    result.printBits(std::cout);
-                    assert(false);
+                    STORM_LOG_ERROR("Getting of bits not correct for index " << i);
+                    STORM_LOG_ERROR("Getting from " << start << " with length " << length);
+                    stringstream stream;
+                    printBits(stream);
+                    stream << std::endl;
+                    result.printBits(stream);
+                    STORM_LOG_ERROR(stream);
+                    STORM_LOG_ASSERT(false, "Getting of bits not correct.");
                 }
             }
             for (uint_fast64_t i = 0; i < bitCount; ++i) {
                 if (i < start || i >= start+length) {
                     if (original.get(i) != get(i)) {
-                        std::cout << "Getting did change bitvector at index " << i << std::endl;
-                        std::cout << "Getting from " << start << " with length " << length << std::endl;
-                        printBits(std::cout);
-                        original.printBits(std::cout);
-                        assert(false);
+                        STORM_LOG_ERROR("Getting did change bitvector at index " << i);
+                        STORM_LOG_ERROR("Getting from " << start << " with length " << length);
+                        stringstream stream;
+                        printBits(stream);
+                        stream << std::endl;
+                        original.printBits(stream);
+                        STORM_LOG_ERROR(stream);
+                        STORM_LOG_ASSERT(false, "Getting of bits not correct.");
                     }
                 }
             }
@@ -750,7 +756,7 @@ namespace storm {
 #ifdef ASSERT_BITVECTOR
             BitVector original(*this);
 #endif
-            assert(start + other.bitCount <= bitCount);
+            STORM_LOG_ASSERT(start + other.bitCount <= bitCount, "Range invalid.");
             
             uint_fast64_t offset = start % 64;
             uint64_t* insertBucket = buckets + (start / 64);
@@ -786,9 +792,9 @@ namespace storm {
             
             // Write last bits
             uint_fast64_t remainingBits = other.bitCount - noBits;
-            assert(remainingBits < 64);
-            assert(insertBucket != buckets + bucketCount());
-            assert(getBucket != other.buckets + other.bucketCount());
+            STORM_LOG_ASSERT(remainingBits < 64, "Too many remaining bits.");
+            STORM_LOG_ASSERT(insertBucket != buckets + bucketCount(), "Bucket index incorrect.");
+            STORM_LOG_ASSERT(getBucket != other.buckets + other.bucketCount(), "Bucket index incorrect.");
             // Get remaining bits of bucket
             getValue = *getBucket;
             if (offset > 0) {
@@ -799,7 +805,7 @@ namespace storm {
             if (remainingBits > offset && offset > 0) {
                 // Remaining bits do not come from one bucket -> consider next bucket
                 ++getBucket;
-                assert(getBucket != other.buckets + other.bucketCount());
+                STORM_LOG_ASSERT(getBucket != other.buckets + other.bucketCount(), "Bucket index incorrect.");
                 getValue |= *getBucket >> offset;
             }
             // Write completely
@@ -810,21 +816,27 @@ namespace storm {
             // Check correctness of setter
             for (uint_fast64_t i = 0; i < other.bitCount; ++i) {
                 if (other.get(i) != get(start + i)) {
-                    std::cout << "Setting of bits not correct for index " << i << std::endl;
-                    std::cout << "Setting from " << start << " with length " << other.bitCount << std::endl;
-                    printBits(std::cout);
-                    other.printBits(std::cout);
-                    assert(false);
+                    STORM_LOG_ERROR("Setting of bits not correct for index " << i);
+                    STORM_LOG_ERROR("Setting from " << start << " with length " << other.bitCount);
+                    stringstream stream;
+                    printBits(stream);
+                    stream << std::endl;
+                    other.printBits(stream);
+                    STORM_LOG_ERROR(stream);
+                    STORM_LOG_ASSERT(false, "Setting of bits not correct.");
                 }
             }
             for (uint_fast64_t i = 0; i < bitCount; ++i) {
                 if (i < start || i >= start+other.bitCount) {
                     if (original.get(i) != get(i)) {
-                        std::cout << "Setting did change bitvector at index " << i << std::endl;
-                        std::cout << "Setting from " << start << " with length " << other.bitCount << std::endl;
-                        printBits(std::cout);
-                        original.printBits(std::cout);
-                        assert(false);
+                        STORM_LOG_ERROR("Setting did change bitvector at index " << i);
+                        STORM_LOG_ERROR("Setting from " << start << " with length " << other.bitCount);
+                        stringstream stream;
+                        printBits(stream);
+                        stream << std::endl;
+                        original.printBits(stream);
+                        STORM_LOG_ERROR(stream);
+                        STORM_LOG_ASSERT(false, "Setting of bits not correct.");
                     }
                 }
             }
@@ -928,7 +940,7 @@ namespace storm {
             
             // Print last bits
             if (index * 64 < bitCount) {
-                assert(index == bucketCount() - 1);
+                STORM_LOG_ASSERT(index == bucketCount() - 1, "Not last bucket.");
                 std::bitset<64> tmp(buckets[index]);
                 for (size_t i = 0; i + index * 64 < bitCount; ++i) {
                     // Bits are counted from rightmost in bitset
diff --git a/src/storm-dyftee.cpp b/src/storm-dyftee.cpp
index ced13bf4d..3ffd665ad 100644
--- a/src/storm-dyftee.cpp
+++ b/src/storm-dyftee.cpp
@@ -36,7 +36,7 @@ void analyzeDFT(std::string filename, std::string property, bool symred = false,
     storm::parser::DFTGalileoParser<ValueType> parser;
     storm::storage::DFT<ValueType> dft = parser.parseDFT(filename);
     std::vector<std::shared_ptr<storm::logic::Formula const>> formulas = storm::parseFormulasForExplicit(property);
-    assert(formulas.size() == 1);
+    STORM_LOG_ASSERT(formulas.size() == 1, "Wrong number of formulas.");
     
     DFTAnalyser<ValueType> analyser;
     analyser.check(dft, formulas[0], symred, allowModularisation, enableDC);
@@ -95,7 +95,7 @@ int main(const int argc, const char** argv) {
         // Set min or max
         bool minimal = true;
         if (dftSettings.isComputeMaximalValue()) {
-            assert(!dftSettings.isComputeMinimalValue());
+            STORM_LOG_THROW(!dftSettings.isComputeMinimalValue(), storm::exceptions::InvalidSettingsException, "Cannot compute minimal and maximal values at the same time.");
             minimal = false;
         }
         
@@ -126,11 +126,11 @@ int main(const int argc, const char** argv) {
         }
         
         if (!targetFormula.empty()) {
-            assert(pctlFormula.empty());
+            STORM_LOG_ASSERT(pctlFormula.empty(), "Pctl formula not empty.");
             pctlFormula = operatorType + (minimal ? "min" : "max") + "=?[" + targetFormula + "]";
         }
         
-        assert(!pctlFormula.empty());
+        STORM_LOG_ASSERT(!pctlFormula.empty(), "Pctl formula empty.");
 
         bool parametric = false;
 #ifdef STORM_HAVE_CARL
diff --git a/src/utility/bitoperations.h b/src/utility/bitoperations.h
index 55456dd61..bec6a6414 100644
--- a/src/utility/bitoperations.h
+++ b/src/utility/bitoperations.h
@@ -1,17 +1,15 @@
 #pragma once
 
 inline size_t smallestIntWithNBitsSet(size_t n) {
-    assert(sizeof(size_t) == 8);
-    assert(n < 64); // TODO fix this for 32 bit architectures!
+    static_assert(sizeof(size_t) == 8, "size_t has wrong size.");
+    STORM_LOG_ASSERT(n < 64, "Input is too large."); // TODO fix this for 32 bit architectures!
     if(n==0) return static_cast<size_t>(0);
     return (1 << n) - 1;
 }
 
 inline size_t nextBitPermutation(size_t v) {
-    if(v==0) return static_cast<size_t>(0);
+    if (v==0) return static_cast<size_t>(0);
     // From https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
     unsigned int t = (v | (v - 1)) + 1;  
     return t | ((((t & -t) / (v & -v)) >> 1) - 1);  
 }
-        
-        
\ No newline at end of file
diff --git a/src/utility/math.h b/src/utility/math.h
index b2c41adc2..dd2fe9052 100644
--- a/src/utility/math.h
+++ b/src/utility/math.h
@@ -20,7 +20,7 @@ namespace storm {
             
             inline uint64_t uint64_log2(uint64_t n)
             {
-                assert(n != 0);
+                STORM_LOG_ASSERT(n != 0, "N is 0.");
                 #define S(k) if (n >= (UINT64_C(1) << k)) { i += k; n >>= k; }
                 uint64_t i = 0; S(32); S(16); S(8); S(4); S(2); S(1); return i;
                 #undef S
@@ -29,4 +29,4 @@ namespace storm {
     }
 }
 
-#endif /* STORM_UTILITY_MATH_H_ */
\ No newline at end of file
+#endif /* STORM_UTILITY_MATH_H_ */
diff --git a/src/utility/storm.h b/src/utility/storm.h
index e3c4798f4..7fa292427 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -399,7 +399,7 @@ namespace storm {
                     psiStates = rightResultPointer->asExplicitQualitativeCheckResult().getTruthValuesVector();
                 } else {
                     // Eventually formula
-                    assert(probOpFormula.getSubformula().isEventuallyFormula());
+                    STORM_LOG_THROW(!probOpFormula.getSubformula().isEventuallyFormula(), storm::exceptions::NotSupportedException, "The parametric engine only supports eventually formulas on CTMCs");
                     storm::logic::EventuallyFormula eventuallyFormula = probOpFormula.getSubformula().asEventuallyFormula();
                     STORM_LOG_THROW(eventuallyFormula.getSubformula().isInFragment(storm::logic::propositional()), storm::exceptions::NotSupportedException, "The parametric engine does not support nested formulas on CTMCs");
                     std::unique_ptr<storm::modelchecker::CheckResult> resultPointer = propositionalModelchecker.check(eventuallyFormula.getSubformula());
diff --git a/src/utility/vector.h b/src/utility/vector.h
index 211340106..0a4da1e03 100644
--- a/src/utility/vector.h
+++ b/src/utility/vector.h
@@ -70,7 +70,7 @@ namespace storm {
              * Constructs a vector [min, min+1, ...., max]
              */
             inline std::vector<uint_fast64_t> buildVectorForRange(uint_fast64_t min, uint_fast64_t max) {
-                assert(min < max);
+                STORM_LOG_ASSERT(min < max, "Invalid range.");
                 uint_fast64_t diff = max - min;
                 std::vector<uint_fast64_t> v;
                 v.reserve(diff);
@@ -700,7 +700,7 @@ namespace storm {
                 for(auto index : filter) {
                     result.push_back(in[index]);
                 }
-                assert(result.size() == filter.getNumberOfSetBits());
+                STORM_LOG_ASSERT(result.size() == filter.getNumberOfSetBits(), "Result does not match.");
                 return result;
             }
             

From c8521f0de3338046b67e4f9003f70229d1c68b25 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Tue, 17 May 2016 18:24:38 +0200
Subject: [PATCH 244/246] Changed more assert to STORM_LOG_ASSERT

Former-commit-id: b42fe54f45740931089ce3c421946d72441975a7
---
 src/storage/dft/DFTBuilder.cpp            | 18 +++++++++---------
 src/storage/dft/DFTBuilder.h              |  4 ++--
 src/storage/dft/DFTStateGenerationInfo.h  | 18 +++++++++---------
 src/storage/dft/elements/DFTAnd.h         |  2 +-
 src/storage/dft/elements/DFTBE.h          |  4 ++--
 src/storage/dft/elements/DFTDependency.h  | 10 +++++-----
 src/storage/dft/elements/DFTElement.h     |  7 +++----
 src/storage/dft/elements/DFTOr.h          |  2 +-
 src/storage/dft/elements/DFTPand.h        |  4 ++--
 src/storage/dft/elements/DFTRestriction.h |  4 ++--
 src/storage/dft/elements/DFTVot.h         |  4 ++--
 src/utility/storm.h                       |  2 +-
 12 files changed, 39 insertions(+), 40 deletions(-)

diff --git a/src/storage/dft/DFTBuilder.cpp b/src/storage/dft/DFTBuilder.cpp
index e6e4ef1ae..840f5b77b 100644
--- a/src/storage/dft/DFTBuilder.cpp
+++ b/src/storage/dft/DFTBuilder.cpp
@@ -25,7 +25,7 @@ namespace storm {
                     if (itFind != mElements.end()) {
                         // Child found
                         DFTElementPointer childElement = itFind->second;
-                        assert(!childElement->isDependency());
+                        STORM_LOG_ASSERT(!childElement->isDependency(), "Child is dependency.");
                         gate->pushBackChild(childElement);
                         childElement->addParent(gate);
                     } else {
@@ -42,9 +42,9 @@ namespace storm {
             for(auto& elem : mRestrictionChildNames) {
                 for(auto const& childName : elem.second) {
                     auto itFind = mElements.find(childName);
-                    assert(itFind != mElements.end());
+                    STORM_LOG_ASSERT(itFind != mElements.end(), "Child not found.");
                     DFTElementPointer childElement = itFind->second;
-                    assert(!childElement->isDependency() && !childElement->isRestriction());
+                    STORM_LOG_ASSERT(!childElement->isDependency() && !childElement->isRestriction(), "Child has invalid type.");
                     elem.first->pushBackChild(childElement);
                     childElement->addRestriction(elem.first);
                 }
@@ -53,7 +53,7 @@ namespace storm {
             // Initialize dependencies
             for (auto& dependency : mDependencies) {
                 DFTGatePointer triggerEvent = std::static_pointer_cast<DFTGate<ValueType>>(mElements[dependency->nameTrigger()]);
-                assert(mElements[dependency->nameDependent()]->isBasicElement());
+                STORM_LOG_ASSERT(mElements[dependency->nameDependent()]->isBasicElement(), "Dependent element is not BE.");
                 std::shared_ptr<DFTBE<ValueType>> dependentEvent = std::static_pointer_cast<DFTBE<ValueType>>(mElements[dependency->nameDependent()]);
                 dependency->initialize(triggerEvent, dependentEvent);
                 triggerEvent->addOutgoingDependency(dependency);
@@ -73,7 +73,7 @@ namespace storm {
             for(DFTElementPointer e : elems) {
                 e->setId(id++);
             }
-            assert(!mTopLevelIdentifier.empty());
+            STORM_LOG_ASSERT(!mTopLevelIdentifier.empty(), "No top level element.");
             return DFT<ValueType>(elems, mElements[mTopLevelIdentifier]);
         }
 
@@ -130,7 +130,7 @@ namespace storm {
 
         template<typename ValueType>
         bool DFTBuilder<ValueType>::addStandardGate(std::string const& name, std::vector<std::string> const& children, DFTElementType tp) {
-            assert(children.size() > 0);
+            STORM_LOG_ASSERT(children.size() > 0, "No child.");
             if(mElements.count(name) != 0) {
                 // Element with that name already exists.
                 return false;
@@ -234,7 +234,7 @@ namespace storm {
                 case DFTElementType::CONSTF:
                 case DFTElementType::CONSTS:
                     // TODO
-                    assert(false);
+                    STORM_LOG_ASSERT(false, "Const elements not supported.");
                     break;
                 case DFTElementType::PDEP:
                 {
@@ -254,7 +254,7 @@ namespace storm {
                     break;
                 }
                 default:
-                    assert(false);
+                    STORM_LOG_ASSERT(false, "Dft type not known.");
                     break;
             }
         }
@@ -273,7 +273,7 @@ namespace storm {
                     addVotElement(gate->name(), std::static_pointer_cast<DFTVot<ValueType>>(gate)->threshold(), children);
                     break;
                 default:
-                    assert(false);
+                    STORM_LOG_ASSERT(false, "Dft type not known.");
                     break;
             }
         }
diff --git a/src/storage/dft/DFTBuilder.h b/src/storage/dft/DFTBuilder.h
index 168b27755..3f9f25f4c 100644
--- a/src/storage/dft/DFTBuilder.h
+++ b/src/storage/dft/DFTBuilder.h
@@ -104,7 +104,7 @@ namespace storm {
                             STORM_LOG_ERROR("Element with name: " << nameDep << " already exists.");
                             return false;
                         }
-                        assert(storm::utility::isOne(probability) || children.size() == 2);
+                        STORM_LOG_ASSERT(storm::utility::isOne(probability) || children.size() == 2, "PDep with multiple children supported.");
                         DFTDependencyPointer element = std::make_shared<DFTDependency<ValueType>>(mNextId++, nameDep, trigger, children[i], probability);
                         mElements[element->name()] = element;
                         mDependencies.push_back(element);
@@ -114,7 +114,7 @@ namespace storm {
             }
 
             bool addVotElement(std::string const& name, unsigned threshold, std::vector<std::string> const& children) {
-                assert(children.size() > 0);
+                STORM_LOG_ASSERT(children.size() > 0, "Has no child.");
                 if(mElements.count(name) != 0) {
                     STORM_LOG_ERROR("Element with name: " << name << " already exists.");
                     return false;
diff --git a/src/storage/dft/DFTStateGenerationInfo.h b/src/storage/dft/DFTStateGenerationInfo.h
index 84680979a..bc7e56140 100644
--- a/src/storage/dft/DFTStateGenerationInfo.h
+++ b/src/storage/dft/DFTStateGenerationInfo.h
@@ -18,7 +18,7 @@ namespace storm {
                 mUsageInfoBits(storm::utility::math::uint64_log2(maxSpareChildCount) + 1), 
                 mIdToStateIndex(nrElements)
             {
-                assert(maxSpareChildCount < pow(2, mUsageInfoBits));
+                STORM_LOG_ASSERT(maxSpareChildCount < pow(2, mUsageInfoBits), "Bit length incorrect.");
             }
 
             size_t usageInfoBits() const {
@@ -26,7 +26,7 @@ namespace storm {
             }
 
             void addStateIndex(size_t id, size_t index) {
-                assert(id < mIdToStateIndex.size());
+                STORM_LOG_ASSERT(id < mIdToStateIndex.size(), "Id invalid.");
                 mIdToStateIndex[id] = index;
             }
 
@@ -39,7 +39,7 @@ namespace storm {
             }
             
             std::vector<size_t> const& seqRestrictionPostElements(size_t index) const {
-                assert(mSeqRestrictionPostElements.count(index) > 0);
+                STORM_LOG_ASSERT(mSeqRestrictionPostElements.count(index) > 0, "Index invalid.");
                 return mSeqRestrictionPostElements.at(index);
             }
             
@@ -53,17 +53,17 @@ namespace storm {
             }
 
             size_t getStateIndex(size_t id) const {
-                assert(id < mIdToStateIndex.size());
+                STORM_LOG_ASSERT(id < mIdToStateIndex.size(), "Id invalid.");
                 return mIdToStateIndex[id];
             }
 
             size_t getSpareUsageIndex(size_t id) const {
-                assert(mSpareUsageIndex.count(id) > 0);
+                STORM_LOG_ASSERT(mSpareUsageIndex.count(id) > 0, "Id invalid.");
                 return mSpareUsageIndex.at(id);
             }
 
             size_t getSpareActivationIndex(size_t id) const {
-                assert(mSpareActivationIndex.count(id) > 0);
+                STORM_LOG_ASSERT(mSpareActivationIndex.count(id) > 0, "Id invalid.");
                 return mSpareActivationIndex.at(id);
             }
 
@@ -114,12 +114,12 @@ namespace storm {
             }
 
             size_t getSymmetryLength(size_t pos) const {
-                assert(pos < mSymmetries.size());
+                STORM_LOG_ASSERT(pos < mSymmetries.size(), "Pos invalid.");
                 return mSymmetries[pos].first;
             }
 
             std::vector<size_t> const& getSymmetryIndices(size_t pos) const {
-                assert(pos < mSymmetries.size());
+                STORM_LOG_ASSERT(pos < mSymmetries.size(), "Pos invalid.");
                 return mSymmetries[pos].second;
             }
 
@@ -149,4 +149,4 @@ namespace storm {
 
         };
     }
-}
\ No newline at end of file
+}
diff --git a/src/storage/dft/elements/DFTAnd.h b/src/storage/dft/elements/DFTAnd.h
index 5a5763166..00f671837 100644
--- a/src/storage/dft/elements/DFTAnd.h
+++ b/src/storage/dft/elements/DFTAnd.h
@@ -24,7 +24,7 @@ namespace storm {
             }
 
             void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                assert(this->hasFailsafeChild(state));
+                STORM_LOG_ASSERT(this->hasFailsafeChild(state), "No failsafe child.");
                 if(state.isOperational(this->mId)) {
                     this->failsafe(state, queues);
                     this->childrenDontCare(state, queues);
diff --git a/src/storage/dft/elements/DFTBE.h b/src/storage/dft/elements/DFTBE.h
index d41e37344..216227af6 100644
--- a/src/storage/dft/elements/DFTBE.h
+++ b/src/storage/dft/elements/DFTBE.h
@@ -38,7 +38,7 @@ namespace storm {
             }
             
             bool addIngoingDependency(DFTDependencyPointer const& e) {
-                assert(e->dependentEvent()->id() == this->id());
+                STORM_LOG_ASSERT(e->dependentEvent()->id() == this->id(), "Ids do not match.");
                 if(std::find(mIngoingDependencies.begin(), mIngoingDependencies.end(), e) != mIngoingDependencies.end()) {
                     return false;
                 }
@@ -113,4 +113,4 @@ namespace storm {
             return os << "{" << be.name() << "} BE(" << be.activeFailureRate() << ", " << be.passiveFailureRate() << ")";
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/storage/dft/elements/DFTDependency.h b/src/storage/dft/elements/DFTDependency.h
index 44a5ab9df..2c5b7d0cc 100644
--- a/src/storage/dft/elements/DFTDependency.h
+++ b/src/storage/dft/elements/DFTDependency.h
@@ -27,8 +27,8 @@ namespace storm {
             virtual ~DFTDependency() {}
 
             void initialize(DFTGatePointer triggerEvent, DFTBEPointer dependentEvent) {
-                assert(triggerEvent->name() == mNameTrigger);
-                assert(dependentEvent->name() == mNameDependent);
+                STORM_LOG_ASSERT(triggerEvent->name() == mNameTrigger, "Name does not match.");
+                STORM_LOG_ASSERT(dependentEvent->name() == mNameDependent, "Name does not match.");
                 mTriggerEvent = triggerEvent;
                 mDependentEvent = dependentEvent;
             }
@@ -46,12 +46,12 @@ namespace storm {
             }
 
             DFTGatePointer const& triggerEvent() const {
-                assert(mTriggerEvent);
+                STORM_LOG_ASSERT(mTriggerEvent, "Trigger does not exist.");
                 return mTriggerEvent;
             }
 
             DFTBEPointer const& dependentEvent() const {
-                assert(mDependentEvent);
+                STORM_LOG_ASSERT(mDependentEvent, "Dependent element does not exists.");
                 return mDependentEvent;
             }
 
@@ -114,4 +114,4 @@ namespace storm {
         };
 
     }
-}
\ No newline at end of file
+}
diff --git a/src/storage/dft/elements/DFTElement.h b/src/storage/dft/elements/DFTElement.h
index 366d0fe91..2eaaff12a 100644
--- a/src/storage/dft/elements/DFTElement.h
+++ b/src/storage/dft/elements/DFTElement.h
@@ -1,7 +1,6 @@
 #pragma once 
 
 #include <string>
-#include <cassert>
 #include <cstdlib>
 #include <iostream>
 #include <functional>
@@ -182,7 +181,7 @@ namespace storm {
             }
             
             bool addOutgoingDependency(DFTDependencyPointer const& e) {
-                assert(e->triggerEvent()->id() == this->id());
+                STORM_LOG_ASSERT(e->triggerEvent()->id() == this->id(), "Ids do not match.");
                 if(std::find(mOutgoingDependencies.begin(), mOutgoingDependencies.end(), e) != mOutgoingDependencies.end()) {
                     return false;
                 }
@@ -217,7 +216,7 @@ namespace storm {
                             break;
                         }
                     }
-                    assert(it != restr->children().cend());
+                    STORM_LOG_ASSERT(it != restr->children().cend(), "Child not found.");
                     ++it;
                     if(it != restr->children().cend()) {
                         res.push_back((*it)->id());
@@ -242,7 +241,7 @@ namespace storm {
                             break;
                         }
                     }
-                    assert(it != restr->children().cend());
+                    STORM_LOG_ASSERT(it != restr->children().cend(), "Child not found.");
                     if(it != restr->children().cbegin()) {
                         --it;
                         res.push_back((*it)->id());
diff --git a/src/storage/dft/elements/DFTOr.h b/src/storage/dft/elements/DFTOr.h
index 93e481d35..3b0fc37d7 100644
--- a/src/storage/dft/elements/DFTOr.h
+++ b/src/storage/dft/elements/DFTOr.h
@@ -12,7 +12,7 @@ namespace storm {
             {}
 
             void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                assert(this->hasFailedChild(state));
+                STORM_LOG_ASSERT(this->hasFailedChild(state), "No failed child.");
                 if(state.isOperational(this->mId)) {
                     this->fail(state, queues);
                 }
diff --git a/src/storage/dft/elements/DFTPand.h b/src/storage/dft/elements/DFTPand.h
index 86472d76f..bb18efe72 100644
--- a/src/storage/dft/elements/DFTPand.h
+++ b/src/storage/dft/elements/DFTPand.h
@@ -31,7 +31,7 @@ namespace storm {
             }
 
             void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                assert(this->hasFailsafeChild(state));
+                STORM_LOG_ASSERT(this->hasFailsafeChild(state), "No failsafe child.");
                 if(state.isOperational(this->mId)) {
                     this->failsafe(state, queues);
                     this->childrenDontCare(state, queues);
@@ -53,4 +53,4 @@ namespace storm {
         }
 
     }
-}
\ No newline at end of file
+}
diff --git a/src/storage/dft/elements/DFTRestriction.h b/src/storage/dft/elements/DFTRestriction.h
index 25441b5b1..f4a03f688 100644
--- a/src/storage/dft/elements/DFTRestriction.h
+++ b/src/storage/dft/elements/DFTRestriction.h
@@ -173,7 +173,7 @@ namespace storm {
 
             
             void checkFails(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                assert(queues.failurePropagationDone());
+                STORM_LOG_ASSERT(queues.failurePropagationDone(), "Failure propagation not finished.");
                 bool childOperationalBefore = false;
                 for(auto const& child : this->mChildren)
                 {
@@ -207,4 +207,4 @@ namespace storm {
         };
 
     }
-}
\ No newline at end of file
+}
diff --git a/src/storage/dft/elements/DFTVot.h b/src/storage/dft/elements/DFTVot.h
index 776055848..0b03954ca 100644
--- a/src/storage/dft/elements/DFTVot.h
+++ b/src/storage/dft/elements/DFTVot.h
@@ -34,7 +34,7 @@ namespace storm {
             }
 
             void checkFailsafe(storm::storage::DFTState<ValueType>& state, DFTStateSpaceGenerationQueues<ValueType>& queues) const override {
-                assert(this->hasFailsafeChild(state));
+                STORM_LOG_ASSERT(this->hasFailsafeChild(state), "No failsafe child.");
                 if(state.isOperational(this->mId)) {
                     unsigned nrFailsafeChildren = 0;
                     for(auto const& child : this->mChildren)
@@ -77,4 +77,4 @@ namespace storm {
         }
 
     }
-}
\ No newline at end of file
+}
diff --git a/src/utility/storm.h b/src/utility/storm.h
index 7fa292427..ce213cf08 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -399,7 +399,7 @@ namespace storm {
                     psiStates = rightResultPointer->asExplicitQualitativeCheckResult().getTruthValuesVector();
                 } else {
                     // Eventually formula
-                    STORM_LOG_THROW(!probOpFormula.getSubformula().isEventuallyFormula(), storm::exceptions::NotSupportedException, "The parametric engine only supports eventually formulas on CTMCs");
+                    STORM_LOG_THROW(probOpFormula.getSubformula().isEventuallyFormula(), storm::exceptions::NotSupportedException, "The parametric engine only supports eventually formulas on CTMCs");
                     storm::logic::EventuallyFormula eventuallyFormula = probOpFormula.getSubformula().asEventuallyFormula();
                     STORM_LOG_THROW(eventuallyFormula.getSubformula().isInFragment(storm::logic::propositional()), storm::exceptions::NotSupportedException, "The parametric engine does not support nested formulas on CTMCs");
                     std::unique_ptr<storm::modelchecker::CheckResult> resultPointer = propositionalModelchecker.check(eventuallyFormula.getSubformula());

From 929a694a64db42a61ac461934ea22a4794d266e6 Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 18 May 2016 11:10:40 +0200
Subject: [PATCH 245/246] Fixed typo

Former-commit-id: 0f880c7e52dd19115741cbdb03adf4bd517084ea
---
 src/builder/ExplicitDFTModelBuilder.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/builder/ExplicitDFTModelBuilder.cpp b/src/builder/ExplicitDFTModelBuilder.cpp
index 74b460e8c..4fb6131df 100644
--- a/src/builder/ExplicitDFTModelBuilder.cpp
+++ b/src/builder/ExplicitDFTModelBuilder.cpp
@@ -435,7 +435,7 @@ namespace storm {
                 STORM_LOG_TRACE("State " << mDft.getStateString(state) << " with id " << stateId << " already exists");
                 
                 // Check if possible pseudo state can be created now
-                STORM_LOG_ASSERT(stateID >= OFFSET_PSEUDO_STATE, "State is no pseudo state.");
+                STORM_LOG_ASSERT(stateId >= OFFSET_PSEUDO_STATE, "State is no pseudo state.");
                 stateId -= OFFSET_PSEUDO_STATE;
                 STORM_LOG_ASSERT(stateId < mPseudoStatesMapping.size(), "Pseudo state not known.");
                 if (mPseudoStatesMapping[stateId].first == 0) {

From eeb0f620ec91db8e0548e1f1ac5e5dca631453ba Mon Sep 17 00:00:00 2001
From: Mavo <matthias.volk@rwth-aachen.de>
Date: Wed, 18 May 2016 14:16:57 +0200
Subject: [PATCH 246/246] STORM_DEVELOPER mode introduced

Former-commit-id: 2749e19eab2ed0c63aea34e7f116ca2804183dc2
---
 CMakeLists.txt                                | 12 +++++------
 .../SparseDtmcEliminationModelChecker.cpp     |  4 ++++
 src/storage/BitVector.cpp                     | 20 +++++++++----------
 3 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 13ccb71fc..f2621cf4d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,7 +18,7 @@ include(ExternalProject)
 ##	CMake options of StoRM
 ##
 #############################################################
-option(STORM_DEBUG "Sets whether the DEBUG mode is used" ON)
+option(STORM_DEVELOPER "Sets whether the development mode is used" OFF)
 option(STORM_USE_POPCNT "Sets whether the popcnt instruction is going to be used." ON)
 option(USE_BOOST_STATIC_LIBRARIES "Sets whether the Boost libraries should be linked statically." ON)
 option(STORM_USE_INTELTBB "Sets whether the Intel TBB libraries should be used." OFF)
@@ -40,11 +40,11 @@ set(MSAT_ROOT "" CACHE STRING "The hint to the root directory of MathSAT (option
 set(ADDITIONAL_INCLUDE_DIRS "" CACHE STRING "Additional directories added to the include directories.")
 set(ADDITIONAL_LINK_DIRS "" CACHE STRING "Additional directories added to the link directories.")
 
-# If the DEBUG option was turned on, we will target a debug version and a release version otherwise.
-if (STORM_DEBUG)
-    set (CMAKE_BUILD_TYPE "DEBUG")
-else()
-    set (CMAKE_BUILD_TYPE "RELEASE")
+# If the STORM_DEVELOPER option was turned on, we will target a debug version.
+if (STORM_DEVELOPER)
+    message(STATUS "StoRM - Using development mode")
+    set(CMAKE_BUILD_TYPE "DEBUG" CACHE STRING "Set the build type" FORCE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSTORM_DEV")
 endif()
 message(STATUS "StoRM - Building ${CMAKE_BUILD_TYPE} version.")
 
diff --git a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
index 0f67cca4a..5a6045f66 100644
--- a/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
+++ b/src/modelchecker/reachability/SparseDtmcEliminationModelChecker.cpp
@@ -271,7 +271,9 @@ namespace storm {
             while (priorityQueue->hasNextState()) {
                 storm::storage::sparse::state_type state = priorityQueue->popNextState();
                 stateEliminator.eliminateState(state, true);
+#ifdef STORM_DEV
                 STORM_LOG_ASSERT(checkConsistent(flexibleMatrix, flexibleBackwardTransitions), "The forward and backward transition matrices became inconsistent.");
+#endif
             }
             
             // Now, we set the values of all states in BSCCs to that of the representative value (and clear the
@@ -903,7 +905,9 @@ namespace storm {
                 if (removeForwardTransitions) {
                     values[state] = storm::utility::zero<ValueType>();
                 }
+#ifdef STORM_DEV
                 STORM_LOG_ASSERT(checkConsistent(transitionMatrix, backwardTransitions), "The forward and backward transition matrices became inconsistent.");
+#endif
             }
         }
         
diff --git a/src/storage/BitVector.cpp b/src/storage/BitVector.cpp
index fcbceca7b..a60b8c10c 100644
--- a/src/storage/BitVector.cpp
+++ b/src/storage/BitVector.cpp
@@ -12,8 +12,8 @@
 
 #include <bitset>
 
-#ifndef NDEBUG
-//#define ASSERT_BITVECTOR
+#ifdef STORM_DEV
+#define ASSERT_BITVECTOR
 #endif
 
 namespace storm {
@@ -725,11 +725,11 @@ namespace storm {
                 if (result.get(i) != get(start + i)) {
                     STORM_LOG_ERROR("Getting of bits not correct for index " << i);
                     STORM_LOG_ERROR("Getting from " << start << " with length " << length);
-                    stringstream stream;
+                    std::stringstream stream;
                     printBits(stream);
                     stream << std::endl;
                     result.printBits(stream);
-                    STORM_LOG_ERROR(stream);
+                    STORM_LOG_ERROR(stream.str());
                     STORM_LOG_ASSERT(false, "Getting of bits not correct.");
                 }
             }
@@ -738,11 +738,11 @@ namespace storm {
                     if (original.get(i) != get(i)) {
                         STORM_LOG_ERROR("Getting did change bitvector at index " << i);
                         STORM_LOG_ERROR("Getting from " << start << " with length " << length);
-                        stringstream stream;
+                        std::stringstream stream;
                         printBits(stream);
                         stream << std::endl;
                         original.printBits(stream);
-                        STORM_LOG_ERROR(stream);
+                        STORM_LOG_ERROR(stream.str());
                         STORM_LOG_ASSERT(false, "Getting of bits not correct.");
                     }
                 }
@@ -818,11 +818,11 @@ namespace storm {
                 if (other.get(i) != get(start + i)) {
                     STORM_LOG_ERROR("Setting of bits not correct for index " << i);
                     STORM_LOG_ERROR("Setting from " << start << " with length " << other.bitCount);
-                    stringstream stream;
+                    std::stringstream stream;
                     printBits(stream);
                     stream << std::endl;
                     other.printBits(stream);
-                    STORM_LOG_ERROR(stream);
+                    STORM_LOG_ERROR(stream.str());
                     STORM_LOG_ASSERT(false, "Setting of bits not correct.");
                 }
             }
@@ -831,11 +831,11 @@ namespace storm {
                     if (original.get(i) != get(i)) {
                         STORM_LOG_ERROR("Setting did change bitvector at index " << i);
                         STORM_LOG_ERROR("Setting from " << start << " with length " << other.bitCount);
-                        stringstream stream;
+                        std::stringstream stream;
                         printBits(stream);
                         stream << std::endl;
                         original.printBits(stream);
-                        STORM_LOG_ERROR(stream);
+                        STORM_LOG_ERROR(stream.str());
                         STORM_LOG_ASSERT(false, "Setting of bits not correct.");
                     }
                 }