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

// ------------------------------------------------------------
//
// grid.h
//
// ------------------------------------------------------------

#ifndef GRID_H_
#define GRID_H_
           
#define anzahl_colors 8

class Nearb_Ablage;

class P_interior;
class P_nearb;
class P_Bo2p;
class P_cellpoi;
class P_interior_cell;
class P_boundary_tet;
class P_parallel; // ^^^^^^^^ Parallel ^^^^^^^^

class Evaluation_Parallelization_object;

class Grid : public Grid_base {
 public:
  Grid(int n_max, All_Domains* dom, Grid_gen_parameters& gpara, MPI_Comm comm);
  Grid(int n_max, All_Domains* dom, MPI_Comm comm);
  Grid(double h_finest_level, All_Domains* dom,
       Grid_gen_parameters& gpara, MPI_Comm comm);
  Grid(double h_finest_level, All_Domains* dom, MPI_Comm comm);
  Grid(int n_max, All_Domains* dom, Grid_gen_parameters& gpara);
  Grid(double  h_finest_level, All_Domains* dom, Grid_gen_parameters& gpara);
  Grid(int n_max, All_Domains* dom);
  Grid(double  h_finest_level, All_Domains* dom);


  void Delete_storage();

  // ^^^^^^^^ Parallel ^^^^^^^^
  void Full_update_Variable(int level);

  void Update_Variable(dir_3D d, int* array_num, int anz_num, int level);
  void Update_Variable(int d, int* array_num, int anz_num, int level);
  void Sum_ghost_nodes_Variable(int* array_num, int anz_num, int level);
  void Sum_ghost_nodes_Variable(int d, int* array_num, int anz_num, int level);

  void Update_Variable_no_full(int* array_num, int anz_num, int level);

  void Update_Variable_for_prolongation(dir_3D d, int* array_num, 
                                        int anz_num, int level);
  void Update_Variable_for_prolongation(int d, int* array_num, 
                                        int anz_num, int level);
  void Update_Variable_for_prolongation(int* array_num, 
                                        int anz_num, int level);
  void Update_boundary_stencil(int num_stencils, int level);
  void Update_global_stencil(int num_stencils, int level);

  void Print_number_of_communication_doubles();

  void Do_non_bock_sending(bool yn);

  // Zeitmessung und MFlops
  void Add_operations(long_int ops, int level);
  void Start_calc_time();
  void Stop_calc_time();
  void Start_calc_time_interior();
  void Stop_calc_time_interior();
  void Start_calc_time_nearbb();
  void Stop_calc_time_nearbb();
  int calc_time() { return calc_yn; }
  void Report_calc_time( const char * what);           

  // Drucke Information ueber alle Punkte
  void Print_poi_Info(int lev);     // innere Punkte auf     Level lev
  void Print_poi_Info();            // innere Punkte auf    maximal level
  void Print_poi_Sum_Info();        // innere Punkte bis zum Level lev
  void Print_poi_Info_all(int lev); // bis zum Level lev

  // number of interior and nearb points on a level
  double Give_number_interior_grid_points(int lev);

  void Print_maximal_interior_angles(); 

  // Berechnung der Mehrgitterkoeffizienten
  void Calc_MG_Coefficients();

  // Setze Zeiger der Variablen auf die Randzellen
  void Set_pointer_on_bocell();

  // Zur Verwaltung der Speicher (Datenspeicher):
  // Um Nummern fuer Speicher zu holen siehe: grid_base.h
  void Initialize();                // Initialisiere Speicher
  void Test_init();                 // Initialisiere Speicher, falls
                                    // notwendig

  void Refine(Index3D I);

  // Startfunktionen bei einer Iteration ueber die Listen
  // Fuer eine Iteration braucht man noch zum Beispiel die Funktion
  // P_interior::Next() 

  P_parallel*  Start_P_parallel(int level);  // ^^^^^^^^ Parallel ^^^^^^^^


  P_interior* Start_P_interior(int level, int color);
  P_nearb*    Start_P_nearb(int level, int color);
  P_Bo2p*     Start_P_Bo2p(int level, int color);
  P_nearb*   Start_P_exteri(int level, int color);
  P_cellpoi*  Start_P_cellpoi(int level);
  P_interior_cell*  Start_P_interior_cell(int level);
  P_boundary_tet*  Start_P_boundary_tet(int level);

  // Zwischenspeicher
  // a) helping storage needed for iteration of expression templates
  Nearb_Ablage* Give_Nearb_Ablage() const { return nearb_ablage; };
  // b) helping storage needed for prolongation, restriction, ...
  double*  Give_vector_ablage() const { return vector_ablage; };
  double** Give_Stencils_fine() const { return stencils_fine; };
  double*  Give_weight_27() const { return weight_27; };
  bool*    Give_label_on_cell_ablage() const { return label_on_cell; };
  bool*    Give_eight_bools() const { return eight_bools; };

  // Gib Speicher fuer locale Sterne:
  double* Give_Loc_stencil(diff_type typ_u, diff_type typ_v) const { 
    return loc_stencils.Give_Loc_sten(typ_u,typ_v); }
  double* Give_Loc_stencil_Poisson() const { 
    return loc_stencils.Give_Loc_sten_Poisson(); }

  // Gib Stern fuer Restriktion
  Restriction_stencil_container *Give_restriction_stencil() const {
    return restriction_stencil;
  }
  // Gib Grob-Gitter Funktion
  // Format: l +  v * 27; wobei l=0,...,26 and v=0,...,7
  int *Give_coarse_grid_functions() const {
    return coarse_grid_functions;
  }

  // For evaluation - parallelization
  Evaluation_Parallelization_object* Give_eval_par() {
    return eval_par_object;
  };
  void Set_type_of_update(int number_variable, int level, type_of_update type)
    const;

  // Fuer Level_verwaltung bei MG
  int Min_interior_level();   // min lev of grid with at least one 
                              //  interior point

 private:
  // Fuer Level_verwaltung bei MG
  int min_interior_level;

  // sum up number of points parallel
  double Total_number_interior_points(int lev);
  double Total_number_nearb_points(int lev);
  double Total_number_exteri_points(int lev);
  double Total_number_bo2p_points(int lev);
  double Total_number_cellpoi_points(int lev);

  // do non_bock_sending?
  bool non_bock_sending;

  // construct storage (used by constructor)
  void Construct_storage();

  // For evaluation - parallelization
  Evaluation_Parallelization_object* eval_par_object;

  // Hilfsfunktion zur Berechnung der Mehrgitterkoeffizienten
  void Calc_Near_bo_MG_Coefficients(Index3D I, int l, double weight);
  Point_mg_coeff_nearb* list_bilding_nearb;  // Hilfspeicher 
  Point_mg_coeff_bo*    list_bilding_bo;     // Hilfspeicher 

  // Zeitmessung
  int calc_yn;
  long_int operations;      // for east
  // double operations;      // sonst
  clock_t t0_interior;    // Zeit fuer Innen
  clock_t t1_interior;       
  clock_t t_sum_interior;       
  clock_t t0_nearbb;      // Zeit fuer Rand und in der Naehe des Randes
  clock_t t1_nearbb;        
  clock_t t_sum_nearbb;        
  clock_t t0_all;         // Gesamte Zeit
  clock_t t1_all;        

  // Speicher fuer local Sterne:
  Loc_stencil_container loc_stencils;
  Restriction_stencil_container* restriction_stencil;

  // Speicher fuer grob Gitter Funktion
  int *coarse_grid_functions;

  // Listen:
  // Anzahl der Punkte
  long_int  number_interior_points[Max_number_levels];    // innen
  long_int  number_nearb_points[Max_number_levels];       // Rand-nah
  long_int  number_exteri_points[Max_number_levels];      // exterior
  long_int  number_bo2p_points[Max_number_levels];        // Rand
  long_int  number_cellpoi_points[Max_number_levels];     // Zellpunkt
  long_int  number_parallel_points[Max_number_levels];  // ^^^^^^^ Parallel ^^^^^^^
  long_int  number_interior_cell_points[Max_number_levels];     // innere Zell-var
  long_int  number_boundary_cell_tet[Max_number_levels];     // Rand Zell-var

  // innere Punkte mit 27-Stern
  void Add_list_interior(Index3D I);
  void Add_list_interior(Index3D I, int level);

  P_interior*** start_P_interior;

  // randnahe Punkte
  void Add_list_nearb(Index3D I);
  void Add_list_nearb(Index3D I, int level);

  P_nearb*** start_P_nearb;

  // exterior Punkte
  void Add_list_exteri(Index3D I);
  void Add_list_exteri(Index3D I, int level);

  P_nearb*** start_P_exteri;

  // Randpunkte 2.Art
  void Add_list_bo2p(Bo2Point* bopoint);

  P_Bo2p*** start_P_Bo2p;  

  // Randzellenpunkte
  void Add_list_cellpoi(BoCell* bocellf);

  P_cellpoi*** start_P_cellpoi;  

  // Points for pararallel
  // ^^^^^^^^ Parallel ^^^^^^^^
  void Add_list_parallel(Index3D I);

  P_parallel** start_P_parallel;  

  // Zell-Variablen innen
  void Add_list_interior_cell(Point_hashtable0 *cellp);

  P_interior_cell** start_P_interior_cell;  

  // Zell-Variablen Rand
  void Add_list_boundary_tet(BoCell *cellp, Tetraeder_storage* tet);

  P_boundary_tet** start_P_boundary_tet;  


  // Zwischenspeicher
  Nearb_Ablage* nearb_ablage;
  double*  vector_ablage;
  double** stencils_fine;
  double*  weight_27;
  bool* label_on_cell;
  bool* eight_bools;
};



// Speicher zu Listen


#include "../access.h"


// Implementierung einiger Memberfunktionen


// Start
inline P_cellpoi* Grid::Start_P_cellpoi(int level) {
  return start_P_cellpoi[0][level]; 
};

//  ^^^^^^^^ Parallel ^^^^^^^^
inline P_parallel* Grid::Start_P_parallel(int level) {
  return start_P_parallel[level]; 
};

inline P_interior* Grid::Start_P_interior(int level, int color) { 
  return start_P_interior[color][level]; 
};


inline P_nearb* Grid::Start_P_nearb(int level, int color) { 
  return start_P_nearb[color][level]; 
};

inline P_nearb* Grid::Start_P_exteri(int level, int color) { 
  return start_P_exteri[color][level]; 
};

inline P_Bo2p* Grid::Start_P_Bo2p(int level, int color) { 
  return start_P_Bo2p[color][level]; 
};


inline P_interior_cell* Grid::Start_P_interior_cell(int level) { 
  return start_P_interior_cell[level]; 
};


inline P_boundary_tet* Grid::Start_P_boundary_tet(int level) { 
  return start_P_boundary_tet[level]; 
};



#endif
        

---