DiscretizedOperators< ElementaryMatrixType > Class Template Reference

#include <DiscretizedOperators.hpp>

Inheritance diagram for DiscretizedOperators< ElementaryMatrixType >:

Inheritance graph
[legend]

List of all members.

Public Types

typedef std::pair< const
ElementaryMatrixType
*, FunctionAndPosition > 		ListPair
typedef std::multimap< const
ElementaryMatrixType
*, FunctionAndPosition > 		List
typedef List::iterator iterator
typedef List::const_iterator const_iterator

Public Member Functions

DiscretizedOperators::iterator begin ()
const
DiscretizedOperators::const_iterator 		begin () const
DiscretizedOperators::iterator end ()
const
DiscretizedOperators::const_iterator 		end () const
 DiscretizedOperators (const ElementaryMatrixSet< ElementaryMatrixType > &e, const Problem &problem)

Private Member Functions

 DiscretizedOperators (const DiscretizedOperators &c)

Private Attributes

const ElementaryMatrixSet
< ElementaryMatrixType > & 		__elementaryMatrixSet
List __list

Classes

class  FunctionAndPosition

Detailed Description

template<typename ElementaryMatrixType>
class DiscretizedOperators< ElementaryMatrixType >

Definition at line 61 of file DiscretizedOperators.hpp.

Member Typedef Documentation

template<typename ElementaryMatrixType>
typedef std::pair<const ElementaryMatrixType*, FunctionAndPosition > DiscretizedOperators< ElementaryMatrixType >::ListPair

Definition at line 150 of file DiscretizedOperators.hpp.

template<typename ElementaryMatrixType>
typedef std::multimap<const ElementaryMatrixType*, FunctionAndPosition > DiscretizedOperators< ElementaryMatrixType >::List

Definition at line 152 of file DiscretizedOperators.hpp.

template<typename ElementaryMatrixType>
typedef List::iterator DiscretizedOperators< ElementaryMatrixType >::iterator

Definition at line 153 of file DiscretizedOperators.hpp.

template<typename ElementaryMatrixType>
typedef List::const_iterator DiscretizedOperators< ElementaryMatrixType >::const_iterator

Definition at line 154 of file DiscretizedOperators.hpp.

Constructor & Destructor Documentation

template<typename ElementaryMatrixType>
DiscretizedOperators< ElementaryMatrixType >::DiscretizedOperators ( const DiscretizedOperators< ElementaryMatrixType > &  c  )  [private]

Copy constructor

Note:
this constructor is forbidden
Parameters:
c given disretized operator

template<typename ElementaryMatrixType>
DiscretizedOperators< ElementaryMatrixType >::DiscretizedOperators ( const ElementaryMatrixSet< ElementaryMatrixType > &  e,
const Problem &  problem 
) [inline]

Constructor

Parameters:
e elementary matrices set
problem problem to discretize

Definition at line 221 of file DiscretizedOperators.hpp.

00223     : __elementaryMatrixSet(e)
00224   {
00225     switch (problem.type()) {
00226     case Problem::pde: {
00227       const PDESystem& pdeSystem
00228         = dynamic_cast<const PDESystem&>(problem);
00229 
00230       for (size_t i=0; i<problem.numberOfUnknown(); ++i) {
00231         const PDE& pde = pdeSystem[i].pde();
00232         for (size_t j=0; j<pdeSystem.numberOfEquations(); ++j) {
00233           const PDEOperatorSum& pdeOpSum = *pde[j];
00234           for (size_t k=0; k<pdeOpSum.numberOfOperators(); ++k) {
00235             const PDEOperator& pdeOperator = *pdeOpSum[k];
00236             switch (pdeOperator.type()) {
00237             case PDEOperator::firstorderop: {
00238               const FirstOrderOperator& firstOrderOperator
00239                 = dynamic_cast<const FirstOrderOperator&>(pdeOperator);
00240               for (size_t m=0; m<3; ++m) {
00241                 if (firstOrderOperator.isSet(m)) {
00242                   __list.insert(ListPair(&__elementaryMatrixSet.firstOrderOperatorDxUV(m),
00243                                          FunctionAndPosition(i,j,firstOrderOperator.nu(m))));
00244                 }
00245               }
00246               break;
00247             }
00248             case PDEOperator::divmugrad: {
00249               const DivMuGrad& divMuGrad
00250                 = dynamic_cast<const DivMuGrad&>(pdeOperator);
00251               __list.insert(ListPair(&__elementaryMatrixSet.divMuGrad(),
00252                                      FunctionAndPosition(i,j,divMuGrad.mu())));
00253               break;
00254             }
00255             case PDEOperator::secondorderop: {
00256               const SecondOrderOperator& secondOrderOperator
00257                 = dynamic_cast<const SecondOrderOperator&>(pdeOperator);
00258               for (size_t m=0; m<3; ++m)
00259                 for (size_t n=0; n<3; ++n) {
00260                   if (secondOrderOperator.isSet(m,n)) {
00261                     __list.insert(ListPair(&__elementaryMatrixSet.secondOrderOperator(m,n),
00262                                            FunctionAndPosition(i,j,secondOrderOperator.A(m,n))));
00263                   }
00264                 }
00265               break;
00266             }
00267             case PDEOperator::massop: {
00268               const MassOperator& massOperator
00269                 = dynamic_cast<const MassOperator&>(pdeOperator);
00270               __list.insert(ListPair(&__elementaryMatrixSet.massOperator(),
00271                                      FunctionAndPosition(i,j,massOperator.alpha())));
00272               break;
00273             }
00274             default: {
00275               throw ErrorHandler(__FILE__,__LINE__,
00276                                  "unknown operator",
00277                                  ErrorHandler::unexpected);
00278             }
00279             }
00280           }
00281         }
00282       }
00283       break;
00284     }
00285     case Problem::variational: {
00286       const VariationalProblem& P
00287         = dynamic_cast<const VariationalProblem&>(problem);
00288       for (VariationalProblem::bilinearOperatorConst_iterator
00289              i = P.beginBilinearOperator();
00290            i != P.endBilinearOperator(); ++i) {
00291         switch ((*(*i)).type()) {
00292         case VariationalBilinearOperator::muGradUGradV: {
00293           const VariationalMuGradUGradVOperator& O
00294             = dynamic_cast<const VariationalMuGradUGradVOperator&>(*(*i));
00295 
00296           __list.insert(ListPair(&__elementaryMatrixSet.divMuGrad(),
00297                                  FunctionAndPosition(O.unknownNumber(),
00298                                                      O.testFunctionNumber(),
00299                                                      O.mu())));
00300 
00301           break;
00302         }
00303         case VariationalBilinearOperator::alphaDxUDxV: {
00304           const VariationalAlphaDxUDxVOperator& O
00305             = dynamic_cast<const VariationalAlphaDxUDxVOperator&>(*(*i));
00306 
00307           const size_t i = O.i();
00308           const size_t j = O.j();
00309         
00310           __list.insert(ListPair(&__elementaryMatrixSet.secondOrderOperator(i,j),
00311                                  FunctionAndPosition(O.unknownNumber(),
00312                                                      O.testFunctionNumber(),
00313                                                      O.alpha())));
00314           break;
00315         }
00316         case VariationalBilinearOperator::nuUdxV: {
00317           const VariationalNuUdxVOperator& O
00318             = dynamic_cast<const VariationalNuUdxVOperator&>(*(*i));
00319 
00320           const size_t n = O.i();
00321           __list.insert(ListPair(&__elementaryMatrixSet.firstOrderOperatorUdxV(n),
00322                                  FunctionAndPosition(O.unknownNumber(),
00323                                                      O.testFunctionNumber(),
00324                                                      O.nu())));
00325           break;
00326         }
00327         case VariationalBilinearOperator::nuDxUV: {
00328           const VariationalNuDxUVOperator& O
00329             = dynamic_cast<const VariationalNuDxUVOperator&>(*(*i));
00330 
00331           const size_t n = O.i();
00332           __list.insert(ListPair(&__elementaryMatrixSet.firstOrderOperatorDxUV(n),
00333                                  FunctionAndPosition(O.unknownNumber(),
00334                                                      O.testFunctionNumber(),
00335                                                      O.nu())));
00336           break;
00337         }
00338         case VariationalBilinearOperator::alphaUV: {
00339           const VariationalAlphaUVOperator& O
00340             = dynamic_cast<const VariationalAlphaUVOperator&>(*(*i));
00341 
00342           __list.insert(ListPair(&__elementaryMatrixSet.massOperator(),
00343                                  FunctionAndPosition(O.unknownNumber(),
00344                                                      O.testFunctionNumber(),
00345                                                      O.alpha())));
00346 
00347           break;
00348         }
00349         default: {
00350           throw ErrorHandler(__FILE__,__LINE__,
00351                              "unknown variational form",
00352                              ErrorHandler::unexpected);
00353         }
00354         }
00355       }
00356       break;
00357     }
00358     default: {
00359       throw ErrorHandler(__FILE__,__LINE__,
00360                          "Unknown problem type",
00361                          ErrorHandler::unexpected);
00362     }
00363     }
00364   }

Member Function Documentation

template<typename ElementaryMatrixType>
DiscretizedOperators::iterator DiscretizedOperators< ElementaryMatrixType >::begin (  )  [inline]

Begining of the list

Returns:
begin iterator

Definition at line 161 of file DiscretizedOperators.hpp.

00162   {
00163     return __list.begin();
00164   }

template<typename ElementaryMatrixType>
const DiscretizedOperators::const_iterator DiscretizedOperators< ElementaryMatrixType >::begin (  )  const [inline]

Begining of the list

Returns:
begin const_iterator

Definition at line 172 of file DiscretizedOperators.hpp.

00173   {
00174     return __list.begin();
00175   }

template<typename ElementaryMatrixType>
DiscretizedOperators::iterator DiscretizedOperators< ElementaryMatrixType >::end (  )  [inline]

End of the list

Returns:
end iterator

Definition at line 183 of file DiscretizedOperators.hpp.

00184   {
00185     return __list.end();
00186   }

template<typename ElementaryMatrixType>
const DiscretizedOperators::const_iterator DiscretizedOperators< ElementaryMatrixType >::end (  )  const [inline]

End of the list

Returns:
end const_iterator

Definition at line 194 of file DiscretizedOperators.hpp.

00195   {
00196     return __list.end();
00197   }

Member Data Documentation

template<typename ElementaryMatrixType>
const ElementaryMatrixSet<ElementaryMatrixType>& DiscretizedOperators< ElementaryMatrixType >::__elementaryMatrixSet [private]

Reference to the elementary matrices set

Definition at line 201 of file DiscretizedOperators.hpp.

Referenced by DiscretizedOperators< FiniteElement::ElementaryMatrix >::DiscretizedOperators().

template<typename ElementaryMatrixType>
List DiscretizedOperators< ElementaryMatrixType >::__list [private]

list of discretized operators

Definition at line 204 of file DiscretizedOperators.hpp.

Referenced by DiscretizedOperators< FiniteElement::ElementaryMatrix >::begin(), DiscretizedOperators< FiniteElement::ElementaryMatrix >::DiscretizedOperators(), and DiscretizedOperators< FiniteElement::ElementaryMatrix >::end().

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