Processor.h

#ifndef HYDROBRICKS_PROCESSOR_H
#define HYDROBRICKS_PROCESSOR_H
 
#include <memory>
 
#include "Brick.h"
#include "Includes.h"
#include "Solver.h"
 
class ModelHydro;
class Splitter;
 
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;
    }
 
    struct SolvableProcess {
        Process* process;     // non-owning
        int connectionCount;  // number of rates this process contributes
        int rateOffset;       // index of its first rate in the global rates vector
    };
 
    struct SolvableBrickEntry {
        Brick* brick;      // non-owning
        int processStart;  // first index in _solvableProcesses
        int processEnd;    // one past the last index in _solvableProcesses
    };
 
    struct DirectProcess {
        Process* process;           // non-owning
        WaterContainer* container;  // non-owning: the container the process draws from
        int outputFluxCount;        // number of output fluxes to link
        int connectionCount;        // number of rates the process produces
        int rateOffset;             // index of its first rate in _changeRatesNoSolver
    };
 
    struct DirectBrickEntry {
        Brick* brick;      // non-owning
        int processStart;  // first index in _directProcesses
        int processEnd;    // one past the last index in _directProcesses
    };
 
    struct DirectUnitEntry {
        int splitterStart;  // first index in _directSplitters
        int splitterEnd;    // one past the last index in _directSplitters
        int brickStart;     // first index in _directBricks
        int brickEnd;       // one past the last index in _directBricks
    };
 
    const vector<SolvableProcess>& GetSolvableProcesses() const {
        return _solvableProcesses;
    }
 
    const vector<SolvableBrickEntry>& GetSolvableBrickEntries() const {
        return _solvableBrickEntries;
    }
 
  protected:
    std::unique_ptr<Solver> _solver;  // owning
    ModelHydro* _model;               // non-owning reference
    int _solvableConnectionCount;
    int _directConnectionCount;
    int _directRateCount;  // size of the direct change-rate buffer (fixed slices)
    vecDoublePt _stateVariableChanges;
    vector<Brick*> _iterableBricks;  // non-owning views into HydroUnits/SubBasin
    // Flattened traversal of the solvable bricks and processes, built once at
    // initialization: the model structure is fixed after the build, so the
    // brick -> process -> connection hierarchy needs no virtual walk on every solver
    // stage of every time step.
    vector<SolvableProcess> _solvableProcesses;
    vector<SolvableBrickEntry> _solvableBrickEntries;
    // Same flattening for the direct (pre-solver) pass over the hydro units.
    vector<Splitter*> _directSplitters;  // non-owning, grouped by hydro unit
    vector<DirectProcess> _directProcesses;
    vector<DirectBrickEntry> _directBricks;
    vector<DirectUnitEntry> _directUnits;
    axd _changeRatesNoSolver;
    axd _ratesBeforeSweep;  // scratch buffer for the constraint fixpoint iteration
 
  private:
    void ValidateFluxTopology() const;
 
    void StoreStateVariableChanges(std::span<double*> values);
 
    void BuildTraversalTables();
 
    void ApplyDirectChanges(const DirectBrickEntry& brickEntry, double timeStepInDays);
};
 
#endif  // HYDROBRICKS_PROCESSOR_H