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

#ifndef VARIABLE_H_
#define VARIABLE_H_
             
// ------------------------------------------------------------
//
//     variable.h 
//     includes later sim2.h
//
// ------------------------------------------------------------

// Abbreviation for dominant
enum Dominace_label { anti_dominant = -1, not_dominant = 0, yes_dominant = 1 };

// Abbreviation for differential operator
enum Differential_op_typ { not_abstract, abstract_with_var, abstract_diag ,
                           abstract_both, not_both };   // ada: add not_both was missing and detected by gcc 3.4.4

// Example: Abbreviation for dominant with respect to level:
/*
  anti_dominant :  expression contains no information about level
  not_dominant  :  expression contains information about level, 
                   but expression is not dominant
  yes_dominant  :  expression contains information about level, 
                   and expression is dominant with respect to level
*/

// 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
*/  


// abbreviation for list of stencils
#define double_stencils_in double *LuN, double *LuW, double *LuM, \
  double *LuE, double *LuS, double *LuT, double *LuD, double *LuND, \
  double *LuWN, double *LuWT, double *LuED, double *LuST, double *LuES, \
  double *LuWD, double *LuET, double *LuEST, double *LuWND, \
  double *LuCell_WSD, double *LuCell_WST, \
  double *LuCell_WND, double *LuCell_WNT, \
  double *LuCell_ESD, double *LuCell_EST, \
  double *LuCell_END, double *LuCell_ENT
#define double_stencils_out LuN, LuW, LuM, LuE, LuS, LuT, LuD, LuND, \
LuWN, LuWT, LuED, LuST, LuES, LuWD, LuET, LuEST, LuWND, \
LuCell_WSD, LuCell_WST, LuCell_WND, LuCell_WNT, \
LuCell_ESD, LuCell_EST, LuCell_END, LuCell_ENT

//  for later:
template<class B>
class DExprSim;

template<class A, class B> 
class DExprAnd;

class Variable;
class Array_Variable;
class Array_Local_var;

template<class R> 
class DExprResVarP;

class ExpdeIndex;
class assignable_vector;

/* FunctionClass for Representing a Restriction operator for a function */
// used in elementary.h
class FunctionClass {
    int  r_boundary;
    bool r_interior;
    bool r_nearb;
 public:
    double (*Formula)(double x,double y,double z);
    template<class R>
  FunctionClass( double (*formula)(double x,double y,double z), const R& r)
    {
      Formula = formula;
      r_boundary = r.run_boundary();
      r_nearb    = r.run_nearb();
      r_interior = r.run_interior();
    }
  bool run_interior() const { return r_interior;  }
  bool run_nearb()    const { return r_nearb; }
  int run_boundary() const { return r_boundary; }

  // Put pointer to grid and activity of boundary points of test space  
  void Put_grid_rbo(Grid* gr, int r_bo) const { };
  // Is the expression an abstract differential operator?
  Differential_op_typ Abstract_differential_operator() const
    { return not_abstract; }
};

//  2 types of local variables 

/*  local variable for double */
class Local_var {
  friend class Array_Local_var;
 private:
  double* value_;
  Local_var() {
    value_ = NULL;
  }
  void Initialize(double* v) {
    value_ = v;
  }
  void Initialize() {
    value_ = new double;
    *value_ = 0.0;
  }
 public:
  Local_var(double* v) {
    value_ = v;
  }
  /*
  Local_var() {
    value_ = new double;
    *value_ = 0.0; 
  }
  ~Local_var() { delete value_; }
  */
  double Give_interior(const P_interior* it_i,const Grid* gr, double h_mesh,
                       int l, double_stencils_in) const {
    return *value_;
  }
  double Give_interior_coarse(const P_interior* it_i,const Grid* gr,
                              double h_mesh,
                              int l, double_stencils_in) const {
    return *value_;
  }
  double Give_nearb(const P_nearb* it_n,const Grid* gr, double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage)
    const {
    return *value_;
  };
  double Give_Bo2p(const P_Bo2p* it_b,const Grid* gr, int l) const {
    return *value_;
  };
  double Give_cellpoi(const P_cellpoi* it_cf,const Grid* gr,
                      const BoCeData* bocedata) const {
    return *value_;
  };

  // for procedure
  double* Give_regular_pointer(const P_interior* it_i,const Grid* gr, int l) 
    const {
    return value_;
  };
  double* Give_regular_pointer(const P_nearb* it_n,const Grid* gr, int l) 
    const {
    return value_;
  };
  double* Give_Bo2p_pointer(const P_Bo2p* it_b,const Grid* gr, int l) const {
    return value_;
  };
  double* Give_cellpoi_pointer(const P_cellpoi* it_cf,const Grid* gr) const {
    return value_;
  };


  // Size of necessary stencil
  int Sice_stencil() const { return 1; }

  // activity of points
  int Level() const { return 0; }
  Dominace_label Dominant_lev() const { return anti_dominant;  }
  Dominace_label Dominant_poi() const { return anti_dominant;  }
  bool run_interior() const { return true; }
  bool run_nearb()    const { return true; }
  int run_boundary()  const { return 1; }
  
  // number of operations
  int ops_interior() const { return 0; }
  // For operator ==
  void Active_Sim_Level( int lev) const {  };
  void Active_Sim_interior(bool run) const {  };
  void Active_Sim_nearb(bool run) const {  };
  void Active_Sim_boundary( int run) const {  };
  void Active_Sim_update(Evaluation_Parallelization_object* evpar,
                         int level, type_of_update typ) const {  };

  // Put pointer to grid and activity of boundary points of test space  
  void Put_grid_rbo(Grid* gr, int r_bo) const { };
  // Is the expression an abstract differential operator?
  Differential_op_typ Abstract_differential_operator()  const { 
    return abstract_both; 
  }
  int Give_number_var_of_abstract_op() const { return -1; }
  bool Give_array_variable_inserted() const {
    return false;
  }
  int Give_length_of_array_variable_inserted() const {
    return 0;
  }
  // For restriction of stencils
  // --------------------------------------
  double Give_interior_sten_element(Index3D I, double meshsize,
                                    int stelle,
                                    const Grid* grid, int l) const {
    return *value_;
  }
  double Give_boundary_sten_element(const Grid* grid, BoCeData* b_cell,
                                    double* u_ablage, int num_v) const {
    return *value_;
  }
  // Get and Put:
  // Set value
  void Put_interior(const P_interior* it_i, int lev, double x) { Put(x); };
  void Put_nearb(const P_nearb* it_n, int lev, double x) { Put(x); };
  void Put_Bo2p(const P_Bo2p* it_b, double x) { Put(x); };
  void Put_cellpoi(const P_cellpoi* it_cf, double x) { Put(x); };

  void Put(double x) {
    *value_=x;
  };
  double Get() const {
    return *value_;
  };          
  double* Give_pointer() const {
    return value_;
  };
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar) 
    const {};
  bool GS_type(int var_number_left, int dim) const {
  return false; }; 

  // at the and of an iteration of an expression
  void clean() const {};
};


/*  local variable for double */
class Local_int {
 private:
  int* value_;
 public:
  Local_int(int* v) {
    value_ = v;
    *value_ = 0; 
  }
  Local_int() {
    value_ = new int;
    *value_ = 0; 
  }
  // ~Local_var() { delete value_; }
  double Give_interior(const P_interior* it_i,const Grid* gr, double h_mesh,
                       int l, double_stencils_in) const {
    return (double)(*value_);
  }
  double Give_interior_coarse(const P_interior* it_i,const Grid* gr,
                              double h_mesh,
                              int l, double_stencils_in) const {
    return (double)(*value_);
  }
  double Give_nearb(const P_nearb* it_n,const Grid* gr, double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage)
    const {
    return (double)(*value_);
  };
  double Give_Bo2p(const P_Bo2p* it_b,const Grid* gr, int l) const {
    return (double)(*value_);
  };
  double Give_cellpoi(const P_cellpoi* it_cf,const Grid* gr,
                      const BoCeData* bocedata) const {
    return (double)(*value_);
  };
  // Size of necessary stencil
  int Sice_stencil() const { return 1; }

  // activity of points
  int Level() const { return 0; }
  Dominace_label Dominant_lev() const { return anti_dominant;  }
  Dominace_label Dominant_poi() const { return anti_dominant;  }
  bool run_interior() const { return true; }
  bool run_nearb()    const { return true; }
  int run_boundary()  const { return 1; }
  
  // number of operations
  int ops_interior() const { return 0; }
  // For operator ==
  void Active_Sim_Level( int lev) const {  };
  void Active_Sim_interior(bool run) const {  };
  void Active_Sim_nearb(bool run) const {  };
  void Active_Sim_boundary( int run) const {  };
  void Active_Sim_update(Evaluation_Parallelization_object* evpar,
                         int level, type_of_update typ) const {  };

  // Put pointer to grid and activity of boundary points of test space  
  void Put_grid_rbo(Grid* gr, int r_bo) const { };
  // Is the expression an abstract differential operator?
  bool Abstract_differential_operator()  const { return false; }
  bool Give_array_variable_inserted() const {
    return false;
  }
  int Give_length_of_array_variable_inserted() const {
    return 0;
  }
  // Get and Put:
  // Set value
  void Put_interior(const P_interior* it_i, int lev, double x) { Put(x); };
  void Put_nearb(const P_nearb* it_n, int lev, double x) { Put(x); };
  void Put_Bo2p(const P_Bo2p* it_b, double x) { Put(x); };
  void Put_cellpoi(const P_cellpoi* it_cf, double x) { Put(x); };

  void Put(double x) {
    cout << " \n type conversion in Local_int! " << endl;
    *value_=(int)x;
  };
  int Get() const {
    return *value_;
  };
  int* Give_pointer() const {
    return value_;
  };
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar) 
    const {};
  bool GS_type(int var_number_left, int dim) const {
  return false; }; 

  // at the and of an iteration of an expression
  void clean() const {};
};



/* wrapper class wich contains  ...contains the expression types 
               - DExprVAR
               - DExprLIT 
               - DExprBinOp 
               - DExprDiffOp 
               - ...           */

#include "sim2.h"

template<class A>
class DExpr {
 private:
  A a_;

 public:
  DExpr(const A& x)
    : a_(x)
    {}
  // special for array
  Grid* Give_grid() const {
    return a_.Give_grid();
  }
  int Number_variable() const {
    return a_.Number_variable();
  }
  int Number_variable_start() const {
    return a_.Number_variable_start();
  }
  int* Give_value() const {
    return a_.Give_value();
  }
  int Give_dim() const {
    return a_.Give_dim();
  }
  template<class B>
  DWrapSim<DExprVecSim<B> >
  operator== (const  B& b_)
  {
    typedef DWrapSim<DExprVecSim<B> > ExprT;
    return ExprT(DExprVecSim<B>(Number_variable_start(),Give_value(),
                                Give_dim(),b_)); 
  }
  // end special
  // for evaluate
  double Give_interior(const P_interior* it_i,const Grid* gr, double h_mesh,
                       int l, double_stencils_in) const {
    return a_.Give_interior(it_i,gr,h_mesh,l, double_stencils_out);
  };
  double Give_interior_coarse(const P_interior* it_i,const Grid* gr, 
                              double h_mesh, int l, double_stencils_in) const {
    return a_.Give_interior_coarse(it_i,gr,h_mesh,l, double_stencils_out);
  };
  double Give_nearb(const P_nearb* it_n,const Grid* gr, double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage)
    const {
    return a_.Give_nearb(it_n,gr,h_mesh,l,nearb_ablage);
  };
  double Give_Bo2p(const P_Bo2p* it_b,const Grid* gr, int l) const {
    return a_.Give_Bo2p(it_b,gr,l);
  };
  double Give_cellpoi(const P_cellpoi* it_cf,const Grid* gr,
                      const BoCeData* bocedata) const {
    return a_.Give_cellpoi(it_cf,gr,bocedata);
  };
  // for evaluate on cell
  double Give_interior_cell(const P_interior_cell* it_icell ,
                            const Grid* gr, int l) const {
    return a_.Give_interior_cell(it_icell,gr,l);
  };
  double Give_bo_tet(const P_boundary_tet* it_bcell, 
                      const Grid* gr) const {
    return a_.Give_bo_tet(it_bcell,gr);
  };

  // Size of necessary stencil
  int Sice_stencil() const { return a_.Sice_stencil(); }

  // activity of points
  int Level() const { return a_.Level(); }
  Dominace_label Dominant_lev() const { return a_.Dominant_lev(); }
  Dominace_label Dominant_poi() const { return a_.Dominant_poi(); }
  bool run_interior() const { return a_.run_interior(); }
  bool run_nearb()    const { return a_.run_nearb(); }
  int run_boundary() const { return a_.run_boundary(); }

  // number of operations
  int ops_interior() const { return a_.ops_interior(); }   

  // For operator ==
  void Active_Sim_Level( int lev) const { a_.Active_Sim_Level(lev); }
  void Active_Sim_interior( bool run) const { a_.Active_Sim_interior(run); }
  void Active_Sim_nearb( bool run)    const { a_.Active_Sim_nearb(run); }
  void Active_Sim_boundary(int run) const { a_.Active_Sim_boundary(run); }
  void Active_Sim_update(Evaluation_Parallelization_object* evpar,
                         int level, type_of_update typ) const 
    {  a_.Active_Sim_update(evpar,level,typ); };

  // Put pointer to grid and activity of boundary points of test space
  void Put_grid_rbo(Grid* gr, int r_bo)  const { a_.Put_grid_rbo(gr,r_bo); }
  // For abstract differential operators:
  // --------------------------------------
  // Is the expression an abstract differential operator?
  Differential_op_typ Abstract_differential_operator() const  {
    return a_.Abstract_differential_operator(); }
  int Give_number_var_of_abstract_op() const { 
    return a_.Give_number_var_of_abstract_op(); };
  bool Give_array_variable_inserted() const {
    return  a_.Give_array_variable_inserted();
  }
  int Give_length_of_array_variable_inserted() const {
    return a_.Give_length_of_array_variable_inserted();
  }
  // For restriction of stencils
  // --------------------------------------
  double Give_interior_sten_element(Index3D I, double meshsize,
                                    int stelle,
                                    const Grid* grid, int level) const {
    return a_.Give_interior_sten_element(I,meshsize,stelle,grid,level); 
  }
  double Give_boundary_sten_element(const Grid* grid, BoCeData* b_cell,
                                    double* u_ablage, int num_v) const {
    return a_.Give_boundary_sten_element(grid, b_cell,u_ablage,num_v);
  }
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar) 
    const {
    a_.Add_variables_for_parallel(evpar);
  };
  bool GS_type(int var_number_left, int dim) const {
    return a_.GS_type(var_number_left, dim);
  }; 

  // for indices -> implemented in variable2.h
  double operator[] (ExpdeIndex& i);

  // at the and of an iteration of an expression
  void clean() const { a_.clean(); };
};


// Wrapper for: Restriction operator with respect to points -- slow by a domain
/* DExprResDomain for Representing a Restriction operator with 
   respect to points */
template<class A>
class DExprResDomain {
  A a_;
  Domain* domain_R;
 public:
  DExprResDomain(const A& a, const Domain& dom)
    : a_(a) {
    // domain_R = &dom; 
    domain_R = new Domain(dom);
  }
  double Give_interior(const P_interior* it_i,const Grid* gr, double h_mesh,
                       int l, double_stencils_in) const {
    return a_.Give_interior(it_i,gr,h_mesh,l, double_stencils_out);
  };
  double Give_interior_coarse(const P_interior* it_i,const Grid* gr,
                              double h_mesh,
                              int l, double_stencils_in) const {
    return a_.Give_interior_coarse(it_i,gr,h_mesh,l, double_stencils_out);
  };
  double Give_nearb(const P_nearb* it_n, const Grid* gr, double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage)
    const {
    return a_.Give_nearb(it_n,gr,h_mesh,l,nearb_ablage);
  };
  double Give_Bo2p(const P_Bo2p* it_b, const Grid* gr, int l) const {
    return a_.Give_Bo2p(it_b,gr,l);
  };
  double Give_cellpoi(const P_cellpoi* it_cf, const Grid* gr,
                      const BoCeData* bocedata)
    const {
    return a_.Give_cellpoi(it_cf,gr,bocedata);
  };

  // Size of necessary stencil
  int Sice_stencil() const { return a_.Sice_stencil(); }

  // activity of points
  int Level() const { return a_.Level(); }
  Dominace_label Dominant_lev() const { return a_.Dominant_lev(); }
  Dominace_label Dominant_poi() const { return yes_dominant; }
  bool run_domain() const { return true; }

  // number of operations
  int ops_interior() const { return a_.ops_interior(); }
  int ops_nearb()    const { return a_.ops_nearb(); }
  int ops_Bo2p()     const { return a_.ops_Bo2p(); }

  // For operator ==
  void Active_Sim_Level( int lev) const { a_.Active_Sim_Level(lev);  };
  void Active_Sim_update(Evaluation_Parallelization_object* evpar,
                         int level, type_of_update typ) const 
    {  a_.Active_Sim_update(evpar,level,typ); };

  // In domain?
  bool point_in_domain(double x, double y, double z) const {
    return domain_R->point_in_domain(D3vector(x,y,z));
  }

  // Put pointer to grid and activity of boundary points of test space
  void Put_grid_rbo(Grid* gr, int r_bo) const { a_.Put_grid_rbo(gr,r_bo); }
  // Is the expression an abstract differential operator?
  Differential_op_typ Abstract_differential_operator()  const {
    return a_.Abstract_differential_operator();
  }
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar) 
    const {
    a_.Add_variables_for_parallel(evpar);
  };
  bool GS_type(int var_number_left, int dim) const {
    return a_.GS_type(var_number_left,dim);
  }; 

  // at the and of an iteration of an expression
  void clean() const { 
    a_.clean();
    delete(domain_R);
  };
};


/* class Variable */
class Variable {
  friend class Array_Variable;
 private:
  Variable();
  void Initialize(Grid* gridp);

  //  public:
  // Aktive Punkte:
  int  r_boundary;   // run boundary point? or on Subgrid?
  bool r_interior;   // run interior point?
  bool r_nearb;      // run nearb point?
  int  level;        // level:

  // Iterator
  P_interior *iter_i;
  P_nearb    *iter_n;
  P_Bo2p     *iter_b;
  P_cellpoi  *iter_cf;

  // Zwischenspeicher
  Nearb_Ablage* nearb_ablage;

  // Gitter
  Grid *grid;

  // Nummer der Variablen
  int number_variable;

  // evaluation of general = operator
  template<class A>
  void evaluate_interior_dom(const DExprResDomain<A>& a_,
                             int lev,double h_mesh);
  template<class A>
  void evaluate_nearb_dom(const DExprResDomain<A>& a_, int lev, double h_mesh);
  template<class A>
  void evaluate_boundary_dom(const DExprResDomain<A>& a_, int lev);
 public:
  Variable(Grid* gridp);

  int my_rank() { return grid->Give_my_rank(); };
  class Variable* Give_my_pointer() { return this; }


  void Print_AVS(ofstream *Datei) {
    grid->Print_Variable_AVS(Datei,number_variable);
  }
  int Number_variable() const { return number_variable; }
  int Number_variable_start() const { // abstract differential operator
    return number_variable; 
  }

  // Size of necessary stencil
  int Sice_stencil() const { return 1; }

  // for array
  bool Give_array_variable_inserted() const {
    return false;
  }
  int Give_length_of_array_variable_inserted() const {
    return 0;
  }
  // Zur Speicherverwaltung:
  inline void Test_init() { grid->Test_init(); }

  // activity of level
  inline int  Level() const { return level; }
  inline int  Ebene() const { return level; }
  inline void Level_up();
  inline void Level_down();
  inline void Active_Level(int Level);

  // number of operations
  int ops_interior() const { return 0; }   

  // activity of points
  inline void Active_interior(bool run);
  inline void Active_nearb(bool run);
  inline void Active_boundary(int run_bo);

  inline void Active_update(Evaluation_Parallelization_object* evpar, 
                            int level, type_of_update typ);

  inline void Active_only_boundary(bool run);

  inline bool run_interior()  const { return r_interior; }
  inline bool run_nearb()     const { return r_nearb; }
  inline int  run_boundary()  const { return r_boundary; }

  Dominace_label Dominant_lev() const { return not_dominant; }
  Dominace_label Dominant_poi() const { return not_dominant; }

  inline int Max_Level() const { return grid->Max_level(); }

  // For operator ==
  void Active_Sim_Level(    int lev) const {  };
  void Active_Sim_interior(bool run) const {  };
  void Active_Sim_nearb(bool run) const {  };
  void Active_Sim_boundary( int run) const {  };
  void Active_Sim_update(Evaluation_Parallelization_object* evpar,
                         int level, type_of_update typ) const {  };

  inline Grid* Give_grid() const {
    if(developer_version) {
      if(grid==NULL) cout << "\n Variable is not initialized! Error!" << endl;
    }
    return grid;
  }

  // for evaluation of simple  expressions
  double Give_interior_simple(const P_interior* it_i,const Grid* gr,
                              int l) const;
  double Give_nearb(const P_nearb* it_n,const  Grid* gr,
                    double h_mesh, int l) const;
  double Give_cellpoi(const P_cellpoi* it_cf, const Grid* gr) const;

  // for evaluation of expression
  double Give_interior(const P_interior* it_i,const Grid* gr,
                       double h_mesh, int l, double_stencils_in) const;
  double Give_interior_coarse(const P_interior* it_i,const Grid* gr,
                       double h_mesh, int l, double_stencils_in) const;
  double Give_nearb(const P_nearb* it_n,const  Grid* gr, double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage) const;
  double Give_Bo2p(const P_Bo2p* it_b, const Grid* gr, int l) const;
  double Give_cellpoi(const P_cellpoi* it_cf, const Grid* gr,
                      const BoCeData* bocedata) const;


  // Set value
  void Put_interior(const P_interior* it_i, int lev, double x);
  void Put_nearb(const P_nearb* it_n, int lev, double x);
  void Put_Bo2p(const P_Bo2p* it_b, double x);
  void Put_cellpoi(const P_cellpoi* it_cf, double x);


  // for assign
  template<class A>
  inline void operator=(const DExpr<A>& a_);
  // ruft auf:

  template<class A>
  void evaluate_interior_15_evaluation_fine(const DExpr<A>& a_,
                Evaluation_Parallelization_object* ev_par_obj,
                double h_mesh, int lev);
  template<class A>
  void evaluate_interior_17_evaluation_fine(const DExpr<A>& a_,
                Evaluation_Parallelization_object* ev_par_obj,
                double h_mesh, int lev);
  template<class A>
  void evaluate_interior_25_evaluation_fine(const DExpr<A>& a_,
                Evaluation_Parallelization_object* ev_par_obj,
                double h_mesh, int lev);
  template<class A>
  void evaluate_interior_1_evaluation_fine(const DExpr<A>& a_,
                Evaluation_Parallelization_object* ev_par_obj,
                double h_mesh, int lev);

  template<class A>
  void operator=(const DExprResDomain<A>& a_);
  void operator=(const Variable &v);
  template<class R>
  void operator=(const DExprResVarP<R> &r_);
  void operator=(double (*Formula)(double x,double y,double z));
  void operator=(const FunctionClass& function);
  void operator= (double x);
  void operator= (Input_data_object& input_object);
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar) 
    const {
  };
  bool GS_type(int var_number_left, int dim) const {
  return false; }; 

  // for indices -> implemented in index.cc
  assignable_vector operator[] (ExpdeIndex& i);

  // at the and of an iteration of an expression
  void clean() const { };







 


  // Put pointer to grid and activity of boundary points of test space  
  void Put_grid_rbo(Grid* gr, int r_bo)  const { };

  /*
  // For abstract differential operators:
  // --------------------------------------
  // Is the expression an abstract differential operator?
  Differential_op_typ Abstract_differential_operator()
    const { return abstract_both; }
  int Give_number_var_of_abstract_op() const { return -1; }
  bool Give_array_variable_inserted() const {
    return  false;
  }
  int Give_length_of_array_variable_inserted() const {
    return 0;
  }

  */




};




/* DExprVAR for Variable */

class DExprVAR {
 private:
  // Aktive Punkte:
  int  r_boundary;   // type boundary point:
  bool r_interior;   // type interior point:
  bool r_nearb;      // type nearb point:
  int  level;        // level:

  // Nummer der Variablen
  int number_variable;
 public:
  DExprVAR(const Variable& vec) {
    r_boundary = vec.run_boundary();
    r_interior = vec.run_interior();
    r_nearb    = vec.run_nearb();
    level      = vec.Level();
    number_variable =  vec.Number_variable();
  }
  double Give_interior(const P_interior* it_i,const Grid* gr, double h_mesh,
                       int l, double_stencils_in) const {
    return it_i->varM(gr,l)[number_variable];
  };
  double Give_interior_coarse(const P_interior* it_i,const Grid* gr,
                              double h_mesh, int l, double_stencils_in) const {
    return it_i->varM(gr,l)[number_variable];
  };
  double Give_nearb(const P_nearb* it_n,const Grid* gr, double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage) 
    const {
    return it_n->varM(gr,l)[number_variable];
  };
  double Give_Bo2p(const P_Bo2p* it_b,const Grid* gr, int l) const {
    return it_b->varM(gr)[number_variable];
  };  
  double Give_cellpoi(const P_cellpoi* it_cf,const Grid* gr,
                      const BoCeData* bocedata) const {
    return it_cf->varM(gr)[number_variable];
  };

  // for procedure
  double* Give_regular_pointer(const P_interior* it_i,const Grid* gr, int l) 
    const {
    return &(it_i->varM(gr,l)[number_variable]);
  };
  double* Give_regular_pointer(const P_nearb* it_n,const Grid* gr, int l) 
    const {
    return &(it_n->varM(gr,l)[number_variable]);
  };
  double* Give_Bo2p_pointer(const P_Bo2p* it_b,const Grid* gr, int l) const {
    return &(it_b->varM(gr)[number_variable]);
  };
  double* Give_cellpoi_pointer(const P_cellpoi* it_cf,const Grid* gr) const {
    return &(it_cf->varM(gr)[number_variable]);
  };

  // Size of necessary stencil
  int Sice_stencil() const { return 1; }

  // activity of points
  int Level() const { return level; }
  Dominace_label Dominant_lev() const { return not_dominant; }
  Dominace_label Dominant_poi() const { return not_dominant; }
  bool run_interior()  const { return r_interior; }
  bool run_nearb()     const { return r_nearb; }
  int run_boundary()  const { return r_boundary; }

  // number of operations
  int ops_interior() const { return 0; }

  // For operator ==
  void Active_Sim_Level(    int lev) const {  };
  void Active_Sim_interior(bool run) const {  };
  void Active_Sim_nearb(bool run) const {  };
  void Active_Sim_boundary( int run) const {  };
  void Active_Sim_update(Evaluation_Parallelization_object* evpar,
                         int level, type_of_update typ) const {  };

  // Put pointer to grid and activity of boundary points of test space  
  void Put_grid_rbo(Grid* gr, int r_bo)  const { };
  // For abstract differential operators:
  // --------------------------------------
  // Is the expression an abstract differential operator?
  Differential_op_typ Abstract_differential_operator()
    const { return abstract_both; }
  int Give_number_var_of_abstract_op() const { return -1; }
  bool Give_array_variable_inserted() const {
    return  false;
  }
  int Give_length_of_array_variable_inserted() const {
    return 0;
  }
  // For restriction of stencils
  // --------------------------------------
  double Give_interior_sten_element(Index3D I, double meshsize,
                                    int stelle,
                                    const Grid* grid, int l) const {
   return (grid->Give_variable(I.neighbour(ESTd),l)[number_variable] +
           grid->Give_variable(I.neighbour(WNDd),l)[number_variable])
      * 0.5;
  }
  double Give_boundary_sten_element(const Grid* grid, BoCeData* b_cell,
                                    double* u_ablage, int num_v) const {
    return b_cell->vars[num_v][number_variable];
    //    return 1.0;
  }
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar)
    const {
  };
  bool GS_type(int var_number_left, int dim) const {
  return false; }; 

  // at the and of an iteration of an expression
  void clean() const { };
};




/* DExprLIT for double */
class DExprLIT {
 private:
  double value_;
 public:
  DExprLIT(double value)
    { value_ = value; }
  double Give_interior(const P_interior* it_i,const Grid* gr,double h_mesh,
                       int l, double_stencils_in) const {
    return value_;
  };
  double Give_interior_coarse(const P_interior* it_i,const Grid* gr,
                              double h_mesh, int l, double_stencils_in) const {
    return value_;
  };
  double Give_nearb(const P_nearb* it_n,const Grid* gr,double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage)
    const {
    return value_;
  };
  double Give_Bo2p(const P_Bo2p* it_b,const  Grid* gr, int l) const {
    return value_;
  };
  double Give_cellpoi(const P_cellpoi* it_cf,const  Grid* gr,
                      const BoCeData* bocedata) const {
    return value_;
  };

  // for evaluate on cell
  double Give_interior_cell(const P_interior_cell* it_icell ,
                            const Grid* gr, int l) const {
    return value_;
  };
  double Give_bo_tet(const P_boundary_tet* it_bcell, 
                      const Grid* gr) const {
    return value_;
  };

  // Size of necessary stencil
  int Sice_stencil() const { return 0; }

  // activity of points
  int Level() const { return 0; }
  Dominace_label Dominant_lev() const { return anti_dominant; }
  Dominace_label Dominant_poi() const { return anti_dominant; }
  bool run_interior()   const { return true; }
  bool run_nearb()   const { return true; }
  int run_boundary()   const { return true; }

  // number of operations
  int ops_interior() const { return 0; }

  // For operator ==
  void Active_Sim_Level( int lev) const {  };
  void Active_Sim_interior(bool run) const {  };
  void Active_Sim_nearb(bool run) const {  };
  void Active_Sim_boundary( int run) const {  };
  void Active_Sim_update(Evaluation_Parallelization_object* evpar,
                         int level, type_of_update typ) const {  };

  // Put pointer to grid and activity of boundary points of test space  
  void Put_grid_rbo(Grid* gr, int r_bo) const  { };
  // For abstract differential operators:
  // --------------------------------------
  // Is the expression an abstract differential operator?
  Differential_op_typ Abstract_differential_operator() const
    { return abstract_both; }
  int Give_number_var_of_abstract_op() const { return -1; }
  bool Give_array_variable_inserted() const {
    return  false;
  }
  int Give_length_of_array_variable_inserted() const {
    return 0;
  }   
  // For restriction of stencils
  // --------------------------------------
  double Give_interior_sten_element(Index3D I, double meshsize,
                                    int stelle,
                                    const Grid* grid, int l) const {
    return value_;
  }
  double Give_boundary_sten_element(const Grid* grid, BoCeData* b_cell,
                                    double* u_ablage, int num_v) const {
    return value_;
  }
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar)
    const {};
  bool GS_type(int var_number_left, int dim) const {
  return false; }; 

  // at the and of an iteration of an expression
  void clean() const { };
};


        //         Declarations 

// 1. Declaration of Scalarproduct
double Maximum(Variable& a);
double Minimum(Variable& a);
double L_infty(Variable& a);

// 2. Declaration of Scalarproduct
double product(Variable& b, Variable& a);
double product(Variable& a1, Variable& a2, Variable& a3,
               Variable& b1, Variable& b2, Variable& b3);


// 3. Print functions
// For AVS:
void Print_UCD(Variable& a,ofstream *Datei);
void Print_UCD_parallel(Variable& a,ofstream *Datei);
void Print_UCD_parallel(Variable& a,ofstream *Datei, int level);
void Print_UCD_surface_parallel(Variable& a,ofstream *Datei);
void Print_UCD(Variable& a, Variable& b, Variable& c, ofstream *Datei);
void Print_UCD_parallel(Variable& a, Variable& b, Variable& c, 
                        ofstream *Datei);
void Print_UCD_moved(Variable& v,
                     Variable& a, Variable& b, Variable& c, ofstream *Datei);
void Print_UCD_moved_parallel(Variable& v,
                     Variable& a, Variable& b, Variable& c, ofstream *Datei);
// For Gnuplot:
void Print_Gnuplot_moved(Variable& a, Variable& b, Variable& c,
                             ofstream *Datei);
// For OpenDx:
void Print_Dx(Variable& a,ofstream *Datei);
void Print_Dx_parallel(Variable& a,ofstream *Datei);
void Print_Dx_moved(Variable& v,
                    Variable& a, Variable& b, Variable& c, ofstream *Datei);
// direct:
void Print(Variable& a);


// 4.: calculate normal vector
void Normal_vector(Variable& vx, Variable& vy, Variable& vz);

// 5.: Parallel update
void Sum_ghost_nodes(Variable& vx);
void Update_ghost_nodes(Variable& vx);


// ------------------------------------------------------------
//  implementierung of the inline member functions of variable
//  other member functions are contained in variable2.h
// ------------------------------------------------------------



inline void Variable::Active_boundary(int run_bo) {
  r_boundary = run_bo; 
  if(run_bo==false && r_interior==false && r_nearb==false)
    Active_interior(true);
}


inline void Variable::Active_update(Evaluation_Parallelization_object* evpar, 
                                    int level, type_of_update typ) {
  evpar->Set_type_of_update(number_variable,level,no_update);
}


inline double Variable::Give_interior_simple(const P_interior* it_i,
                                             const  Grid* gr, int l) const {
  return it_i->varM(gr,l)[number_variable];
};

inline double Variable::Give_interior(const P_interior* it_i,const  Grid* gr,
                       double h_mesh, int l, double_stencils_in) const {
  return it_i->varM(gr,l)[number_variable];
};

inline double Variable::Give_interior_coarse(const P_interior* it_i,
                       const  Grid* gr,
                       double h_mesh, int l, double_stencils_in) const {
  return it_i->varM(gr,l)[number_variable];
};

inline double Variable::Give_nearb(const P_nearb* it_n,const  Grid* gr,
                            double h_mesh, int l) const {
  return it_n->varM(gr,l)[number_variable];
};

inline double Variable::Give_nearb(const P_nearb* it_n,const  Grid* gr,
                                   double h_mesh, int l, 
                                   const Nearb_Ablage* nearb_ablage) const {
  return it_n->varM(gr,l)[number_variable];
};

inline double Variable::Give_Bo2p(const P_Bo2p* it_b, const Grid* gr, int l)
     const {
  return it_b->varM(gr)[number_variable];
};

inline double Variable::Give_cellpoi(const P_cellpoi* it_cf, const Grid* gr,
                                     const BoCeData* bocedata) const {
  return it_cf->varM(gr)[number_variable];
};
inline double Variable::Give_cellpoi(const P_cellpoi* it_cf,
                                     const Grid* gr) const {
  return it_cf->varM(gr)[number_variable];
};

inline void Variable::Put_interior(const P_interior* it_i, int lev, double x) {
  it_i->varM(grid,lev)[number_variable] = x;
};
inline void Variable::Put_nearb(const P_nearb* it_n, int lev, double x) {
  it_n->varM(grid,lev)[number_variable] = x;
};
inline void Variable::Put_Bo2p(const P_Bo2p* it_b, double x) {
  it_b->varM(grid)[number_variable] = x;
};
inline void Variable::Put_cellpoi(const P_cellpoi* it_cf, double x) {
  it_cf->varM(grid)[number_variable] = x;
};


inline void Variable::Level_up()   { 
  level++; 
}
inline void Variable::Level_down() { 
  level--; 
}
inline void Variable::Active_Level(int Level) { 
  level = Level; 
}


inline void Variable::Active_interior(bool run)  { 
  r_interior = run; 
}
inline void Variable::Active_nearb(bool run)     { 
  r_nearb    = run;
}

inline void Variable::Active_only_boundary(bool run) { 
  r_boundary = run; 
}


#endif
           

---