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


//                  abbbreviations


#ifndef ABBREVI_H_
#define ABBREVI_H_
      
// update types for variables
enum type_of_update { no_update,  partial_update, full_update };

// types of diffrenetial opeartors
enum diff_type { Dx_type, Dy_type, Dz_type, Helm_type, Poisson_type };

// 1D
//-------------
enum dir1D { Ld,  Rd };
enum Ort1D { LOrt, MOrt, ROrt };

enum f_type { an,  spitz };        // face type

// 2D
//-------------
// direction of sons in 2D
enum dir2D_sons { SWdir, SEdir, NWdir, NEdir };

// directions in 2D
enum dir_2D { Wdir2D, Edir2D, Sdir2D, Ndir2D };

// Stern in 2D
//enum stencil_2D { SWsten, Ssten, SEsten, 
//                  Wsten, Msten,  Esten, 
//                  NWsten, Nsten, NEsten  };

// 3D
//-------------
// directions fuer Soehne, oder Ecken einer Zellen
enum dir_sons { WSDd, ESDd, WNDd, ENDd, WSTd, ESTd, WNTd, ENTd }; 

// directions in 3D
enum dir_3D { Wdir, Edir, Sdir, Ndir, Ddir, Tdir };

// main_directions in 3D
enum main_dir_3D { WE_dir, SN_dir, DT_dir };

// edges of a cell
enum Edges_cell { SDed, NDed, STed, NTed, WDed, EDed, WTed, ETed,
                  SWed, SEed, NWed, NEed }; 


// for domain
//-------------

// is it possible to calculate the distance to the boundary?
//----------------------------------------------------------
enum calc_dis { no, yes, more_than };


// type of a point given by domain
//---------------------------------------------
enum PointtypeD { exteriorD, interiorD };

// type of a corner given by a cell
//--------------------------------------------------
enum Cornertype { exCorner, intCorner, boCorner  };

// type of point
//--------------------
enum Pointtype { parallel_p, exterior, multigrid,    interior, slave, nearb, 
                 boundary,   uniform,  hierarchical, ausnahme  };

// type of cell
//--------------------
enum Celltype { noinfo, ex_cell, int_cell, bo_cell, fine_bo_cell, 
                no_cell_exists };

// type of edge
//--------------------
enum Edgetype { edge_not_interior, edge_interior, noeinfo};


// class: edge point of corner point of a boundary cell

enum Cell_type_points { corner_poi_typ,  edge_poi_typ, cell_poi_typ };

enum types_of_label_send { dont_send, Dirichlet_send, Neumann_send };

class Edge_Corner_point {
  public:
   Cell_type_points edge_point; // edge point, corner point, or point in cell
   dir_sons corner; // corner of boundary cell
   dir_3D   d;      // direction of edge in case of edgepoint
};

// indices: 

enum typ_of_general_points { type_P_Bo2p , type_P_interior,
                             type_P_cellpoi, type_P_nearb };

//  funktionen for transformation


// main direction of 3D-direction
//-----------------------------
inline main_dir_3D Main_direction(dir_3D d) {
  if(d>Ndir) return DT_dir;
  if(d<Sdir) return WE_dir;
  return SN_dir;
}


// 1D-part of 3D-direction
//-----------------------------
inline dir1D OneDpart(dir_3D d) {
  if(d>Ndir) return (dir1D)(d-4);
  if(d<Sdir) return (dir1D)d;
  return (dir1D)(d-2);
}

// 3D-direction by 1D-part and main direction
//--------------------------------------------
inline dir_3D Add(dir1D lr, main_dir_3D md) {
  if(md==WE_dir) return (dir_3D)(lr);
  if(md==SN_dir) return (dir_3D)(2+lr);
  return (dir_3D)(4+lr);
}


// corners of the face of a cell
//------------------------------
inline dir_sons corner_sur(dir_3D f, dir2D_sons cor) {
  if(f < Sdir)
    return (dir_sons)(f + 2*(cor&1) + 4*(cor>>1));
  if(f > Ndir)
    return (dir_sons)(4*(f-4) + (cor&1) + 2*(cor>>1));
  return (dir_sons)(2*(f-2) + (cor&1) + 4*(cor>>1));
};

// direction from one corner to another
//-------------------------------------
inline dir_3D direction_from_to(dir_sons from, dir_sons to) {
  if((from&1) != (to&1)) {
    if((from&1) < (to&1)) return Edir;
    else return Wdir;
  }
  if((from&2) != (to&2)) {
    if((from&2) < (to&2)) return Ndir;
    else return Sdir;
  }
  if((from&4) < (to&4)) return Tdir;
  else return Ddir;
}

// corners of an edge of a cell 
//------------------------------
inline dir_sons Transform(Edges_cell ec, dir1D d) {
  enum dir_3D dir;
  dir = (dir_3D) ((ec >> 2) << 1);
  if(dir<Sdir) return (dir_sons)(d+4*((ec>>1)&1)+2*(ec&1));
  if(dir>Ndir) return (dir_sons)(2*((ec>>1)&1)+(ec&1)+4*d);
  return (dir_sons)(4*((ec>>1)&1)+2*d+(ec&1));
}

// direction of the edge of a cell
//---------------------------------
inline dir_3D Trans_dir(Edges_cell ec, dir1D d) {
  return (dir_3D) (((ec >> 2) << 1) + d);
}

// next corner of a cell in a certain direction
//--------------------------------------------------
inline dir_sons Next_corner(dir_sons co, dir_3D dir) {
  if(dir<Sdir) {
    return (dir_sons)((co&(~1)) + ((~co)&1));
  }
  if(dir>Ndir) {
    return (dir_sons)((co&(~(1<<2))) + (((~(co>>2))&1)<<2));
  }
  return (dir_sons)((co&(~(1<<1))) + (((~(co>>1))&1)<<1));
}

inline dir_sons Next_corner_x(dir_sons co) {
  return (dir_sons)((co&(~1)) + ((~co)&1));
}
inline dir_sons Next_corner_y(dir_sons co) {
  return (dir_sons)((co&(~(1<<1))) + (((~(co>>1))&1)<<1));
}
inline dir_sons Next_corner_z(dir_sons co) {
    return (dir_sons)((co&(~(1<<2))) + (((~(co>>2))&1)<<2));
}

// opposite face type
//--------------------------
inline f_type opposite(f_type f) {
  if(f==an) return spitz;
  else return an;
}

// dir_3D coordinate of the direction of "dir_sons"
//-------------------------------------------------
inline dir_3D xCoord(dir_sons d) {
  return (dir_3D)(d&1);
}
inline dir_3D yCoord(dir_sons d) {
  return (dir_3D)(((d>>1)&1)+2);
}
inline dir_3D zCoord(dir_sons d) {
  return (dir_3D)(((d>>2)&1)+4);
}

// D3vector unit-vector of the corners of a cell
inline double Unit_vector_x(dir_sons d) {
  return double(d&1);
};
inline double Unit_vector_y(dir_sons d) {
  return double((d&2)>>1);
};
inline double Unit_vector_z(dir_sons d) {
  return double((d&4)>>2);
};


// Sign (-1 falls links, 1 falls rechts) of a dir_3D direction
//-------------------------------------------------------------------
inline int sign(dir_3D d) {
  return (2*(d&1)-1);
}

// Change
//-------------
inline void Change(Edge_Corner_point& A, Edge_Corner_point& B) {
  static Edge_Corner_point sp;
  sp = A; A = B;  B = sp;
}

// Calc face type
//-----------------------
inline f_type Calc_f_type(dir_3D dx, dir_3D dy) {
  return (f_type)((OneDpart(dx)+OneDpart(dy))&1);
}
// opposite face type
//-----------------------
inline f_type opposite_face_type(f_type a) {
  return (f_type)((~a)&1);
};

// dir1D coordinate of direction "dir_sons"
//---------------------------------------------
inline dir1D x1DCoord(dir_sons d) {
  return (dir1D)(d&1);
}
inline dir1D y1DCoord(dir_sons d) {
  return (dir1D)((d>>1)&1);
}
inline dir1D z1DCoord(dir_sons d) {
  return (dir1D)((d>>2)&1);
}


// number of equal coordinates x,y,z of two corners (dir_sons)
//---------------------------------------------------------------
inline int How_Equal(dir_sons da, dir_sons db) {
  return (int)((da&1) == (db&1)) + 
    (int)((da&2) == (db&2)) +
    (int)((da&4) == (db&4));
}

// opposite directions in 3D
//-----------------------------------
inline dir_3D opposite3D(dir_3D dir) {
  if(dir<Sdir) return (dir_3D)((~dir)&1);
  if(dir>Ndir) return (dir_3D)(((~(dir-4))&1)+4);
  return (dir_3D)(((~(dir-2))&1)+2);
}

inline dir_sons opposite3D(dir_sons dir) {
  return (dir_sons)((~dir)&7);
}

inline Edges_cell opposite3D(Edges_cell ed) {
  if(ed==SDed) return NTed;
  if(ed==NDed) return STed;
  if(ed==STed) return NDed;
  if(ed==NTed) return SDed;

  if(ed==EDed) return WTed;
  if(ed==WDed) return ETed;
  if(ed==ETed) return WDed;
  if(ed==WTed) return EDed;

  if(ed==NEed) return SWed;
  if(ed==NWed) return SEed;
  if(ed==SEed) return NWed;
  return NEed;
}

// edge of a cell
// d direction of the edge, sons direction of the orthogonal face
//--------------------------------------------------------------------
inline Edges_cell CalcEdge_cells(dir_3D d, dir2D_sons sons) {
  return (Edges_cell)(((d >> 1) << 2) + sons);
}


// edge of the face of a cell
//-----------------------------
inline Edges_cell Edge_surface(dir_3D surf, dir_2D dir) {
  if(surf<Sdir) {
    return (Edges_cell)(surf+2*(dir>>1)+4*((dir&1)+1));
  }
  if(surf==Ddir) {
    if((dir>>1)==0) 
      return (Edges_cell)(4*((dir&1)));
    return (Edges_cell)(1+4*((dir&1)));
  }
  if(surf==Tdir) {
    if((dir>>1)==0) 
      return (Edges_cell)(2+4*((dir&1)));
    return (Edges_cell)(3+4*((dir&1)));
  }
  if((dir&1)==0) 
    return (Edges_cell)((surf-2)+2*(dir>>1)+4*(2*(dir&1)));
  return (Edges_cell)(2*(surf-2)+(dir>>1)+4*(2*(dir&1)));

}

//  orthogonal directions of an edge
//  ----------------------------------
inline dir_3D OrthoA(Edges_cell ec) {
  static dir_3D dir;
  dir = (dir_3D) ((ec >> 2) << 1);
  if(dir<Sdir) return (dir_3D)((ec&1)+2);
  if(dir>Ndir) return (dir_3D)(ec&1);
  return (dir_3D)(ec&1);
}


inline dir_3D OrthoB(Edges_cell ec) {
  static dir_3D dir;
  dir = (dir_3D) ((ec >> 2) << 1);
  if(dir<Sdir) return (dir_3D) (((ec>>1)&1)+4);
  if(dir>Ndir) return (dir_3D) (((ec>>1)&1)+2);
  return (dir_3D) (((ec>>1)&1)+4);
}

// formula for integer-value: i+3*j+9*k
inline dir_sons dir_sons_from_three_LR(dir1D i, dir1D j, dir1D k) {
  return (dir_sons)(i+2*j+4*k);
}


// describtion of a 27-stencil by
// - (Ort1D)i, (Ort1D)j, (Ort1D)k       or
// - the integer-value i+3*j+9*k
// here are some transformatiuon formulas


// formula for integer-value: i+3*j+9*k
inline int trans27(Ort1D i, Ort1D j,Ort1D k) {
  return i+3*j+9*k;
}

// integer-value of a point ds in a neighbour cell dz
inline int trans_cellP_27(dir_sons dz, dir_sons ds) {
  return ((ds&1) + (dz&1)) +
    3*(((ds>>1)&1) + ((dz>>1)&1)) + 
    9*(((ds>>2)&1) + ((dz>>2)&1));
}

inline Ort1D trans_cellP_27_x(dir_sons dz, dir_sons ds) {
  return (Ort1D)((ds&1) + (dz&1));
}
inline Ort1D trans_cellP_27_y(dir_sons dz, dir_sons ds) {
  return (Ort1D)(((ds>>1)&1) + ((dz>>1)&1));
}
inline Ort1D trans_cellP_27_z(dir_sons dz, dir_sons ds) {
  return (Ort1D)(((ds>>2)&1) + ((dz>>2)&1));
}





// print-functions for testing
// ----------------------------
inline void Print(dir_sons d) {
  if(d==WSDd) cout << "WSDd"; 
  if(d==ESDd) cout << "ESDd"; 
  if(d==WNDd) cout << "WNDd"; 
  if(d==ENDd) cout << "ENDd"; 
  if(d==WSTd) cout << "WSTd"; 
  if(d==ESTd) cout << "ESTd"; 
  if(d==WNTd) cout << "WNTd"; 
  if(d==ENTd) cout << "ENTd"; 
}
inline void Print(dir2D_sons d) {
  if(d==SWdir)  cout << "SWdir"; 
  if(d==SEdir)  cout << "SEdir"; 
  if(d==NWdir)  cout << "NWdir"; 
  if(d==NEdir)  cout << "NEdir"; 
}

inline void Print(dir_3D d) {
  if(d==Wdir) cout << "Wdir"; 
  if(d==Edir) cout << "Edir"; 
  if(d==Sdir) cout << "Sdir"; 
  if(d==Ndir) cout << "Ndir"; 
  if(d==Ddir) cout << "Ddir"; 
  if(d==Tdir) cout << "Tdir"; 
}

inline void Print(dir_2D d) {
  if(d==Wdir2D) cout << "Wdir2D"; 
  if(d==Edir2D) cout << "Edir2D"; 
  if(d==Sdir2D) cout << "Sdir2D"; 
  if(d==Ndir2D) cout << "Ndir2D"; 
}

inline void Print(Edges_cell ed) {
  if(ed==SDed) cout << "SDed";
  if(ed==NDed) cout << "NDed";
  if(ed==STed) cout << "STed";
  if(ed==NTed) cout << "NTed";
  if(ed==WDed) cout << "WDed";
  if(ed==EDed) cout << "EDed";
  if(ed==WTed) cout << "WTed";
  if(ed==ETed) cout << "ETed";
  if(ed==SWed) cout << "SWed";
  if(ed==SEed) cout << "SEed";
  if(ed==NWed) cout << "NWed";
  if(ed==NEed) cout << "NEed";
}

inline void Print(dir1D d) {
  if(d==Ld) cout << "Ld";
  if(d==Rd) cout << "Rd";
}

inline void Print(Pointtype p) {
  if(p==exterior) cout << "exterior";
  if(p==multigrid) cout << "multigrid";
  if(p==interior) cout << "interior";
  if(p==slave) cout << "slave";
  if(p==nearb) cout << "nearb";
  if(p==boundary) cout << "boundary";
  if(p==uniform) cout << "uniform";
  if(p==hierarchical) cout << "hierarchical";
  if(p==ausnahme) cout << "ausnahme";
}

#endif
   

---