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

// ------------------------------------------------------------
// eleme.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 "eleme.h"

           // 1.:  Coordinate functions
           // 2.:  Class for Functions
           // 3.:  Restriction operator with respect to points
           // 4.:  Binary operators

// 1. Coordinate functions

DExpr<CoordinateX> X() {
  typedef CoordinateX ExprT;
  return DExpr<ExprT>(ExprT());
}

DExpr<CoordinateY> Y() {
  typedef CoordinateY ExprT;
  return DExpr<ExprT>(ExprT());
}

DExpr<CoordinateZ> Z() {
  typedef CoordinateZ ExprT;
  return DExpr<ExprT>(ExprT());
}



// 2.:  Class for Functions



 // 3.1:  Restriction operator with respect to points


Subgrid operator&(Subgrid a, Subgrid b) {
  if(a.run_boundary()==true || b.run_boundary()==true) {
    return Subgrid(a.run_interior() || b.run_interior(),
                   a.run_nearb()    || b.run_nearb(),true);
  }
  if(a.run_boundary()<false && b.run_boundary()<false) {
    int r_boundary;
    r_boundary = -a.grid->Give_number_label_bo();
    a.grid->Put_union_label(-r_boundary,-a.run_boundary(),-b.run_boundary());

    if(a.static_grid==false) a.Free();
    if(b.static_grid==false) b.Free();

    return Subgrid(a.run_interior() || b.run_interior(),
                   a.run_nearb()    || b.run_nearb(),
                   r_boundary,a.grid);
  }
  /* old mit Fehler
  if(a.run_boundary()<false) {
    if(a.static_grid==false) a.Free();
    return Subgrid(a.run_interior() || b.run_interior(),
                   a.run_nearb()    || b.run_nearb(),
                   a.run_boundary(),a.grid);
  }
  if(b.static_grid==false) b.Free();
  return Subgrid(a.run_interior() || b.run_interior(),
                 a.run_nearb()    || b.run_nearb(),
                 b.run_boundary(),b.grid);
  */
  if(a.run_boundary()<false) { //dann: b.run_boundary==false
    return Subgrid(a.static_grid,
                   a.run_interior() || b.run_interior(),
                   a.run_nearb()    || b.run_nearb(),
                   a.run_boundary(),a.grid);
  }
  //dann: a.run_boundary==false
  // und: a.run_boundary==false || a.run_boundary<false
  return Subgrid(b.static_grid,
                 a.run_interior() || b.run_interior(),
                 a.run_nearb()    || b.run_nearb(),
                 b.run_boundary(),b.grid);

}

/* Restrict on points */
DExpr<DExprResP<DExprLIT, Subgrid> >
operator|(double x, const Subgrid& r)
{
  typedef DExprResP<DExprLIT, Subgrid> ExprT;
  return DExpr<ExprT>(ExprT(x,r));
}

DExprResVarP<Subgrid>
operator|(Variable &a, const Subgrid& r)
{
  typedef DExprResVarP<Subgrid> ExprT;
  return ExprT(ExprT(a,r));
}

FunctionClass
operator|(double (*formula)(double x,double y, double z), const Subgrid& r)
{
  return FunctionClass(formula,r);
}

 // 3.2:  Restriction operator with respect to points (domain)

DExprResDomain<DExprLIT>
operator|(double x, const Domain& dom)
{
  typedef DExprResDomain<DExprLIT> ExprT;
  return ExprT(x,dom);
}


 // 4.:  Binary operators


/* Mul */
DExpr<DExprBinOp<DExprLIT, DExprVAR, DApMul> >
operator*(double x, Variable& a)
{
  typedef DExprBinOp<DExprLIT, DExprVAR, DApMul> ExprT;
  return DExpr<ExprT>(ExprT(DExprLIT(x),DExprVAR(a)));
}


DExpr<DExprBinOp<Local_var, DExprVAR, DApMul> >
operator*( Local_var& x,Variable& a)
{
  typedef DExprBinOp<Local_var, DExprVAR, DApMul> ExprT;
  return DExpr<ExprT>(ExprT(x,DExprVAR(a)));
}


DExpr<DExprBinOp<DExprVAR, DExprLIT, DApMul> >
operator*(Variable& a,double x)
{
  typedef DExprBinOp<DExprVAR, DExprLIT, DApMul> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(a),DExprLIT(x)));
}


DExpr<DExprBinOp<DExprVAR, Local_var, DApMul> >
operator*(Variable& a,Local_var& x)
{
  typedef DExprBinOp<DExprVAR, Local_var, DApMul> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(a),x));
}


DExpr<DExprBinOp<DExprVAR, DExprVAR, DApMul> >
operator*(Variable& b, Variable& a)
{
  typedef DExprBinOp<DExprVAR, DExprVAR, DApMul> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(b),DExprVAR(a)));
}



DExpr<DExprBinOp<Local_var, DExprLIT, DApMul> >
operator*(Local_var&  a,double x)
{
  typedef DExprBinOp<Local_var, DExprLIT, DApMul> ExprT;
  return DExpr<ExprT>(ExprT(a,DExprLIT(x)));
}

DExpr<DExprBinOp<DExprLIT, Local_var, DApMul> >
operator*(double x, Local_var&  a)
{
  typedef DExprBinOp<DExprLIT, Local_var, DApMul> ExprT;
  return DExpr<ExprT>(ExprT(DExprLIT(x),a));
}

DExpr<DExprBinOp<Local_var, Local_var, DApMul> >
operator*(Local_var& b, Local_var& a)
{
  typedef DExprBinOp<Local_var, Local_var, DApMul> ExprT;
  return DExpr<ExprT>(ExprT(b,a));
}





/* Add */
DExpr<DExprBinOp<DExprLIT, DExprVAR, DApAdd> >
operator+(double x,Variable& a)
{
  typedef DExprBinOp<DExprLIT, DExprVAR, DApAdd> ExprT;
  return DExpr<ExprT>(ExprT(DExprLIT(x),DExprVAR(a)));
}


DExpr<DExprBinOp<Local_var, DExprVAR, DApAdd> >
operator+( Local_var& x,Variable& a)
{
  typedef DExprBinOp<Local_var, DExprVAR, DApAdd> ExprT;
  return DExpr<ExprT>(ExprT(x,DExprVAR(a)));
}


DExpr<DExprBinOp<DExprVAR, DExprLIT, DApAdd> >
operator+(Variable& a,double x)
{
  typedef DExprBinOp<DExprVAR, DExprLIT, DApAdd> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(a),DExprLIT(x)));
}



DExpr<DExprBinOp<DExprVAR, Local_var, DApAdd> >
operator+(Variable& a,Local_var& x)
{
  typedef DExprBinOp<DExprVAR, Local_var, DApAdd> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(a),x));
}



DExpr<DExprBinOp<DExprVAR, DExprVAR, DApAdd> >
operator+(Variable& b, Variable& a)
{
  typedef DExprBinOp<DExprVAR, DExprVAR, DApAdd> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(b),DExprVAR(a)));
}


DExpr<DExprBinOp<Local_var, DExprLIT, DApAdd> >
operator+(Local_var&  a,double x)
{
  typedef DExprBinOp<Local_var, DExprLIT, DApAdd> ExprT;
  return DExpr<ExprT>(ExprT(a,DExprLIT(x)));
}

DExpr<DExprBinOp<DExprLIT, Local_var, DApAdd> >
operator+(double x, Local_var&  a)
{
  typedef DExprBinOp<DExprLIT, Local_var, DApAdd> ExprT;
  return DExpr<ExprT>(ExprT(DExprLIT(x),a));
}

DExpr<DExprBinOp<Local_var, Local_var, DApAdd> >
operator+(Local_var& b, Local_var& a)
{
  typedef DExprBinOp<Local_var, Local_var, DApAdd> ExprT;
  return DExpr<ExprT>(ExprT(b,a));
}

/* Sub */
DExpr<DExprBinOp<DExprLIT, DExprVAR, DApSub> >
operator-(double x,Variable& a)
{
  typedef DExprBinOp<DExprLIT, DExprVAR, DApSub> ExprT;
  return DExpr<ExprT>(ExprT(DExprLIT(x),DExprVAR(a)));
}


DExpr<DExprBinOp<Local_var, DExprVAR, DApSub> >
operator-( Local_var& x,Variable& a)
{
  typedef DExprBinOp<Local_var, DExprVAR, DApSub> ExprT;
  return DExpr<ExprT>(ExprT(x,DExprVAR(a)));
}


DExpr<DExprBinOp<DExprVAR, DExprLIT, DApSub> >
operator-(Variable& a,double x)
{
  typedef DExprBinOp<DExprVAR, DExprLIT, DApSub> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(a),DExprLIT(x)));
}


DExpr<DExprBinOp<DExprVAR, Local_var, DApSub> >
operator-(Variable& a,Local_var& x)
{
  typedef DExprBinOp<DExprVAR, Local_var, DApSub> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(a),x));
}



DExpr<DExprBinOp<DExprVAR, DExprVAR, DApSub> >
operator-(Variable& b, Variable& a)
{
  typedef DExprBinOp<DExprVAR, DExprVAR, DApSub> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(b),DExprVAR(a)));
}


DExpr<DExprBinOp<Local_var, DExprLIT, DApSub> >
operator-(Local_var&  a,double x)
{
  typedef DExprBinOp<Local_var, DExprLIT, DApSub> ExprT;
  return DExpr<ExprT>(ExprT(a,DExprLIT(x)));
}

DExpr<DExprBinOp<DExprLIT, Local_var, DApSub> >
operator-(double x, Local_var&  a)
{
  typedef DExprBinOp<DExprLIT, Local_var, DApSub> ExprT;
  return DExpr<ExprT>(ExprT(DExprLIT(x),a));
}


DExpr<DExprBinOp<Local_var, Local_var, DApSub> >
operator-(Local_var& b, Local_var& a)
{
  typedef DExprBinOp<Local_var, Local_var, DApSub> ExprT;
  return DExpr<ExprT>(ExprT(b,a));
}

/* Divide */
DExpr<DExprBinOp<DExprLIT, DExprVAR, DApDivide> >
operator/(double x,Variable& a)
{
  typedef DExprBinOp<DExprLIT, DExprVAR, DApDivide> ExprT;
  return DExpr<ExprT>(ExprT(DExprLIT(x),DExprVAR(a)));
}


DExpr<DExprBinOp<Local_var, DExprVAR, DApDivide> >
operator/( Local_var& x,Variable& a)
{
  typedef DExprBinOp<Local_var, DExprVAR, DApDivide> ExprT;
  return DExpr<ExprT>(ExprT(x,DExprVAR(a)));
}



DExpr<DExprBinOp<DExprVAR, DExprLIT, DApDivide> >
operator/(Variable& a,double x)
{
  typedef DExprBinOp<DExprVAR, DExprLIT, DApDivide> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(a),DExprLIT(x)));
}


DExpr<DExprBinOp<DExprVAR, Local_var, DApDivide> >
operator/(Variable& a,Local_var& x)
{
  typedef DExprBinOp<DExprVAR, Local_var, DApDivide> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(a),x));
}

DExpr<DExprBinOp<DExprVAR, DExprVAR, DApDivide> >
operator/(Variable& b, Variable& a)
{
  typedef DExprBinOp<DExprVAR, DExprVAR, DApDivide> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(b),DExprVAR(a)));
}


DExpr<DExprBinOp<Local_var, DExprLIT, DApDivide> >
operator/(Local_var&  a,double x)
{
  typedef DExprBinOp<Local_var, DExprLIT, DApDivide> ExprT;
  return DExpr<ExprT>(ExprT(a,DExprLIT(x)));
}

DExpr<DExprBinOp<DExprLIT, Local_var, DApDivide> >
operator/(double x, Local_var&  a)
{
  typedef DExprBinOp<DExprLIT, Local_var, DApDivide> ExprT;
  return DExpr<ExprT>(ExprT(DExprLIT(x),a));
}

DExpr<DExprBinOp<Local_var, Local_var, DApDivide> >
operator/(Local_var& b, Local_var& a)
{
  typedef DExprBinOp<Local_var, Local_var, DApDivide> ExprT;
  return DExpr<ExprT>(ExprT(b,a));
}


 // 5.:  Unary operator


/* Sub */
DExpr<DExprMinusUnaOp<Local_var> >
operator-(Local_var& x)
{
  typedef DExprMinusUnaOp<Local_var> ExprT;
  return DExpr<ExprT>(ExprT(x));
}

DExpr<DExprMinusUnaOp<DExprVAR> >
operator-(Variable& v)
{
  typedef DExprMinusUnaOp<DExprVAR> ExprT;
  return DExpr<ExprT>(ExprT(DExprVAR(v)));
}

---