src/expde/grid/SSten.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
//

// ------------------------------------------------------------
// SSten.h
//
// ------------------------------------------------------------

#ifndef SSTEN_H_
#define SSTEN_H_


// Speicher fuer Stencil

// Nearb_Ablage ist Zwischenspeicher und enthaelt
// die Zeiger auf
// *u bei Randzellen. Informationen fuer Formeln
// auf Randzellen.
// Anwendung in z.B.  operator.h

class Nearb_Ablage {
 public:
  void Initialize_leer(int numvar);  // nur am Anfang aufrufen
  void Put_leer();  // muss am besten nach jeder Iteration aufgerufen werden,
                    // damit  zu_on_cell 0 wird

  Index3D I;
  inline void Initialize(Grid* gr, P_nearb* it_n, int l);
  void Initialize_17(Grid* gr, P_nearb* it_n, int l);
  void Initialize_27(const Grid* grid, Index3D I, int l);
  BoCeData* Give_BoData(dir_sons is)  const { return bocedatas[is]; };
  Celltype  Give_Celltyp(dir_sons is) const { return celltyps[is]; };
  double*const * Give_u_Recell(dir_sons is) const { return zu_on_cell[is]; };
 private:
  BoCeData* bocedatas[8]; 
  Celltype  celltyps[8];
  double*  zu_on_cell[8][8];
  int i,j,k, cor;
  double* ZU[27];

  //       L       L       L    
  double *UWN,   *UN;  
  double *UWND,  *UND;

  double *UWT,   *UT;
  double *UW,    *UM,    *UE;
  double         *UD,    *UED;

  double         *UST,   *UEST;  
  double         *US,    *UES;
  //       L       L       L

  // special for 17-stencils
  double         *UWD,    *UET;

  double *ULeer;
};

// Implementierung der Memberfunktionen

inline void Nearb_Ablage::Initialize_leer(int numvar) {
  ULeer = new double[numvar];
  for(i=0;i<numvar;++i) ULeer[i] = 0.0;

  zu_on_cell[WNTd][WNTd] = ULeer;
  zu_on_cell[WNTd][ENTd] = ULeer;
  zu_on_cell[WNDd][WSDd] = ULeer;
  zu_on_cell[WSTd][WSTd] = ULeer;
  zu_on_cell[WSTd][WSDd] = ULeer;
  zu_on_cell[WSDd][WSDd] = ULeer;
  zu_on_cell[WSDd][WSTd] = ULeer;
  zu_on_cell[WSDd][WNDd] = ULeer;
  zu_on_cell[WSDd][ESDd] = ULeer;
  zu_on_cell[ENTd][ENTd] = ULeer;
  zu_on_cell[ENTd][ENDd] = ULeer;
  zu_on_cell[ENTd][ESTd] = ULeer;
  zu_on_cell[ENTd][WNTd] = ULeer;
  zu_on_cell[ENDd][ENDd] = ULeer;
  zu_on_cell[ENDd][ENTd] = ULeer;
  zu_on_cell[ESTd][ENTd] = ULeer;
  zu_on_cell[ESDd][ESDd] = ULeer;
  zu_on_cell[ESDd][WSDd] = ULeer;
}

// This function has to be used after 
inline void Nearb_Ablage::Put_leer() {
  for(i=0;i<8;++i)  for(j=0;j<8;++j) {
    zu_on_cell[i][j] = ULeer;
  } 
}


inline void Nearb_Ablage::Initialize_17(Grid* grid, P_nearb* it_n, int l) {
  Initialize(grid,it_n,l);

  if(celltyps[WNDd]==int_cell || celltyps[WSDd]==int_cell)
    UWD  = it_n->varWD(grid,l);

  if(celltyps[ENTd]==int_cell || celltyps[ESTd]==int_cell)
    UET  = it_n->varET(grid,l);


  if(celltyps[ENTd]==int_cell)
    zu_on_cell[ENTd][ESTd] = UET;
  if(celltyps[ESTd]==int_cell)
    zu_on_cell[ESTd][ENTd] = UET;


  if(celltyps[WNDd]==int_cell)
    zu_on_cell[WNDd][WSDd] = UWD;
  if(celltyps[WSDd]==int_cell)
    zu_on_cell[WSDd][WNDd] = UWD;
}

inline void Nearb_Ablage::Initialize_27(const Grid* grid, Index3D I, int l) {
  // the following can be improved!!
  Index3D I_son;
  double* zeiger;
  for(i=0;i<8;++i) {
    I_son = I.next((dir_sons)i,l+1); // center of neighbour cell
    for(j=0;j<8;++j) {
      zeiger = grid->Give_variable_slow(I_son.next((dir_sons)j,l+1),l);
      if(zeiger!=NULL) zu_on_cell[i][j] = zeiger;
      else             zu_on_cell[i][j] = ULeer;
    }
  }
}
  

inline void Nearb_Ablage::Initialize(Grid* grid, P_nearb* it_n, int l) {
  // Zelltyp
  for(i=0;i<8;++i) {
    celltyps[i]=it_n->Give_cell_typ(grid,(dir_sons)i,l);
  }

  // Randzellen
  for(i=0;i<8;++i) {
    if(celltyps[i] >= bo_cell) {
      //      bocedatas[i]=grid->Give_Bo_cell(I.next((dir_sons)i,l+1));
      bocedatas[i]=it_n->Give_Bo_cell(grid,(dir_sons)i,l);
    }
    else bocedatas[i]=NULL;
  }

  // a) for 15-Stencil
  // put U-values, if no boundary cell
  // later we put these values in the 
  // storage for cells: zu_on_cell
  //----------------------------------
  if(celltyps[WNDd]==int_cell)
    UWND = it_n->varWND(grid,l);
  if(celltyps[ESTd]==int_cell)
    UEST = it_n->varEST(grid,l);

  if(celltyps[WNTd]==int_cell || celltyps[WNDd]==int_cell)
    UWN  = it_n->varWN(grid,l);
  if(celltyps[WNDd]==int_cell || celltyps[ENDd]==int_cell)
    UND  = it_n->varND(grid,l);
  if(celltyps[WNTd]==int_cell || celltyps[WSTd]==int_cell)
    UWT  = it_n->varWT(grid,l);
  if(celltyps[ENDd]==int_cell || celltyps[ESDd]==int_cell)
    UED  = it_n->varED(grid,l);
  if(celltyps[ESTd]==int_cell || celltyps[WSTd]==int_cell)
    UST  = it_n->varST(grid,l);
  if(celltyps[ESTd]==int_cell || celltyps[ESDd]==int_cell)
    UES  = it_n->varES(grid,l);

  if(celltyps[ESTd]==int_cell || celltyps[ESDd]==int_cell ||
     celltyps[ENTd]==int_cell || celltyps[ENDd]==int_cell)
    UE  = it_n->varE(grid,l);
  if(celltyps[WSTd]==int_cell || celltyps[WSDd]==int_cell ||
     celltyps[WNTd]==int_cell || celltyps[WNDd]==int_cell)
    UW  = it_n->varW(grid,l);
  if(celltyps[WSTd]==int_cell || celltyps[ESTd]==int_cell ||
     celltyps[WNTd]==int_cell || celltyps[ENTd]==int_cell)
    UT  = it_n->varT(grid,l);
  if(celltyps[WSDd]==int_cell || celltyps[ESDd]==int_cell ||
     celltyps[WNDd]==int_cell || celltyps[ENDd]==int_cell)
    UD  = it_n->varD(grid,l);
  if(celltyps[WNDd]==int_cell || celltyps[ENDd]==int_cell ||
     celltyps[WNTd]==int_cell || celltyps[ENTd]==int_cell)
    UN  = it_n->varN(grid,l);
  if(celltyps[WSDd]==int_cell || celltyps[ESDd]==int_cell ||
     celltyps[WSTd]==int_cell || celltyps[ESTd]==int_cell)
    US  = it_n->varS(grid,l);

  UM  = it_n->varM(grid,l);


  // the following can be improved!!

  // b) put values for "bo_cell's" 
  //    these cells appear only on coarse grids
  //    therefore this is slow, but it can be improved!!
  Index3D I_son;
  double* zeiger;
  for(i=0;i<8;++i) 
    if(celltyps[i]==bo_cell) {
    I_son = it_n->Ind().next((dir_sons)i,l+1); // center of neighbour cell
    for(j=0;j<8;++j) {
      zeiger = grid->Give_variable_slow(I_son.next((dir_sons)j,l+1),l);
      if(zeiger!=NULL) zu_on_cell[i][j] = zeiger;
      else             zu_on_cell[i][j] = ULeer;
    }
  }
  
  
  // c) for interior cells we set zu_on_cell
  if(celltyps[WNTd]==int_cell) {
    zu_on_cell[WNTd][WNDd] = UWN;
    zu_on_cell[WNTd][WSTd] = UWT;

    zu_on_cell[WNTd][WSDd] = UW;
    zu_on_cell[WNTd][ENDd] = UN;
    zu_on_cell[WNTd][ESTd] = UT;
    zu_on_cell[WNTd][ESDd] = UM;
  }
  
  if(celltyps[WNDd]==int_cell) {
    zu_on_cell[WNDd][WNDd] = UWND;
    zu_on_cell[WNDd][WNTd] = UWN;
    zu_on_cell[WNDd][ENDd] = UND;

    zu_on_cell[WNDd][WSTd] = UW;
    zu_on_cell[WNDd][ESDd] = UD;
    zu_on_cell[WNDd][ENTd] = UN;
    zu_on_cell[WNDd][ESTd] = UM;
  }

  if(celltyps[WSTd]==int_cell) {
    zu_on_cell[WSTd][WNTd] = UWT;
    zu_on_cell[WSTd][ESTd] = UST;

    zu_on_cell[WSTd][WNDd] = UW;
    zu_on_cell[WSTd][ENTd] = UT;
    zu_on_cell[WSTd][ESDd] = US;
    zu_on_cell[WSTd][ENDd] = UM;
  }
  
  if(celltyps[WSDd]==int_cell) {
    zu_on_cell[WSDd][WNTd] = UW;
    zu_on_cell[WSDd][ENDd] = UD;
    zu_on_cell[WSDd][ESTd] = US;
    zu_on_cell[WSDd][ENTd] = UM;
  }

  if(celltyps[ENTd]==int_cell) {
    zu_on_cell[ENTd][ESDd] = UE;
    zu_on_cell[ENTd][WSTd] = UT;
    zu_on_cell[ENTd][WNDd] = UN;
    zu_on_cell[ENTd][WSDd] = UM;
  }

  if(celltyps[ENDd]==int_cell) {
    zu_on_cell[ENDd][ESDd] = UED;
    zu_on_cell[ENDd][WNDd] = UND;

    zu_on_cell[ENDd][ESTd] = UE;
    zu_on_cell[ENDd][WSDd] = UD;
    zu_on_cell[ENDd][WNTd] = UN;
    zu_on_cell[ENDd][WSTd] = UM;
  }

  if(celltyps[ESTd]==int_cell) {
    zu_on_cell[ESTd][ESTd] = UEST;
    zu_on_cell[ESTd][ESDd] = UES;
    zu_on_cell[ESTd][WSTd] = UST;

    zu_on_cell[ESTd][ENDd] = UE;
    zu_on_cell[ESTd][WNTd] = UT;
    zu_on_cell[ESTd][WSDd] = US;
    zu_on_cell[ESTd][WNDd] = UM;
  }

  if(celltyps[ESDd]==int_cell) {
    zu_on_cell[ESDd][ESTd] = UES;
    zu_on_cell[ESDd][ENDd] = UED;

    zu_on_cell[ESDd][ENTd] = UE;
    zu_on_cell[ESDd][WNDd] = UD;
    zu_on_cell[ESDd][WSTd] = US;
    zu_on_cell[ESDd][WNTd] = UM;
  }
};


#endif
    

---