HArD::Core2D
Hybrid Arbitrary Degree::Core 2D - Library to implement 2D schemes with edge and cell polynomials as unknowns
Loading...
Searching...
No Matches
Classes | Typedefs | Functions
HArDCore2D::DSL Namespace Reference

Classes

class  BottiMassa
 
struct  ComputeErrorsParameters
 
struct  ComputeMass
 
class  DiscreteSpace
 
class  DiscreteSpaceDescriptor
 
struct  DiscreteSpaceError
 
class  GlobalDOFTable
 Base class for global DOF spaces. Provides functions to manipulate global DOFs (the local version being provided by LocalDOFTable). More...
 
struct  HHODOFsTypes
 
struct  HHODOFsTypes< Scalar >
 
struct  HHODOFsTypes< Vector >
 
class  HYPRE
 
struct  HYPREParameters
 
struct  InterpolateParameters
 
class  LocalDOFTable
 
struct  LocalSpaceDimensions
 
struct  LocalSpaceDimensions< GolyCellType >
 
struct  LocalSpaceDimensions< GolyComplCellType >
 
struct  LocalSpaceDimensions< PolyCellType >
 
struct  LocalSpaceDimensions< PolyEdgeType >
 
struct  LocalSpaceDimensions< PolynCellType >
 
struct  LocalSpaceDimensions< PolynEdgeType >
 
struct  LocalSpaceDimensions< PolynxnCellType >
 
struct  LocalSpaceDimensions< RealnVertexType >
 
struct  LocalSpaceDimensions< RealnxnVertexType >
 
struct  LocalSpaceDimensions< RealVertexType >
 
struct  LocalSpaceDimensions< RolyCellType >
 
struct  LocalSpaceDimensions< RolyComplCellType >
 
struct  LocalSpaceDimensions< SymPolynxnCellType >
 
class  PkpoPkPkPk
 
class  RTNPkPkPk
 

Typedefs

typedef Family< GradientBasis< ShiftedBasis< MonomialScalarBasisCell > > > GolyCellType
 
typedef Family< GolyComplBasisCell > GolyComplCellType
 
typedef Family< MonomialScalarBasisCell > PolyCellType
 
typedef Family< MonomialScalarBasisEdge > PolyEdgeType
 
typedef TensorizedVectorFamily< PolyCellType, dimspace > PolynCellType
 
typedef TensorizedVectorFamily< Family< MonomialScalarBasisEdge >, dimspace > PolynEdgeType
 
typedef MatrixFamily< PolyCellType, dimspace > PolynxnCellType
 
typedef VectorRd RealnVertexType
 
typedef MatrixRd RealnxnVertexType
 
typedef double RealVertexType
 
typedef Family< CurlBasis< ShiftedBasis< MonomialScalarBasisCell > > > RolyCellType
 
typedef Family< RolyComplBasisCell > RolyComplCellType
 
typedef TensorizedVectorFamily< PolyCellType, static_cast< size_t >(dimspace+1)> SymPolynxnCellType
 
typedef boost::fusion::vector< PolyCellType, PolyEdgeType, PolynCellType, PolynxnCellType, PolynEdgeType, RolyCellType, RolyComplCellType, GolyCellType, GolyComplCellType, RealVertexType, RealnVertexType, RealnxnVertexType, SymPolynxnCellType > LocalPolynomialSpaces
 

Functions

template<TensorRankE Rank>
std::vector< std::pair< double, double > > compute_hho_component_norms (const DiscreteSpace &Vh, const std::vector< Eigen::VectorXd > &vh, bool use_threads=true)
 
template<TensorRankE Rank>
std::vector< std::pair< double, double > > compute_hho_potential_norms (const DiscreteSpace &Vh, const std::vector< Eigen::MatrixXd > &potential, const std::vector< Eigen::MatrixXd > &stabilization, const std::vector< Eigen::VectorXd > &vh, bool use_threads=true)
 
template<typename CellDofsMapType , typename EdgeDofsMapType >
std::vector< double > compute_l2_dof_norms (const DiscreteSpace &Vh, const CellDofsMapType &cell_dofs_map, const EdgeDofsMapType &edge_dofs_map, const std::vector< Eigen::VectorXd > &vh, bool use_threads=true)
 Compute L2 component norms for spaces with generic cell and edge DOFs.
 
DiscreteSpaceDescriptor::LocalPolynomialSpaceDescriptor make_dof (const std::string name, size_t degree)
 
bool compare_degrees (const DiscreteSpaceDescriptor::LocalPolynomialSpaceDescriptor &P1, const DiscreteSpaceDescriptor::LocalPolynomialSpaceDescriptor &P2)
 
template<TensorRankE Rank, typename F >
Eigen::VectorXd hho_interpolate (const DiscreteSpace &Vh, const F &v, const InterpolateParameters &parameters={})
 
std::map< std::string, double > compute_discrete_errors (const HYPRE *scheme, const Eigen::VectorXd &uph, const Eigen::VectorXd &upI, const double &viscosity, const ComputeErrorsParameters &parameters={})
 
std::map< std::string, double > compute_errors (const HYPRE *scheme, const HArDCore2D::NavierStokesSolutions::IExactSolution *isolution, const Eigen::VectorXd &uh, const Eigen::VectorXd &ph, const ComputeErrorsParameters &parameters={})
 Compute errors between the discrete solution and the continuous one.
 
std::map< std::string, double > compute_l2_dof_errors (const HYPRE *scheme, const Eigen::VectorXd &uph, const Eigen::VectorXd &upI, const ComputeErrorsParameters &parameters)
 Compute the errors on DOFs.
 
std::map< std::string, double > compute_energy_errors (const HYPRE *scheme, const HArDCore2D::NavierStokesSolutions::IExactSolution *isolution, const Eigen::VectorXd &uph, const Eigen::VectorXd &upI, const double &viscosity, const double &current_time, const ComputeErrorsParameters &parameters={})
 
std::map< std::string, double > compute_energy_errors (const HYPRE *scheme, const HArDCore2D::NavierStokesSolutions::IExactSolution *isolution, const Eigen::VectorXd &uph_half, const Eigen::VectorXd &upI_half, const Eigen::VectorXd &uph, const Eigen::VectorXd &upI, const double &viscosity, const double &current_time, const double &time_step, const ComputeErrorsParameters &parameters={})
 
std::map< std::string, double > compute_discrete_errors (const HYPRE *scheme, const Eigen::VectorXd &uph, const Eigen::VectorXd &upI, const Eigen::VectorXd &brh, const Eigen::VectorXd &brI, const double &viscosity, const double &magnetic_diffusivity, const ComputeErrorsParameters &parameters={})
 
std::map< std::string, double > compute_errors (const HYPRE *scheme, const HArDCore2D::NavierStokesSolutions::IExactSolution *isolution, const Eigen::VectorXd &uh, const Eigen::VectorXd &ph, const Eigen::VectorXd &bh, const Eigen::VectorXd &rh, const ComputeErrorsParameters &parameters={})
 Compute errors between the discrete solution and the continuous one.
 
std::map< std::string, double > compute_l2_dof_errors (const HYPRE *scheme, const Eigen::VectorXd &uph, const Eigen::VectorXd &upI, const Eigen::VectorXd &brh, const Eigen::VectorXd &brI, const ComputeErrorsParameters &parameters)
 Compute the errors on DOFs.
 

Typedef Documentation

◆ GolyCellType

typedef Family< GradientBasis< ShiftedBasis< MonomialScalarBasisCell > > > HArDCore2D::DSL::GolyCellType

◆ GolyComplCellType

typedef Family< GolyComplBasisCell > HArDCore2D::DSL::GolyComplCellType

◆ LocalPolynomialSpaces

typedef boost::fusion::vector< PolyCellType, PolyEdgeType, PolynCellType, PolynxnCellType, PolynEdgeType, RolyCellType, RolyComplCellType, GolyCellType, GolyComplCellType, RealVertexType, RealnVertexType, RealnxnVertexType > HArDCore2D::DSL::LocalPolynomialSpaces

◆ PolyCellType

typedef Family< MonomialScalarBasisCell > HArDCore2D::DSL::PolyCellType

◆ PolyEdgeType

typedef Family< MonomialScalarBasisEdge > HArDCore2D::DSL::PolyEdgeType

◆ PolynCellType

typedef TensorizedVectorFamily< PolyCellType, dimspace > HArDCore2D::DSL::PolynCellType

◆ PolynEdgeType

typedef TensorizedVectorFamily< Family< MonomialScalarBasisEdge >, dimspace > HArDCore2D::DSL::PolynEdgeType

◆ PolynxnCellType

typedef MatrixFamily< PolyCellType, dimspace > HArDCore2D::DSL::PolynxnCellType

◆ RealnVertexType

typedef VectorRd HArDCore2D::DSL::RealnVertexType

◆ RealnxnVertexType

typedef MatrixRd HArDCore2D::DSL::RealnxnVertexType

◆ RealVertexType

typedef double HArDCore2D::DSL::RealVertexType

◆ RolyCellType

typedef Family< CurlBasis< ShiftedBasis< MonomialScalarBasisCell > > > HArDCore2D::DSL::RolyCellType

◆ RolyComplCellType

typedef Family< RolyComplBasisCell > HArDCore2D::DSL::RolyComplCellType

◆ SymPolynxnCellType

typedef TensorizedVectorFamily<PolyCellType, static_cast<size_t>(dimspace+1)> HArDCore2D::DSL::SymPolynxnCellType

Function Documentation

◆ compare_degrees()

bool HArDCore2D::DSL::compare_degrees ( const DiscreteSpaceDescriptor::LocalPolynomialSpaceDescriptor &  P1,
const DiscreteSpaceDescriptor::LocalPolynomialSpaceDescriptor &  P2 
)

◆ compute_discrete_errors() [1/2]

std::map< std::string, double > HArDCore2D::DSL::compute_discrete_errors ( const HYPRE *  scheme,
const Eigen::VectorXd &  uph,
const Eigen::VectorXd &  upI,
const double &  viscosity,
const ComputeErrorsParameters &  parameters = {} 
)

Compute errors between the discrete solution and the interpolate of the continuous one using the component norm and/or the potential norm, depending on which one is computable

◆ compute_discrete_errors() [2/2]

std::map< std::string, double > HArDCore2D::DSL::compute_discrete_errors ( const HYPRE *  scheme,
const Eigen::VectorXd &  uph,
const Eigen::VectorXd &  upI,
const Eigen::VectorXd &  brh,
const Eigen::VectorXd &  brI,
const double &  viscosity,
const double &  magnetic_diffusivity,
const ComputeErrorsParameters &  parameters = {} 
)

Compute errors between the discrete solution and the interpolate of the continuous one using the component norm and/or the potential norm, depending on which one is computable

◆ compute_energy_errors() [1/2]

std::map< std::string, double > HArDCore2D::DSL::compute_energy_errors ( const HYPRE *  scheme,
const HArDCore2D::NavierStokesSolutions::IExactSolution *  isolution,
const Eigen::VectorXd &  uph,
const Eigen::VectorXd &  upI,
const double &  viscosity,
const double &  current_time,
const ComputeErrorsParameters &  parameters = {} 
)

Compute errors between the discrete solution and the interpolate of the continuous one using norms and seminorms appearing in the definition of the energy norm

◆ compute_energy_errors() [2/2]

std::map< std::string, double > HArDCore2D::DSL::compute_energy_errors ( const HYPRE *  scheme,
const HArDCore2D::NavierStokesSolutions::IExactSolution *  isolution,
const Eigen::VectorXd &  uph_half,
const Eigen::VectorXd &  upI_half,
const Eigen::VectorXd &  uph,
const Eigen::VectorXd &  upI,
const double &  viscosity,
const double &  current_time,
const double &  time_step,
const ComputeErrorsParameters &  parameters = {} 
)

Compute errors between the discrete solution and the interpolate of the continuous one using norms and seminorms appearing in the definition of the energy norm This version is geared towards a Crank-Nicolson time stepping: it takes the approximate and exact solutions at two time steps, to compute the L2 norm at integer time steps and the viscosity/advection norms at half-time steps.

Compute errors between the discrete solution and the interpolate of the continuous one using norms and seminorms appearing in the definition of the energy norm

Parameters
uphapproximate solution at time t^{n+1/2}
upIinterpolate of exact solution at time t^{n+1/2}
brhapproximate solution at time t^{n+1}
brIinterpolate of exact solution at time t^{n+1}

◆ compute_errors() [1/2]

std::map< std::string, double > HArDCore2D::DSL::compute_errors ( const HYPRE *  scheme,
const HArDCore2D::NavierStokesSolutions::IExactSolution *  isolution,
const Eigen::VectorXd &  uh,
const Eigen::VectorXd &  ph,
const ComputeErrorsParameters &  parameters = {} 
)

Compute errors between the discrete solution and the continuous one.

◆ compute_errors() [2/2]

std::map< std::string, double > HArDCore2D::DSL::compute_errors ( const HYPRE *  scheme,
const HArDCore2D::NavierStokesSolutions::IExactSolution *  isolution,
const Eigen::VectorXd &  uh,
const Eigen::VectorXd &  ph,
const Eigen::VectorXd &  bh,
const Eigen::VectorXd &  rh,
const ComputeErrorsParameters &  parameters = {} 
)

Compute errors between the discrete solution and the continuous one.

◆ compute_hho_component_norms()

template<TensorRankE Rank>
std::vector< std::pair< double, double > > HArDCore2D::DSL::compute_hho_component_norms ( const DiscreteSpace &  Vh,
const std::vector< Eigen::VectorXd > &  vh,
bool  use_threads = true 
)

◆ compute_hho_potential_norms()

template<TensorRankE Rank>
std::vector< std::pair< double, double > > HArDCore2D::DSL::compute_hho_potential_norms ( const DiscreteSpace &  Vh,
const std::vector< Eigen::MatrixXd > &  potential,
const std::vector< Eigen::MatrixXd > &  stabilization,
const std::vector< Eigen::VectorXd > &  vh,
bool  use_threads = true 
)

◆ compute_l2_dof_errors() [1/2]

std::map< std::string, double > HArDCore2D::DSL::compute_l2_dof_errors ( const HYPRE *  scheme,
const Eigen::VectorXd &  uph,
const Eigen::VectorXd &  upI,
const ComputeErrorsParameters &  parameters 
)

Compute the errors on DOFs.

◆ compute_l2_dof_errors() [2/2]

std::map< std::string, double > HArDCore2D::DSL::compute_l2_dof_errors ( const HYPRE *  scheme,
const Eigen::VectorXd &  uph,
const Eigen::VectorXd &  upI,
const Eigen::VectorXd &  brh,
const Eigen::VectorXd &  brI,
const ComputeErrorsParameters &  parameters 
)

Compute the errors on DOFs.

◆ compute_l2_dof_norms()

template<typename CellDofsMapType , typename EdgeDofsMapType >
std::vector< double > HArDCore2D::DSL::compute_l2_dof_norms ( const DiscreteSpace &  Vh,
const CellDofsMapType &  cell_dofs_map,
const EdgeDofsMapType &  edge_dofs_map,
const std::vector< Eigen::VectorXd > &  vh,
bool  use_threads = true 
)

Compute L2 component norms for spaces with generic cell and edge DOFs.

◆ hho_interpolate()

template<TensorRankE Rank, typename F >
Eigen::VectorXd HArDCore2D::DSL::hho_interpolate ( const DiscreteSpace &  Vh,
const F &  v,
const InterpolateParameters &  parameters = {} 
)

◆ make_dof()

DiscreteSpaceDescriptor::LocalPolynomialSpaceDescriptor HArDCore2D::DSL::make_dof ( const std::string  name,
size_t  degree 
)
Generated by doxygen 1.9.8