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

// ------------------------------------------------------------
// sim2.h
//
// ------------------------------------------------------------


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);
  };
  bool GS_type(int var_number_left, int dim_left) const {
    return a_.GS_type(var_number_left, dim_left);
  }
  // at the and of an iteration of an expression
  void clean() const { a_.clean(); };
};



template<class B>
class DExprVecSim {
 private:
  // Nummer der Variablen
  int number_variable;
  int *value_;
  int dim;

  // variable
  Variable* a;  // not used

  // expression
  B b_;
 public:
  DExprVecSim(int num_var, int* val, int dime, const B& b) : b_(b) {
    number_variable = num_var;
    value_          = val;
    dim = dime;
  }
  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_] = 
      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+*value_] =
      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+*value_] = 
      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+*value_] = 
      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+*value_] =
      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_Sim_update(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,dim);
  };

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

---