Cubo.h

/***********************************************************************
Cubo: Header file for the Cubo class.
 Copyright (C) 2008 by Giovanni Marelli <sabeiro@virgilio.it>


This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
***********************************************************************/
#ifndef CUBO_H
#define CUBO_H
#include <list>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <stdarg.h>
#include <signal.h>
#include "Matematica.h"
#define MAX_JOINT_VERTEX 16


using namespace std;
class DomDecBasics{
 private:
 public:
  double BoundCond[27][3];
  int cCurr;
  int NeiListCurr[27];
  int NNeiCurr;
  int nNeiCurr;
  int p1Curr;
  int p2Curr;
  int IfLoopCurr;
  int Mod10[3];
  int NCell;
  int NSect[3];
  double Edge[3];
  double InvEdge[3];
  double CutOff;
  double PosCurr[3];
  int NAllocP;
  int NPart;
  int NNeighbour;
  DomDecBasics();
  void SigErr(int Condition,const char * s, ...);
  int PosRet(const double Pos[3]);
  int pNPart();
  int pNCell();
  int pCella(const double Pos[3]);
  void pCella(const double Pos[3],int c[4]);
  int GetCoorNumb(double *Pos);
  int GetCellCoord(int c,int Coord,int *NeiList);
  int GetCellCoord(double *Pos,int *NeiList);
  int GetCellCh(int c,int *NeiList);
  int GetCell(double *Pos,int *NeiList);
  void PrintCell(const int c);
  void PrintCells();
  void PrintList(const int c);
  void PrintLists();
  void CheckList();
  void CheckNei(int p);
  int SetCutOff(double CutOffExt);
};
class DomPart {
 private:
  int *Prev;
  int *Next;
  int NPart;
 public:
  DomPart(int NPart);
  int operator[](int col);
  DomPart& operator++();
};
typedef struct {
  double Pos[3];
  int Next;
  int Prev;
  int Coord;
  int Cell;
  //double Pos[3];
} DOMAIN_PART;
class DomCell{
  friend void operator+(DomCell &Dc);
 public:
  DomCell(){};
  int NPart;
  int First;
  int Last;
  int Curr1;
  int Curr2;
  DomCell& operator=(const DomCell &Dc);
  DomCell& operator+=(const int i);
  DomCell& operator++();
};
class DdLinkedList : public DomDecBasics{
private:
public:
  DdLinkedList(double Edge[3],int NPart,double CutOff);
  void Erase();
  void Clear(){Erase();};
  int SwapPart(int p1,double *Pos1,int p2,double *Pos2);
  void AddPart(const int p,double *Pos);
  void RemPart(const int p,double *Pos);
  void RemPart(const int p);
  void AddPart(const int p,const int c);
  void RemPart(const int p,const int c);
  void MovePart(const int p,double *OldPos,double *NewPos);
  void MovePart(const int p,double *NewPos);
  int PosRet(const double Pos[3]);
  int pNPart(const int c){return Cella[c].NPart;};
  int pNPart(){return NPart;};
  int pCell(const int p){return Pc[p].Cell;};
  int First(const int c){return Cella[c].First;};
  int Next(const int p){return Pc[p].Next;};
  int ItCell(const int c);
  int IfItCell(const int c);
  int IfItCouple(const int c);
  int SetCoorNumb(double *Pos,int p);
  int GetNei(double *Pos,int *NeiList){
    return GetCell(Pos,NeiList);
    // return GetCellCoord(Pos,NeiList);
  }
  void SetCounters(int c);
  void Couple(const int c,int *p1,int *p2);
  void PrintCell(const int c);
  void PrintCells();
  void SetCurr(int p);
  void SetCurrGhost(double *Pos);
  void NextCurr();
  void NextCurrGhost();
  int IfCurr();
  int IfCurrGhost();
  void Dist2Curr(double *DistRel);
  void Dist2CurrGhost(double *DistRel);
  void PrintList(const int c);
  void PrintLists();
  void CheckList();
  void CheckNei(int p);
  void IncrCurr(const int c);
  void IncrCurrList(const int c);
  int FindClosest(int p1);
  DomCell *Cella;
  DOMAIN_PART *Pc;
};
typedef struct{
  list <int> Part;
}DdCell;
class DdArray : DomDecBasics{
private:
  double Edge[3];
  int NSect[3];
  int Mod10[3];
  int NPart;
  int NCell;
  double CutOff;
  list <int>::iterator NCurr;
  list <int>::iterator NCurr2;
public:
  DdArray(double EdgeExt[3],int NPart,double CutOff);
  DdCell *Cella;
  void Erase();
  void Clear(){Erase();};
  void AddPart(int p,double *Pos);
  void RemPart(int p,double *Pos);
  void MovePart(int p,double *OldPos,double *NewPos);
  void SwapPart(int p1,double *Pos1,int p2,double *Pos2);
  void SetCounters(int c);
  int IfItCell(int c);
  void IncrCurr(int c);
  int ItCell(int c);
  int GetNei(double *Pos,int *NeiList){
    return GetCell(Pos,NeiList);
  }
  void Couple(const int c,int *p1,int *p2);
  int IfItCouple(const int c);
  void IncrCurrList(const int c);
  int pNCell(){return NCell;};
  void PrintCell(const int c);
  void PrintCells();
};
typedef struct{
  int NPart;
  int *Part;
}DdFixCell;
class DdFixedSize : DomDecBasics{
private:
  int NPCell;
  int NCurr;
  int NCurr2;
public:
  DdFixedSize(double EdgeExt[3],int NPart,double CutOff);
  DdFixCell *Cella;
  void Erase();
  void Clear(){Erase();};
  void AddPart(int p,double *Pos);
  void RemPart(int p,double *Pos);
  void AddPart(int p,int c);
  void RemPart(int p1,int c);
  void MovePart(int p,double *OldPos,double *NewPos);
  void SwapPart(int p1,double *Pos1,int p2,double *Pos2);
  void SetCounters(int c);
  int IfItCell(int c);
  void IncrCurr(int c);
  int ItCell(int c);
  int GetNei(double *Pos,int *NeiList){
    return GetCell(Pos,NeiList);
  }
  void Couple(const int c,int *p1,int *p2);
  int IfItCouple(const int c);
  void IncrCurrList(const int c);
  void PrintCell(const int c);
  void PrintCells();
};
class DdDoubleLoop : public DomDecBasics{
private:
public:
  DdDoubleLoop(double Edge[3],int NPart,double CutOff);
  void Erase();
  void Clear(){Erase();};
  int SwapPart(int p1,double *Pos1,int p2,double *Pos2);
  void AddPart(const int p,double *Pos);
  void RemPart(const int p,double *Pos);
  void RemPart(const int p);
  void AddPart(const int p,const int c);
  void RemPart(const int p,const int c);
  void MovePart(const int p,double *OldPos,double *NewPos);
  void MovePart(const int p,double *NewPos);
  int PosRet(const double Pos[3]);
  int pNPart(const int c){return Cella[c].NPart;};
  int pNPart(){return NPart;};
  int pCell(const int p){return Pc[p].Cell;};
  int First(const int c){return Cella[c].First;};
  int Next(const int p){return Pc[p].Next;};
  int ItCell(const int c);
  int IfItCell(const int c);
  int SetCoorNumb(double *Pos,int p);
  int GetNei(double *Pos,int *NeiList){
    return GetCell(Pos,NeiList);
    // return GetCellCoord(Pos,NeiList);
  }
  void SetCounters(int c);
  void PrintCell(const int c);
  void PrintCells();
  void SetCurr(int p);
  void NextCurr();
  int IfCurr();
  void Dist2Curr(double *DistRel);
  void PrintList(const int c);
  void PrintLists();
  void CheckList();
  void CheckNei(int p);
  void IncrCurr(const int c);
  void IncrCurrList(const int c);
  DomCell *Cella;
  DOMAIN_PART *Pc;
};
/* typedef struct { */
/*   /// Position */
/*   double Pos[3]; */
/* } PPOS; */
/* typedef struct { */
/*   /// Vertex id */
/*   list <int> v; */
/* } VERTEX; */
typedef struct {
  double Pos[3];
  int v;
  int t[MAX_JOINT_VERTEX];
  int NTria;
} VERTEX;
class NeiVertex{
 private:
  //list <int>::iterator tCurr;
  int tCurr;
  int vCurr;
  VERTEX *Vertex;
  /* /// List of positions */
  /* list <PPOS> vPos; */
  int *vMemPos;
  double Edge[3];
  int NGrid;
  int NVert;
  int NTria;
  int NvPt;
 public:
  NeiVertex(int NTriaExt,int NvPtExt,int NGridExt,double *EdgeExt);
  ~NeiVertex();
  void Add(int v,int t,double *Pos);
  void Add(double *Pos,int t);
  void Rem(int v,int t);
  void CopyVert2To1(VERTEX Vert1,VERTEX Vert2);
  void Swap(int v1,int v2);
  void Reorder();
  void SetCounters(int v);
  void SetCounters();
  int GetVertex(double *Pos);
  int IfItCell(int v);
  void IncrCurr(int v);
  int VertCurr(int v);
  int TriaCurr(int v);
  void PosVertex(int v,double *Pos);
  void Print();
};

#endif //CUBO_H