MeshedSurfaceProxy.H 6.07 KB
Newer Older
Mark Olesen's avatar
Mark Olesen committed
1 2 3 4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
5
    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
6
     \\/     M anipulation  | Copyright (C) 2016-2017 OpenCFD Ltd.
Mark Olesen's avatar
Mark Olesen committed
7 8 9 10
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

11 12 13 14
    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.
Mark Olesen's avatar
Mark Olesen committed
15 16 17 18 19 20 21

    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
22
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
Mark Olesen's avatar
Mark Olesen committed
23 24 25 26 27 28 29 30 31 32

Class
    Foam::MeshedSurfaceProxy

Description
    A proxy for writing MeshedSurface, UnsortedMeshedSurface and surfMesh
    to various file formats.

SourceFiles
    MeshedSurfaceProxy.C
33
    MeshedSurfaceProxys.C
Mark Olesen's avatar
Mark Olesen committed
34 35 36 37 38 39 40

\*---------------------------------------------------------------------------*/

#ifndef MeshedSurfaceProxy_H
#define MeshedSurfaceProxy_H

#include "pointField.H"
41
#include "labelledTri.H"
Mark Olesen's avatar
Mark Olesen committed
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

#include "surfZoneList.H"
#include "surfaceFormatsCore.H"
#include "runTimeSelectionTables.H"
#include "memberFunctionSelectionTables.H"
#include "HashSet.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

// Forward declaration of friend functions and operators

template<class Face> class MeshedSurface;

/*---------------------------------------------------------------------------*\
                     Class MeshedSurfaceProxy Declaration
\*---------------------------------------------------------------------------*/

template<class Face>
class MeshedSurfaceProxy
:
    public fileFormats::surfaceFormatsCore
{
    //- Private data

        const pointField& points_;

        const List<Face>& faces_;

        const List<surfZone>& zones_;

        const List<label>& faceMap_;

Andrew Heather's avatar
Andrew Heather committed
77

Mark Olesen's avatar
Mark Olesen committed
78 79
public:

80 81 82 83 84 85
    // Public typedefs

        //- Face type used
        typedef Face FaceType;


Andrew Heather's avatar
Andrew Heather committed
86 87
    // Static

Mark Olesen's avatar
Mark Olesen committed
88 89 90
        //- Runtime type information
        ClassName("MeshedSurfaceProxy");

91 92 93 94
        //- The file format types that can be written via MeshedSurfaceProxy
        static wordHashSet writeTypes();

        //- Can this file format type be written via MeshedSurfaceProxy?
Mark Olesen's avatar
Mark Olesen committed
95 96 97 98 99 100 101 102
        static bool canWriteType(const word& ext, const bool verbose=false);


    // Constructors

        //- Construct from component references
        MeshedSurfaceProxy
        (
103 104 105
            const pointField& pointLst,
            const List<Face>& faceLst,
            const List<surfZone>& zoneLst = List<surfZone>(),
Mark Olesen's avatar
Mark Olesen committed
106 107 108
            const List<label>& faceMap = List<label>()
        );

Andrew Heather's avatar
Andrew Heather committed
109

110 111
    //- Destructor
    virtual ~MeshedSurfaceProxy();
Mark Olesen's avatar
Mark Olesen committed
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128


    // Member Function Selectors

        declareMemberFunctionSelectionTable
        (
            void,
            MeshedSurfaceProxy,
            write,
            fileExtension,
            (
                const fileName& name,
                const MeshedSurfaceProxy<Face>& surf
            ),
            (name, surf)
        );

129
        //- Write to file, selected based on its extension
130 131
        static void write
        (
132 133 134 135 136 137 138 139 140 141
            const fileName& name,
            const MeshedSurfaceProxy& surf
        );

        //- Write to file, selected based on given extension
        static void write
        (
            const fileName& name,
            const word& ext,
            const MeshedSurfaceProxy& surf
142
        );
Mark Olesen's avatar
Mark Olesen committed
143 144 145 146


    // Member Functions

Andrew Heather's avatar
Andrew Heather committed
147 148
        // Access

149 150 151 152 153 154
            //- The surface size is the number of faces
            inline label size() const
            {
                return faces_.size();
            }

Andrew Heather's avatar
Andrew Heather committed
155 156 157 158 159 160 161
            //- Return const access to the points
            inline const pointField& points() const
            {
                return points_;
            }

            //- Return const access to the faces
162
            inline const List<Face>& surfFaces() const
Andrew Heather's avatar
Andrew Heather committed
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
            {
                return faces_;
            }

            //- Const access to the surface zones.
            //  If zones are defined, they must be contiguous and cover the
            //  entire surface
            inline const List<surfZone>& surfZones() const
            {
                return zones_;
            }

            //- Const access to the faceMap, zero-sized when unused
            inline const List<label>& faceMap() const
            {
                return faceMap_;
            }

            //- Use faceMap?
            inline bool useFaceMap() const
            {
                return faceMap_.size() == faces_.size();
            }

187 188 189 190
            //- Count number of triangles.
            inline label nTriangles() const;


Andrew Heather's avatar
Andrew Heather committed
191 192 193 194 195 196 197 198
        // Write

            //- Generic write routine. Chooses writer based on extension.
            virtual void write(const fileName& name) const
            {
                write(name, *this);
            }

199 200 201 202 203 204
            //- Generic write routine. Chooses writer based on extension.
            virtual void write(const fileName& name, const word& ext) const
            {
                write(name, ext, *this);
            }

Andrew Heather's avatar
Andrew Heather committed
205
            //- Write to database
206 207
            virtual void write
            (
208
                const Time& t,
209 210
                const word& surfName = word::null
            ) const;
Mark Olesen's avatar
Mark Olesen committed
211 212 213 214 215 216 217 218 219 220
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#ifdef NoRepository
221
    #include "MeshedSurfaceProxy.C"
Mark Olesen's avatar
Mark Olesen committed
222 223 224 225 226 227 228
#endif

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //