BCFunc.H

Go to the documentation of this file.

#ifdef CH_LANG_CC
/*
*      _______              __
*     / ___/ /  ___  __ _  / /  ___
*    / /__/ _ \/ _ \/  V \/ _ \/ _ \
*    \___/_//_/\___/_/_/_/_.__/\___/
*    Please refer to Copyright.txt, in Chombo's root directory.
*/
#endif

#ifndef _BCFUNC_H_
#define _BCFUNC_H_

#include "IntVect.H"
#include "RealVect.H"
#include "FArrayBox.H"
#include "ProblemDomain.H"
#include "RefCountedPtr.H"
#include "NamespaceHeader.H"


typedef void(*BCFunc)(FArrayBox&           a_state,
                      const Box&           a_valid,
                      const ProblemDomain& a_domain,
                      Real                 a_dx,
                      bool                 a_homogeneous);

class BCFunction
{
public:
  virtual ~BCFunction()
  {
  }

  virtual void operator()(FArrayBox&           a_state,
                          const Box&           a_valid,
                          const ProblemDomain& a_domain,
                          Real                 a_dx,
                          bool                 a_homogeneous) = 0;
};

class BCHolder
{
public:
  BCHolder():m_funcptr(NULL){;}
  BCHolder(BCFunc funcptr):m_funcptr(funcptr){;}
  BCHolder(RefCountedPtr<BCFunction> refptr):m_funcptr(NULL),m_bc(refptr){;}
  void operator()(FArrayBox&           a_state,
                  const Box&           a_valid,
                  const ProblemDomain& a_domain,
                  Real                 a_dx,
                  bool                 a_homogeneous)
  {
    if (m_funcptr != NULL)
    {
      m_funcptr(a_state, a_valid, a_domain, a_dx, a_homogeneous);
    }
    else
    {
      m_bc->operator()(a_state, a_valid, a_domain, a_dx, a_homogeneous);
    }
  }

protected:
  BCFunc m_funcptr;
  RefCountedPtr<BCFunction> m_bc;
};


typedef void(*BCValueFunc)(Real*           a_pos,
                           int*            a_dir,
                           Side::LoHiSide* a_side,
                           Real*           a_value);

class BCValueFunction
{
public:
  virtual ~BCValueFunction()
  {
  }

  virtual void operator()(Real*           a_pos,
                          int*            a_dir,
                          Side::LoHiSide* a_side,
                          Real*           a_value) = 0;
};

class BCValueHolder
{
public:
  BCValueHolder():m_funcptr(NULL){;}
  BCValueHolder(BCValueFunc funcptr):m_funcptr(funcptr){;}
  BCValueHolder(RefCountedPtr<BCValueFunction> refptr):m_funcptr(NULL),m_bc(refptr){;}

  virtual ~BCValueHolder(){;}

  virtual void operator()(Real*           a_pos,
                  int*            a_dir,
                  Side::LoHiSide* a_side,
                  Real*           a_value)
  {
    if (m_funcptr != NULL)
    {
      m_funcptr(a_pos, a_dir, a_side, a_value);
    }
    else
    {
      m_bc->operator()(a_pos, a_dir, a_side, a_value);
    }
  }

protected:
  BCValueFunc m_funcptr;
  RefCountedPtr<BCValueFunction> m_bc;
};

// Class used by ConstDiriNeumBC to define BCs which can be passed anywhere a
// BCFunction/BCHolder is needed
class ConstBCFunction: public BCFunction
{
public:
  ConstBCFunction(const IntVect&  a_loSideType,
                  const RealVect& a_loSideValue,
                  const IntVect&  a_hiSideType,
                  const RealVect& a_hiSideValue);

  ~ConstBCFunction();

  virtual void operator()(FArrayBox&           a_state,
                          const Box&           a_valid,
                          const ProblemDomain& a_domain,
                          Real                 a_dx,
                          bool                 a_homogeneous);

protected:
  IntVect  m_loSideType;
  RealVect m_loSideValue;

  IntVect  m_hiSideType;
  RealVect m_hiSideValue;
};


RefCountedPtr<BCFunction> ConstDiriNeumBC(const IntVect&  a_loSideType,
                                          const RealVect& a_loSideValue,
                                          const IntVect&  a_hiSideType,
                                          const RealVect& a_hiSideValue);


void NeumBC(FArrayBox&      a_state,
            const Box&      a_valid,
            Real            a_dx,
            bool            a_homogeneous,
            const BCValueHolder&   a_value,
            int             a_dir,
            Side::LoHiSide  a_side);


void NeumBC(FArrayBox&      a_state,
            const Box&      a_valid,
            Real            a_dx,
            bool            a_homogeneous,
            BCValueHolder   a_value);


void DiriBC(FArrayBox&      a_state,
            const Box&      a_valid,
            Real            a_dx,
            bool            a_homogeneous,
            BCValueHolder   a_value,
            int             a_dir,
            Side::LoHiSide  a_side,
            int             a_order = 1);


void DiriBC(FArrayBox&      a_state,
            const Box&      a_valid,
            Real            a_dx,
            bool            a_homogeneous,
            BCValueHolder   a_value,
            int             a_order = 1);


void NoSlipVectorBC(FArrayBox&     a_state,
                    const Box&     a_valid,
                    Real           a_dx,
                    int            a_dir,
                    Side::LoHiSide a_side,
                    int            a_order = 2);


void ReflectiveVectorBC(FArrayBox&     a_state,
                        const Box&     a_valid,
                        Real           a_dx,
                        int            a_dir,
                        Side::LoHiSide a_side,
                        int            a_order = 2);

#include "NamespaceFooter.H"
#endif

---