FortranInterfaceIBC.H

Go to the documentation of this file.

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

//
//  FortranInterfaceIBC.H
// ============
//
// PhysIBC-derived class for interfacing with fortran -- IBC fields like 
// initial ice thickness and topography are passed in as fortran arrays, which 
// are then used to set values in the BISICLES code
//

#ifndef _FORTRANTHICKNESSIBC_H_
#define _FORTRANTHICKNESSIBC_H_

#include "IceThicknessIBC.H"
#include "RefCountedPtr.H"
#include "NamespaceHeader.H"

class AmrIce;

enum FIBC_types {FIBC_Dirichlet = 0,
                 FIBC_Neumann,
                 FIBC_iceDivide,
                 FIBC_iceStreamXBC,
                 NUM_FIBC_TYPES};



class FortranInterfaceIBC : public IceThicknessIBC
{

 
public:

  FortranInterfaceIBC();


  virtual ~FortranInterfaceIBC();


  virtual void define(const ProblemDomain& a_domain,
                      const Real&          a_dx);


  static void  setFAB(Real* a_data_ptr,
                      const int* a_dimInfo,
                      const int* boxlo, const int* boxhi, 
                      const Real* a_dew, const Real* a_dns,
                      const IntVect& a_offset,
                      const IntVect& a_nGhost,
                      FArrayBox& a_fab,
                      FArrayBox& a_ccFab,
                      const bool a_nodal,
                      const bool a_verbose = false);


  virtual void  setVelFAB(Real* a_uVelPtr, Real* a_vVelPtr,
                          const int* a_dimInfo,
                          const int* boxlo, const int* boxhi, 
                          const Real* a_dew, const Real* a_dns,
                          const IntVect& a_offset,
                          const IntVect& a_nGhost,
                          FArrayBox& a_uFab,
                          FArrayBox& a_vFab,
                          FArrayBox& a_uccFab,
                          FArrayBox& a_vccFab,
                          const bool a_nodal = false,
                          const bool a_fillData = false);


  virtual void setThickness(Real* a_data_ptr,
                            const int* a_dimInfo,
                            const int* boxlo, const int* boxhi, 
                            const Real* a_dew, const Real* a_dns,
                            const IntVect& a_offset, 
                            const IntVect& a_nGhost = IntVect::Zero, 
                            const bool a_nodal = false);

  virtual void setTopography(Real* a_data_ptr,
                             const int* a_dimInfo,
                             const int* boxlo, const int* boxhi, 
                             const Real* a_dew, const Real* a_dns,
                             const IntVect& a_offset,
                             const IntVect& a_nGhost = IntVect::Zero, 
                             const bool a_nodal = false);


  virtual void setSurface(Real* a_data_ptr,
                          const int* a_dimInfo,
                          const int* boxlo, const int* boxhi, 
                          const Real* a_dew, const Real* a_dns,
                          const IntVect& a_offset,
                          const IntVect& a_nGhost = IntVect::Zero, 
                          const bool a_nodal = false);
  


  virtual void setThicknessClearRegions(const Vector<Box>& a_clearRegions);


  virtual IceThicknessIBC* new_thicknessIBC();




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


  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) ;

  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) ;


  virtual void flattenIceGeometry(const Vector<RefCountedPtr<LevelSigmaCS> > & a_amrGeometry);

  virtual void flattenData(Real* a_data_ptr,
                           const int* a_dimInfo,
                           const int* a_boxlo, const int* a_boxhi,
                           const Real* a_dew, const Real* a_dns,
                           const IntVect& a_offset,
                           const Vector<LevelData<FArrayBox>* >& a_amrData,
                           const Vector<int>& a_vectRefRatio,
                           const Vector<Real>& a_amrDx,
                           int a_srcComp, 
                           int a_destComp,
                           int a_nComp,
                           const IntVect& a_nGhost,
                           const bool a_nodal);
               

  void flattenVelocity(Real* a_uVelPtr, Real* a_vVelPtr,
                       const int* a_dimInfo,
                       const int* a_boxlo, const int* a_boxhi,
                       const Real* a_dew, const Real* a_dns,
                       const IntVect& a_offset,
                       const Vector<LevelData<FArrayBox>* >& a_amrVel,
                       const Vector<int>& a_vectRefRatio,
                       const Vector<Real>& a_amrDx,
                       const IntVect& a_nGhost,
                       const bool a_nodal);
  


  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);


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


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


  virtual RefCountedPtr<CompGridVTOBC> velocitySolveBC();

  void setVerbose(bool a_verbose) {m_verbose = a_verbose;}

  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);
  

  static void setGrids(DisjointBoxLayout& a_grids,
                       const Box& a_gridBox,
                       const ProblemDomain& a_domain,
                       bool a_verbose);

  bool gridsSet() const {return m_gridsSet;}



  virtual void fillTopographyHoles(Real holeVal);

  virtual void checkOK() const;

  // accessor
  const RefCountedPtr<LevelData<FArrayBox> >& inputThicknessPtr() const
  {return  m_inputThicknessLDF;}

protected:

  // ice sheet thickness at domain boundaries
  Real          m_boundaryThickness;

  RealVect m_domainSize;

  bool m_verbose;

  // have bc's been set up?
  bool m_isBCsetUp;

  void setupBCs();

  bool m_extrapBoundary; //extrapolate the boundary geoemtry? or reflect it?

  RefCountedPtr<CompGridVTOBC> m_velBCs;

  DisjointBoxLayout m_grids;
  bool m_gridsSet;

  // ice sheet thickness from glimmer
  FArrayBox m_inputThickness;
  bool m_nodalThickness;

  FArrayBox m_ccInputThickness;
      
  RealVect m_inputThicknessDx;
  IntVect m_thicknessGhost; 
  RefCountedPtr<LevelData<FArrayBox> > m_inputThicknessLDF;

  Vector<Box> m_thicknessClearRegions;

  FArrayBox m_inputTopography;
  // true if m_inputTopography is nodal
  bool m_nodalTopography;

  FArrayBox m_ccInputTopography;

  RealVect m_inputTopographyDx;
  IntVect m_topographyGhost;
  RefCountedPtr<LevelData<FArrayBox> > m_inputTopographyLDF;


  FArrayBox m_inputSurface;
  // true if m_inputSurface is nodal
  bool m_nodalSurface;

  FArrayBox m_ccInputSurface;

  RealVect m_inputSurfaceDx;
  IntVect m_surfaceGhost;
  RefCountedPtr<LevelData<FArrayBox> > m_inputSurfaceLDF;

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

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

#include "NamespaceFooter.H"
#endif