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

// ------------------------------------------------------------
// sim.h
//
// ------------------------------------------------------------


#ifndef SIM_H_
#define SIM_H_
            
//  1. Expresions for several equations
//  2. while cnstruction (not finished now)

//  1. Expresions for several equations



/* DExprAnd */
template<class A, class B>
class DExprAnd {
  A a_;
  B b_;
 public:
  DExprAnd(const A& a, const B& b)
    : a_(a), b_(b)
    {}
  double Give_interior(const P_interior* it_i, const Grid* gr, double h_mesh,
                       int l, double_stencils_in) const {
    b_.Run_interior(it_i,gr,h_mesh,l, double_stencils_out);
    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 {
    b_.Run_interior_coarse(it_i,gr,h_mesh,l, double_stencils_out);
    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 {
    b_.Run_nearb(it_n,gr,h_mesh,l,nearb_ablage);
    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 {
    b_.Run_Bo2p(it_b,gr,l);
    return a_.Give_Bo2p(it_b,gr,l);
  };
  double Give_cellpoi(const P_cellpoi* it_cf,const Grid* gr,
                      const BoCeData* bocedata) const {
    b_.Run_cellpoi(it_cf,gr,bocedata);
    return a_.Give_cellpoi(it_cf,gr,bocedata);
  };

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

  // activity of points
  int Level() const { 
    if(b_.Dominant_lev()==yes_dominant || a_.Dominant_lev() == anti_dominant)
      return b_.Level();
    else
      if(a_.Dominant_lev()==yes_dominant|| b_.Dominant_lev() == anti_dominant)
        return a_.Level();
    else return MAX(a_.Level(),b_.Level()); 
  }
  Dominace_label Dominant_lev() const {
    return (Dominace_label)(MAX(a_.Dominant_lev(),b_.Dominant_lev()));
  }
  Dominace_label Dominant_poi() const {
    return (Dominace_label)(MAX(a_.Dominant_poi(),b_.Dominant_poi()));
  }
  bool run_interior() const { 
    if(a_.Dominant_poi()==yes_dominant || b_.Dominant_poi() == anti_dominant)
      return a_.run_interior();
    else return b_.run_interior(); 
  }
  bool run_nearb() const { 
    if(a_.Dominant_poi()==yes_dominant || b_.Dominant_poi() == anti_dominant)
      return a_.run_nearb();
    else return b_.run_nearb(); 
  }
  int run_boundary() const { 
    if(a_.Dominant_poi()==yes_dominant || b_.Dominant_poi() == anti_dominant)
      return a_.run_boundary();
    else return b_.run_boundary(); 
  }
  // calculation of computational time and MFlops
  int ops_interior() const { return a_.ops_interior() + b_.ops_interior(); }
  // For operator ==
  void Active_Sim_Level( int lev) const { 
    a_.Active_Sim_Level(lev); b_.Active_Sim_Level(lev); };
  void Active_Sim_interior(bool run) const { 
    a_.Active_Sim_interior(run); b_.Active_Sim_interior(run); };
  void Active_Sim_nearb(bool run) const { 
    a_.Active_Sim_nearb(run); b_.Active_Sim_nearb(run); };
  void Active_Sim_boundary( int run) const { 
    a_.Active_Sim_boundary(run); b_.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); 
    b_.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);
    b_.Put_grid_rbo(gr,r_bo); }
  // Is the expression an abstract differential operator?
  bool Abstract_differential_operator() {
    return false; }
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar) 
    const {
    a_.Add_variables_for_parallel(evpar);
    b_.Add_variables_for_parallel(evpar);
  };
  bool GS_type(int var_number_left, int dim_left) const {
    if(b_.GS_type(var_number_left, dim_left)==true) return true;
    return a_.GS_type(var_number_left, dim_left);
  };

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

/* DExprAnd */
template<class A, class B>
class DExprAndSim {
  A a_;
  B b_;
 public:
  DExprAndSim(const A& a, const B& b)
    : a_(a), b_(b)
    {}
  void Run_interior(const P_interior* it_i, const Grid* gr, double h_mesh,
                       int l, double_stencils_in) const {
    b_.Run_interior(it_i,gr,h_mesh,l, double_stencils_out);
    a_.Run_interior(it_i,gr,h_mesh,l, double_stencils_out);
  }
  void Run_interior_coarse(const P_interior* it_i, const Grid* gr,
                           double h_mesh,
                           int l, double_stencils_in) const {
    b_.Run_interior_coarse(it_i,gr,h_mesh,l, double_stencils_out);
    a_.Run_interior_coarse(it_i,gr,h_mesh,l, double_stencils_out);
  }
  void Run_nearb(const P_nearb* it_n,const Grid* gr, double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage)
    const {
    b_.Run_nearb(it_n,gr,h_mesh,l,nearb_ablage);
    a_.Run_nearb(it_n,gr,h_mesh,l,nearb_ablage);
  };
  void Run_Bo2p(const P_Bo2p* it_b,const Grid* gr, int l) const {
    b_.Run_Bo2p(it_b,gr,l);
    a_.Run_Bo2p(it_b,gr,l);
  };
  void Run_cellpoi(const P_cellpoi* it_cf,const Grid* gr,
                      const BoCeData* bocedata) const {
    b_.Run_cellpoi(it_cf,gr,bocedata);
    a_.Run_cellpoi(it_cf,gr,bocedata);
  };

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

  // activity of points
  int Level() const { 
    if(b_.Dominant_lev()==yes_dominant || a_.Dominant_lev() == anti_dominant)
      return b_.Level();
    else
      if(a_.Dominant_lev()==yes_dominant|| b_.Dominant_lev() == anti_dominant)
        return a_.Level();
    else return MAX(a_.Level(),b_.Level()); 
  }
  Dominace_label Dominant_lev() const {
    return (Dominace_label)(MAX(a_.Dominant_lev(),b_.Dominant_lev()));
  }
  Dominace_label Dominant_poi() const {
    return (Dominace_label)(MAX(a_.Dominant_poi(),b_.Dominant_poi()));
  }
  bool run_interior() const { 
    if(a_.Dominant_poi()==yes_dominant || b_.Dominant_poi() == anti_dominant)
      return a_.run_interior();
    else return b_.run_interior(); 
  }
  bool run_nearb() const { 
    if(a_.Dominant_poi()==yes_dominant || b_.Dominant_poi() == anti_dominant)
      return a_.run_nearb();
    else return b_.run_nearb(); 
  }
  int run_boundary() const { 
    if(a_.Dominant_poi()==yes_dominant || b_.Dominant_poi() == anti_dominant)
      return a_.run_boundary();
    else return b_.run_boundary(); 
  }

  // calculation of computational time and MFlops
  int ops_interior() const { return a_.ops_interior() + b_.ops_interior(); }
  // For operator ==
  void Active_Sim_Level( int lev) const { 
    a_.Active_Sim_Level(lev); b_.Active_Sim_Level(lev); };
  void Active_Sim_interior(bool run) const { 
    a_.Active_Sim_interior(run); b_.Active_Sim_interior(run); };
  void Active_Sim_nearb(bool run) const { 
    a_.Active_Sim_nearb(run); b_.Active_Sim_nearb(run); };
  void Active_Sim_boundary( int run)  const {
    a_.Active_Sim_boundary(run); b_.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); 
    b_.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);
    b_.Put_grid_rbo(gr,r_bo); }
  // Is the expression an abstract differential operator?
   Differential_op_typ Abstract_differential_operator() const
    { return not_abstract; }
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar) 
    const {
    a_.Add_variables_for_parallel(evpar);
    b_.Add_variables_for_parallel(evpar);
  };
  bool GS_type(int var_number_left, int dim_left) const {
    if(b_.GS_type(var_number_left, dim_left)==true) return true;
    return a_.GS_type(var_number_left, dim_left);
  };

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

// Sim

/* Wrapper Sim */
/* DExprSim */
/*
template<class A>
class DWrapSim {
  A a_;
 public:
  DWrapSim(const A& a)
    : a_(a)
    {}
  void Run_interior(const P_interior* it_i,const Grid* gr, double h_mesh,
                       int l, double_stencils_in) const {
    a_.Run_interior(it_i,gr,h_mesh,l, double_stencils_out);
  };
  void Run_interior_coarse(const P_interior* it_i,const Grid* gr,
                           double h_mesh,
                           int l, double_stencils_in) const {
    a_.Run_interior_coarse(it_i,gr,h_mesh,l, double_stencils_out);
  };
  void Run_nearb(const P_nearb* it_n,const Grid* gr, double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage)
    const {
    a_.Run_nearb(it_n,gr,h_mesh,l,nearb_ablage);
  };
  void Run_Bo2p(const P_Bo2p* it_b,const Grid* gr, int l) const {
    a_.Run_Bo2p(it_b,gr,l);
  };
  void Run_cellpoi(const P_cellpoi* it_cf,const Grid* gr,
                      const BoCeData* bocedata) const {
    a_.Run_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 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); }
  // Is the expression an abstract differential operator?
   Differential_op_typ Abstract_differential_operator() const
    { return not_abstract; }
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar) 
    const {
    a_.Add_variables_for_parallel(evpar);
  };

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


/* DExprSim */
template<class B>
class DExprSim {
 private:
  // Nummer der Variablen
  int number_variable;
  // variable
  Variable* a;

  // expression
  B b_;
 public:
  DExprSim(Variable& vec, const B& b) : b_(b) {
    number_variable =  vec.Number_variable();
    a = vec.Give_my_pointer();
  }
  void Run_interior(const P_interior* it_i,const Grid* gr, double h_mesh,
                       int l, double_stencils_in) const {
    it_i->varM(gr,l)[number_variable] = 
      b_.Give_interior(it_i,gr,h_mesh,l, double_stencils_out);
  };
  void Run_interior_coarse(const P_interior* it_i,const Grid* gr,
                           double h_mesh,
                       int l, double_stencils_in) const {
    it_i->varM(gr,l)[number_variable] =
      b_.Give_interior_coarse(it_i,gr,h_mesh,l, double_stencils_out);
  };
  void Run_nearb(const P_nearb* it_n,const Grid* gr, double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage) const {
    it_n->varM(gr,l)[number_variable] = 
      b_.Give_nearb(it_n,gr,h_mesh,l,nearb_ablage);
  };
  void Run_Bo2p(const P_Bo2p* it_b,const Grid* gr, int l) const {
    it_b->varM(gr)[number_variable] = 
      b_.Give_Bo2p(it_b,gr,l);
  };
  void Run_cellpoi(const P_cellpoi* it_cf,const Grid* gr,
                      const BoCeData* bocedata) const {
    it_cf->varM(gr)[number_variable] =
      b_.Give_cellpoi(it_cf,gr,bocedata);
  };

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

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

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

  // For operator ==
  void Active_Sim_Level( int lev) const {
    a->Active_Level(lev); 
    b_.Active_Sim_Level(lev); }
  void Active_Sim_interior(bool run) const {
    a->Active_interior(run); 
    b_.Active_Sim_interior(run); }
  void Active_Sim_nearb(bool run) const {
    a->Active_nearb(run); 
    b_.Active_Sim_nearb(run); }
  void Active_Sim_boundary( int run) const {
    a->Active_boundary(run);
    b_.Active_Sim_boundary(run); }
  void Active_Sim_update(Evaluation_Parallelization_object* evpar,
                         int level, type_of_update typ) const { 
    a->Active_update(evpar,level,typ); 
    b_.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 {
    b_.Put_grid_rbo(gr,r_bo); }
  // Is the expression an abstract differential operator?
   Differential_op_typ Abstract_differential_operator() const
    { return not_abstract; }
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar) 
    const {
    b_.Add_variables_for_parallel(evpar);
  };
  bool GS_type(int var_number_left, int dim_left) const {
    return b_.GS_type(number_variable,0);
  };

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


/* DExprSimLit */
class DExprSimLit {
 private:
  // Aktive Punkte:
  int  r_boundary;   // type boundary point:
  bool r_interior;   // type interior point:
  bool r_nearb;      // type nearb point:
  int  level;        // level:
  // variable
  Variable* a;

  // Nummer der Variablen
  int number_variable;

  // value
  double value_;
 public:
  DExprSimLit(Variable& vec, double value) {
    r_boundary = vec.run_boundary();
    r_interior = vec.run_interior();
    r_nearb    = vec.run_nearb();
    level      = vec.Level();
    number_variable =  vec.Number_variable();
    value_ = value;

    a = vec.Give_my_pointer();
  }
  void Run_interior(const P_interior* it_i,const Grid* gr, double h_mesh,
                       int l, double_stencils_in) const {
    it_i->varM(gr,l)[number_variable] = value_;
  };
  void Run_interior_coarse(const P_interior* it_i,const Grid* gr,
                           double h_mesh,
                           int l, double_stencils_in) const {
    it_i->varM(gr,l)[number_variable] = value_;
  };
  void Run_nearb(const P_nearb* it_n,const Grid* gr, double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage) const {
    it_n->varM(gr,l)[number_variable] = value_;
  };
  void Run_Bo2p(const P_Bo2p* it_b,const Grid* gr, int l) const {
    it_b->varM(gr)[number_variable] = value_;
  };
  void Run_cellpoi(const P_cellpoi* it_cf,const Grid* gr,
                      const BoCeData* bocedata) const {
    it_cf->varM(gr)[number_variable] = value_;
  };

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

  // activity of points
  int Level() const { return level;  }
  Dominace_label Dominant_lev() const { return yes_dominant; }
  Dominace_label Dominant_poi() const { return yes_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 {
    a->Active_Level(lev); }
  void Active_Sim_interior(bool run) const {
    a->Active_interior(run); }
  void Active_Sim_nearb(bool run) const {
    a->Active_nearb(run); }
  void Active_Sim_boundary( int run) const {
    a->Active_boundary(run); }
  void Active_Sim_update(Evaluation_Parallelization_object* evpar,
                         int level, type_of_update typ) const { 
    a->Active_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 { };
  // Is the expression an abstract differential operator?
   Differential_op_typ Abstract_differential_operator() const
    { return not_abstract; }
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar) 
    const { 
  };
  bool GS_type(int var_number_left, int dim_left) const {
  return false; }; 

  void clean() const { };
};

// new:
template<class B>
class DExprSimloc {
  double *a;
  B b_;
 public:
  DExprSimloc(const Local_var& av, const B& b)
    : a(av.Give_pointer()), b_(b)
    {}
  void Run_interior(const P_interior* it_i,const Grid* gr, double h_mesh,
                       int l, double_stencils_in) const {
    *a = b_.Give_interior(it_i,gr,h_mesh,l, double_stencils_out);
  };
  void Run_interior_coarse(const P_interior* it_i,const Grid* gr,
                           double h_mesh,
                           int l, double_stencils_in) const {
    *a = b_.Give_interior(it_i,gr,h_mesh,l, double_stencils_out);
  };
  void Run_nearb(const P_nearb* it_n,const Grid* gr, double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage) const {
    *a = b_.Give_nearb(it_n,gr,h_mesh,l,nearb_ablage);
  };
  void Run_Bo2p(const P_Bo2p* it_b,const Grid* gr, int l) const {
    *a = b_.Give_Bo2p(it_b,gr,l);
  };
  void Run_cellpoi(const P_cellpoi* it_cf,const Grid* gr,
                      const BoCeData* bocedata) const {
    *a = b_.Give_cellpoi(it_cf,gr,bocedata);
  };

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

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

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

  // For operator ==
  void Active_Sim_Level( int lev) const {
    b_.Active_Sim_Level(lev); }
  void Active_Sim_interior(bool run) const {
    b_.Active_Sim_interior(run); }
  void Active_Sim_nearb(bool run) const {
    b_.Active_Sim_nearb(run); }
  void Active_Sim_boundary( int run) const {
    b_.Active_Sim_boundary(run); }
  void Active_Sim_update(Evaluation_Parallelization_object* evpar,
                         int level, type_of_update typ) const { 
    b_.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 {
    b_.Put_grid_rbo(gr,r_bo); }
  // Is the expression an abstract differential operator?
   Differential_op_typ Abstract_differential_operator() const
    { return not_abstract; }
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar) 
    const {
    b_.Add_variables_for_parallel(evpar);
  };
  bool GS_type(int var_number_left, int dim_left) const {
    return b_.GS_type(var_number_left, dim_left);
  }; 

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

class DExprSimlocLit {
  double *a;
  double x;
 public:
  DExprSimlocLit(const Local_var& av, double x_)
    : a(av.Give_pointer()), x(x_)
    {}
  void Run_interior(const P_interior* it_i,const Grid* gr, double h_mesh,
                       int l, double_stencils_in) const {
    *a = x;
  };
  void Run_interior_coarse(const P_interior* it_i,const Grid* gr,
                           double h_mesh,
                           int l, double_stencils_in) const {
    *a = x;
  };
  void Run_nearb(const P_nearb* it_n,const Grid* gr, double h_mesh, int l,
                    const Nearb_Ablage* nearb_ablage) const {
    *a = x;
  };
  void Run_Bo2p(const P_Bo2p* it_b,const Grid* gr, int l) const {
    *a = x;
  };
  void Run_cellpoi(const P_cellpoi* it_cf,const Grid* gr,
                      const BoCeData* bocedata) const {
    *a = x;
  };

  // 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 1; }
  bool run_boundary() const { return 1; }
  int run_nearb() 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 not_abstract; }
  // for Parallelization
  void Add_variables_for_parallel(Evaluation_Parallelization_object *evpar) 
    const { };
  bool GS_type(int var_number_left, int dim_left) const {
  return false; }; 

  void clean() const { };
};


// several & operators for systems of equations

template<class A, class B>
DExpr<DExprAnd<DExpr<A>,  DWrapSim<B> > >
operator&(const  DExpr<A>& a, const DWrapSim<B>& b)
{
  typedef DExprAnd<DExpr<A>,  DWrapSim<B> >  ExprT;
  return DExpr<ExprT>(ExprT(a,b));
}


template<class A, class B>
DWrapSim<DExprAndSim<DWrapSim<A>,  DWrapSim<B> > >
operator&(const  DWrapSim<A>& a, const DWrapSim<B>& b)
{
  typedef DExprAndSim<DWrapSim<A>,  DWrapSim<B> >  ExprT;
  return DWrapSim<ExprT>(ExprT(a,b));
}


template<class B>
DExpr<DExprAnd<DExprVAR,  DWrapSim<B> > >
operator&(Variable& a, const DWrapSim<B>& b)
{
  typedef DExprAnd<DExprVAR,  DWrapSim<B> >  ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(a),b));
}

template<class B>
DExpr<DExprAnd<DExprLIT,  DWrapSim<B> > >
operator&(double value, const DWrapSim<B>& b)
{
  typedef DExprAnd<DExprLIT,  DWrapSim<B> >  ExprT;
  return DExpr<ExprT>(ExprT(DExprLIT(value),b));
}


template<class B>
DExpr<DExprAnd<Local_var,  DWrapSim<B> > >
operator&(Local_var &a, const DWrapSim<B>& b)
{
  typedef DExprAnd<Local_var,  DWrapSim<B> >  ExprT;
  return DExpr<ExprT>(ExprT(a,b));
}

/*
template<class B>
DWrapSim<DExprVecSim<B> >
operator== (DExpr<DExprVAR_ARR>& a, const  B& b_)
{
  typedef DWrapSim<DExprVecSim<B> > ExprT;
  return ExprT(DExprVecSim<B>(a.Number_variable(),a.Give_value(),b_)); 
}
*/
template<class B> 
DWrapSim<DExprSim<B> >
operator== (Variable& a, const  B& b_)
{
  typedef DWrapSim<DExprSim<B> > ExprT;
  return ExprT(DExprSim<B>(a,b_)); 
}

DWrapSim<DExprSimLit>
operator== (Variable& a, double value);


template<class B> 
DWrapSim<DExprSimloc<B> > 
operator== (const Local_var& a, const  B& b_)
{
  typedef DWrapSim<DExprSimloc<B> > ExprT;
  return ExprT(DExprSimloc<B>(a,b_)); 
}

DWrapSim<DExprSimlocLit>
operator== (const Local_var& a, double x);

DWrapSim<DExprSimloc<DExprVAR> >
operator== (const Local_var& a, Variable& b);


//  2. while cnstruction

/* DExprWhile */
/*
template<class B>
class DExprWhile {
  Local_var *a;
  B b_;
 public:
  DExprWhile(Local_var *av, const B& b)
    : a(av), b_(b)
    {}
  void run_interior(const I_point *i_point, const double h_mesh) const {
   while(a->Get()>0) b_.run_interior(i_point,h_mesh);
  }
  void run_black(const I_point *i_point, const double h_mesh) const {
   while(a->Get()>0) b_.run_black(i_point,h_mesh);
  }
  void run_red(const I_point *i_point, const double h_mesh) const {
   while(a->Get()>0) b_.run_red(i_point,h_mesh);
  }
  void run_boundary(const I_point *i_point, const double h_mesh) const {
   while(a->Get()>0) b_.run_boundary(i_point,h_mesh);
  }
  void run_R(const I_point *i_point, const double h_mesh) const {
    cout << " \n fehlt noch in DExprWhile! \n";
  }

  // activity of points
  int Level() const { 
    return b_.Level();
  }
  //  int Dominant() const { return b_.Dominant(); }
  int Dominant() const { return -1; }
  int run_red() const { return b_.run_red(); }
  int run_boundary() const { return b_.run_boundary(); }
  int run_interior() const { return b_.run_interior(); }
  int run_black() const { return b_.run_black(); }
  int run_boundary() const { return b_.run_boundary(); }

  // calculation of computational time and MFlops
  int ops_black() const { return b_.ops_black(); }
  int ops_red()   const { return b_.ops_red(); }
  int ops_interior() const { return b_.ops_interior(); }
  int ops_boundary()  const { return b_.ops_boundary(); }
  int ops()       const { return b_.ops(); }
  // For operator ==
  void Active_Sim_Level( int lev) const {
    b_.Active_Sim_Level(lev); }
  void Active_Sim_interior( int run) const {
    b_.Active_Sim_interior(run); }
  void Active_Sim_black( int run) const {
    b_.Active_Sim_black(run); }
  void Active_Sim_boundary( int run) const {
    b_.Active_Sim_boundary(run); }
  void Active_Sim_red( int run) const {
    b_.Active_Sim_red(run);}
  void Active_Sim_boundary( int run) const {
    b_.Active_Sim_boundary(run);}
  void Active_Sim_update(Evaluation_Parallelization_object* evpar,
  int level, type_of_update typ) const { 
    b_.Active_Sim_update(evpar,level,typ); };

};

template<class B>
DExprWhile<B>
While(Local_var& a, const B& b)
{
 return DExprWhile<B>(&a,b);
}


template<class A, class B>
DExpr<DExprAnd<DExpr<A> ,  DExprWhile<B> > >
operator&(const DExpr<A>& a, const DExprWhile<B>& b)
{
  typedef DExprAnd<DExpr<A>,  DExprWhile<B> >  ExprT;
  return DExpr<ExprT>(ExprT(a,b));
}


template<class B>
DExpr<DExprAnd<DExprLIT,  DExprWhile<B> > >
operator&(double value, const DExprWhile<B>& b)
{
  typedef DExprAnd<DExprLIT,  DExprWhile<B> >  ExprT;
  return DExpr<ExprT>(ExprT(DExprLIT(value),b));
}


template<class B>
DExpr<DExprAnd<Local_var,  DExprWhile<B> > >
operator&(Local_var& a, const DExprWhile<B>& b)
{
  typedef DExprAnd<Local_var,  DExprWhile<B> >  ExprT;
  return DExpr<ExprT>(ExprT(a,b));
}

*/

#endif
             

---