#ifndef ROE_FLUX_FORM_EULERIAN_COMPOSITE_SOLVER_V2_HPP
#define ROE_FLUX_FORM_EULERIAN_COMPOSITE_SOLVER_V2_HPP

#include <mesh/MeshTraits.hpp>

#include <scheme/RusanovEulerianCompositeSolverTools.hpp>

#include <memory>
#include <tuple>
#include <vector>

inline double
signe(const double a)
{
  if (a < 0)
    return -1.;
  if (a > 0)
    return 1;

  return 0;
}
class Rp;
class Rpxp;

std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
           std::shared_ptr<const DiscreteFunctionVariant>,
           std::shared_ptr<const DiscreteFunctionVariant>>
roeFluxFormEulerianCompositeSolver_v2(
  const std::shared_ptr<const DiscreteFunctionVariant>& rho,
  const std::shared_ptr<const DiscreteFunctionVariant>& u,
  const std::shared_ptr<const DiscreteFunctionVariant>& E,
  const double& gamma,
  const std::shared_ptr<const DiscreteFunctionVariant>& c,
  const std::shared_ptr<const DiscreteFunctionVariant>& p,
  // const size_t& degree,
  const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list,
  const double& dt,
  const bool check = false);
/*
class DiscreteFunctionVariant;
class IBoundaryConditionDescriptor;
class MeshVariant;
template <size_t Dimension>
class Mesh;

template <size_t Dimension, int number_of_unknowns>
class RoeFluxFormEulerianCompositeSolver_v2
{
 private:
  static constexpr int p = number_of_unknowns + (Dimension - 1);
  using Rp               = TinyVector<p>;   // number_of_unknowns + (Dimension - 1)>;

  using Rpxp = TinyMatrix<p, p, double>;
  // private:
 public:
  JacobianStructuralInfoSystemsOfEquations<Dimension, number_of_unknowns> JacobianInfos;

  // KN<std::vector<std::vector<Rn> > > _sign_jacobian_matrix_dof_in_cell;
  // KN<std::vector<std::vector<Rn> > > _vp_jacobian_matrix_dof_in_cell;
  // //KN<std::vector<Rnm> > _jac_jacobian_matrix_dof_in_cell;
  // KN<std::vector<std::vector<Rnm> > > _right_eigenv_matrix_dof_in_cell;
  // KN<std::vector<std::vector<Rnm> > >  _left_eigenv_matrix_dof_in_cell;
  // //KN<std::vector<Rnm> >  _rotation_matrix_dof_in_cell;
  // KN<std::vector<R2nm> >  _MatriceU_dof_in_cell;

  NodeValuePerCell<const Rp> _vp_jacobian_matrix_node_in_cell;
  EdgeValuePerCell<const Rp> _vp_jacobian_matrix_edge_in_cell;
  FaceValuePerCell<const Rp> _vp_jacobian_matrix_face_in_cell;

  NodeValuePerCell<const Rpxp> _right_eigenv_matrix_node_in_cell;
  EdgeValuePerCell<const Rpxp> _right_eigenv_matrix_edge_in_cell;
  FaceValuePerCell<const Rpxp> _right_eigenv_matrix_face_in_cell;

  NodeValuePerCell<const Rpxp> _left_eigenv_matrix_node_in_cell;
  EdgeValuePerCell<const Rpxp> _left_eigenv_matrix_edge_in_cell;
  FaceValuePerCell<const Rpxp> _left_eigenv_matrix_face_in_cell;

  NodeValuePerCell<const Rpxp> _MatriceU_node_in_cell;
  EdgeValuePerCell<const Rpxp> _MatriceU_edge_in_cell;
  FaceValuePerCell<const Rpxp> _MatriceU_face_in_cell;

 public:
  RoeFluxFormEulerianCompositeSolver_v2() {}

  ~RoeFluxFormEulerianCompositeSolver_v2() {}
};
*/
#endif