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

14 15 16 17
    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
18 19 20 21 22 23 24

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

Class
    Foam::MeshedSurfaceProxy

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

SourceFiles
    MeshedSurfaceProxy.C
36
    MeshedSurfaceProxys.C
Mark Olesen's avatar
Mark Olesen committed
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

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

#ifndef MeshedSurfaceProxy_H
#define MeshedSurfaceProxy_H

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

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

namespace Foam
{

54
// Forward Declarations
Mark Olesen's avatar
Mark Olesen committed
55 56 57 58 59 60 61 62 63 64 65
template<class Face> class MeshedSurface;

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

template<class Face>
class MeshedSurfaceProxy
:
    public fileFormats::surfaceFormatsCore
{
66
    // Private Data
Mark Olesen's avatar
Mark Olesen committed
67 68 69

        const pointField& points_;

70
        const UList<Face>& faces_;
Mark Olesen's avatar
Mark Olesen committed
71

72
        const UList<surfZone>& zones_;
Mark Olesen's avatar
Mark Olesen committed
73

74
        const UList<label>& faceMap_;
Andrew Heather's avatar
Andrew Heather committed
75

Mark Olesen's avatar
Mark Olesen committed
76 77
public:

78
    // Public Typedefs
79

80 81 82 83 84
        //- The face type
        typedef Face face_type;

        //- The point type
        typedef point point_type;
85 86


87 88
    //- Declare type-name (with debug switch)
    ClassName("MeshedSurfaceProxy");
Andrew Heather's avatar
Andrew Heather committed
89

90 91

    // Static Functions
Mark Olesen's avatar
Mark Olesen committed
92

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

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


    // Constructors

        //- Construct from component references
        MeshedSurfaceProxy
        (
105
            const pointField& pointLst,
106 107
            const UList<Face>& faceLst,
            const UList<surfZone>& zoneLst = List<surfZone>(),
108
            const labelUList& faceMap = labelUList::null()
Mark Olesen's avatar
Mark Olesen committed
109 110
        );

Andrew Heather's avatar
Andrew Heather committed
111

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


    // Member Function Selectors

        declareMemberFunctionSelectionTable
        (
            void,
            MeshedSurfaceProxy,
            write,
            fileExtension,
            (
                const fileName& name,
126
                const MeshedSurfaceProxy<Face>& surf,
127
                IOstreamOption streamOpt,
128
                const dictionary& options
Mark Olesen's avatar
Mark Olesen committed
129
            ),
130
            (name, surf, streamOpt, options)
Mark Olesen's avatar
Mark Olesen committed
131 132
        );

133
        //- Write to file, select based on its extension
134 135
        static void write
        (
136
            const fileName& name,
137
            const MeshedSurfaceProxy& surf,
138 139
            IOstreamOption streamOpt = IOstreamOption(),
            const dictionary& options = dictionary::null
140 141
        );

142 143
        //- Write to file with given format type.
        //  If the format type is "", uses the file extension.
144 145 146
        static void write
        (
            const fileName& name,
147
            const word& fileType,
148
            const MeshedSurfaceProxy& surf,
149 150
            IOstreamOption streamOpt = IOstreamOption(),
            const dictionary& options = dictionary::null
151
        );
Mark Olesen's avatar
Mark Olesen committed
152 153 154 155


    // Member Functions

Andrew Heather's avatar
Andrew Heather committed
156 157
        // Access

158
            //- The surface size is the number of faces
159
            label size() const
160 161 162 163
            {
                return faces_.size();
            }

Andrew Heather's avatar
Andrew Heather committed
164
            //- Return const access to the points
165
            const pointField& points() const
Andrew Heather's avatar
Andrew Heather committed
166 167 168 169 170
            {
                return points_;
            }

            //- Return const access to the faces
171
            const UList<Face>& surfFaces() const
Andrew Heather's avatar
Andrew Heather committed
172 173 174 175 176 177 178
            {
                return faces_;
            }

            //- Const access to the surface zones.
            //  If zones are defined, they must be contiguous and cover the
            //  entire surface
179
            const UList<surfZone>& surfZones() const
Andrew Heather's avatar
Andrew Heather committed
180 181 182 183 184
            {
                return zones_;
            }

            //- Const access to the faceMap, zero-sized when unused
185
            const labelUList& faceMap() const
Andrew Heather's avatar
Andrew Heather committed
186 187 188 189
            {
                return faceMap_;
            }

190 191
            //- Can/should use faceMap?
            bool useFaceMap() const
Andrew Heather's avatar
Andrew Heather committed
192 193 194 195
            {
                return faceMap_.size() == faces_.size();
            }

196 197 198 199
            //- Count number of triangles.
            inline label nTriangles() const;


200
    // Write
Andrew Heather's avatar
Andrew Heather committed
201

202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
        //- Write to file, choosing writer based on the file extension.
        virtual void write
        (
            const fileName& name,
            IOstreamOption streamOpt = IOstreamOption(),
            const dictionary& options = dictionary::null
        ) const
        {
            write(name, *this, streamOpt, options);
        }

        //- Write to file with given format type.
        //  If the format type is "", uses the file extension.
        virtual void write
        (
            const fileName& name,
            const word& fileType,
            IOstreamOption streamOpt = IOstreamOption(),
            const dictionary& options = dictionary::null
        ) const
        {
            write(name, fileType, *this, streamOpt, options);
        }
225

226 227 228 229 230 231
        //- Write to database
        virtual void write
        (
            const Time& t,
            const word& surfName = word::null
        ) const;
Mark Olesen's avatar
Mark Olesen committed
232 233 234 235 236 237 238 239 240 241
};


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

} // End namespace Foam

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

#ifdef NoRepository
242
    #include "MeshedSurfaceProxy.C"
Mark Olesen's avatar
Mark Olesen committed
243 244 245 246 247 248 249
#endif

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

#endif

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