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

// ------------------------------------------------------------
//
// evpar.h
//
// ------------------------------------------------------------

#ifndef EVPAR_H_
#define EVPAR_H_
                  

/*
 
         
          X~~~~~~~~~~~~~~~ X
        /                / |
      /                /   |
    /                /     |
   X~~~~~~~~~~~~~~~X       |
   |               |       |
   |  WNT --- ENT  |       |
   |/  |     / |   |       |
  WST --- EST  |   |       X
   |   |   |   |   |     /
   |  WND --- END  |   /
   | /     |  /    | /
  WSD --- ESD ~~~~ X
 
      


// ENTd -> interior      // first 
// WNTd -> W-face        // second
// WSTd -> WS-edge       // third
// WSDd -> WSD corner    // forth
// WNDd -> WD-edge       // fifth
// ENDd -> D-face        // sixth
// ESDd -> SD-edge       // seventh
// ESTd -> S-face        // eighth

*/


inline dir_sons reordering_formula(dir_sons d) {
  if(d==ENTd) return (dir_sons)0;  // first
  if(d==WNTd) return (dir_sons)1;  // second
  if(d==WSTd) return (dir_sons)2;  // ...
  if(d==WSDd) return (dir_sons)3;

  if(d==WNDd) return (dir_sons)4;
  if(d==ENDd) return (dir_sons)5;
  if(d==ESDd) return (dir_sons)6;
  //  if(d==ESTd)
              return (dir_sons)7;  // eighth  
}

inline dir_sons reordering_boundary_formula(Index3D I, dir_3D d, Index3D my_index) {
  bool fine_x, fine_y, fine_z;
  fine_x = my_index.I_x() <= I.I_x();
  fine_y = my_index.I_y() <= I.I_y();
  fine_z = my_index.I_z() <= I.I_z();

  if(fine_x && fine_y && fine_z) return (dir_sons)0; // (first  is interior)

  if(fine_y && fine_z) {       
    if(d!=Wdir && d!=Edir) 
      return (dir_sons)1;     // (second is W-face)
    else return (dir_sons)0;
  }
  if(fine_x && fine_y) {
    if(d!=Ddir && d!=Tdir) 
      return (dir_sons)5;     // (sixth  is D-face)
    else return (dir_sons)0;
  }

  if(fine_x && fine_z) {
    if(d!=Sdir && d!=Ndir)
      return (dir_sons)7;     // (eighth is S-face)
    else return (dir_sons)0;
  }

  if(fine_x) {
    if(d==Wdir || d==Edir)
      return (dir_sons)6; // (seventh is SD-edge)
    else return (dir_sons)0;
  }
  if(fine_y) {
    if(d==Ndir || d==Sdir)
      return (dir_sons)4; // (fifth   is WD-edge)
    else return (dir_sons)0;
  }
  if(fine_z) {
    if(d==Ddir || d==Tdir)
      return (dir_sons)2; // (third   is WS-edge)
    else return (dir_sons)0;
  }
  
  return (dir_sons)3; // ( forth is WSD-corner)
}

enum evaluation_typ { 
  stop_evaluation,
  interior_1_evaluation_fine,
  interior_15_evaluation_fine,
  interior_17_evaluation_fine,
  interior_25_evaluation_fine,
  interior_1_evaluation_coarse,
  interior_15_evaluation_coarse,
  interior_17_evaluation_coarse,
  interior_25_evaluation_coarse,
  nearb_1_evaluation,
  nearb_15_evaluation,
  nearb_17_evaluation,
  cellf_1_evaluation,
  cellf_large_evaluation,
  boundary_evaluation_all,
  boundary_evaluation_subset,
  exteri_1_evaluation_subset,
  exteri_15_evaluation_subset,
  exteri_17_evaluation_subset
};
// Bemerkung:
//   exteri_1_evaluation_subset,
//   exteri_15_evaluation_subset,
//   exteri_17_evaluation_subset
// werden unter nearb subsummiert.

class Run_type_object {
 public:
  int  r_boundary;   // run boundary point? or on Subgrid?
  bool  r_interior;   // run interior point? or some of them?
  bool r_nearb;      // run nearb point?
};

// remark with respect to r_boundary:
/*
  r_boundary == 1:              run all boundary points
  r_boundary == 0:              run no  boundary points
  r_boundary == i = -1,-2, ...: run     boundary points of label -i
*/  

class Evaluation_Parallelization_object {
 private:
  Grid *grid;
  Run_type_object run_object;
  int level;
  int max_level;
  int size_stencil;
  int number_ops;

  P_interior* interior_pointer;
  P_nearb*    nearb_pointer;
  P_Bo2p*     Bo2p_pointer;
  P_cellpoi*  cellpoi_pointer;

  int status;

  // which vars are in expression
  int max_var;            // maximal number of variables
  bool *array_vars;       // array of size max_var; var is in Expr. of level
  bool *array_vars_other; // array of size max_var; var is in Expr. of 
                          // level: level+1 or level-1
  bool other_is_fine;
  bool other_is_coarse;

  bool update_ENT;
  bool update_WSD;
  bool update_other_bla;

  // how to update left hand side for systems
  type_of_update left_update;
  int left_level;

  // transformed in the following; needed by communication:
  int  *array_num;
  int anz_num;
  int  *array_num_other;
  int anz_num_other;

  // GS expression (or Jacobi)
  bool GS_expression;
  dir_3D Parallel_GS_formula[8];

  // storage for update type of variables
  // code: max_level*number_variable+level-1
  type_of_update *storage_of_update_type;
 public:
  // constructor used only in grid.cc
  Evaluation_Parallelization_object(Grid *g, int max_v);

  // functions for type_of_update
  type_of_update Give_type_of_update(int number_variable, int level);
  void Set_type_of_update(int number_variable, int level, type_of_update type);

  // how to update left hand side for systems
  type_of_update Give_left_update() { return left_update; }
  int            Give_left_level()  { return left_level;  }

  // needed by communication:
  int  Give_anz_num()   { return anz_num; };
  int *Give_array_num() { return array_num; };

  void Start_evaluation_seriel(const Run_type_object rob, const int l,
                               const int ss, const int num_ops);
  void StartA_evaluation(const Run_type_object rob, const int l,
                        const int ss, const int num_ops);
  //  void StartB_evaluation(const int number_variable);
  void StartB_evaluation(const int number_variable, const bool GS_expr);

  void StartA_varcon_evaluation(const int l); // used in varcon.h
  void StartB_varcon_evaluation();            // used in varcon.h
  evaluation_typ Give_next_evaluation_typ();
  // functions used by part of expression
  void Variable_contained_in_expression(int num_variable);
  void Variable_contained_in_expression_other(int num_variable);
  void Other_is_coarse() { other_is_coarse =true; }
  void Other_is_fine() { other_is_fine =true; }

  P_interior* Start_interior_pointer() { return interior_pointer;   };
  P_nearb*    Start_nearb_pointer()    { return nearb_pointer; };
  P_Bo2p*     Start_Bo2p_pointer()     { return Bo2p_pointer; };
  P_cellpoi*  Start_cellpoi_pointer()  { return cellpoi_pointer; };
};

inline void 
Evaluation_Parallelization_object::Variable_contained_in_expression(
                                   int num_variable) { 
  if(developer_version) {
    if(num_variable<0) 
      cout << " error 1 in ev_par::Variable_contained_in_expression! " << endl;
    if(num_variable>=max_var) 
      cout << " error 1 in ev_par::Variable_contained_in_expression! " << endl;
  }
  array_vars[num_variable] = true;
}

inline void 
Evaluation_Parallelization_object::Variable_contained_in_expression_other(
                                   int num_variable) { 
  if(developer_version) {
    if(num_variable<0) 
      cout << " error 1 in ev_par::Variable_contained_in_expression_other! " 
           << endl;
    if(num_variable>=max_var) 
      cout << " error 1 in ev_par::Variable_contained_in_expression_other! " 
           << endl;
  }
  array_vars_other[num_variable] = true;
}


inline type_of_update Evaluation_Parallelization_object::Give_type_of_update(
                                                  int number_variable,
                                                  int level) {
  if(developer_version) {
     if(max_level*number_variable+level>max_level*(max_var+1))
       cout << 
         "error in Evaluation_Parallelization_object::Give_type_of_update!! " 
            << endl;
  }
  return storage_of_update_type[max_level*number_variable+level-1];
};

inline void Evaluation_Parallelization_object::Set_type_of_update(
                                                      int number_variable,
                                                      int level,
                                                      type_of_update type) {
  if(developer_version) {
     if(max_level*number_variable+level>max_level*(max_var+1))
       cout << 
         "error in Evaluation_Parallelization_object::Set_type_of_update!! " 
            << endl;
  }
  storage_of_update_type[max_level*number_variable+level-1] = type;
}

#endif
        

---