Processor.h

#ifndef HYDROBRICKS_PROCESSOR_H
#define HYDROBRICKS_PROCESSOR_H
 
#include <memory>
 
#include "Brick.h"
#include "Includes.h"
#include "Solver.h"
 
class ModelHydro;
 
class Processor {
  public:
    explicit Processor();
 
    virtual ~Processor();
 
    void Initialize(const SolverSettings& solverSettings);
 
    void SetModel(ModelHydro* model);
 
    void ConnectToElementsToSolve();
 
    [[nodiscard]] int GetStateVariableCount() const;
 
    bool ProcessTimeStep(double timeStepInDays);
 
    void GatherState(axd& state) const;
 
    void ScatterState(const axd& state);
 
    void ResetState();
 
    void EvaluateRates(axd& rates, double timeStepInDays, bool applyConstraints = true);
 
    void ConstrainRates(axd& rates, double timeStepInDays);
 
    void EnforceConstraints(axd& rates, double timeStepInDays);
 
    void ApplyRates(const axd& rates, double timeStepInDays);
 
    void FinalizeTimeStep();
 
    int GetSolvableConnectionCount() const {
        return _solvableConnectionCount;
    }
 
    const vector<Brick*>& GetSolvableBricks() const {
        return _iterableBricks;
    }
 
    int GetDirectConnectionCount() const {
        return _directConnectionCount;
    }
 
  protected:
    std::unique_ptr<Solver> _solver;  // owning
    ModelHydro* _model;               // non-owning reference
    int _solvableConnectionCount;
    int _directConnectionCount;
    vecDoublePt _stateVariableChanges;
    vector<Brick*> _iterableBricks;  // non-owning views into HydroUnits/SubBasin
    axd _changeRatesNoSolver;
    axd _ratesBeforeSweep;  // scratch buffer for the constraint fixpoint iteration
 
  private:
    void ValidateFluxTopology() const;
 
    void StoreStateVariableChanges(std::span<double*> values);
 
    void ApplyDirectChanges(Brick* brick, int& ptIndex, double timeStepInDays);
};
 
#endif  // HYDROBRICKS_PROCESSOR_H