src/expde/grid/listnb/listnb4.h

Go to the documentation of this file.

//    expde: expression templates for partial differential equations.
//    Copyright (C) 2001  Christoph Pflaum
//    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.
//
//                 SEE  Notice1.doc made by 
//                 LAWRENCE LIVERMORE NATIONAL LABORATORY
//

// ------------------------------------------------------------
// listnb4.h
//
// ------------------------------------------------------------

#define initialize_nearb true

// near boundary points
class P_nearb {
 public:
  P_nearb(Index3D I, P_nearb* Next) : ind(I), next(Next) {};

  // initialize
  void initialize(const Grid* gitter, int level);

  // idem
  double *varM(const Grid* gitter,int level) const;
  double *varP_slow(const Grid* gitter,int var_ebene, Ort1D i,Ort1D j,Ort1D k,
                    int level) const;

  // next:
  double *varN(const Grid* gitter, int level) const;
  double *varS(const Grid* gitter, int level) const;
  double *varW(const Grid* gitter, int level) const;
  double *varE(const Grid* gitter, int level) const;
  double *varT(const Grid* gitter, int level) const;
  double *varD(const Grid* gitter, int level) const;
  // double next:
  double *varND(const Grid* gitter, int level) const;
  double *varWN(const Grid* gitter, int level) const;
  double *varWT(const Grid* gitter, int level) const;
  double *varED(const Grid* gitter, int level) const;
  double *varST(const Grid* gitter, int level) const;
  double *varES(const Grid* gitter, int level) const;
  // third next:
  double *varEST(const Grid* gitter, int level) const;
  double *varWND(const Grid* gitter, int level) const;

  // double next special
  double *varWD(const Grid* gitter, int level) const;
  double *varET(const Grid* gitter, int level) const;

  // informations about the neighbour cells:
  Celltype  Give_cell_typ(const Grid* grid, dir_sons i, int l) const;
  BoCeData* Give_Bo_cell( const Grid* grid, dir_sons i, int l) const;

  // physical coordinates
  D3vector coordinate(const Grid* gitter) const;
  double coordinateX(const Grid* gitter) const;
  double coordinateY(const Grid* gitter) const;
  double coordinateZ(const Grid* gitter) const;

  // for iteration:
  P_nearb* Next() const { return next; };

  // index of point
  Index3D Ind() const { return ind; };

  // for MG
  void Set_first_mg_coeff_nearb(Point_mg_coeff_nearb* first) {
    first_mg_coeff_nearb = first;
  }
  void Set_first_mg_coeff_bo(   Point_mg_coeff_bo*    first) {
    first_mg_coeff_bo    = first;
  }
  Point_mg_coeff_nearb* Give_first_mg_coeff_nearb() const {
    return first_mg_coeff_nearb;
  }
  Point_mg_coeff_bo* Give_first_mg_coeff_bo() const {
    return first_mg_coeff_bo;
  }

  // label for boundary points
  bool Give_Label(int num, int level, const Grid* gitter) const;
 private:
  Index3D ind;
  P_nearb *next;

  double* pointer_varM;
  
  double* pointer_varN;
  double* pointer_varS;
  double* pointer_varE;
  double* pointer_varW;
  double* pointer_varT;
  double* pointer_varD;
  
  double* pointer_varND;
  double* pointer_varWN;
  double* pointer_varWT;
  double* pointer_varED;
  double* pointer_varST;
  double* pointer_varES;
  
  double* pointer_varEST;
  double* pointer_varWND;

  BoCeData* bocedatas[8]; 
  Celltype  celltyps[8];

  // for MG
  Point_mg_coeff_nearb* first_mg_coeff_nearb;
  Point_mg_coeff_bo*    first_mg_coeff_bo;
};

inline void P_nearb::initialize(const Grid* gitter, int level) {
  int i;
  Index3D next; 
  Index3D ori(2,2,2);

  pointer_varM = gitter->Give_variable(ind,level);
  pointer_varN = gitter->Give_variable_slow(ind.next_NS(Rd,level),level);
  pointer_varS = gitter->Give_variable_slow(ind.next_NS(Ld,level),level);
  pointer_varE = gitter->Give_variable_slow(ind.next_EW(Rd,level),level);
  pointer_varW = gitter->Give_variable_slow(ind.next_EW(Ld,level),level);
  pointer_varT = gitter->Give_variable_slow(ind.next_TD(Rd,level),level);
  pointer_varD = gitter->Give_variable_slow(ind.next_TD(Ld,level),level);
  pointer_varND = 
    gitter->Give_variable_slow(ind.next_NS(Rd,level).next_TD(Ld,level),level);
  pointer_varWN = 
    gitter->Give_variable_slow(ind.next_NS(Rd,level).next_EW(Ld,level),level);
  pointer_varWT = 
    gitter->Give_variable_slow(ind.next_TD(Rd,level).next_EW(Ld,level),level);
  pointer_varED =
    gitter->Give_variable_slow(ind.next_TD(Ld,level).next_EW(Rd,level),level);
  pointer_varST =
    gitter->Give_variable_slow(ind.next_TD(Rd,level).next_NS(Ld,level),level);
  pointer_varES =
    gitter->Give_variable_slow(ind.next_EW(Rd,level).next_NS(Ld,level),level);
  pointer_varEST =
    gitter->Give_variable_slow(
          ind.next_EW(Rd,level).next_NS(Ld,level).next_TD(Rd,level),level);
  pointer_varWND =
    gitter->Give_variable_slow(
          ind.next_EW(Ld,level).next_NS(Rd,level).next_TD(Ld,level),level);

  // Zelltyp
  for(i=0;i<8;++i) {
   next = ind.next((dir_sons)i,level+1);
   if(ori <= next)
     celltyps[i] = gitter->Give_cell_typ(next);
   else
     celltyps[i] = ex_cell;
  }
  for(i=0;i<8;++i) {
    if(celltyps[i] >= bo_cell) {
      bocedatas[i] = gitter->Give_Bo_cell(ind.next((dir_sons)i,level+1));
    }
    else bocedatas[i]=NULL;
  }
}



// coordinate
inline D3vector P_nearb::coordinate(const Grid* gitter) const {
  return gitter->transform_coord(ind);
};
inline double P_nearb::coordinateX(const Grid* gitter) const {
  return gitter->transform_coordX(ind);
};
inline double P_nearb::coordinateY(const Grid* gitter) const {
  return gitter->transform_coordY(ind);
};
inline double P_nearb::coordinateZ(const Grid* gitter) const {
  return gitter->transform_coordZ(ind);
};


// next:
inline double *P_nearb::varN(const Grid* gitter, int level)
     const {
  return pointer_varN;
};
inline double *P_nearb::varS(const Grid* gitter, int level)
     const {
  return pointer_varS;
};
inline double *P_nearb::varE(const Grid* gitter, int level)
     const {
  return pointer_varE;
};
inline double *P_nearb::varW(const Grid* gitter, int level)
     const {
  return pointer_varW;
};
inline double *P_nearb::varT(const Grid* gitter, int level)
     const {
  return pointer_varT;
};
inline double *P_nearb::varD(const Grid* gitter, int level)
     const {
  return pointer_varD;
};
// double next:
inline double *P_nearb::varND(const Grid* gitter, int level)
     const {
  return pointer_varND;
};
inline double *P_nearb::varWN(const Grid* gitter, int level)
     const {
  return pointer_varWN;
};
inline double *P_nearb::varWT(const Grid* gitter, int level)
     const {
  return pointer_varWT;
};
inline double *P_nearb::varED(const Grid* gitter, int level)
     const {
  return pointer_varED;
};
inline double *P_nearb::varST(const Grid* gitter, int level)
     const {
  return pointer_varST;
};
inline double *P_nearb::varES(const Grid* gitter, int level)
     const {
  return pointer_varES;
};
// third next:
inline double *P_nearb::varEST(const Grid* gitter, int level)
     const {
  return pointer_varEST;
};
inline double *P_nearb::varWND(const Grid* gitter, int level)
     const {
  return pointer_varWND;
};


// double next special:
inline double *P_nearb::varWD(const Grid* gitter, int level)
     const {
  return gitter->Give_variable(ind.next_WD(level),level);
};
inline double *P_nearb::varET(const Grid* gitter, int level)
     const {
  return gitter->Give_variable(ind.next_ET(level),level);
};


// idem
inline double *P_nearb::varM(const Grid* gitter, int level) const {
  return pointer_varM;
};

inline double *P_nearb::varP_slow(const Grid* gitter,int var_ebene,
                             Ort1D i, Ort1D j, Ort1D k, int level) const {
  return gitter->Give_variable_slow(ind.next(i,j,k,level),var_ebene);
};


// informations about the neighbour cells:
inline Celltype  P_nearb::Give_cell_typ(const Grid* grid, dir_sons i, int l)
     const {
  return celltyps[i];
};
inline BoCeData* P_nearb::Give_Bo_cell(const Grid* grid, dir_sons i, int l)
     const {
  return bocedatas[i];
};

inline bool P_nearb::Give_Label(int num, int level, const Grid* gitter) const {
  // since no Dirichlet boundary condition, we can run that point. 
  return gitter->Give_label_bo_D(ind,num,level)==false;
};

---