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

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

void Print_UCD(Cell_Variable& a, ofstream *Datei) {
  a.Give_grid()->Print_Cell_Variable_AVS(Datei,a.Number_cell_variable());
};
void Print_UCD_moved(Cell_Variable& v, 
                     Variable& a, Variable& b, Variable& c, ofstream *Datei) {
  a.Give_grid()->Print_Cell_Variable_AVS_moved(Datei,
                                               v.Number_cell_variable(),
                                               a.Number_variable(),
                                               b.Number_variable(),
                                               c.Number_variable());
};

void Print_UCD_parallel(Cell_Variable& a, ofstream *Datei) {
  a.Give_grid()->Print_Cell_Variable_AVS_parallel(Datei,
                                                  a.Number_cell_variable());
};

CoExpr<CoExprTrans> Cell_Interpolation(const Variable& vec) {
  typedef CoExprTrans ExprT;
  return CoExpr<ExprT>(ExprT(vec));
}

void Cell_Variable::operator=(double (*Formula)(double x,double y,double z)) {
  D3vector V;
  Test_init();  // Grid storage initialization

  // interior_cells
  for(iter_ice=grid->Start_P_interior_cell(level);
      iter_ice!=NULL;iter_ice=iter_ice->Next()) {
    V = iter_ice->coordinate(grid);
    iter_ice->varM(grid)[number_cell_variable] = 
      Formula(V.x,V.y,V.z);
  }
  // boundary cells
  for(iter_bce=grid->Start_P_boundary_tet(level);
      iter_bce!=NULL;iter_bce=iter_bce->Next()) {
    V = iter_bce->coordinate(grid);
    iter_bce->varM(grid)[number_cell_variable] = 
      Formula(V.x,V.y,V.z);
  }
}



void Cell_Variable::operator=(Input_data_object& input_object) {
  D3vector V;
  Test_init();  // Grid storage initialization

  // interior_cells
  for(iter_ice=grid->Start_P_interior_cell(level);
      iter_ice!=NULL;iter_ice=iter_ice->Next()) {
    V = iter_ice->coordinate(grid);
    iter_ice->varM(grid)[number_cell_variable] = 
      input_object.Interpolate_value(V);
  }
  // boundary cells
  for(iter_bce=grid->Start_P_boundary_tet(level);
      iter_bce!=NULL;iter_bce=iter_bce->Next()) {
    V = iter_bce->coordinate(grid);
    iter_bce->varM(grid)[number_cell_variable] = 
      input_object.Interpolate_value(V);
  }
}



void Cell_Variable::operator=(double x) {
  Test_init();  // Grid storage initialization

  // interior_cells
  for(iter_ice=grid->Start_P_interior_cell(level);
      iter_ice!=NULL;iter_ice=iter_ice->Next()) {
    iter_ice->varM(grid)[number_cell_variable] = x;
  }
  // boundary cells
  for(iter_bce=grid->Start_P_boundary_tet(level);
      iter_bce!=NULL;iter_bce=iter_bce->Next()) {
    iter_bce->varM(grid)[number_cell_variable] = x;
  }
}

double Maximum(Cell_Variable& v) {
  v.Test_init();  // Grid storage initialization
  double maxi,x;
  Grid *grid;
  int number_cell_variable;
  P_interior_cell  *iter_ice;
  P_boundary_tet  *iter_bce;
  number_cell_variable = v.Number_cell_variable();

  grid = v.Give_grid(); 
  maxi = grid->Start_P_interior_cell(
               v.Level())->varM(grid)[number_cell_variable];
  // interior_cells
  for(iter_ice=grid->Start_P_interior_cell(v.Level());
      iter_ice!=NULL;iter_ice=iter_ice->Next()) {
    x = iter_ice->varM(grid)[number_cell_variable];
    if(maxi<x) maxi=x;
  }
  // boundary cells
  for(iter_bce=grid->Start_P_boundary_tet(v.Level());
      iter_bce!=NULL;iter_bce=iter_bce->Next()) {
    x = iter_bce->varM(grid)[number_cell_variable];
    if(maxi<x) maxi=x;
  }
  return maxi;
}

double L_infty(Cell_Variable& v) {
  v.Test_init();  // Grid storage initialization
  double maxi,x;
  Grid *grid;
  int number_cell_variable;
  P_interior_cell  *iter_ice;
  P_boundary_tet  *iter_bce;
  number_cell_variable = v.Number_cell_variable();

  grid = v.Give_grid(); 
  maxi = 0.0;
  // interior_cells
  for(iter_ice=grid->Start_P_interior_cell(v.Level());
      iter_ice!=NULL;iter_ice=iter_ice->Next()) {
    x = ABS(iter_ice->varM(grid)[number_cell_variable]);
    if(maxi<x) maxi=x;
  }
  // boundary cells
  for(iter_bce=grid->Start_P_boundary_tet(v.Level());
      iter_bce!=NULL;iter_bce=iter_bce->Next()) {
    x = ABS(iter_bce->varM(grid)[number_cell_variable]);
    if(maxi<x) maxi=x;
  }
  return maxi;
}

double Minimum(Cell_Variable& v) {
  v.Test_init();  // Grid storage initialization
  double mini,x;
  Grid *grid;
  int number_cell_variable;
  P_interior_cell  *iter_ice;
  P_boundary_tet  *iter_bce;
  number_cell_variable = v.Number_cell_variable();

  grid = v.Give_grid(); 
  mini = grid->Start_P_interior_cell(
               v.Level())->varM(grid)[number_cell_variable];
  // interior_cells
  for(iter_ice=grid->Start_P_interior_cell(v.Level());
      iter_ice!=NULL;iter_ice=iter_ice->Next()) {
    x = iter_ice->varM(grid)[number_cell_variable];
    if(mini>x) mini=x;
  }
  // boundary cells
  for(iter_bce=grid->Start_P_boundary_tet(v.Level());
      iter_bce!=NULL;iter_bce=iter_bce->Next()) {
    x = iter_bce->varM(grid)[number_cell_variable];
    if(mini>x) mini=x;
  }
  return mini;
}


// ------------------------------------------------------------
//  Addition, Multi, ...
// ------------------------------------------------------------

#define Macro_set_expressions_for_cells(insertA,insertB) \
CoExpr<CoExprBinOp<CoExprLIT, CoExprVAR, insertA> > \
insertB(double x, Cell_Variable& a) \
{ \
  typedef CoExprBinOp<CoExprLIT, CoExprVAR, insertA> ExprT; \
  return CoExpr<ExprT>(ExprT(CoExprLIT(x),CoExprVAR(a))); \
} \
CoExpr<CoExprBinOp<CoExprVAR, CoExprLIT, insertA> > \
insertB(Cell_Variable& a,double x) \
{ \
  typedef CoExprBinOp<CoExprVAR, CoExprLIT, insertA> ExprT; \
  return CoExpr<ExprT>(ExprT(CoExprVAR(a),CoExprLIT(x))); \
} \
CoExpr<CoExprBinOp<CoExprVAR, CoExprVAR, insertA> > \
insertB(Cell_Variable& b, Cell_Variable& a) \
{ \
  typedef CoExprBinOp<CoExprVAR, CoExprVAR, insertA> ExprT; \
  return CoExpr<ExprT>(ExprT(CoExprVAR(b),CoExprVAR(a))); \
}










Macro_set_expressions_for_cells(CoApMul,operator*)
Macro_set_expressions_for_cells(CoApAdd,operator+)
Macro_set_expressions_for_cells(CoApDivide,operator/)
Macro_set_expressions_for_cells(CoApSub,operator-)

---