IceThicknessIBC.H

Go to the documentation of this file.

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

//
//  IceThicknessIBC.H
// ============
//
// Virtual base class through which a user specifies the initial and boundary
// conditions for a hyperbolic system of PDEs.
//

#ifndef _ICETHICKNESSIBC_H_
#define _ICETHICKNESSIBC_H_

#include "PhysIBC.H"
#include "LevelSigmaCS.H"
#include "PetscCompGridVTO.H"
#include "BCFunc.H"

#include "NamespaceHeader.H"


class IceBCFuncWrapper: public CompGridVTOBC
{
public:
  IceBCFuncWrapper():m_funcptr(NULL) 
  {
  }

  IceBCFuncWrapper(BCFunc funcptr):m_funcptr(funcptr)
  {
  }

  virtual ~IceBCFuncWrapper() 
  {
  }

  virtual void operator()(FArrayBox&           a_state,
                          const Box&           a_valid,
                          const ProblemDomain& a_domain,
                          Real                 a_dx,
                          bool                 a_homogeneous)
  {
    CH_assert(m_funcptr != NULL);
    m_funcptr(a_state, a_valid, a_domain, a_dx, a_homogeneous);
  }
    
  //explictly allow copy and assignment operators
  IceBCFuncWrapper(const IceBCFuncWrapper& src):m_funcptr(src.m_funcptr)
  {
  }

  virtual IceBCFuncWrapper& operator=(const IceBCFuncWrapper& src)
  {
    m_funcptr = src.m_funcptr;
    return *this;
  }

  protected:
  BCFunc m_funcptr;

};






class IceThicknessIBC : public PhysIBC
{
public:

  IceThicknessIBC() {}


  virtual ~IceThicknessIBC() {}


  virtual void define(const ProblemDomain& a_domain,
                      const Real&          a_dx)
  {PhysIBC::define(a_domain, a_dx);}


  virtual PhysIBC* new_physIBC() 
  {return static_cast<PhysIBC*>(new_thicknessIBC());}

  virtual IceThicknessIBC* new_thicknessIBC() = 0;
 


  virtual void initialize(LevelData<FArrayBox>& a_U) = 0;

  virtual void initializeIceGeometry(LevelSigmaCS& a_coords,
                                     const RealVect& a_dx,
                                     const RealVect& a_domainSize,
                                     const Real& a_time, 
                                     const LevelSigmaCS* a_crseCoords,
                                     const int a_refRatio) = 0;
  

  /*  Default is to do nothing, and return false, 
      in which case the topography probably needs 
      to be interpolated by the user. 
  */
  virtual bool regridIceGeometry(LevelSigmaCS& a_coords,
                                 const RealVect& a_dx,
                                 const RealVect& a_domainSize,
                                 const Real& a_time,
                                 const LevelSigmaCS* a_crseCoords,
                                 const int a_refRatio) 
  {
    return false;
  }

  virtual void primBC(FArrayBox&            a_WGdnv,
                      const FArrayBox&      a_Wextrap,
                      const FArrayBox&      a_W,
                      const int&            a_dir,
                      const Side::LoHiSide& a_side,
                      const Real&           a_time) = 0;


  virtual
  void setBdrySlopes(FArrayBox&       a_dW,
                     const FArrayBox& a_W,
                     const int&       a_dir,
                     const Real&      a_time) = 0;


  virtual
  void artViscBC(FArrayBox&       a_F,
                 const FArrayBox& a_U,
                 const FArrayBox& a_divVel,
                 const int&       a_dir,
                 const Real&      a_time) = 0;


  virtual RefCountedPtr<CompGridVTOBC> velocitySolveBC() = 0;



  virtual void velocityGhostBC(LevelData<FArrayBox>& a_velocity,
                               const LevelSigmaCS& a_coords,
                               const ProblemDomain& a_domain,
                               Real a_time)
  {
    RefCountedPtr<CompGridVTOBC> velBC = velocitySolveBC();
    const RealVect& dx = a_coords.dx();
    for (DataIterator dit=a_velocity.dataIterator(); dit.ok(); ++dit)
      (*velBC)(a_velocity[dit],a_velocity.getBoxes()[dit],
               a_domain, dx[0], dit(), false);
  }

      
  

  virtual void modifyVelocityRHS(LevelData<FArrayBox>& a_rhs,
                                 LevelSigmaCS& a_coords,
                                 const ProblemDomain& a_domain,
                                 Real a_time, Real a_dt) {;}


  virtual void modifyFaceVelocity(LevelData<FluxBox>& a_faceVel,
                                  const LevelSigmaCS& a_coords,
                                  const ProblemDomain& a_domain) const 
  {;}




  virtual void setSurfaceHeightBCs(LevelData<FArrayBox>& a_zSurface,
                                   LevelSigmaCS& a_coords,
                                   const ProblemDomain& a_domain,
                                   const RealVect& a_dx,
                                   Real a_time, Real a_dt) {;}

  

  virtual void setGeometryBCs(LevelSigmaCS& a_coords,
                              const ProblemDomain& a_domain,
                              const RealVect& a_dx,
                              Real a_time, Real a_dt) {;}


  virtual void setIceFractionBCs(LevelData<FArrayBox>& a_iceFrac,
                                 const ProblemDomain& a_domain,
                                 const RealVect& a_dx,
                                 Real a_time, Real a_dt){;}
  

  virtual void setGridHierarchy(Vector<RefCountedPtr<LevelSigmaCS > >& a_vectCS,
                                Vector<ProblemDomain>& a_vectDomain) {;}


  // this is just here to so that FortranInterfaceIBC can re-implement it
  // and I can pester it on a frequent basis to work out who is 
  // corrupting its memory
  virtual void checkOK() const {;}

protected:

  

private:
  // Disallowed for all the usual reasons
  void operator=(const IceThicknessIBC& a_input)
  {
    MayDay::Error("invalid operator");
  }

  // Disallowed for all the usual reasons
  IceThicknessIBC(const IceThicknessIBC& a_input)
  {
    MayDay::Error("invalid operator");
  }
};



class  IceVelBCFunction : public CompGridVTOBC
{
public:
  IceVelBCFunction() {;}  

  IceVelBCFunction(Vector<RefCountedPtr<LevelSigmaCS > >& a_vectCS,
                   Vector<ProblemDomain>& a_vectDomain) {;}

  
  ~IceVelBCFunction() {;}

  virtual void define(Vector<RefCountedPtr<LevelSigmaCS> >& a_vectCS,
                      Vector<ProblemDomain>& a_vectDomain) =0;

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


protected:
  Vector<RefCountedPtr<LevelSigmaCS > > m_vectCS;

  Vector<ProblemDomain>                       m_vectDomain;


};


#include "NamespaceFooter.H"
#endif