triSurfaceMesh.H 7.36 KB
Newer Older
mattijs's avatar
mattijs committed
1
2
3
4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
5
    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
mattijs's avatar
mattijs committed
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
     \\/     M anipulation  |
-------------------------------------------------------------------------------
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 2 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, write to the Free Software Foundation,
    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Class
26
    Foam::triSurfaceMesh
mattijs's avatar
mattijs committed
27
28
29
30
31
32
33
34
35
36
37
38

Description
    IOoject and searching on triSurface

SourceFiles
    triSurfaceMesh.C

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

#ifndef triSurfaceMesh_H
#define triSurfaceMesh_H

mattijs's avatar
mattijs committed
39
#include "treeBoundBox.H"
mattijs's avatar
mattijs committed
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include "searchableSurface.H"
#include "objectRegistry.H"
#include "indexedOctree.H"
#include "treeDataTriSurface.H"
#include "treeDataEdge.H"

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

namespace Foam
{

/*---------------------------------------------------------------------------*\
                           Class triSurfaceMesh Declaration
\*---------------------------------------------------------------------------*/

class triSurfaceMesh
:
    public searchableSurface,
58
    public objectRegistry,      // so we can store fields
mattijs's avatar
mattijs committed
59
60
61
62
63
64
65
66
67
68
69
70
    public triSurface
{
private:

    // Private member data

        //- Search tree (triangles)
        mutable autoPtr<indexedOctree<treeDataTriSurface> > tree_;

        //- Search tree for boundary edges.
        mutable autoPtr<indexedOctree<treeDataEdge> > edgeTree_;

71
72
73
74
75
76
        //- Names of regions
        mutable wordList regions_;

        //- Is surface closed
        mutable label surfaceClosed_;

mattijs's avatar
mattijs committed
77
78
79
80
81
82
83
84
85
    // Private Member Functions

        //- Check file existence
        static const fileName& checkFile
        (
            const fileName& fName,
            const fileName& objectName
        );

86
87
88
89
        //- Check whether surface is closed without calculating any permanent
        //  addressing.
        bool isSurfaceClosed() const;

mattijs's avatar
mattijs committed
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
        //- Disallow default bitwise copy construct
        triSurfaceMesh(const triSurfaceMesh&);

        //- Disallow default bitwise assignment
        void operator=(const triSurfaceMesh&);


public:

    //- Runtime type information
    TypeName("triSurfaceMesh");


    // Constructors

        //- Construct from triSurface
        triSurfaceMesh(const IOobject&, const triSurface&);

        //- Construct read
        triSurfaceMesh(const IOobject& io);

111
        //- Construct from dictionary (used by searchableSurface)
112
        //  Dictionary may contain a 'scale' entry (eg, 0.001: mm -> m)
mattijs's avatar
mattijs committed
113
114
        triSurfaceMesh
        (
115
            const IOobject& io,
mattijs's avatar
mattijs committed
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
            const dictionary& dict
        );


    // Destructor

        virtual ~triSurfaceMesh();

        //- Clear storage
        void clearOut();


    // Member Functions

        //- Move points
        virtual void movePoints(const pointField&);

        //- Demand driven contruction of octree
        const indexedOctree<treeDataTriSurface>& tree() const;

        //- Demand driven contruction of octree for boundary edges
        const indexedOctree<treeDataEdge>& edgeTree() const;


        // searchableSurface implementation

142
143
144
145
146
            virtual const wordList& regions() const;

            //- Whether supports volume type below. I.e. whether is closed.
            virtual bool hasVolumeType() const;

mattijs's avatar
mattijs committed
147
148
149
150
151
            //- Range of local indices that can be returned.
            virtual label size() const
            {
                return triSurface::size();
            }
152
153

            virtual void findNearest
mattijs's avatar
mattijs committed
154
            (
155
156
157
                const pointField& sample,
                const scalarField& nearestDistSqr,
                List<pointIndexHit>&
mattijs's avatar
mattijs committed
158
159
            ) const;

160
            virtual void findLine
mattijs's avatar
mattijs committed
161
            (
162
163
164
                const pointField& start,
                const pointField& end,
                List<pointIndexHit>&
mattijs's avatar
mattijs committed
165
166
            ) const;

167
            virtual void findLineAny
mattijs's avatar
mattijs committed
168
            (
169
170
171
                const pointField& start,
                const pointField& end,
                List<pointIndexHit>&
mattijs's avatar
mattijs committed
172
173
            ) const;

174
175
            //- Get all intersections in order from start to end.
            virtual void findLineAll
mattijs's avatar
mattijs committed
176
            (
177
178
179
                const pointField& start,
                const pointField& end,
                List<List<pointIndexHit> >&
mattijs's avatar
mattijs committed
180
181
            ) const;

182
183
            //- From a set of points and indices get the region
            virtual void getRegion
mattijs's avatar
mattijs committed
184
            (
185
186
187
188
189
190
191
192
193
                const List<pointIndexHit>&,
                labelList& region
            ) const;

            //- From a set of points and indices get the normal
            virtual void getNormal
            (
                const List<pointIndexHit>&,
                vectorField& normal
mattijs's avatar
mattijs committed
194
195
196
197
            ) const;

            //- Determine type (inside/outside/mixed) for point. unknown if
            //  cannot be determined (e.g. non-manifold surface)
198
199
200
201
202
203
            virtual void getVolumeType
            (
                const pointField&,
                List<volumeType>&
            ) const;

mattijs's avatar
mattijs committed
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
            //- Set bounds of surface. Bounds currently set as list of
            //  bounding boxes. The bounds are hints to the surface as for
            //  the range of queries it can expect. faceMap/pointMap can be
            //  set if the surface has done any redistribution.
            virtual void distribute
            (
                const List<treeBoundBox>&,
                const bool keepNonLocal,
                autoPtr<mapDistribute>& faceMap,
                autoPtr<mapDistribute>& pointMap
            )
            {}

        // Other

            //- Specific to triSurfaceMesh: from a set of hits (points and
            //  indices) get the specified field. Misses do not get set.
            virtual void getField
            (
                const word& fieldName,
                const List<pointIndexHit>&,
                labelList& values
            ) const;

228
229
230
231
232
233
234
235

        // regIOobject implementation

            bool writeData(Ostream&) const
            {
                notImplemented("triSurfaceMesh::writeData(Ostream&) const");
                return false;
            }
mattijs's avatar
mattijs committed
236

mattijs's avatar
mattijs committed
237
238
239
240
241
242
243
244
            //- Write using given format, version and compression
            virtual bool writeObject
            (
                IOstream::streamFormat fmt,
                IOstream::versionNumber ver,
                IOstream::compressionType cmp
            ) const;

mattijs's avatar
mattijs committed
245
246
247
248
249
250
251
252
253
254
255
256
};


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

} // End namespace Foam

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

#endif

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