prom_node.hh

//  $Id: prom_node.hh,v 1.7 2004/05/11 23:46:56 adams Exp $
//  Author:             Mark F. Adams
// Copyright (c) 2000 by Mark F. Adams 
//  Filename:           prom_node.hh
//
#ifndef __PROM_NODE_H__
#define __PROM_NODE_H__

#include "prom_obj.hh"
#include "prom_list.hh"
#include "prom_tabl.hh"
#include "prom_options.hh"
#include "prom_perf.hh"

typedef enum promMG{PROM_GEOMG=0,PROM_AGGMG,PROM_NUMMGTYPES}PromMGType;

/**** PETSc *******/
#if defined(PROM_USE_PETSC)
#include "prom_petsc.hh"
/**** Petra ****/
#elif defined(PROM_USE_PETRA)
#include "prom_petra.hh"
#else
#error ERROR pick one!
#endif

struct bitsTAG {
  unsigned int  state      : 2; // state of deletion in coarsening
  unsigned int  topo       : 2; // CORNER...
  unsigned int  type       : 2; // BRICK...
  unsigned int  color      : 9; // 255 color max, par.shpsz; SetnChildInSel
  unsigned int  exterior   : 1;
  unsigned int  dead       : 1;
  unsigned int  qual       : 1; 
  unsigned int  dof0       : 1; // dof fixity (15)
  unsigned int  dof1       : 1;
  unsigned int  dof2       : 1;
  unsigned int  dof3       : 1;
  unsigned int  dof4       : 1;
  unsigned int  dof5       : 1;
  unsigned int  dof6       : 1;
  unsigned int  dof7       : 1;
  unsigned int  dof8       : 1;
  unsigned int  dof9       : 1;
  unsigned int  dof10      : 1;
  unsigned int  dof11      : 1;
  unsigned int  dof12      : 1;
  unsigned int  dof13      : 1;

  unsigned int  dof14      : 1;
  unsigned int  isenv      : 1; // temp helper flag bitv
  unsigned int  done       : 1; // temp helper flag bitv
  unsigned int  mat_topo   : 1;
  unsigned int  malloced   : 1; 
  unsigned int  pointer    : 1;  
  unsigned int  shp_sz     : 14; // elem.nnodes
  unsigned int  aux        : 8;  // SetMinAdjInSel
  unsigned int  ndf        : 4;
};

#define PROM_MAXSTATE 3
#define PROM_MAX_COLOR 511
#define PROM_MAX_AUX_SZ 255
#define PROM_MAX_SHP_SZ 16385
#define PROM_MAXNDF 8 // this could be 15! 


class PromElement
{
  friend class PromNode;
public:  
  PromElement();
  void reset();
  PromElement &operator=( const PromElement& a );
  virtual ~PromElement(){};
  virtual int Archive(FILE *file=stderr,const PromArchiveType type=PROM_PRINT);
  int Write( int **buff ) const;
  int Read( int **buff );
  static int GetWrite_size(int &sz){
    sz = sizeof(struct bitsTAG)/sizeof(int);
    return 0;
  }
  // data acces and querry functions
  void mark( bool b = TRUE ){ assert(this!=NULL); bits_.done = (b)?1:0;}  
  bool isMarked() const{ assert(this!=NULL);  return (bool)bits_.done; }
  
  bool isEnvelope() const{ assert(this!=NULL); return bits_.isenv; }
  void setEnvelope( bool b = TRUE ) { assert(this!=NULL);  bits_.isenv = (b)?1:0; }

  PromNodeState getState() const{ 
    assert(this!=NULL);    return (PromNodeState)bits_.state;
  }
  PromNodeState getState(int &ierr)const{
    ierr = (this==NULL); return (PromNodeState)bits_.state;
  }
  void setState(PromNodeState s){
    assert(this!=NULL); assert(s<=PROM_MAXSTATE); 
    bits_.state = s;
  }
  PromNodeTopo  getTopoType() const {
    assert(this!=NULL); return (PromNodeTopo)bits_.topo;
  }
  void setTopoType( PromNodeTopo s ){
    assert(this!=NULL && s>=0 && s<=PROM_NUMTOPO); 
    bits_.topo = (unsigned int)s; 
  }
  int getNDF() const{ 
    assert(this!=NULL);  return (int)bits_.ndf;
  }
  int SetNDF(int s){
    assert(this!=NULL); 
    if(s<0 || s>PROM_MAXNDF) SETERRQ1(1,"ndf=%d",s);
    bits_.ndf = (unsigned int)s; 
    return 0;
  }
  PromElemType  getType() const{ 
    assert(this!=NULL);  return (PromElemType)bits_.type;
  }
  void setType(PromElemType s){
    assert(this!=NULL); assert(s<=PROM_NUMELEMTYPES); 
    bits_.type = (unsigned int)s; 
  }
  
  bool isExterior() const { assert(this!=NULL);  return bits_.exterior; }
  void setExterior(int i=TRUE){assert(this!=NULL);bits_.exterior = i?1:0;}

  void kill( const bool d = TRUE ){ assert(this!=NULL); bits_.dead = d; }
  bool isDead() const{ 
    if(this==NULL){
      PetscTraceBackErrorHandler(1,"44","55","66",2,3,"77",(void*)"8");
      return 0; 
    }
    return (bool)bits_.dead; 
  }    
  bool setFixed ( int tp, bool f = TRUE );
  inline void setAllFixed( const int ndf );
  bool isFixed ( const int ndf, int type = -9 ) const;
  inline bool isAllFixed( const int ndf ) const;
public:
  void setMaterialTopo(int tp=1){assert(this!=NULL);bits_.mat_topo = tp ? 1:0;}
  bool isMaterialTopo() const{   assert(this!=NULL); return bits_.mat_topo; }
  int  color()const{ assert(this!=NULL); return (int)bits_.color; }
  void setColor(unsigned int i){ 
    assert(this!=NULL); bits_.color = i; assert(i<=PROM_MAX_COLOR); 
  }
protected:
  struct bitsTAG bits_; 
};

class PromFacet;

#define PROM_NODE_MAXFACET 6
 

class PromParent : public PromElement, public PromStack
{ 
  friend class PromParentBank;
public:
  PromParent() : procID_(-9), gIndex_(-9), geq_(-9), DAP_(NULL), P0_(NULL){}
  //PromParent( const PromParent &a );
  virtual ~PromParent();
  //bool     isShpPointer()const{assert(this!=NULL);return(bits_.pointer);}
  //void     setShpPointer( int i = TRUE ){
  //assert(this!=NULL); bits_.pointer = (i==TRUE) ? TRUE : FALSE; 
  //}
  PromParent &operator=( const PromParent &a );
  int      Copy( const PromNode * const, const int mype );
  int      Write( int **ppb )const;
  int      Read( int **ppb );
  int      GetWrite_size( int &sz ) const;
  // stored id[ gloabal index, addrsp index index]; sp[0,addrsp]
  int      proc(int &ierr)const{ierr = !(this&&procID_ >= 0); return procID_;} 
  int      proc()const{ assert(this!=NULL&&procID_ >= 0); return procID_;} 
  int      global(int &ierr)const{ierr = !(this && gIndex_>=0);return gIndex_;}
  int      global()const{ assert(this!=NULL && gIndex_ >= 0);return gIndex_;}
  int geq()const{ assert(this!=NULL && geq_ >= 0);return geq_;}
  int geq(int &ierr)const{assert(this!=NULL);ierr=(geq_<0);return geq_;}
  void     setProc(int f){ assert(this!=NULL); procID_ = f; }
  void     setGlobal( int g ){ assert(this!=NULL); gIndex_ = g; }
  void     setGEQ( int g ){ assert(this!=NULL && g>=0); geq_ = g; }
  int      isIerr()const{return !( gIndex_ >= 0 && procID_ >= 0 );}
  int      Archive(FILE *file = stderr, const PromArchiveType type=PROM_PRINT);
  // shp and P are synonymous -- shape' is used for GMG and P for AMG
  int      getPsz()const { assert(this!=NULL); return (int)bits_.shp_sz; }
  int      SetPsz( int i );
  int      SetPsz_hard( int i ){
    bits_.shp_sz = i;  assert(this!=NULL); assert(i>=0 && i<=PROM_MAX_SHP_SZ);
    bits_.pointer = (i>0) ? 1 : 0;
    if ( bits_.shp_sz == 1 ) shape_ = 0.0;
    return 0;
  }
  void setMalloced( bool b = TRUE ){ bits_.malloced = (b ? 1: 0); }
  int SetP( const int i, shpfloat *sh ){
    assert(this!=NULL); assert(i>=0 && i<=PROM_MAX_SHP_SZ);
    P0_ = sh; bits_.shp_sz = i; 
    bits_.pointer = 1;
    return 0;
  }
  // geo version of 'setScalarP' and 'getScalarP'
  int setScalarP0( shpfloat val );  // geo mg
  shpfloat getScalarP0() const {    // 
    assert(this!=NULL); assert(bits_.shp_sz == 1); 
    return (bits_.pointer!=0) ? ((P0_!=NULL) ? P0_[0] : 0.0) : shape_;
  }
  // data
  shpfloat  *DAP_;   // amg only
  union{             // shape (R_ij)
    shpfloat *P0_;   // amg
    shpfloat shape_; // geo or scalar amg
  };
private:   
  int        geq_;
  int        gIndex_;
  int        procID_; 
};
 

class PromParentBank
{  
  friend class Prometheus;
public:
  PromParentBank() : parBlocks_(NULL), freePar_(NULL), currPar_(NULL), 
    numParFree_(0) {}
  ~PromParentBank(){ ClearCache(); }
  // PromParentBank
public:    
  int         ClearCache();
  int         Deallocate( PromParent *par );
  int         GetFreePar( PromParent** );  
private:
  // data
  PromList<PromParent*> *parBlocks_;
  PromParent         *currPar_;
  PromParent         *freePar_;
  int                 numParFree_;
}; // PromParentBank


class PromParentArr
{
public:    
  PromParentArr( PromParentBank * const bank, const int n );
  virtual ~PromParentArr();

  int  GetWrite_size( int &sz ) const;
  int  Write( int **ppb )const;
  int  Read( int **ppb ); 
  int  SetSize( PromParentBank * const bank, int n );
  int  getSize() const { return np_; }
  // data
  PromParent **data_;
protected:
  int           np_;
};


class PromParentArr_extra : public PromParentArr
{
public:     
  PromParentArr_extra( PromParentBank *const bank, int n, int gid, int geq,
                       int ndf, bool isalfx ):
    PromParentArr(bank,n), gid_(gid), geq_(geq)
    {
      bits_.done = 0; bits_.isfixed = isalfx;  bits_.ndf = ndf; 
    }  
  void mark( bool b = TRUE ){ assert(this!=NULL); bits_.done = (b) ? 1 : 0; }
  bool isMarked() const{ assert(this!=NULL);  return (bool)bits_.done; }
  int SetGID( int id ){ 
    assert(this!=NULL);
    if(id<0 || id>=1073741824)SETERRQ1(1,"gid %d out of bounds",id); 
    gid_ = id;
    return 0;
  }
  int getGID() const{ assert(this!=NULL); return gid_; } 
  int getGEq() const{ assert(this!=NULL); return geq_; } 
  bool isFixed()const{ assert(this!=NULL); return bits_.isfixed; }
  void setFixed( bool b = TRUE ){assert(this!=NULL); bits_.isfixed = (b)?1:0;}
  int getNDF()const{ assert(this!=NULL); return bits_.ndf; }
private:
  struct {
    unsigned int done    : 1;
    unsigned int isfixed : 1;
    unsigned int ndf     : 30;
  }bits_;
  int gid_;
  int geq_;
};


class PromPoly;
class PromDTet;
class PromSymbData {
public:
  PromSymbData();
  virtual ~PromSymbData();
  // data
  PromList<PromPoly*>  elemList;  // elements list used for GEO mostly
  PromTable<PromNode*> adjac;     // adjacentcy list
  PromNode        *child;     // node in last grid
  PromList<PromGlobalID*> *dependents;// <DEP>, only used for boundary nodes
  PromNode        *parent;    // node in next grid
  PromGlobalID     ghostID;   // ghost nodes real index on other proc
};


class PromNodeBase : public PromElement
{
public:
  virtual ~PromNodeBase(){}
  PromNodeBase() : geq_(-9) { }
  PromNodeBase &operator=( const PromNodeBase &a );

  int  geq()const{ assert(this!=NULL && geq_ >= 0);return geq_;}
  int  geq(int &ierr)const{assert(this!=NULL);ierr=(geq_<0);return geq_;}
  void     setGEQ( int g ){ assert(this!=NULL && g>=0); geq_ = g; } 
  // data 
  PromLocalID    index_;     // could derive this
protected:
  int geq_;
};


class PromCR 
{
 public:
  PromCR( int nnodes );
  PromCR( int **ppb );
  ~PromCR();
  int        Write( int **ppb ) const;
  int        Read( int **ppb );
  int        GetWrite_size( int &sz ) const;
  void       mark(bool b=TRUE){assert(this!=NULL); bits_.flag = (b==TRUE) ? 1 : 0;}
  bool       isMarked(){return (bits_.flag == 1);}
  void       setEq(int eq){assert(this && eq >= 0); bits_.eq = eq;}
  int        eq()const{assert(this!=NULL); return bits_.eq;}
  //void       setLen(int len){assert(this && len>=0); bits_.len = len;}
  int        len()const{assert(this!=NULL); return bits_.len;}
  // 
  int *gnodes_;
  double *vals_;
private:
  struct{
    unsigned int eq   : 32; 
    unsigned int len  : 31; 
    unsigned int flag : 1;
  }bits_;
};

class PromBank;
class PromMPINode;

class PromNode : public PromNodeBase, public PromStack
{
public:
  PromNode() : parents_(NULL), symbData_(NULL) {}
  virtual           ~PromNode();
  // copy methods
  virtual int        LiftCopy( const PromNode * const a );
  virtual int        Copy( const PromMPINode &a );
  virtual int        Write( int **ppb ) const = 0;
  virtual int        Read( PromParentBank * const bank, int **ppb ) = 0;
  virtual int        GetWrite_size(int &sz) const = 0;
  virtual int        Die( PromBank *bank )=0;
  virtual int        LiftCopyIn( PromMPINode *mpinode ) const ;
  virtual int        getNextNDF() const = 0;
  virtual void       reset();
  virtual int Archive(FILE *file=stderr,const PromArchiveType type=PROM_PRINT);

  int nParents()const 
  { 
    assert(this!=NULL); 
    return (parents_ != NULL) ? parents_->getSize() : 0;
  }
  int       SetnParents( PromParentBank * const bank, const int i );
  // general (parallel) methods
  PromNode* getParent() const;
  bool      isBound()const{
    assert( this != NULL && symbData_ != NULL );
    return (symbData_->dependents && symbData_->ghostID.lIndex_<0); }
  bool      isExtended() const { 
    assert( this != NULL && symbData_ != NULL );
    return (symbData_->dependents ? TRUE : FALSE);
  }
  bool      isGhost() const {
    assert(this != NULL && symbData_ != NULL);
    return (symbData_->ghostID.lIndex_ >= 0);
  }   
  bool isFixed()const{ return PromElement::isFixed(bits_.ndf); }
  bool isFixed( int type )const{ return PromElement::isFixed(bits_.ndf,type);}
  inline bool isEqualFixed( const PromNode *node ) const;
  inline bool isMoreFixed( const PromNode *node ) const;
  bool isAllFixed()const{ return PromElement::isAllFixed(bits_.ndf); } 
  // AMG helpers
  int minAdjInSel()const{
    assert(getState() == PROM_SELECTED); assert(this!=NULL);
    return (int)bits_.aux;
  }
  int       SetMinAdjInSel( unsigned int i ){ 
    assert(this!=NULL); 
    if(i>PROM_MAX_AUX_SZ){
      //PetscPrintf(PETSC_COMM_SELF,"WARNING: SetMinAdjInSel:i(%d) > %d ",i,PROM_MAX_AUX_SZ);
      i = PROM_MAX_AUX_SZ;
    }
    bits_.aux = i; 
    return 0;
  }
  int       nChildInSel()const{ 
    assert(this!=NULL); 
    return (int)bits_.color;
  }
  int       SetnChildInSel( unsigned int i ){ 
    assert(this!=NULL); 
    if(i>PROM_MAX_SHP_SZ){
      PetscPrintf(PETSC_COMM_SELF,"WARNING: SetnChildInSel:i(%d) > %d ",
                  i,PROM_MAX_COLOR);
      i = PROM_MAX_COLOR;
    }
    bits_.color = i; 
    return 0; 
  }
  bool skipSmooth()const { return bits_.qual; }
  int SetSkipSmooth( bool b = TRUE ){ bits_.qual = b; return 0; }
  // data
  PromParentArr *parents_; 
  PromSymbData  *symbData_;   // symbolic data
};


class PromAggNode : public PromNode
{
 friend int isAMGDeleteable( const PromNode *curr, const PromNode *n1, 
                              bool &deletable );
public:
  PromAggNode();
  virtual ~PromAggNode();

  // copy methods
  virtual void reset();
  virtual int  LiftCopy( const PromNode * const a );
  virtual int  LiftCopyIn( PromMPINode *mpinode ) const ;
  virtual int  getNextNDF() const;
  virtual int  Write( int **ppb )const;
  virtual int  Read( PromParentBank * const bank, int **ppb );
  virtual int  GetWrite_size( int &sz ) const;
  virtual int  Die( PromBank *bank );
  virtual int  Archive( FILE *file = stderr, 
                        const PromArchiveType type = PROM_PRINT );
  int MigrateToAgg( const unsigned int hard, const int kk,
                    const int * const ewgts,
                    PromTable<PromList<PromNode*>*> &proc_list, 
                    bool &didit, PromNode *nodes[], 
                    const PromTable<PromNode*> &ghosts, 
                    const int my0, const int nloc, PromTable<int> &node_wt,
                    PromTable<int> &table,
                    const int nchildInSel = 1000 );
  int MigrateTo( PromNode *c2, PromTable<PromList<PromNode*>*> &proc_list,
                 PromTable<int> &table );
  int       getBsz()const{ assert(this!=NULL); return Bsz_; }
  int       SetBsz(int ss);
  // data
  shpfloat  *B_; // amg
private:
  int        Bsz_;
};


class PromSymbGeoData { 
public: 
  PromSymbGeoData() :
    parElem(NULL),
    coord(0.,0.,0.)
  {
    for(int i=0;i<PROM_NODE_MAXFACET;i++) faceID[i] = -9;
  }
  PromCoord   coord;     // coordinate
  PromDTet   *parElem;   // elem in next grid (GEO)
  int         faceID[PROM_NODE_MAXFACET]; // symb
};


class PromGeoNode : public PromNode
{
  friend int IsGeoDeleteable( const PromNode * const curr, 
                              const PromNode * const n1, 
                              bool &deletable ); 
public:
  PromGeoNode();
  virtual ~PromGeoNode();
  // copy methods
  virtual void reset();
  virtual int LiftCopy( const PromNode * const a );
  virtual int Copy( const PromMPINode &a );
  virtual int LiftCopyIn( PromMPINode *mpinode ) const ;
  virtual int getNextNDF() const{ return getNDF();} 
  virtual int Write( int **ppb )const;
  virtual int Read( PromParentBank * const bank, int **ppb );
  virtual int GetWrite_size( int &sz ) const;
  virtual int Die( PromBank *bank );
  virtual int Archive(FILE *file=stderr,const PromArchiveType type=PROM_PRINT);
  // GEO MG mrthods
  PromDTet *setElemWithList( const PromList<PromPoly*> *eList, 
                             PromParentBank * const bank, const int mype, 
                             int numtries, gfloat tol, const bool set, const bool nested );
  PromDTet *setElem(PromDTet *e, PromParentBank * const bank, const int mype, 
                    const gfloat t, const bool, const int, 
                    const PromDTet*, const bool, PromDTet **best = NULL,
                    gfloat *fout=NULL );
  int   MakeExteriorFacets( PromFacet *[], PromGeoNode *[][2], gfloat*,
                            PromBank *bank, int &out ) const;
  int   SetElemAdjac()const;
  int   MaxOff( gfloat &smax, int *maxi = NULL, gfloat *buff = NULL ) const;
  int   SetFaceIDs( int id0, int id1 = -9, int id2 = -9, int id3 = -9,
                    int id4 = -9, int id5 = -9 );
  int   MaxFaceID()const;
  int   ReadFaceIDs( int *&buff ){
    assert(this && symbGeoData_);
    int i,ii,ret = PromContext::Read( ii, symbGeoData_->faceID, buff );
    for( i = ii ; i < PROM_NODE_MAXFACET ; i++ ) symbGeoData_->faceID[i] = -9; 
    return ret;
  } 
  int   numFaces()const{
    assert(this && symbGeoData_);
    int ret;
    for(ret=0 ; ret < PROM_NODE_MAXFACET && symbGeoData_->faceID[ret]>=0;ret++)
      /*VOID*/;
    return ret;
  }
  int   WriteFaceIDs(int *&buff)const{
    return PromContext::Write( numFaces(), symbGeoData_->faceID, buff );
  }
  //protected:
  // static buffer
  static PromTable<PromDTet*> *bufftable_; // (GEO)
public:
  static int clearBuffers(){
    if(bufftable_){delete bufftable_; bufftable_=NULL;}
    return 0;
  }
  // data
  PromSymbGeoData *symbGeoData_;
};


class PromMPINode : public PromNodeBase
{
public:
  PromMPINode(): fIndex_(-8), angle_(-99.){}
  PromMPINode( PromMPINode &a ){
    PromNodeBase::operator=( a );
    coord_ = a.coord_;
    ghostID_ = a.ghostID_;
    fIndex_ = a.fIndex_;
    angle_ = a.angle_;
  }
  PromMPINode &operator=( const PromMPINode &a ){
    PromNodeBase::operator=( a );      
    coord_ = a.coord_;       PromElement::operator=( a );
    ghostID_ = a.ghostID_; 
    fIndex_ = a.fIndex_;
    angle_ = a.angle_;    
    return *this;
  }
  int  feap(int &ierr)const{ ierr = !(this && fIndex_ >= 0); return fIndex_;} 
  int  feap()const{ assert(this!=NULL && fIndex_ >= 0); return fIndex_;} 
  void setFeap( int f ){ assert(this!=NULL); fIndex_ = f; }

  int Write( int **ppb )const;
  int Read( int **ppb );
  static int GetWrite_size( int &sz );
  // data
  int          fIndex_; // use in parititioning only
  PromCoord    coord_; // first for alignment
  PromGlobalID ghostID_; 
  gfloat       angle_;
}; 

#endif //__PROM_NODE__H__

---