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

// ------------------------------------------------------------
// oper_conv.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 "../formulas/diffopcv.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 "varcon.h"

#include "opera.h"
#include "operav.h"
#include "op_conv.h"
//#include "extemp/mg_op.h"
//#include "extemp/sim.h"
//#include "extemp/res_op.h"
//#include "extemp/res_opv.h"
//#include "extemp/extra.h"





               // 1.: member functions of oper_conv.h



/* Unary operators */
// Laplace


DExpr<DVarDiff_25S_Op_convar<Cell_Variable, laplace_FE_cell_variable> >
Laplace_FE_var(Cell_Variable a, Variable v)
{
 typedef DVarDiff_25S_Op_convar<Cell_Variable, laplace_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}


DExpr<DVarDiff_25S_Op_convar<Cell_Variable, dxdx_FE_cell_variable> >
DxDx_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, dxdx_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, dydy_FE_cell_variable> >
DyDy_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, dydy_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, dzdz_FE_cell_variable> >
DzDz_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, dzdz_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, helm_FE_cell_variable> >
Helm_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, helm_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

// Nichsymmetrische Terme

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, dxdy_FE_cell_variable> >
DxDy_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, dxdy_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, dydx_FE_cell_variable> >
DyDx_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, dydx_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, dxdz_FE_cell_variable> >
DxDz_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, dxdz_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, dzdx_FE_cell_variable> >
DzDx_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, dzdx_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}


DExpr<DVarDiff_25S_Op_convar<Cell_Variable, dydz_FE_cell_variable> >
DyDz_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, dydz_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, dzdy_FE_cell_variable> >
DzDy_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, dzdy_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}


DExpr<DVarDiff_25S_Op_convar<Cell_Variable, dxhelm_FE_cell_variable> >
DX_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, dxhelm_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, dyhelm_FE_cell_variable> >
DY_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, dyhelm_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, dzhelm_FE_cell_variable> >
DZ_FE_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, dzhelm_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, helmdx_FE_cell_variable> >
DX_FE_var_t(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, helmdx_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, helmdy_FE_cell_variable> >
DY_FE_var_t(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, helmdy_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, helmdz_FE_cell_variable> >
DZ_FE_var_t(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, helmdz_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}

/*
// Rand-operatoren

DExpr<DVarDiff_25S_Op_convar<Cell_Variable, L2boundary_variable> >
Int_boundary_var(Cell_Variable a, Variable v)
{
  typedef DVarDiff_25S_Op_convar<Cell_Variable, L2boundary_variable> ExprT;
  return DExpr<ExprT>(ExprT(a,v));
}
*/

/* Unary operators */

// Laplace
DExpr<DiagonalDiff_Op_convar<Cell_Variable, laplace_FE_cell_variable> >
Diag_Laplace_FE_var(Cell_Variable a)
{
 typedef DiagonalDiff_Op_convar<Cell_Variable, laplace_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DxDx
DExpr<DiagonalDiff_Op_convar<Cell_Variable, dxdx_FE_cell_variable> >
Diag_DxDx_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, dxdx_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DyDy
DExpr<DiagonalDiff_Op_convar<Cell_Variable, dydy_FE_cell_variable> >
Diag_DyDy_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, dydy_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DzDz
DExpr<DiagonalDiff_Op_convar<Cell_Variable, dzdz_FE_cell_variable> >
Diag_DzDz_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, dzdz_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// Helm
DExpr<DiagonalDiff_Op_convar<Cell_Variable, helm_FE_cell_variable> >
Diag_Helm_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, helm_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// Nichsymmetrische Terme

// DxDy
DExpr<DiagonalDiff_Op_convar<Cell_Variable, dxdy_FE_cell_variable> >
Diag_DxDy_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, dxdy_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DyDx
DExpr<DiagonalDiff_Op_convar<Cell_Variable, dydx_FE_cell_variable> >
Diag_DyDx_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, dydx_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}


// DxDz
DExpr<DiagonalDiff_Op_convar<Cell_Variable, dxdz_FE_cell_variable> >
Diag_DxDz_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, dxdz_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DzDx
DExpr<DiagonalDiff_Op_convar<Cell_Variable, dzdx_FE_cell_variable> >
Diag_DzDx_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, dzdx_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DyDz
DExpr<DiagonalDiff_Op_convar<Cell_Variable, dydz_FE_cell_variable> >
Diag_DyDz_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, dydz_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DzDy
DExpr<DiagonalDiff_Op_convar<Cell_Variable, dzdy_FE_cell_variable> >
Diag_DzDy_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, dzdy_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DX
DExpr<DiagonalDiff_Op_convar<Cell_Variable, dxhelm_FE_cell_variable> >
Diag_DX_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, dxhelm_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DY
DExpr<DiagonalDiff_Op_convar<Cell_Variable, dyhelm_FE_cell_variable> >
Diag_DY_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, dyhelm_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DZ
DExpr<DiagonalDiff_Op_convar<Cell_Variable, dzhelm_FE_cell_variable> >
Diag_DZ_FE_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, dzhelm_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DX
DExpr<DiagonalDiff_Op_convar<Cell_Variable, helmdx_FE_cell_variable> >
Diag_DX_FE_var_t(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, helmdx_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DY
DExpr<DiagonalDiff_Op_convar<Cell_Variable, helmdy_FE_cell_variable> >
Diag_DY_FE_var_t(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, helmdy_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}

// DZ
DExpr<DiagonalDiff_Op_convar<Cell_Variable, helmdz_FE_cell_variable> >
Diag_DZ_FE_var_t(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, helmdz_FE_cell_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}


/*
// Rand-operatoren

DExpr<DiagonalDiff_Op_convar<Cell_Variable, L2boundary_con_variable> >
Diag_Int_boundary_var(Cell_Variable a)
{
  typedef DiagonalDiff_Op_convar<Cell_Variable, L2boundary_variable> ExprT;
  return DExpr<ExprT>(ExprT(a));
}
*/

   

---