src/expde/extemp/mg.cc

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

// ------------------------------------------------------------
// mg.cc
//
// ------------------------------------------------------------

// Include level 0:
#ifdef COMP_GNUOLD
 #include <iostream.h>
 #include <fstream.h>
 #include <time.h>
 #include <math.h>
#else
 #include <iostream>
 #include <fstream>
 #include <ctime>
 #include <cmath>
#endif 


// Include level 0:
#include "../parser.h"

// Include level 1:
#include "../paramete.h"
#include "../abbrevi.h"
#include "../math_lib/math_lib.h"

// Include level 2:
#include "../basic/basic.h"

// Include level 3:
#include "../domain/domain.h"

// Include level 4:
#include "../formulas/boundy.h"
#include "../formulas/loc_sten.h"

// Include level 5:
#include "../grid/gpar.h"
#include "../grid/parallel.h"
#include "../grid/mgcoeff.h"
#include "../grid/sto_man.h"
#include "../grid/gridbase.h"
#include "../grid/grid.h"
#include "../grid/input.h"

// Include level 5.1
#include "../evpar/evpar.h"


// Include level 6:
#include "variable.h"
#include "mg_op.h"

    // functions of mg.h

/* Unary operator */

DExpr<DVar_Res_Op>
Restriction_FE(Variable a)
{
  typedef DVar_Res_Op ExprT;
  return DExpr<ExprT>(ExprT(a));
}

DExpr<DVar_Prol_Op>
Prolongation_FE(Variable a)
{
  typedef DVar_Prol_Op ExprT;
  return DExpr<ExprT>(ExprT(a));
}



// Interpolation at a regular point near the boundary, l level of fine grid
double DVar_Prol_Op::Give_at_Index(const Index3D I, const Grid* grid,
                                   int l) const {


  if(I.I_x().Tiefe()==l) {
    if(I.I_y().Tiefe()==l) {
      if(I.I_z().Tiefe()==l) {
        // middle point
        // edge between EST-WND
        return 0.5 *
          (grid->Give_variable(I.next_EST(l),l-1)[v_.Number_variable()] +
           grid->Give_variable(I.next_WND(l),l-1)[v_.Number_variable()]);
      }
      else {
        // TD-surface
        // edge between ES-WN
        return 0.5 *
          (grid->Give_variable(I.next_ES(l),l-1)[v_.Number_variable()] +
           grid->Give_variable(I.next_WN(l),l-1)[v_.Number_variable()]);
      }
    }
    else {
      if(I.I_z().Tiefe()==l) {
        // NS-surface
        // edge between WT-ED
        return 0.5 *
          (grid->Give_variable(I.next_WT(l),l-1)[v_.Number_variable()] +
           grid->Give_variable(I.next_ED(l),l-1)[v_.Number_variable()]);
      }
      else {
        // EW-edge
        return 0.5 *
          (grid->Give_variable(I.next_E(l),l-1)[v_.Number_variable()] +
           grid->Give_variable(I.next_W(l),l-1)[v_.Number_variable()]);
      }
    }
  }
  else {
    if(I.I_y().Tiefe()==l) {
      if(I.I_z().Tiefe()==l) {
        // EW-surface
        // edge between ST-ND
        return 0.5 *
          (grid->Give_variable(I.next_ST(l),l-1)[v_.Number_variable()] +
           grid->Give_variable(I.next_ND(l),l-1)[v_.Number_variable()]);
      }
      else {
        // NS-edge
        return 0.5 *
          (grid->Give_variable(I.next_N(l),l-1)[v_.Number_variable()] +
           grid->Give_variable(I.next_S(l),l-1)[v_.Number_variable()]);
      }
    }
    else {
      if(I.I_z().Tiefe()==l) {
        // TD-edge
        return 0.5 *
          (grid->Give_variable(I.next_T(l),l-1)[v_.Number_variable()] +
           grid->Give_variable(I.next_D(l),l-1)[v_.Number_variable()]);


      }
      else {
        // idem-point
        return grid->Give_variable(I,l-1)[v_.Number_variable()];
      }
    }
  }
  return 0.0;
};

---