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

// ------------------------------------------------------------
//
// loc_sten.h
//
// ------------------------------------------------------------

#ifndef LOCSTEN_H_
#define LOCSTEN_H_
     
// Notation:
// a(u,v) is stored in stencil[v+8*u]
// where stencil is:
//      double* stencil;
// Here a(u,v) is evaluated only on a cell.
// Therefore, it must be:
//       0 <= v,u < 8 



// This is a class which can calculate a local stencil
// If a local stencil was calculated, then
// this stencil is stored.
// Therefore next time, this stencil does not have to be calculated again. 
class Loc_stencil_container {
 public:
  Loc_stencil_container();
  double* Give_Loc_sten(diff_type typ_u, diff_type typ_v) const;
  double* Give_Loc_sten_Poisson() const { return sten_Poisson; };
 private:
  double*** sten;
  double* sten_Poisson;
  double* sten_sp;
};

void Restrict_local_stiffness_matrix(double*  Stencil_coarse,
                                     double** Stencils_fine,
                                     bool* corner_in_domain);
void Restrict_local_stiffness_matrix(double*  Stencil_coarse,
                                     double** Stencils_fine,
                                     int* coarse_grid_functions);

// used in mg_op.h
class Restriction_stencil_container {
 public:
  Restriction_stencil_container();
  double Calc_trans_weight(dir_sons i, dir_sons j, dir_sons k);
 private:
  int reg_formula[5][5][5];
};


inline double Restriction_stencil_container::Calc_trans_weight(dir_sons i,
                                                               dir_sons j,
                                                               dir_sons k) {
  return reg_formula[2*(i&1) + (j&1) + (k&1)]
                    [2*((i>>1)&1) + ((j>>1)&1) + ((k>>1)&1)]
                    [2*((i>>2)&1) + ((j>>2)&1) + ((k>>2)&1)];
}



   //  evaluation of a local stiffness matrix

inline double Evaluate_lsm(double*const * u_Recell, int num_var,
                           dir_sons dir_v, double* sten) {
  static int i;
  static double sum;
  sum = 0.0;
  for(i=0;i<8;++i) sum = sum + sten[dir_v+8*i] * u_Recell[i][num_var];
  return sum;
}


//-------------------------------------------------------------------------
// The following functions are not very important.
// They are used only for the implementation of the code.
void Set_coarse_function(double U[27], dir_sons v);
void Set_coarse_function(int    U[27], dir_sons v); //multipiziert mit Faktor 2

// Print 27-stencil using 64-local stencil
void Print_27_stencil_of_local_matrix(double* sten);

void Print_u_Recell(double*const * u_Recell, int num);

// Print 64-local stencil
void Print_Loc_stencil(double* sten);
void Print_part_loc_stencil(double* sten); // used by Print_Loc_stencil

void Print_Factor(diff_type typ_u, diff_type typ_v);
void Print_Factor_Poisson();

void Print_27_stencil(double Sten27[27]);
void Print_27_stencil(diff_type typ_u, diff_type typ_v);
void Print_27_stencil_var(diff_type typ_u, diff_type typ_v);
void Print_27_stencil_formula_var(diff_type typ_u, diff_type typ_v);
void Print_27_stencil_Poisson();
void Print_27_stencil_Poisson_var();

void Calc_Loc_stencil(double* sten, diff_type typ_u, diff_type typ_v);
double Test_evaluation_of_lsm(double* sten, dir_sons dir_v,
                              bool* corner_in_domain);
double Test_evaluation_of_lsm(double* sten, dir_sons dir_v);
double Test_evaluation_of_lsm(double* sten, dir_sons dir_v, double* UU);

void Print_restriction_formula();

#endif
    

---