StochasticDataProvider.h

Go to the documentation of this file.

#ifndef BPMNOS_Model_StochasticDataProvider_H
#define BPMNOS_Model_StochasticDataProvider_H
 
#include <bpmn++.h>
#include <limex.h>
#include "DataProvider.h"
#include "StochasticScenario.h"
#include "model/utility/src/CSVReader.h"
#include "model/utility/src/RandomDistributionFactory.h"
#include "model/bpmnos/src/extensionElements/Expression.h"
#include <memory>
#include <vector>
 
namespace BPMNOS::Model {
 
/**
 * @brief Data provider supporting stochastic behavior.
 *
 * StochasticDataProvider supports:
 * - 3-column format (INSTANCE_ID, NODE_ID, INITIALIZATION) - static behavior
 * - 4-column format (+ DISCLOSURE) - dynamic behavior
 * - 6-column format (+ ARRIVAL, COMPLETION) - stochastic behavior
 *
 * Has its own LIMEX handle with lookup tables from Model plus random functions.
 */
class StochasticDataProvider : public DataProvider {
public:
  StochasticDataProvider(const std::string& modelFile, const std::string& instanceFileOrString,
                         unsigned int seed = 0);
  StochasticDataProvider(const std::string& modelFile, const std::vector<std::string>& folders,
                         const std::string& instanceFileOrString, unsigned int seed = 0);
  ~StochasticDataProvider() override = default;
 
  std::unique_ptr<Scenario> createScenario(unsigned int scenarioId = 0) override;
 
  /// Get the stochastic LIMEX handle (for expression compilation)
  const LIMEX::Handle<double>& getStochasticHandle() const { return stochasticHandle; }
 
protected:
  CSVReader reader;
  unsigned int seed;
  size_t columnCount;
 
  /// Dedicated LIMEX handle with lookup tables + random functions
  LIMEX::Handle<double> stochasticHandle;
 
  /// Random distribution factory
  RandomDistributionFactory randomFactory;
 
  void initializeStochasticHandle();
  void readInstances();
 
  struct StochasticInstanceData {
    const BPMN::Process* process;
    BPMNOS::number id;
    BPMNOS::number instantiation;
    std::unordered_map<const Attribute*, BPMNOS::number> data;
  };
 
  std::unordered_map<long unsigned int, StochasticInstanceData> instances;
  std::unordered_map<const Attribute*, BPMNOS::number> globalValueMap;
 
  /// Pending disclosures with expressions to evaluate at disclosure time
  std::unordered_map<size_t, std::vector<StochasticPendingDisclosure>> pendingDisclosures;
 
  /// Arrival expressions per (instance, node)
  std::unordered_map<size_t, std::unordered_map<const BPMN::Node*, std::vector<ArrivalExpression>>> arrivalExpressions;
 
  /// Completion expressions per (instance, node)
  std::unordered_map<size_t, std::unordered_map<const BPMN::Node*, std::vector<CompletionExpression>>> completionExpressions;
 
  /// Node disclosure times
  std::unordered_map<size_t, std::unordered_map<const BPMN::Node*, BPMNOS::number>> disclosure;
 
  BPMNOS::number earliestInstantiation;
  BPMNOS::number latestInstantiation;
 
  void ensureDefaultValue(StochasticInstanceData& instance, const std::string attributeId,
                          std::optional<BPMNOS::number> value = std::nullopt);
  std::pair<std::string, std::string> parseInitialization(const std::string& initialization) const;
  BPMNOS::number evaluateExpression(const std::string& expression) const;
  BPMNOS::number getEffectiveDisclosure(size_t instanceId, const BPMN::Node* node, BPMNOS::number ownDisclosure);
};
 
} // namespace BPMNOS::Model
 
#endif // BPMNOS_Model_StochasticDataProvider_H