EBData.H

Go to the documentation of this file.

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

//  ANAG, LBNL

#ifndef _EBDATA_H_
#define _EBDATA_H_

template <class T>
int linearSize(const T& inputT);

template <class T>
void linearIn(T& a_outputT, const void* const inBuf);

template <class T>
void linearOut(void* const a_outBuf, const T& inputT);

#include "REAL.H"
#include "EBGraph.H"
#include "IrregNode.H"
#include "BaseIVFAB.H"
#include "BaseIFFAB.H"
#include "RealVect.H"
#include "NamespaceHeader.H"

class BoundaryData
{
public:
  BoundaryData();
  BoundaryData(const Real& bndryArea, const RealVect& normal,
               const RealVect& bndryCentroid, int phase,const VolIndex& index):
    m_bndryArea(bndryArea), m_normal(normal), m_bndryCentroid(bndryCentroid),
    m_bndryPhase(phase), m_volIndex(index){}
  Real     m_bndryArea;
  RealVect m_normal;
  RealVect m_bndryCentroid;
  int      m_bndryPhase;
  VolIndex m_volIndex;
};


class VolData
{
public:
  VolData();
  Real                 m_volFrac;
  RealVect             m_volCentroid;
  BoundaryData         m_averageFace;
  Vector<BoundaryData> m_phaseFaces;
};

//[NOTE: see also SPMD.H. <dbs>]
template < >
int linearSize(const VolData& vdata);
template < >
void linearIn(VolData& a_outputT, const void* const inBuf);
template < >
void linearOut(void* const a_outBuf, const VolData& a_inputT);



std::ostream& operator<< (std::ostream&  a_os,
                          const VolData& a_iv);

class FaceData
{
public:
  Real     m_areaFrac;
  RealVect m_faceCentroid;
};

template < >
int linearSize(const FaceData& vdata);
template < >
void linearIn(FaceData& a_outputT, const void* const inBuf);
template < >
void linearOut(void* const a_outBuf, const FaceData& a_inputT);


class EBDataImplem
{

public:

  EBDataImplem();

  ~EBDataImplem();


  void define(const Box& box, int comps);


  EBDataImplem(const Box& a_box, int a_comps);


  void copy(const Box&      a_regionFrom,
            const Interval& a_Cd,
            const Box&      a_regionto,
            const EBDataImplem&   a_source,
            const Interval& a_Cs);

  void
  defineVoFData(const EBGraph& a_graph, const Box& a_region);

  void
  defineFaceData(const EBGraph& a_graph, const Box& a_region);

  void
  define(const EBGraph&           a_graph,
         const Vector<IrregNode>& a_irregData,
         const Box&               a_validBox);

  void
  coarsenVoFs(const EBDataImplem&   a_fineEBDataImplem,
              const EBGraph&        a_fineGraph,
              const EBGraph&        a_coarGraph,
               const Box&           a_validRegion);

  void
  coarsenFaces(const EBDataImplem& a_fineEBDataImplem,
               const EBGraph&      a_fineGraph,
               const EBGraph&      a_coarGraph,
               const Box&          a_validRegion);
  const Real& volFrac(const VolIndex& a_vof) const;

  const Real& areaFrac(const FaceIndex& a_face1) const;

  const RealVect& centroid(const FaceIndex& facein) const;

  const RealVect& centroid(const VolIndex& a_vof) const;

  const RealVect& bndryCentroid(const VolIndex& a_vof) const;
  const RealVect& bndryCentroid(const VolIndex& a_vof, int face) const;

  const Real& bndryArea(const VolIndex& a_vof) const;
  const Real& bndryArea(const VolIndex& a_vof, int face) const;

  const RealVect& normal(const VolIndex& a_vof) const;
  const RealVect& normal(const VolIndex& a_vof, int face) const;

  //  New set of boundary inquiry functions to support multi-fluid applications

  int facePhase(const VolIndex& a_vof, int face) const ;

  const VolIndex& faceIndex(const VolIndex& a_vof, int face) const ;

  void setFacePhase(const VolIndex& a_vof, int face, int phase);
  void setFaceIndex(const VolIndex& a_vof, int face, const VolIndex& index);

  int numFacePhase(const VolIndex& a_vof) const ;

  void clearMultiBoundaries();
  void setBoundaryPhase(int phase);
  int size(const Box& R, const Interval& comps) const;

  void linearOut(void* buf, const Box& R, const Interval& comps) const;

  void linearIn(void* buf, const Box& R, const Interval& comps);

  static int preAllocatable()
  {
    return 2; // dyanmic allocatable.
  }

  BaseIVFAB<VolData>& getVolData()
  {
    return m_volData;
  }
  const BaseIVFAB<VolData>& getVolData() const
  {
    return m_volData;
  }

  void addFullIrregularVoFs(const IntVectSet& a_vofsToChange,
                            const EBGraph&    a_newGhostGraph,
                            const BaseIVFAB<VolData>&     a_newGhostData,
                            const EBGraph&    a_oldGhostGraph);

  static void setVerbose(bool a_verbose);
  static void setVerboseDebug(bool a_verboseDebug);
private:

  static   bool s_verbose;
  static   bool s_verboseDebug;
  BaseIVFAB<VolData>   m_volData;

  BaseIFFAB<FaceData>  m_faceData[SpaceDim];

  bool m_isFaceDataDefined;

  bool m_isVoFDataDefined;

  void operator=(const EBDataImplem& ebiin)
  {;}

  EBDataImplem(const EBDataImplem& ebiin)
  {;}

  void
  coarsenFaceCentroid(RealVect&                a_centroidCoar,
                      const Vector<RealVect>&  a_centroidsFine,
                      const Vector<Real>&      a_areaFracFine,
                      const Vector<FaceIndex>& a_facesFine,
                      const FaceIndex&         a_faceCoar);
  void
  coarsenAreaFrac(Real& a_areaFracCoar,
                  const Vector<Real>& a_areaFracFine);

  void
  coarsenVolFracAndCentroid(Real&                   a_volFracCoar,
                            RealVect&               a_volCentroidCoar,
                            const Vector<Real>&     a_volFracFine,
                            const Vector<RealVect>& a_volCentroidFine,
                            const Vector<VolIndex>& a_fineVoFs,
                            const VolIndex&         a_coarVoF);

  void
  coarsenBoundaryAreaAndNormal(Real&                    a_bndryAreaCoar,
                               RealVect&                a_normalCoar,
                               const Vector<Real>&      a_bndryAreaFine,
                               const Vector<RealVect>&  a_normalFine);

  RealVect
  fineToCoarseTransform(const RealVect& a_finePoint,
                        const IntVect&  a_coarCell,
                        const IntVect&  a_fineCell);

  void
  coarsenBndryCentroid(RealVect&               a_bndryCentroidCoar,
                       const Vector<RealVect>& a_bndryCentroidFine,
                       const Vector<Real>&     a_bndryAreaFine,
                       const Vector<VolIndex>& a_fineVoFs,
                       const VolIndex&         a_coarVoF);

  void fetch(std::list<const VolData*>& fineVols, const Vector<VolIndex>& vofsFine) const;
};


class EBData
{
public:

  EBData();

  ~EBData();


  void define(const Box& box, int comps);


  EBData(const Box& a_box, int a_comps);


  void copy(const Box&      a_regionFrom,
            const Interval& a_Cd,
            const Box&      a_regionto,
            const EBData&   a_source,
            const Interval& a_Cs);

  void
  defineVoFData(const EBGraph& a_graph, const Box& a_region);

  void
  defineFaceData(const EBGraph& a_graph, const Box& a_region);

  void
  define(const EBGraph&           a_graph,
         const Vector<IrregNode>& a_irregData,
         const Box&               a_validBox);

  void
  coarsenVoFs(const EBData&   a_fineEBData,
              const EBGraph&  a_fineGraph,
              const EBGraph&  a_coarGraph,
              const Box&      a_validRegion);

  void
  coarsenFaces(const EBData&  a_fineEBData,
               const EBGraph& a_fineGraph,
               const EBGraph& a_coarGraph,
               const Box&     a_validRegion);
  const Real& volFrac(const VolIndex& a_vof) const;

  const Real& areaFrac(const FaceIndex& a_face1) const;

  const RealVect& centroid(const FaceIndex& facein) const;

  const RealVect& centroid(const VolIndex& a_vof) const;

  const RealVect& bndryCentroid(const VolIndex& a_vof) const;
  const RealVect& bndryCentroid(const VolIndex& a_vof, int face) const;

  const Real& bndryArea(const VolIndex& a_vof) const;
  const Real& bndryArea(const VolIndex& a_vof, int face) const;

  const RealVect& normal(const VolIndex& a_vof) const;
  const RealVect& normal(const VolIndex& a_vof, int face) const;

  int facePhase(const VolIndex& a_vof, int face) const ;

  const VolIndex& faceIndex(const VolIndex& a_vof, int face) const ;

  void setFacePhase(const VolIndex& a_vof, int face, int phase);

  void setFaceIndex(const VolIndex& a_vof, int face, int index);
  int numFacePhase(const VolIndex& a_vof) const ;

  void clearMultiBoundaries();
  void setBoundaryPhase(int phase);
  EBData(const EBData& a_ebiin);


  bool operator==(const EBData& a_ebiin);

  EBData& operator=(const EBData& a_ebiin);


  int size(const Box& R, const Interval& comps) const;

  void linearOut(void* buf, const Box& R, const Interval& comps) const;

  void linearIn(void* buf, const Box& R, const Interval& comps);

  void addFullIrregularVoFs(const IntVectSet& a_vofsToChange,
                            const EBGraph&    a_newGhostGraph,
                            const BaseIVFAB<VolData>& a_grownData,
                            const EBGraph&    a_oldGhostGraph);

  void
  computeNormalsAndBoundaryAreas(const EBGraph& a_graph,
                                 const Box&     a_validRegion);

  BaseIVFAB<VolData>& getVolData()
  {
    return m_implem->getVolData();
  }

  const BaseIVFAB<VolData>& getVolData() const
  {
    return m_implem->getVolData();
  }

  static int preAllocatable()
  {
    return 2; // dyanmic allocatable.
  }
private:

  RefCountedPtr<EBDataImplem> m_implem;

};

/*******************************/
inline const Real& EBData::volFrac(const VolIndex& a_vof) const
{
  return m_implem->volFrac(a_vof);
}
/*******************************/
inline const Real& EBData::bndryArea(const VolIndex& a_vof, int face) const
{
  return m_implem->bndryArea(a_vof, face);
}
inline const Real& EBData::bndryArea(const VolIndex& a_vof) const
{
  return m_implem->bndryArea(a_vof);
}
/*******************************/
inline const RealVect& EBData::normal(const VolIndex& a_vof, int face) const
{
  return m_implem->normal(a_vof, face);
}
inline const RealVect& EBData::normal(const VolIndex& a_vof) const
{
  return m_implem->normal(a_vof);
}
/*******************************/
inline const RealVect& EBData::centroid(const VolIndex& a_vof) const
{
  return m_implem->centroid(a_vof);
}
/*******************************/
inline const RealVect& EBData::bndryCentroid(const VolIndex& a_vof, int face) const
{
  return m_implem->bndryCentroid(a_vof, face);
}
inline const RealVect& EBData::bndryCentroid(const VolIndex& a_vof) const
{
  return m_implem->bndryCentroid(a_vof);
}
/*******************************/
inline const RealVect& EBData::centroid(const FaceIndex& a_face) const
{
  return m_implem->centroid(a_face);
}
/*******************************/
inline const Real& EBData::areaFrac(const FaceIndex& a_face) const
{
  return m_implem->areaFrac(a_face);
}
/*******************************/

#include "NamespaceFooter.H"
#endif

---