Domain.h

#ifndef __DOMAIN__
#define __DOMAIN__

#include <BaseCell.h>
#include <BoundPart.h>
#include <Collection.h>
#include <Iterator.h>
#include <Vertex.h>

class TDatabase;

#ifdef __MORTAR__
struct TMortarFaceStruct
       {
         TBaseCell *Cell;
         int LocFaceNumber[2];
       };

typedef struct TMortarFaceStruct TMortarFace;
#endif

class TDomain
{
  protected:
    
    int N_BoundParts;    
    
    TBoundPart **BdParts;

    int N_BoundComps;
    
    int *StartBdCompID;

    int *Interfaces;

    int N_Holes;
    
    double *PointInHole;

    int N_Regions;
    
    double *PointInRegion;

    TBaseCell **CellTree;
    
    int N_RootCells;

    int N_InitVCells;

    double StartX;
    double StartY;
    double BoundX;
    double BoundY;

#ifdef __3D__

      double StartZ;
      int N_InitVCellsY;
      double BoundZ;
#endif

    int RefLevel;

#ifdef __MORTAR__

      int N_MortarFaces;
      TMortarFace *MortarFaces;

      int *BeginMFace;
#endif
    
    friend class TTetGenMeshLoader;

#ifdef  _MPI

      int *GlobalCellIndex;

      int N_OwnCells;
#endif

  public:
    // Constructors
    TDomain();

    TDomain(char *ParamFile);
    
    // Methods
    int ReadGeo(char *GeoFile);

    int GmshGen(char *GeoFile);
    
#ifdef __3D__

    int ReadSandwichGeo(char *GeoFile);

    void MakeBdParamsConsistent(TCollection *coll);
    
    int CloseGrid(int level);
    
    int TetrameshGen(char *GeoFile);
    
#endif

#ifdef __2D__

    void CorrectParametersAndShapes();
    
    void TriMeshGen(struct triangulateio *In);
#endif

    int ReadParam(char *ParamFile);
    int ReadBdParam(char *ParamFile, int &Flag);
    int ReadMapFile(char *MapFile, TDatabase *database);

    int GetBdPartID(int BdCompID);
    int GetLocalBdCompID(int BdCompID);
    int GetLastLocalComp(int BdPartID)
    { return StartBdCompID[BdPartID+1] - StartBdCompID[BdPartID] - 1; }
    void SetStartBdCompID(int BdCompID, int i)
    { StartBdCompID[i] = BdCompID; }

    TBoundPart* GetBdPart(int i)
    { return BdParts[i]; }

    void GetTreeInfo(TBaseCell **&celltree, int &N_rootcells)
    { 
      celltree = CellTree;
      N_rootcells = N_RootCells;
    }

    void SetTreeInfo(TBaseCell **celltree, int N_rootcells)
    {
      CellTree = celltree;
      N_RootCells = N_rootcells;

      #ifdef  _MPI
      N_OwnCells = 0;
      #endif 
    }

    #ifdef __MORTAR__

      int SetSubGridIDs(IntFunct2D *TestFunc);
      int GenMortarStructs();
      int GetN_MortarFace()
      { return N_MortarFaces; }
      TMortarFace *GetMortarFace(int i)
      { return &(MortarFaces[i]); }

      TCollection *GetMortarColl(Iterators it, int level);

      int InitMortarJoints(Iterators it, int level, TCollection *coll);
    #endif

    int GenInitGrid();
    #ifdef __2D__

      int MakeGrid(double *DCORVG, int *KVERT, int *KNPR, int N_Vertices,
                   int NVE);
      int MakeGrid(double *DCORVG, int *KVERT, int *KNPR, int *ELEMSREF,
                   int N_Vertices, int NVE);
    #else

      int MakeGrid(double *DCORVG, int *KVERT, int *KNPR, int *ELEMSREF,
                   int N_Vertices, int NVE, int *BoundFaces, int *FaceParam,
                   int NBF, int NVpF,
                   int *Interfaceparam, int N_Interfaces);
      int MakeSandwichGrid(double *DCORVG, int *KVERT, int *KNPR,
                           int N_Vertices, int NVE,
                           double DriftX, double DriftY, double DriftZ,
                           int N_Layers, double *Lambda);
    #endif

    void Init(char *PRM, char *GEO);

    int Draw(char *name, Iterators iterator, int arg);
    int PS(const char *name, Iterators iterator, int arg);
    int PS(const char *name, TCollection *Coll);
    int MD_raw(const char *name, Iterators iterator, int arg);

    int Refine();
    int RegRefineAll();
    int RegRefineSub(int ID);
    int RefineallxDirection();
    int Gen1RegGrid();
    int RefineByIndicator(DoubleFunct2D *Indicator);
    int MakeConfClosure();

    int RefineByErrorEstimator(TCollection *Collection,double *eta_K,
                               double eta_max,double tolerance,
                               bool ConfClosure);

    void Refine1Reg(int MinLevel, int MaxLevel);

    void DeRefine();

    int ConvertQuadToTri(int type);

    TCollection *GetCollection(Iterators it, int level);
    
    TCollection *GetCollection(TCollection *coll, int reference);

#ifdef  _MPI 

    TCollection *GetOwnCollection(Iterators it, int level, int ID);
#endif

    void GetSortedCollection(TCollection* &Coll, int* &Indices);

    void GetBoundBox(double &startx, double &starty,
                     double &boundx, double &boundy)
    {
      startx = StartX;
      starty = StartY;
      boundx = BoundX;
      boundy = BoundY;
    }
    
#ifdef __3D__

    void GetBoundBox(double &startx, double &starty, double &startz,
                     double &boundx, double &boundy, double &boundz)
    {
      startx = StartX;
      starty = StartY;
      startz = StartZ;
      boundx = BoundX;
      boundy = BoundY;
      boundz = BoundZ;
    }
    
    void SetBoundBox(double startx, double starty, double startz,
                     double boundx, double boundy, double boundz)
    {
      StartX = startx;
      StartY = starty;
      StartZ = startz;
      BoundX = boundx;
      BoundY = boundy;
      BoundZ = boundz;
    }
#endif
    
    // test
    #ifndef __3D__
      void TestGrid1();
      void TestGrid2();
      void TestGrid3();
      void TestMortar();
      void TestShishkin();
      void TriangleShishkin();
      void UnitSquare();
      void UnitSquareRef();
      void TwoTriangles();
      void TwoTrianglesRef();
      void SquareInSquare();
      void SquareInSquareRef();
      void SetBoundBox(double boundx, double boundy);
      void SetBoundBoxstart(double startx , double starty);
      void RefOnMortarEdge();
      void RefCardioide(double A);
      void PeriodicSquares();
      void PeriodicSquaresLarge();
      void PeriodicRectangle_2_4();
      void PeriodicTrianglesLarge();
      void QuadShishkin(double tau1, double tau2);
      void Rectangular(int dimx, int dimy);
      void TestTriaConf();
      void TestTriaConf2();
      void CheckCells();

    #else
      void TestGrid3D();
      void SetBoundBox(double boundx, double boundy, double boundz);
    #endif

    #ifdef __3D__
      int Grape(const char *name, TCollection *coll);

    #endif

    void TetrameshGen();


    #ifdef  _MPI
      void ReplaceTreeInfo(int n_cells, TBaseCell **cells, int *GLOB_cellIndex, int n_OwnCells)
       {
        if(CellTree) delete CellTree;
        N_RootCells = n_cells;
        CellTree = cells;
        GlobalCellIndex = GLOB_cellIndex;
        N_OwnCells = n_OwnCells;
       }

      void SetN_OwnCells(int n_OwnCells)
       { N_OwnCells = n_OwnCells; }

      int GetN_OwnCells()
       { return N_OwnCells; }

      int GetN_HaloCells()
       { return (N_RootCells - N_OwnCells); }
     #endif
    
#ifdef __3D__
  public: 

//      int Tetgen(const char*);

     int GenerateEdgeInfo();

#endif

  int AdaptRefineAll();    
     
};

#endif