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

// ------------------------------------------------------------
// operatorv.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 "../formulas/diffop.h"
#include "../formulas/diffopc.h"
#include "../formulas/diffopv.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 "opera.h"
#include "operav.h"
//#include "extemp/mg_op.h"
#include "sim.h"
#include "res_op.h"
//#include "extemp/res_opv.h"
//#include "extemp/extra.h"
#include "array.h"





               // 1.: member functions of operatorv.h



/* Unary operators */
// Laplace
#define Macro_operator_var_implement(insertA,insertB) \
DExpr<DVarDiff_17S_Op_var< insertA , insertB ,laplace_FE_variable> > \
Laplace_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA , insertB ,laplace_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, dxdx_FE_variable> > \
DxDx_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, dxdx_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, dydy_FE_variable> > \
DyDy_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, dydy_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, dzdz_FE_variable> > \
DzDz_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, dzdz_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, helm_FE_variable> > \
Helm_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, helm_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
/* ///////////////////////// \
// Nichsymmetrische Terme \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, dxdy_FE_variable> > \
DxDy_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, dxdy_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, dydx_FE_variable> > \
DyDx_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, dydx_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, dxdz_FE_variable> > \
DxDz_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, dxdz_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, dzdx_FE_variable> > \
DzDx_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, dzdx_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, dydz_FE_variable> > \
DyDz_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, dydz_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, dzdy_FE_variable> > \
DzDy_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, dzdy_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, dxhelm_FE_variable> > \
DX_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, dxhelm_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, dyhelm_FE_variable> > \
DY_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, dyhelm_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, dzhelm_FE_variable> > \
DZ_FE_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, dzhelm_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, helmdx_FE_variable> > \
DX_FE_var_t(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, helmdx_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, helmdy_FE_variable> > \
DY_FE_var_t(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, helmdy_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, helmdz_FE_variable> > \
DZ_FE_var_t(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, helmdz_FE_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
} \
/* ///////////////////////// \
// Rand-operatoren \
DExpr<DVarDiff_17S_Op_var< insertA, insertB, L2boundary_variable> > \
Int_boundary_var(insertA a, insertB v) \
{ \
  typedef DVarDiff_17S_Op_var< insertA, insertB, L2boundary_variable> ExprT; \
  return DExpr<ExprT>(ExprT(a,v)); \
}

Macro_operator_var_implement(Variable,Variable);
Macro_operator_var_implement(DExpr<DExprVAR_ARR>,DExpr<DExprVAR_ARR>);
//Macro_operator_var_implement(DExpr<DExprVAR_ARR>,Variable);
//Macro_operator_var_implement(Variable,DExpr<DExprVAR_ARR>);

/* Unary operators */

// Laplace
DExpr<DiagonalDiff_Op_var<laplace_FE_variable> >
Diag_Laplace_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<laplace_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DxDx
DExpr<DiagonalDiff_Op_var<dxdx_FE_variable> >
Diag_DxDx_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<dxdx_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DyDy
DExpr<DiagonalDiff_Op_var<dydy_FE_variable> >
Diag_DyDy_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<dydy_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DzDz
DExpr<DiagonalDiff_Op_var<dzdz_FE_variable> >
Diag_DzDz_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<dzdz_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// Helm
DExpr<DiagonalDiff_Op_var<helm_FE_variable> >
Diag_Helm_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<helm_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// Nichsymmetrische Terme

// DxDy
DExpr<DiagonalDiff_Op_var<dxdy_FE_variable> >
Diag_DxDy_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<dxdy_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DyDx
DExpr<DiagonalDiff_Op_var<dydx_FE_variable> >
Diag_DyDx_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<dydx_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}


// DxDz
DExpr<DiagonalDiff_Op_var<dxdz_FE_variable> >
Diag_DxDz_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<dxdz_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DzDx
DExpr<DiagonalDiff_Op_var<dzdx_FE_variable> >
Diag_DzDx_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<dzdx_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DyDz
DExpr<DiagonalDiff_Op_var<dydz_FE_variable> >
Diag_DyDz_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<dydz_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DzDy
DExpr<DiagonalDiff_Op_var<dzdy_FE_variable> >
Diag_DzDy_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<dzdy_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DX
DExpr<DiagonalDiff_Op_var<dxhelm_FE_variable> >
Diag_DX_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<dxhelm_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DY
DExpr<DiagonalDiff_Op_var<dyhelm_FE_variable> >
Diag_DY_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<dyhelm_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DZ
DExpr<DiagonalDiff_Op_var<dzhelm_FE_variable> >
Diag_DZ_FE_var(Variable a)
{
  typedef DiagonalDiff_Op_var<dzhelm_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DX
DExpr<DiagonalDiff_Op_var<helmdx_FE_variable> >
Diag_DX_FE_var_t(Variable a)
{
  typedef DiagonalDiff_Op_var<helmdx_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DY
DExpr<DiagonalDiff_Op_var<helmdy_FE_variable> >
Diag_DY_FE_var_t(Variable a)
{
  typedef DiagonalDiff_Op_var<helmdy_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DZ
DExpr<DiagonalDiff_Op_var<helmdz_FE_variable> >
Diag_DZ_FE_var_t(Variable a)
{
  typedef DiagonalDiff_Op_var<helmdz_FE_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}


// Rand-operatoren

DExpr<DiagonalDiff_Op_var<L2boundary_variable> >
Diag_Int_boundary_var(Variable a)
{
  typedef DiagonalDiff_Op_var<L2boundary_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

---