surfMesh.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-2016 OpenFOAM Foundation
    Copyright (C) 2016-2024 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::surfMesh
 
Description
    A surface mesh consisting of general polygon faces that has
    IO capabilities and a registry for storing fields.
 
Note
    In many places the Foam::polySurface class may be more flexible.
 
SourceFiles
    surfMesh.C
    surfMeshClear.C
    surfMeshIO.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef Foam_surfMesh_H
#define Foam_surfMesh_H
 
#include "surfaceRegistry.H"
#include "MeshedSurfaceIOAllocator.H"
#include "primitivePatch.H"
#include "surfZoneIOList.H"
#include "surfFieldsFwd.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
// Forward Declarations
class dimensionSet;
class meshedSurf;
template<class Face> class MeshedSurface;
 
/*---------------------------------------------------------------------------*\
                          Class surfMesh Declaration
\*---------------------------------------------------------------------------*/
 
class surfMesh
:
    public  surfaceRegistry,
    private Detail::MeshedSurfaceIOAllocator,
    public  PrimitivePatch<::Foam::UList<face>, const pointField&>
{
public:
 
    // Public Data Types
 
        //- Enumeration defining the state of the mesh after a read update.
        //  Used for post-processing applications, where the mesh
        //  needs to update based on the files written in time directories
        enum readUpdateState
        {
            UNCHANGED,
            POINTS_MOVED,
            TOPO_CHANGE,
            TOPO_PATCH_CHANGE
        };
 
 
private:
 
    // Private Typedefs
 
        //- Memory and IO management
        typedef
            Detail::MeshedSurfaceIOAllocator
            Allocator;
 
        //- Internal mesh storage type
        typedef
            PrimitivePatch<::Foam::UList<face>, const pointField&>
            MeshReference;
 
 
    // Private Data
 
        //- The surface zones
        surfZoneIOList surfZones_;
 
 
protected:
 
    // Protected Member Functions
 
        //- Non-const access to global points
        pointField& storedPoints()
        {
            return Allocator::storedIOPoints();
        }
 
        //- Non-const access to the faces
        faceList& storedFaces()
        {
            return Allocator::storedIOFaces();
        }
 
        //- Non-const access to the surface zones
        surfZoneList& storedZones()
        {
            return surfZones_;
        }
 
        //- Update point/face references
        void updateRefs();
 
 
public:
 
    // Public Typedefs
 
    //- Typedef required for GeoMesh
    typedef surfMesh Mesh;
 
    //- Placeholder only, but do not remove - it is needed for GeoMesh
    typedef bool BoundaryMesh;
 
 
    //- Declare type-name, virtual type (with debug switch)
    TypeName("surfMesh");
 
    //- Return the mesh sub-directory name (normally "surfMesh")
    static word meshSubDir;
 
 
    // Generated Methods
 
        //- No copy construct
        surfMesh(const surfMesh&) = delete;
 
        //- No copy assignment
        void operator=(const surfMesh&) = delete;
 
 
    // Constructors
 
        //- Read construct from IOobject.
        //  Writing = NO_WRITE
        explicit surfMesh(const IOobject& io);
 
        //- Read construct from IOobject, with alternative surface name
        //  Writing = NO_WRITE
        surfMesh(const IOobject& io, const word& surfName);
 
        //- Construct empty with specified name on the given registry.
        surfMesh(const word& surfName, const objectRegistry& obr);
 
        //- Copy construct from MeshedSurface<face>
        surfMesh
        (
            const IOobject& io,
            const MeshedSurface<face>& surf,
            const word& surfName = word::null
        );
 
        //- Move construct from MeshedSurface<face>
        surfMesh
        (
            const IOobject& io,
            MeshedSurface<face>&& surf,
            const word& surfName = word::null
        );
 
 
    //- Destructor
    virtual ~surfMesh();
 
 
    // Member Functions
 
    // Database
 
        //- Return the local mesh directory (dbDir()/meshSubDir)
        fileName meshDir() const;
 
        //- Return the current instance directory for points
        //  Used when constructing geometric mesh data dependent on points
        const fileName& pointsInstance() const;
 
        //- Return the current instance directory for faces
        const fileName& facesInstance() const;
 
        //- Set the instance for mesh files
        void setInstance
        (
            const fileName& inst,
            IOobjectOption::writeOption wOpt = IOobjectOption::AUTO_WRITE
        );
 
        //- Adjust the write option for all components
        void setWriteOption(IOobjectOption::writeOption wOpt);
 
 
    // Access
 
        //- Return the number of raw points
        virtual label nPoints() const;
 
        //- Return the number of raw faces
        virtual label nFaces() const;
 
        //- Return number of faces
        virtual label size() const
        {
            return nFaces();
        }
 
 
        //- Return points
        virtual const pointField& points() const;
 
        //- Return faces
        virtual const faceList& faces() const;
 
        //- Return surface zones
        virtual const surfZoneList& surfZones() const
        {
            return surfZones_;
        }
 
        //- Return face area vectors (normals)
        const vectorField& Sf() const
        {
            return MeshReference::faceAreas();
        }
 
        //- Return face area magnitudes
        const scalarField& magSf() const
        {
            return MeshReference::magFaceAreas();
        }
 
        //- Face centres
        const vectorField& Cf() const
        {
            return MeshReference::faceCentres();
        }
 
 
    // Zones
 
        //- Add surface zones, optionally validating the zone coverage
        void addZones
        (
            const surfZoneList& zones,
            bool validate = true
        );
 
        //- Remove surface zones
        void removeZones();
 
        //- Check the surface zone definitions
        void checkZones(const bool verbose=true);
 
 
    // Modification
 
        //- Update with new contents
        void copySurface
        (
            const pointField& points,
            const faceList& faces,
            bool validate=false
        );
 
        //- Update with new contents
        void copySurface
        (
            const meshedSurf& surf,
            bool validate=false
        );
 
        //- Update with new contents
        void copySurface
        (
            const MeshedSurface<face>& surf,
            bool validate=false
        );
 
        //- Transfer the contents of the argument and annul the argument
        //  Optionally validate the zone coverage.
        void transfer
        (
            MeshedSurface<face>& surf,
            bool validate=false
        );
 
        //- Update mesh based on the files saved in time directories
        virtual readUpdateState readUpdate();
 
 
    // Fields
 
        //- Create/store named zero field as face or point data
        //- (template parameter).
        //
        //  - Default is face-data (surfGeoMesh as template).
        //  - For point-data use surfPointGeoMesh as template.
        //
        //  \return reference to the field
        template<class Type, class GeoMeshType = surfGeoMesh>
        DimensionedField<Type, GeoMeshType>&
        newField
        (
            const word& fieldName,
            const dimensionSet& dims
        );
 
        //- Copy/store named field as face or point data (template parameter).
        //
        //  - Default is face-data (surfGeoMesh as template).
        //  - For point-data use surfPointGeoMesh as template.
        //
        //  \return reference to the field
        template<class Type, class GeoMeshType = surfGeoMesh>
        DimensionedField<Type, GeoMeshType>&
        storeField
        (
            const word& fieldName,
            const dimensionSet& dims,
            const Field<Type>& values
        );
 
        //- Move/store named field as face or point data (template parameter).
        //
        //  - Default is face-data (surfGeoMesh as template).
        //  - For point-data use surfPointGeoMesh as template.
        //
        //  \return reference to the field
        template<class Type, class GeoMeshType = surfGeoMesh>
        DimensionedField<Type, GeoMeshType>&
        storeField
        (
            const word& fieldName,
            const dimensionSet& dims,
            Field<Type>&& values
        );
 
 
    // Writing
 
        //- Avoid masking the normal objectRegistry write
        using surfaceRegistry::write;
 
        //- Write all components using given format, version and compression
        virtual bool writeObject
        (
            IOstreamOption streamOpt,
            const bool writeOnProc
        ) const;
 
 
        //- Write to file, choosing writer based on its extension.
        //  Uses MeshedSurfaceProxy for writing.
        void write
        (
            const fileName& name,
            IOstreamOption streamOpt = IOstreamOption(),
            const dictionary& options = dictionary::null
        ) const;
 
        //- Write to file, choosing writer for given fileType.
        //  Uses MeshedSurfaceProxy for writing.
        void write
        (
            const fileName& name,
            const word& fileType,
            IOstreamOption streamOpt = IOstreamOption(),
            const dictionary& options = dictionary::null
        ) const;
 
 
    // Storage Management
 
        //- Release the geometry and return as a MeshedSurface<face>.
        autoPtr<MeshedSurface<face>> releaseGeom();
 
        //- Clear geometry
        void clearGeom();
 
        //- Clear addressing
        void clearAddressing();
 
        //- Clear all geometry and addressing unnecessary for CFD
        void clearOut();
 
        //- Clear primitive data (points, faces and cells)
        void clearPrimitives();
 
        //- Clear stored fields
        void clearFields();
 
        //- Remove all files from mesh instance
        void removeFiles(const fileName& instanceDir) const;
 
        //- Remove all files from mesh instance()
        void removeFiles() const;
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#ifdef NoRepository
    #include "surfMeshTemplates.C"
#endif
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //