fixed issue related to Markov automata without proababilistic states

src/storm/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp

@@ -44,9 +44,16 @@ namespace storm {
                 // * a matrix aProbabilistic with all (non-discretized) transitions from probabilistic non-goal states to other probabilistic non-goal states.
                 // * a matrix aProbabilisticToMarkovian with all (non-discretized) transitions from probabilistic non-goal states to all Markovian non-goal states.
                 typename storm::storage::SparseMatrix<ValueType> aMarkovian = transitionMatrix.getSubmatrix(true, markovianNonGoalStates, markovianNonGoalStates, true);
-                typename storm::storage::SparseMatrix<ValueType> aMarkovianToProbabilistic = transitionMatrix.getSubmatrix(true, markovianNonGoalStates, probabilisticNonGoalStates);
-                typename storm::storage::SparseMatrix<ValueType> aProbabilistic = transitionMatrix.getSubmatrix(true, probabilisticNonGoalStates, probabilisticNonGoalStates);
-                typename storm::storage::SparseMatrix<ValueType> aProbabilisticToMarkovian = transitionMatrix.getSubmatrix(true, probabilisticNonGoalStates, markovianNonGoalStates);
+                
+                bool existProbabilisticStates = !probabilisticNonGoalStates.empty();
+                typename storm::storage::SparseMatrix<ValueType> aMarkovianToProbabilistic;
+                typename storm::storage::SparseMatrix<ValueType> aProbabilistic;
+                typename storm::storage::SparseMatrix<ValueType> aProbabilisticToMarkovian;
+                if (existProbabilisticStates) {
+                    aMarkovianToProbabilistic = transitionMatrix.getSubmatrix(true, markovianNonGoalStates, probabilisticNonGoalStates);
+                    aProbabilistic = transitionMatrix.getSubmatrix(true, probabilisticNonGoalStates, probabilisticNonGoalStates);
+                    aProbabilisticToMarkovian = transitionMatrix.getSubmatrix(true, probabilisticNonGoalStates, markovianNonGoalStates);
+                }
                 
                 // The matrices with transitions from Markovian states need to be digitized.
                 // Digitize aMarkovian. Based on whether the transition is a self-loop or not, we apply the two digitization rules.
@@ -64,6 +71,7 @@ namespace storm {
                 }
                 
                 // Digitize aMarkovianToProbabilistic. As there are no self-loops in this case, we only need to apply the digitization formula for regular successors.
+                if (existProbabilisticStates) {
                     rowIndex = 0;
                     for (auto state : markovianNonGoalStates) {
                         for (auto& element : aMarkovianToProbabilistic.getRow(rowIndex)) {
@@ -71,13 +79,17 @@ namespace storm {
                         }
                         ++rowIndex;
                     }
+                }
                 
                 // Initialize the two vectors that hold the variable one-step probabilities to all target states for probabilistic and Markovian (non-goal) states.
-                std::vector<ValueType> bProbabilistic(aProbabilistic.getRowCount());
+                std::vector<ValueType> bProbabilistic(existProbabilisticStates ? aProbabilistic.getRowCount() : 0);
                 std::vector<ValueType> bMarkovian(markovianNonGoalStates.getNumberOfSetBits());
                 
                 // Compute the two fixed right-hand side vectors, one for Markovian states and one for the probabilistic ones.
-                std::vector<ValueType> bProbabilisticFixed = transitionMatrix.getConstrainedRowGroupSumVector(probabilisticNonGoalStates, goalStates);
+                std::vector<ValueType> bProbabilisticFixed;
+                if (existProbabilisticStates) {
+                    bProbabilisticFixed = transitionMatrix.getConstrainedRowGroupSumVector(probabilisticNonGoalStates, goalStates);
+                }
                 std::vector<ValueType> bMarkovianFixed;
                 bMarkovianFixed.reserve(markovianNonGoalStates.getNumberOfSetBits());
                 for (auto state : markovianNonGoalStates) {
@@ -110,6 +122,7 @@ namespace storm {
                 // *    perform one timed-step using v_MS := A_MSwG * v_MS + A_MStoPS * v_PS + (A * 1_G)|MS
                 std::vector<ValueType> markovianNonGoalValuesSwap(markovianNonGoalValues);
                 for (uint64_t currentStep = 0; currentStep < numberOfSteps; ++currentStep) {
+                    if (existProbabilisticStates) {
                         // Start by (re-)computing bProbabilistic = bProbabilisticFixed + aProbabilisticToMarkovian * vMarkovian.
                         aProbabilisticToMarkovian.multiplyWithVector(markovianNonGoalValues, bProbabilistic);
                         storm::utility::vector::addVectors(bProbabilistic, bProbabilisticFixed, bProbabilistic);
@@ -120,16 +133,24 @@ namespace storm {
                         // (Re-)compute bMarkovian = bMarkovianFixed + aMarkovianToProbabilistic * vProbabilistic.
                         aMarkovianToProbabilistic.multiplyWithVector(probabilisticNonGoalValues, bMarkovian);
                         storm::utility::vector::addVectors(bMarkovian, bMarkovianFixed, bMarkovian);
+                    }
+                    
                     aMarkovian.multiplyWithVector(markovianNonGoalValues, markovianNonGoalValuesSwap);
                     std::swap(markovianNonGoalValues, markovianNonGoalValuesSwap);
+                    if (existProbabilisticStates) {
                         storm::utility::vector::addVectors(markovianNonGoalValues, bMarkovian, markovianNonGoalValues);
+                    } else {
+                        storm::utility::vector::addVectors(markovianNonGoalValues, bMarkovianFixed, markovianNonGoalValues);
+                    }
                 }
                 
+                if (existProbabilisticStates) {
                     // After the loop, perform one more step of the value iteration for PS states.
                     aProbabilisticToMarkovian.multiplyWithVector(markovianNonGoalValues, bProbabilistic);
                     storm::utility::vector::addVectors(bProbabilistic, bProbabilisticFixed, bProbabilistic);
                     solver->solveEquations(env, dir, probabilisticNonGoalValues, bProbabilistic);
                 }
+            }
              
             template <typename ValueType, typename std::enable_if<!storm::NumberTraits<ValueType>::SupportsExponential, int>::type>
             void SparseMarkovAutomatonCslHelper::computeBoundedReachabilityProbabilities(Environment const& env, OptimizationDirection dir, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, std::vector<ValueType> const& exitRates, storm::storage::BitVector const& goalStates, storm::storage::BitVector const& markovianNonGoalStates, storm::storage::BitVector const& probabilisticNonGoalStates, std::vector<ValueType>& markovianNonGoalValues, std::vector<ValueType>& probabilisticNonGoalValues, ValueType delta, uint64_t numberOfSteps, storm::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory) {