cellModel.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2011-2015 OpenFOAM Foundation
    Copyright (C) 2017-2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.
 
    OpenFOAM 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 3 of the License, or
    (at your option) any later version.
 
    OpenFOAM 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.
 
    You should have received a copy of the GNU General Public License
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
Class
    Foam::cellModel
 
Description
    Maps a geometry to a set of cell primitives.
 
    This enables geometric cell data to be calculated without access
    to the primitive geometric level. This means mapping a 3D
    geometry to a set of pyramids which are each described by a cell
    face and the cell centre point.
 
    Also includes a static collection of cell models (normally loaded from
    etc/cellModels), and a means of looking them up.
 
SourceFiles
    cellModelI.H
    cellModel.C
    cellModels.C
    cellModelIO.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef cellModel_H
#define cellModel_H
 
#include "pointField.H"
#include "edgeList.H"
#include "faceList.H"
#include "InfoProxy.H"
#include "autoPtr.H"
#include "PtrList.H"
#include "Enum.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
// Forward Declarations
class cellModel;
Ostream& operator<<(Ostream& os, const cellModel& cm);
 
/*---------------------------------------------------------------------------*\
                          Class cellModel Declaration
\*---------------------------------------------------------------------------*/
 
class cellModel
{
public:
 
        //- Enumeration of commonly used cellModel types.
        //  The indices must match those in "etc/cellModels"
        enum modelType
        {
            UNKNOWN = 0,     
            HEX = 3,         
            WEDGE = 4,       
            PRISM = 5,       
            PYR = 6,         
            TET = 7,         
            SPLITHEX = 8,    
            TETWEDGE = 9,    
        };
 
        //- Names of commonly used cellModels corresponding to modelType.
        //  The names must match those in "etc/cellModels"
        static const Enum<modelType> modelNames;
 
 
    // Lookup Methods
 
        //- Look up pointer to cellModel by enumeration, or nullptr on failure.
        static const cellModel* ptr(const modelType model);
 
        //- Look up pointer to cellModel by name, or nullptr on failure.
        static const cellModel* ptr(const word& modelName);
 
        //- Look up pointer to cellModel by index, or nullptr on failure
        static const cellModel* ptr(const label modelIndex);
 
 
        //- Look up reference to cellModel by enumeration. Fatal on failure
        static const cellModel& ref(const modelType model);
 
        //- Look up reference to cellModel by name. Fatal on failure
        static const cellModel& ref(const word& modelName);
 
        //- Look up reference to cellModel by index. Fatal on failure
        static const cellModel& ref(const label modelIndex);
 
 
private:
 
    // Private Static Data
 
        //- PtrList of predefined models
        static PtrList<cellModel> models_;
 
        //- Lookup of model pointers (in models_) by index
        static List<const cellModel*> modelPtrs_;
 
 
    // Private Data
 
        //- (Unique) model name
        word name_;
 
        //- Index in the model list
        label index_;
 
        //- Number of points in the model which determines the geometry
        label nPoints_;
 
        //- Faces of the model
        faceList faces_;
 
        //- Edges of the model
        edgeList edges_;
 
 
    // Private Member Functions
 
        //- Construct from central "etc/cellModels" file.
        static void constructModels();
 
 
public:
 
    // Constructors
 
        //- Construct from Istream
        explicit cellModel(Istream& is);
 
        //- Return a new cellModel created from Istream
        static autoPtr<cellModel> New(Istream& is)
        {
            return autoPtr<cellModel>::New(is);
        }
 
        //- Return clone
        autoPtr<cellModel> clone() const
        {
            return autoPtr<cellModel>::New(*this);
        }
 
 
    // Member Functions
 
        //- Return model name
        inline const word& name() const noexcept;
 
        //- Return index of model in the model list
        inline label index() const noexcept;
 
        //- Return number of points
        inline label nPoints() const noexcept;
 
        //- Return number of edges
        inline label nEdges() const noexcept;
 
        //- Return number of faces
        inline label nFaces() const noexcept;
 
        //- Return a raw list of model edges
        inline const edgeList& modelEdges() const noexcept;
 
        //- Return a raw list of model faces
        inline const faceList& modelFaces() const noexcept;
 
        //- Return list of cell edges
        inline edgeList edges(const labelUList& pointLabels) const;
 
        //- Return list of cell faces
        inline faceList faces(const labelUList& pointLabels) const;
 
        //- Return the cell edge for specified model edge
        inline Foam::edge edge
        (
            const label modelEdgei,
            const labelUList& pointLabels
        ) const;
 
        //- Return the cell face for specified model face
        inline Foam::face face
        (
            const label modelFacei,
            const labelUList& pointLabels
        ) const;
 
 
        //- Centroid of the cell
        vector centre
        (
            const labelList& pointLabels,
            const UList<point>& points
        ) const;
 
        //- Cell volume
        scalar mag
        (
            const labelList& pointLabels,
            const UList<point>& points
        ) const;
 
        //- Return info proxy.
        //  Used to print information to a stream
        InfoProxy<cellModel> info() const
        {
            return *this;
        }
 
        //- The writeData member function required by regIOobject
        bool writeData(Ostream& os) const
        {
            os << *this;
            return os.good();
        }
 
 
    // Ostream Operator
 
        friend Ostream& operator<<(Ostream& os, const cellModel& cm);
};
 
 
// Ostream Operators
 
template<>
Ostream& operator<<(Ostream& os, const InfoProxy<cellModel>& ip);
 
 
// Global Operators
 
//- Equality: true when model pointers are identical
inline bool operator==(const cellModel& lhs, const cellModel& rhs) noexcept;
 
//- Inequality: true when model pointers are not identical
inline bool operator!=(const cellModel& lhs, const cellModel& rhs) noexcept;
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#include "cellModelI.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //