Convection< MeshOfHexahedra > Class Template Reference

#include <Convection.hpp>

Inheritance diagram for Convection< MeshOfHexahedra >:

Inheritance graph
[legend]
Collaboration diagram for Convection< MeshOfHexahedra >:

Collaboration graph
[legend]

List of all members.

Public Types

enum  Type {
  cfunction, constant, convection, dgfunction,
  femfunction, linearBasis, spectral, unaryMinus,
  modulo, sum, difference, product,
  division, power, min, max,
  gt, ge, lt, le,
  ne, eq, and_, or_,
  xor_, not_, derivate, integrate,
  normal, domainCharacteristic, meshCharacteristic, objectCharacteristic,
  composed, references, FEM0, undefined
}

Public Member Functions

real_t operator() (const TinyVector< 3 > &X) const
 Ealuates the convected function at position X.
bool canBeSimplified () const
 Convection (const Convection< MeshOfHexahedra > &C)
 Convection (const ScalarFunctionBase &phi, const FieldOfScalarFunction &u, const real_t &dt, const MeshOfHexahedra &M)
 ~Convection ()
void setName (const std::string &name)
const std::string & name () const
const Type & type () const
real_t operator() (const real_t &x, const real_t &y, const real_t &z) const
virtual real_t operator() (const TinyVector< 3, real_t > &X) const =0
virtual real_t dx (const TinyVector< 3, real_t > &x) const
virtual real_t dy (const TinyVector< 3, real_t > &x) const
virtual real_t dz (const TinyVector< 3, real_t > &x) const

Protected Attributes

const Type __type
std::string __name

Private Member Functions

std::ostream & __put (std::ostream &os) const

Private Attributes

const real_t __deltaT
 The time interval for the equation integration.
const MeshOfHexahedra & __mesh
 __mesh where to convect v.
const FieldOfScalarFunction & __u
 The $ u$ function.
const ScalarFunctionBase & __phi
 __phi The scalar function that is to convect.

Friends

std::ostream & operator<< (std::ostream &os, const ScalarFunctionBase &scalarFunction)

Detailed Description

template<>
class Convection< MeshOfHexahedra >

Definition at line 403 of file Convection.hpp.

Member Enumeration Documentation

enum ScalarFunctionBase::Type [inherited]

Enumerator:
cfunction 
constant 
convection 
dgfunction 
femfunction 
linearBasis 
spectral 
unaryMinus 
modulo 
sum 
difference 
product 
division 
power 
min 
max 
gt 
ge 
lt 
le 
ne 
eq 
and_ 
or_ 
xor_ 
not_ 
derivate 
integrate 
normal 
domainCharacteristic 
meshCharacteristic 
objectCharacteristic 
composed 
references 
FEM0 
undefined 

Definition at line 40 of file ScalarFunctionBase.hpp.

00040             {
00041     cfunction,
00042     constant,
00043     convection,
00044     dgfunction,
00045     femfunction,
00046     linearBasis,
00047     spectral,
00048     unaryMinus,
00049 
00050     modulo,
00051     sum,
00052     difference,
00053     product,
00054     division,
00055     power,
00056 
00057     min,
00058     max,
00059 
00060     gt,
00061     ge,
00062     lt,
00063     le,
00064     ne,
00065     eq,
00066     and_,
00067     or_,
00068     xor_,
00069 
00070     not_,
00071 
00072     derivate,
00073     integrate,
00074 
00075     normal,
00076 
00077     domainCharacteristic,
00078     meshCharacteristic,
00079     objectCharacteristic,
00080 
00081     composed,
00082     references,
00083 
00084     FEM0,
00085 
00086     undefined
00087   };

Constructor & Destructor Documentation

Convection< MeshOfHexahedra >::Convection ( const Convection< MeshOfHexahedra > &  C  )  [inline]

Copy constructor

Parameters:
C given convection function

Definition at line 539 of file Convection.hpp.

00540     : ScalarFunctionBase(ScalarFunctionBase::convection),
00541       __deltaT(C.__deltaT),
00542       __mesh(C.__mesh),
00543       __u(C.__u),
00544       __phi(C.__phi)
00545   {
00546     ;
00547   }

Convection< MeshOfHexahedra >::Convection ( const ScalarFunctionBase &  phi,
const FieldOfScalarFunction &  u,
const real_t &  dt,
const MeshOfHexahedra &  M 
) [inline]

Constructor

Parameters:
phi the function to convect
u the velocity field
dt the time step
M the mesh

Definition at line 557 of file Convection.hpp.

00561     : ScalarFunctionBase(ScalarFunctionBase::convection),
00562       __deltaT(dt),
00563       __mesh(M),
00564       __u(u),
00565       __phi(phi)
00566   {
00567     ;
00568   }

Convection< MeshOfHexahedra >::~Convection (  )  [inline]

Destructor

Definition at line 574 of file Convection.hpp.

00575   {
00576     ;
00577   }

Member Function Documentation

std::ostream& Convection< MeshOfHexahedra >::__put ( std::ostream &  os  )  const [inline, private, virtual]

Writes the function to a stream

Parameters:
os output stream
Returns:
the modified stream

Implements ScalarFunctionBase.

Definition at line 407 of file Convection.hpp.

00408   {
00409     os << "convect(" << __u << ","
00410        << __deltaT << ',' << __phi << ')';
00411     return os;
00412   }

real_t Convection< MeshOfHexahedra >::operator() ( const TinyVector< 3 > &  X  )  const [inline]

Ealuates the convected function at position X.

Definition at line 428 of file Convection.hpp.

References Connectivity< MeshType >::cells(), Mesh::T_iterator< MeshType, CellType >::end(), ConnectivityBuilder< MeshType >::generates(), Connectivity< MeshType >::hasCellToCells(), ConformTransformationQ1Hexahedron::invertT(), and ConformTransformationQ1Hexahedron::value().

00429   {
00430     MeshOfHexahedra::const_iterator h = __mesh.find(X[0], X[1], X[2]);
00431     if (h.end()) return 0; // we are outside the mesh
00432 
00433     const ScalarFunctionBase& u0 = *__u.function(0);
00434     const ScalarFunctionBase& u1 = *__u.function(1);
00435     const ScalarFunctionBase& u2 = *__u.function(2);
00436 
00437     const Connectivity<MeshOfHexahedra>& connectivity = __mesh.connectivity();
00438     if (not(connectivity.hasCellToCells())) {
00439       ConnectivityBuilder<MeshOfHexahedra> c(__mesh);
00440       c.generates(Connectivity<MeshOfHexahedra>::CellToCells);
00441     }
00442 
00443     TinyVector<3, real_t> X0 = X;
00444 
00445     TinyVector<3, real_t> Xhat0;
00446     {
00447       ConformTransformationQ1Hexahedron T0(*h);
00448       T0.invertT(X0, Xhat0);
00449     }
00450 
00451     real_t dt0 = __deltaT;
00452 
00453     const size_t faceNumberConverter[6] = {4,2,1,3,0,5};
00454 
00455     do {
00456       const Hexahedron& H = (*h);
00457       ConformTransformationQ1Hexahedron T(H);
00458 
00459       T.value(Xhat0,X0);
00460 
00461       TinyVector<3, real_t> X1;
00462       X1[0] = X0[0]-u0(X0)*dt0;
00463       X1[1] = X0[1]-u1(X0)*dt0;
00464       X1[2] = X0[2]-u2(X0)*dt0;
00465 
00466       TinyVector<3, real_t> Xhat1;
00467       T.invertT(X1, Xhat1);
00468 
00469       if((   Xhat1[0] >= 0)
00470          and(Xhat1[1] >= 0)
00471          and(Xhat1[2] >= 0)
00472          and(Xhat1[0] <= 1)
00473          and(Xhat1[1] <= 1)
00474          and(Xhat1[2] <= 1)) {
00475         dt0 = 0;
00476         X0 = X1;
00477       } else {
00478 
00479         const TinyVector<3, real_t> deltaX = Xhat1-Xhat0;
00480         
00481         // Get the planes which are required to compute intersection
00482         TinyVector<3, real_t> x0 = 0;
00483         for (size_t i=0; i<3; ++i) {
00484           if (deltaX[i]>0) x0[i] = 1;
00485         }
00486 
00487         // Computes the linear abcisse required to reach faces
00488         TinyVector<3, real_t> coef = std::numeric_limits<real_t>::max();
00489         for (size_t i=0; i<3; ++i) {
00490           if (std::abs(deltaX[i])>0) {
00491             coef[i] = std::abs((x0[i]-Xhat0[i])/deltaX[i]);
00492           }
00493         }
00494 
00495         size_t minimumCoefficentNumber = 0;
00496         for (size_t i=1; i<3; ++i) {
00497           minimumCoefficentNumber
00498             = (coef[minimumCoefficentNumber]<coef[i])?minimumCoefficentNumber:i;
00499         }
00500 
00501         const size_t outGoingFace
00502           = faceNumberConverter[2*minimumCoefficentNumber + ((deltaX[minimumCoefficentNumber]>0)?1:0)];
00503 
00504         const real_t dt = dt0*coef[minimumCoefficentNumber];
00505 
00506         Xhat0 += coef[minimumCoefficentNumber] * deltaX;
00507         dt0-=dt;
00508 
00509         h = connectivity.cells(*h)[outGoingFace];
00510         if (h.end()) {
00511           T.value(Xhat0,X0);
00512           dt0=0;
00513         } // takes the value on the border when going outside
00514 
00515         // X0 is not updated. We compute the value of Xhat0 in the next cell
00516         // This make the periodic boundary conditions valid
00517         Xhat0[minimumCoefficentNumber] = 1-x0[minimumCoefficentNumber];
00518       }
00519     } while (dt0>0);
00520 
00521     return __phi(X0);
00522   }

Here is the call graph for this function:

bool Convection< MeshOfHexahedra >::canBeSimplified (  )  const [inline, virtual]

Checks if the function can be simplified

Returns:
false

Implements ScalarFunctionBase.

Definition at line 529 of file Convection.hpp.

00530   {
00531     return false;
00532   }

void ScalarFunctionBase::setName ( const std::string &  name  )  [inline, inherited]

Sets the name of the function

Parameters:
name name to give to this function

Definition at line 109 of file ScalarFunctionBase.hpp.

References ScalarFunctionBase::__name.

Referenced by FunctionExpressionVariable::execute().

00110   {
00111     __name = name;
00112   }

const std::string& ScalarFunctionBase::name (  )  const [inline, inherited]

Gets the name of the function

Returns:
__name

Definition at line 119 of file ScalarFunctionBase.hpp.

References ScalarFunctionBase::__name.

00120   {
00121     return __name;
00122   }

const Type& ScalarFunctionBase::type (  )  const [inline, inherited]

Read-only access to the type of the function

Returns:
__type

Definition at line 129 of file ScalarFunctionBase.hpp.

References ScalarFunctionBase::__type.

Referenced by WriterVTK::__fillCrossedComponent(), WriterMedit::__fillCrossedComponent(), ScalarFunctionBuilder::Simplifier::__getOperatorF1SimplifiedFunction(), ScalarFunctionBuilder::Simplifier::__getOperatorSimplifiedFunction(), WriterVTK::__proceed(), WriterMedit::__proceedData(), WriterRaw::__saveScalarFunction(), FEMDiscretization< Structured3DMesh, TypeOfDiscretization >::assembleSecondMember(), InstructionAffectation< FunctionExpression, FunctionVariable >::execute(), FEMFunction< MeshType, FiniteElementTraits >::operator=(), and DGFunction< MeshType, FiniteElementTraits >::operator=().

00130   {
00131     return __type;
00132   }

real_t ScalarFunctionBase::operator() ( const real_t &  x,
const real_t &  y,
const real_t &  z 
) const [inline, inherited]

Evaluates the function at point $ (x,y,z) $

Parameters:
x $ x $
y $ y $
z $ z $
Returns:
$ f(x,y,z) $

Definition at line 162 of file ScalarFunctionBase.hpp.

00165   {
00166     return this->operator()(TinyVector<3, real_t>(x,y,z));    
00167   }

virtual real_t ScalarFunctionBase::operator() ( const TinyVector< 3, real_t > &  X  )  const [pure virtual, inherited]

Evaluates the gunction at point $ X $

Parameters:
X point of evaluation of the function
Returns:
$ f(X) $

Implemented in DGFunction< MeshType, FiniteElementTraits >, FEMFunction< MeshType, FiniteElementTraits >, ScalarFunctionAnd, ScalarFunctionCFunction, ScalarFunctionComposed, ScalarFunctionConstant, ScalarFunctionDerivative, ScalarFunctionDifference, ScalarFunctionDivision, ScalarFunctionDomainCharacteristic, ScalarFunctionEqual, ScalarFunctionGreaterEqual, ScalarFunctionGreaterThan, ScalarFunctionIntegrate, ScalarFunctionLinearBasis, ScalarFunctionLowerEqual, ScalarFunctionLowerThan, ScalarFunctionMax, ScalarFunctionMeshCharacteristic, ScalarFunctionMeshElementsReferences, ScalarFunctionMin, ScalarFunctionModulo, ScalarFunctionNormal, ScalarFunctionNot, ScalarFunctionNotEqual, ScalarFunctionObjectCharacteristic, ScalarFunctionOr, ScalarFunctionPower, ScalarFunctionProduct, ScalarFunctionSum, ScalarFunctionUnaryMinus, ScalarFunctionXor, and SpectralFunction.

virtual real_t ScalarFunctionBase::dx ( const TinyVector< 3, real_t > &  x  )  const [inline, virtual, inherited]

Evaluates first derivative of the function

Parameters:
x position of evaluation
Returns:
$ \partial_x f $ at position $ x $

Definition at line 185 of file ScalarFunctionBase.hpp.

References ErrorHandler::normal.

00186   {
00187     std::stringstream errorMsg;
00188 
00189     errorMsg << "cannot compute derivative of non discrete functions :-(\n";
00190     errorMsg << "the function " << (*this) << " is not of that kind"
00191              << std::ends;
00192 
00193     throw ErrorHandler(__FILE__,__LINE__,
00194                        errorMsg.str(),
00195                        ErrorHandler::normal);
00196     return 0;
00197   }

virtual real_t ScalarFunctionBase::dy ( const TinyVector< 3, real_t > &  x  )  const [inline, virtual, inherited]

Evaluates second derivative of the function

Parameters:
x position of evaluation
Returns:
$ \partial_y f $ at position $ x $

Definition at line 206 of file ScalarFunctionBase.hpp.

References ErrorHandler::normal.

00207   {
00208     std::stringstream errorMsg;
00209 
00210     errorMsg << "cannot compute derivative of non discrete functions :-(\n";
00211     errorMsg << "the function " << (*this) << " is not of that kind"
00212              << std::ends;
00213 
00214     throw ErrorHandler(__FILE__,__LINE__,
00215                        errorMsg.str(),
00216                        ErrorHandler::normal);
00217     return 0;
00218   }

virtual real_t ScalarFunctionBase::dz ( const TinyVector< 3, real_t > &  x  )  const [inline, virtual, inherited]

Evaluates third derivative of the function

Parameters:
x position of evaluation
Returns:
$ \partial_z f $ at position $ x $

Definition at line 227 of file ScalarFunctionBase.hpp.

References ErrorHandler::normal.

00228   {
00229     std::stringstream errorMsg;
00230 
00231     errorMsg << "cannot compute derivative of non discrete functions :-(\n";
00232     errorMsg << "the function " << (*this) << " is not of that kind"
00233              << std::ends;
00234 
00235     throw ErrorHandler(__FILE__,__LINE__,
00236                        errorMsg.str(),
00237                        ErrorHandler::normal);
00238     return 0;
00239   }

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const ScalarFunctionBase &  scalarFunction 
) [friend, inherited]

Writes the function scalarFunction to the stream os

Parameters:
os the output stream
scalarFunction the function to write
Returns:
os

Definition at line 142 of file ScalarFunctionBase.hpp.

00144   {
00145     if (scalarFunction.__name.size()>0) {
00146       os << scalarFunction.__name;
00147       return os;
00148     } else {
00149       return scalarFunction.__put(os);
00150     }
00151   }

Member Data Documentation

const real_t Convection< MeshOfHexahedra >::__deltaT [private]

The time interval for the equation integration.

Definition at line 415 of file Convection.hpp.

const MeshOfHexahedra& Convection< MeshOfHexahedra >::__mesh [private]

__mesh where to convect v.

Definition at line 418 of file Convection.hpp.

const FieldOfScalarFunction& Convection< MeshOfHexahedra >::__u [private]

The $ u$ function.

Definition at line 421 of file Convection.hpp.

const ScalarFunctionBase& Convection< MeshOfHexahedra >::__phi [private]

__phi The scalar function that is to convect.

Definition at line 424 of file Convection.hpp.

const Type ScalarFunctionBase::__type [protected, inherited]

type of the function

Definition at line 90 of file ScalarFunctionBase.hpp.

Referenced by ScalarFunctionBase::type().

std::string ScalarFunctionBase::__name [protected, inherited]

name of the function

Definition at line 92 of file ScalarFunctionBase.hpp.

Referenced by ScalarFunctionBase::name(), and ScalarFunctionBase::setName().

The documentation for this class was generated from the following file:
Generated on Wed Nov 19 00:05:19 2008 for FreeFEM3D (aka ff3d) by  doxygen 1.5.6