ScalarDegreeOfFreedomPositionsSet::Builder Class Reference

Collaboration diagram for ScalarDegreeOfFreedomPositionsSet::Builder:

Collaboration graph
[legend]

List of all members.

Public Member Functions

 Builder (ScalarDegreeOfFreedomPositionsSet &dofPositionsSet)
 ~Builder ()
void build (const ScalarDiscretizationTypeBase &discretizationType, const Mesh &mesh)

Private Member Functions

template<typename FiniteElementType, typename MeshType>
size_t __computeFEMNbDOF (const MeshType &mesh)
template<typename MeshType, typename FiniteElementType>
void __buildFEM (const MeshType &mesh)
template<typename MeshType>
void __buildLegendre (const MeshType &mesh, const ScalarDiscretizationTypeSpectral &spectralDiscretizationType)
template<typename MeshType>
void __build (const ScalarDiscretizationTypeBase &discretizationType, const MeshType &mesh)
template<>
void __buildLegendre (const SpectralMesh &mesh, const ScalarDiscretizationTypeSpectral &spectralDiscretizationType)
template<>
void __buildLegendre (const OctreeMesh &mesh, const ScalarDiscretizationTypeSpectral &spectralDiscretizationType)

Private Attributes

ScalarDegreeOfFreedomPositionsSet & __dofPositionsSet

Detailed Description

Definition at line 44 of file ScalarDegreeOfFreedomPositionsSet.cpp.

Constructor & Destructor Documentation

ScalarDegreeOfFreedomPositionsSet::Builder::Builder ( ScalarDegreeOfFreedomPositionsSet &  dofPositionsSet  )  [inline]

Constructor

Parameters:
dofPositionsSet degrees of freedom position set to built

Definition at line 301 of file ScalarDegreeOfFreedomPositionsSet.cpp.

00302     : __dofPositionsSet(dofPositionsSet)
00303   {
00304     ;
00305   }

ScalarDegreeOfFreedomPositionsSet::Builder::~Builder (  )  [inline]

Destructor

Definition at line 311 of file ScalarDegreeOfFreedomPositionsSet.cpp.

00312   {
00313     ;
00314   }

Member Function Documentation

template<typename FiniteElementType, typename MeshType>
size_t ScalarDegreeOfFreedomPositionsSet::Builder::__computeFEMNbDOF ( const MeshType &  mesh  )  [inline, private]

Computes the number of degrees of freedom on a mesh for a given finite element type

Parameters:
mesh given mesh
Returns:
the number of degrees of freedom

Definition at line 61 of file ScalarDegreeOfFreedomPositionsSet.cpp.

References ffout(), and ConnectivityBuilder< MeshType >::generates().

00062   {
00063     size_t nbDOF = 0;
00064     size_t neededConnectivities = 0;
00065 
00066     // adds vertices dof
00067     if (FiniteElementType::numberOfVertexDegreesOfFreedom > 0) {
00068       nbDOF
00069         += FiniteElementType::numberOfVertexDegreesOfFreedom
00070         *  mesh.numberOfVertices();
00071     }
00072     
00073     // adds edges dof
00074     if (FiniteElementType::numberOfEdgeDegreesOfFreedom > 0) {
00075       if (not(mesh.hasEdges())) {
00076         const_cast<MeshType&>(mesh).buildEdges();
00077       }
00078       if (not(mesh.connectivity().hasCellToEdges())) {
00079         neededConnectivities += Connectivity<MeshType>::CellToEdges;
00080       }
00081 
00082       nbDOF
00083         += FiniteElementType::numberOfEdgeDegreesOfFreedom
00084         *  mesh.numberOfEdges();
00085     }
00086 
00087     // adds faces dof
00088     if (FiniteElementType::numberOfFaceDegreesOfFreedom > 0) {
00089       if (not(mesh.hasFaces())) {
00090         const_cast<MeshType&>(mesh).buildFaces();
00091       }
00092       if (not(mesh.connectivity().hasCellToFaces())) {
00093         neededConnectivities += Connectivity<MeshType>::CellToFaces;
00094       }
00095       nbDOF
00096         += FiniteElementType::numberOfFaceDegreesOfFreedom
00097         *  mesh.numberOfFaces();
00098     }
00099 
00100     // adds cells dof
00101     if (FiniteElementType::numberOfVolumeDegreesOfFreedom > 0) {
00102       nbDOF
00103         += FiniteElementType::numberOfVolumeDegreesOfFreedom
00104         *  mesh.numberOfCells();
00105     }
00106 
00107     if (neededConnectivities > 0) {
00108       ConnectivityBuilder<MeshType> builder(mesh);
00109       builder.generates(neededConnectivities);
00110     }
00111 
00112     ffout(3) << "- number of degrees of freedom positions: " << nbDOF << '\n';
00113     return nbDOF;
00114   }

Here is the call graph for this function:

template<typename MeshType, typename FiniteElementType>
void ScalarDegreeOfFreedomPositionsSet::Builder::__buildFEM ( const MeshType &  mesh  )  [inline, private]

Builds the degree of freedom set for a finite element type and a given mesh

Parameters:
mesh given mesh

Definition at line 124 of file ScalarDegreeOfFreedomPositionsSet.cpp.

References ScalarDegreeOfFreedomPositionsSet::__dofNumber, __dofPositionsSet, ScalarDegreeOfFreedomPositionsSet::__numberOfDOFPerCell, ScalarDegreeOfFreedomPositionsSet::__positions, Connectivity< MeshType >::edges(), and Vector< T >::resize().

00125   {
00126     typedef typename MeshType::CellType CellType;
00127 
00128     __dofPositionsSet.__numberOfDOFPerCell = FiniteElementType::numberOfDegreesOfFreedom;
00129     __dofPositionsSet.__dofNumber.resize(mesh.numberOfCells()*FiniteElementType::numberOfDegreesOfFreedom);
00130     // fills the correspondance table with wrong values
00131     __dofPositionsSet.__dofNumber = std::numeric_limits<size_t>::max();
00132 
00133     // Computes the number of degrees of freedom
00134     const size_t nbDOF = __computeFEMNbDOF<FiniteElementType>(mesh);
00135 
00136     __dofPositionsSet.__positions.resize(nbDOF);
00137 
00138     size_t begin = 0;
00139     size_t end = 0;
00140 
00141     // vertices
00142     if (FiniteElementType::numberOfVertexDegreesOfFreedom > 0) {
00143       begin = end;
00144       end += mesh.numberOfVertices();
00145       for (size_t i=begin; i < end; ++i) {
00146         __dofPositionsSet.__positions[i] = mesh.vertex(i);
00147       }
00148       for (size_t i=0; i<mesh.numberOfCells(); ++i) {
00149         const CellType& cell = mesh.cell(i);
00150         for (size_t j=0; j<CellType::NumberOfVertices; ++j) {
00151           const size_t vertexNumber = mesh.vertexNumber(cell(j));
00152           __dofPositionsSet.__dofNumber[i*FiniteElementType::numberOfDegreesOfFreedom+j]
00153             = vertexNumber;
00154         }
00155       }
00156     }
00157 
00158     // edges
00159     if (FiniteElementType::numberOfEdgeDegreesOfFreedom > 0) {
00160       begin = end;
00161       end += mesh.numberOfEdges();
00162       for (size_t i=begin; i < end; ++i) {
00163         const Edge& edge = mesh.edge(i-begin);
00164         __dofPositionsSet.__positions[i] = 0.5*(edge(0)+edge(1));
00165       }
00166 
00167       // Take into account vertices degrees of freedom in numbering
00168       const size_t inputShift
00169         = FiniteElementType::numberOfVertexDegreesOfFreedom
00170         * CellType::NumberOfVertices;
00171       const size_t outputShift
00172         = mesh.numberOfVertices()
00173         * FiniteElementType::numberOfVertexDegreesOfFreedom;
00174 
00175       const Connectivity<MeshType>&
00176         connectivity = mesh.connectivity();
00177 
00178       for (size_t i=0; i<mesh.numberOfCells(); ++i) {
00179         const CellType& cell = mesh.cell(i);
00180         const typename Connectivity<MeshType>::CellToEdgesType&
00181           cellEdges = connectivity.edges(cell);
00182         for (size_t j=0; j<CellType::NumberOfEdges; ++j) {
00183           const Edge& edge = *(cellEdges[j]);
00184           const size_t edgeNumber = mesh.edgeNumber(edge);
00185           __dofPositionsSet.__dofNumber[i*FiniteElementType::numberOfDegreesOfFreedom+inputShift+j]
00186             = edgeNumber + outputShift;
00187         }
00188       }
00189     }
00190 
00191     // faces
00192     if (FiniteElementType::numberOfFaceDegreesOfFreedom > 0) {
00193       begin = end;
00194       end += mesh.numberOfFaces();
00195       for (size_t i=begin; i < end; ++i) {
00196         typedef typename MeshType::CellType::FaceType FaceType;
00197 
00198         const FaceType& face = mesh.face(i-begin);
00199         __dofPositionsSet.__positions[i] = 0;
00200         for (size_t j=0; j<FaceType::NumberOfVertices; ++j) {
00201           __dofPositionsSet.__positions[i] += face(j);
00202         }
00203         __dofPositionsSet.__positions[i] *= 1./FaceType::NumberOfVertices;
00204       }
00205 
00206       // Take into account vertices and edges degrees of freedom in
00207       // numbering
00208       const size_t inputShift
00209         = FiniteElementType::numberOfVertexDegreesOfFreedom
00210         * CellType::NumberOfVertices
00211         + FiniteElementType::numberOfEdgeDegreesOfFreedom
00212         * CellType::NumberOfEdges;
00213       const size_t outputShift
00214         = mesh.numberOfVertices()
00215         * FiniteElementType::numberOfVertexDegreesOfFreedom
00216         + (mesh.hasEdges() ? mesh.numberOfEdges() : 0)
00217         * FiniteElementType::numberOfEdgeDegreesOfFreedom;
00218 
00219       const Connectivity<MeshType>&
00220         connectivity = mesh.connectivity();
00221 
00222       for (size_t i=0; i<mesh.numberOfCells(); ++i) {
00223         const CellType& cell = mesh.cell(i);
00224         const typename Connectivity<MeshType>::CellToFacesType&
00225           cellFaces = connectivity.faces(cell);
00226 
00227         for (size_t j=0; j<CellType::NumberOfFaces; ++j) {
00228           const typename CellType::FaceType& face = *(cellFaces[j]);
00229           const size_t faceNumber = mesh.faceNumber(face);
00230           __dofPositionsSet.__dofNumber[i*FiniteElementType::numberOfDegreesOfFreedom+inputShift+j]
00231             = faceNumber + outputShift;
00232         }
00233       }
00234     }
00235 
00236     // cells
00237     if (FiniteElementType::numberOfVolumeDegreesOfFreedom > 0) {
00238       begin = end;
00239       end += mesh.numberOfCells();
00240 
00241       for (size_t i=0; i<mesh.numberOfCells(); ++i) {
00242         const CellType& cell = mesh.cell(i);
00243         TinyVector<3, real_t> position = 0;
00244         for (size_t l = 0; l<MeshType::CellType::NumberOfVertices; ++l) {
00245           position += cell(l);
00246         }
00247         position /= MeshType::CellType::NumberOfVertices;
00248         __dofPositionsSet.__positions[i+begin] = position;
00249       }
00250 
00251       // Take into account vertices, edges and face degrees of freedom
00252       // in numbering
00253       const size_t inputShift
00254         = FiniteElementType::numberOfVertexDegreesOfFreedom
00255         * CellType::NumberOfVertices
00256         + FiniteElementType::numberOfEdgeDegreesOfFreedom
00257         * CellType::NumberOfEdges
00258         + FiniteElementType::numberOfFaceDegreesOfFreedom
00259         * CellType::NumberOfFaces;
00260       const size_t outputShift
00261         = mesh.numberOfVertices()
00262         * FiniteElementType::numberOfVertexDegreesOfFreedom
00263         + (mesh.hasEdges() ? mesh.numberOfEdges() : 0)
00264         * FiniteElementType::numberOfEdgeDegreesOfFreedom
00265         + (mesh.hasFaces() ? mesh.numberOfFaces() : 0)
00266         * FiniteElementType::numberOfFaceDegreesOfFreedom;
00267 
00268       for (size_t i=0; i<mesh.numberOfCells(); ++i) {
00269         __dofPositionsSet.__dofNumber[i*FiniteElementType::numberOfDegreesOfFreedom+inputShift]
00270           = i + outputShift;
00271       }
00272     }
00273   }

Here is the call graph for this function:

template<typename MeshType>
void ScalarDegreeOfFreedomPositionsSet::Builder::__buildLegendre ( const MeshType &  mesh,
const ScalarDiscretizationTypeSpectral &  spectralDiscretizationType 
) [inline, private]

Definition at line 276 of file ScalarDegreeOfFreedomPositionsSet.cpp.

References ErrorHandler::unexpected.

00278   {
00279     throw ErrorHandler(__FILE__,__LINE__,
00280                        "Cannot build spectral degrees of freefom on '"
00281                        +mesh.typeName()+"'",
00282                        ErrorHandler::unexpected);
00283   }

template<typename MeshType>
void ScalarDegreeOfFreedomPositionsSet::Builder::__build ( const ScalarDiscretizationTypeBase &  discretizationType,
const MeshType &  mesh 
) [inline, private]

Builds the degrees of freedom position set for a discretization type and a given mesh

Parameters:
discretizationType discretization type
mesh given mesh

Definition at line 368 of file ScalarDegreeOfFreedomPositionsSet.cpp.

References ScalarDiscretizationTypeBase::lagrangianFEM0, ScalarDiscretizationTypeBase::lagrangianFEM1, ScalarDiscretizationTypeBase::lagrangianFEM2, ScalarDiscretizationTypeBase::name(), ScalarDiscretizationTypeBase::spectralLegendre, ScalarDiscretizationTypeBase::type(), and ErrorHandler::unexpected.

Referenced by build().

00370 {
00371   typedef typename MeshType::CellType CellType;
00372   switch(discretizationType.type()) {
00373   case ScalarDiscretizationTypeBase::lagrangianFEM0: {
00374     typedef
00375       typename FiniteElementTraits<CellType,
00376       ScalarDiscretizationTypeBase::lagrangianFEM0>::Type
00377       FiniteElementType;
00378     __buildFEM<MeshType, FiniteElementType>(mesh);
00379     break;
00380   }
00381   case ScalarDiscretizationTypeBase::lagrangianFEM1: {
00382     typedef
00383       typename FiniteElementTraits<CellType,
00384       ScalarDiscretizationTypeBase::lagrangianFEM1>::Type
00385       FiniteElementType;
00386     __buildFEM<MeshType, FiniteElementType>(mesh);
00387     break;
00388   }
00389   case ScalarDiscretizationTypeBase::lagrangianFEM2: {
00390     typedef
00391       typename FiniteElementTraits<CellType,
00392       ScalarDiscretizationTypeBase::lagrangianFEM2>::Type
00393       FiniteElementType;
00394     __buildFEM<MeshType, FiniteElementType>(mesh);
00395     break;
00396   }
00397   case ScalarDiscretizationTypeBase::spectralLegendre: {
00398     switch (discretizationType.type()) {
00399     case ScalarDiscretizationTypeBase::spectralLegendre: {
00400       const ScalarDiscretizationTypeSpectral& spectralDiscretizationType
00401         = dynamic_cast<const ScalarDiscretizationTypeSpectral&>(discretizationType);
00402       __buildLegendre<MeshType>(mesh, spectralDiscretizationType);
00403       break;
00404     }
00405     default: {
00406       throw ErrorHandler(__FILE__,__LINE__,
00407                          "Unknown spectral discretization type: '"+
00408                          ScalarDiscretizationTypeBase::name(discretizationType)+"'",
00409                          ErrorHandler::unexpected);
00410     }
00411     }
00412     break;
00413   }
00414   default: {
00415     throw ErrorHandler(__FILE__,__LINE__,
00416                        "not implemented",
00417                        ErrorHandler::unexpected);
00418   }
00419   }
00420 }

Here is the call graph for this function:

void ScalarDegreeOfFreedomPositionsSet::Builder::build ( const ScalarDiscretizationTypeBase &  discretizationType,
const Mesh &  mesh 
)

Build a ScalarDegreeOfFreedomPositionsSet

Parameters:
discretizationType given discretizationType
mesh given mesh

Definition at line 424 of file ScalarDegreeOfFreedomPositionsSet.cpp.

References __build(), Mesh::cartesianHexahedraMesh, ffout(), Mesh::hexahedraMesh, ErrorHandler::normal, Mesh::octreeMesh, Mesh::spectralMesh, Mesh::surfaceMeshQuadrangles, Mesh::surfaceMeshTriangles, Mesh::tetrahedraMesh, Mesh::trianglesMesh, Mesh::type(), and ErrorHandler::unexpected.

Referenced by ScalarDegreeOfFreedomPositionsSet::__build().

00426 {
00427   ffout(2) << "Computing degrees of freedom positions...\n";
00428   switch(mesh.type()) {
00429   case Mesh::cartesianHexahedraMesh: {
00430     __build(discretizationType, static_cast<const Structured3DMesh&>(mesh));
00431     break;
00432   }
00433   case Mesh::octreeMesh: {
00434     __build(discretizationType, static_cast<const OctreeMesh&>(mesh));
00435     break;
00436   }
00437   case Mesh::hexahedraMesh: {
00438     __build(discretizationType, static_cast<const MeshOfHexahedra&>(mesh));
00439     break;
00440   }
00441   case Mesh::spectralMesh: {
00442     __build(discretizationType, static_cast<const SpectralMesh&>(mesh));
00443     break;
00444   }
00445   case Mesh::tetrahedraMesh: {
00446     __build(discretizationType, static_cast<const MeshOfTetrahedra&>(mesh));
00447     break;
00448   }
00449   case Mesh::trianglesMesh: {
00450     __build(discretizationType, static_cast<const MeshOfTriangles&>(mesh));
00451     break;
00452   }
00453   case Mesh::surfaceMeshTriangles:
00454   case Mesh::surfaceMeshQuadrangles: {
00455     throw ErrorHandler(__FILE__,__LINE__,
00456                        "Cannot solve problems on surface meshes",
00457                        ErrorHandler::normal);
00458     break;
00459   }
00460   default: {
00461     throw ErrorHandler(__FILE__,__LINE__,
00462                        "type of mesh not supported",
00463                        ErrorHandler::unexpected);
00464   }
00465   }
00466   ffout(2) << "Computing degrees of freedom positions: done\n";
00467 }

Here is the call graph for this function:

template<>
void ScalarDegreeOfFreedomPositionsSet::Builder::__buildLegendre ( const SpectralMesh &  mesh,
const ScalarDiscretizationTypeSpectral &  spectralDiscretizationType 
) [inline, private]

template<>
void ScalarDegreeOfFreedomPositionsSet::Builder::__buildLegendre ( const OctreeMesh &  mesh,
const ScalarDiscretizationTypeSpectral &  spectralDiscretizationType 
) [inline, private]

Member Data Documentation

ScalarDegreeOfFreedomPositionsSet& ScalarDegreeOfFreedomPositionsSet::Builder::__dofPositionsSet [private]

Reference to the ScalarDegreeOfFreedomPositionsSet

Definition at line 48 of file ScalarDegreeOfFreedomPositionsSet.cpp.

Referenced by __buildFEM().

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