condition_action_sequence_2.hpp

#ifndef CONDITION_ACTION_SEQUENCE2_HPP
#define CONDITION_ACTION_SEQUENCE2_HPP 1

#include "condition_action_sequence.hpp"
#include "spatial_reconstruction.hpp"
#include "../common/LagrangianHLLC.hpp"

class ConditionActionSequence2 : public FluxCalculator
{
public:

        class Action2
        {
        public:

                virtual void operator()
                        (const Edge& edge,
                                const size_t index,
                                const Tessellation& tess,
                                const Vector2D& edge_velocity,
                                const vector<ComputationalCell>& cells,
                                const EquationOfState& eos,
                                const bool aux,
                                const pair<ComputationalCell, ComputationalCell> & edge_values,
                                Extensive &res,
                                double time,
                                TracerStickerNames const& tracerstickernames) const = 0;

                virtual void Reset(void) const {}

                virtual ~Action2(void);
        private:
          //      Action2(const Action2&);
        };

        ConditionActionSequence2
                (const vector<pair<const ConditionActionSequence::Condition*, const ConditionActionSequence::Action*> >& sequence,
                        const vector<pair<const ConditionActionSequence::Condition*, const ConditionActionSequence2::Action2*> >& sequence2,
                        SpatialReconstruction const& interp);

        ~ConditionActionSequence2(void);

        vector<Extensive> operator()
                (const Tessellation& tess,
                        const vector<Vector2D>& edge_velocities,
                        const vector<ComputationalCell>& cells,
                        const vector<Extensive>& extensives,
                        const CacheData& cd,
                        const EquationOfState& eos,
                        const double time,
                        const double dt,
                        TracerStickerNames const& tracerstickernames) const;

private:
        const vector<pair<const ConditionActionSequence::Condition*, const ConditionActionSequence::Action*> > sequence_;
        const vector<pair<const ConditionActionSequence::Condition*, const Action2*> > sequence2_;
        const SpatialReconstruction & interp_;
        mutable vector<pair<ComputationalCell, ComputationalCell> > edge_values_;
};

class RegularFlux2 : public ConditionActionSequence2::Action2
{
public:

        explicit RegularFlux2(const RiemannSolver& rs);

        void operator()
                (const Edge& edge,
                        const size_t index,
                        const Tessellation& tess,
                        const Vector2D& edge_velocity,
                        const vector<ComputationalCell>& cells,
                        const EquationOfState& eos,
                        const bool aux,
                        const pair<ComputationalCell, ComputationalCell> & edge_values,
                        Extensive &res, double time,
                        TracerStickerNames const& tracerstickernames) const;

private:

        const RiemannSolver& rs_;
};


class RigidWallFlux2 : public ConditionActionSequence2::Action2
{
public:

        explicit RigidWallFlux2(const RiemannSolver& rs);

        void operator()
                (const Edge& edge,
                        const size_t index,
                        const Tessellation& tess,
                        const Vector2D& edge_velocity,
                        const vector<ComputationalCell>& cells,
                        const EquationOfState& eos,
                        const bool aux,
                        const pair<ComputationalCell, ComputationalCell> & edge_values,
                        Extensive &res, double time,
                        TracerStickerNames const& tracerstickernames) const;

private:
        const RiemannSolver& rs_;
};

class Ratchet : public ConditionActionSequence2::Action2
{
public:

        Ratchet(const RiemannSolver& rs, const bool in);

        void operator()
                (const Edge& edge,
                        const size_t index,
                        const Tessellation& tess,
                        const Vector2D& edge_velocity,
                        const vector<ComputationalCell>& cells,
                        const EquationOfState& eos,
                        const bool aux,
                        const pair<ComputationalCell, ComputationalCell> & edge_values,
                        Extensive &res, double time,
                        TracerStickerNames const& tracerstickernames) const;

private:
        const bool in_;
        const RigidWallFlux2 wall_;
        const FreeFlowFlux free_;
};

class LagrangianFlux : public ConditionActionSequence2::Action2
{
public:

        class LagrangianCriteria
        {
        public:
                virtual bool operator()(const Edge& edge,
                        const size_t index,
                        const Tessellation& tess,
                        const Vector2D& edge_velocity,
                        const vector<ComputationalCell>& cells,
                        const EquationOfState& eos,
                        const bool aux,
                        const pair<ComputationalCell, ComputationalCell> & edge_values,
                        double time,
                        TracerStickerNames const& tracerstickernames) const = 0;

                virtual ~LagrangianCriteria();
        };

        LagrangianFlux(const LagrangianHLLC& rs,const LagrangianHLLC& rs2,LagrangianCriteria const& criteria);

        void operator()
                (const Edge& edge,
                        const size_t index,
                        const Tessellation& tess,
                        const Vector2D& edge_velocity,
                        const vector<ComputationalCell>& cells,
                        const EquationOfState& eos,
                        const bool aux,
                        const pair<ComputationalCell, ComputationalCell> & edge_values,
                        Extensive &res, double time,
                        TracerStickerNames const& tracerstickernames) const;

        void Reset(void) const;

  mutable vector<double> ws_;
  mutable vector<double> edge_vel_;
  mutable vector<bool> Lag_calc_;
private:
  const LagrangianHLLC& rs_;
  const LagrangianHLLC& rs2_;
  const LagrangianCriteria& criteria_;
};

class WallsMassFlux : public LagrangianFlux::LagrangianCriteria
{
public:
        WallsMassFlux();

        bool operator()(const Edge& edge,
                const size_t index,
                const Tessellation& tess,
                const Vector2D& edge_velocity,
                const vector<ComputationalCell>& cells,
                const EquationOfState& eos,
                const bool aux,
                const pair<ComputationalCell, ComputationalCell> & edge_values,
                double time,
                TracerStickerNames const& tracerstickernames) const;
};

#endif // CONDITION_ACTION_SEQUENCE2_HPP