1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243 | /**
* MOAB, a Mesh-Oriented datABase, is a software component for creating,
* storing and accessing finite element mesh data.
*
* Copyright 2004 Sandia Corporation. Under the terms of Contract
* DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
* retains certain rights in this software.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
*/
#ifndef STRUCTURED_ELEMENT_SEQUENCE
#define STRUCTURED_ELEMENT_SEQUENCE
//
// Class: StructuredElementSeq
//
// Purpose: represent a rectangular element of mesh
//
// A ScdElement represents a rectangular element of mesh, including both vertices and
// elements, and the parametric space used to address that element. Vertex data,
// i.e. coordinates, may not be stored directly in the element, but the element returns
// information about the vertex handles of vertices in the element. Vertex and element
// handles associated with the element are each contiguous.
#include "ElementSequence.hpp"
#include "ScdElementData.hpp"
namespace moab
{
class StructuredElementSeq : public ElementSequence
{
public:
//! constructor
StructuredElementSeq( EntityHandle start_handle,
const int imin,
const int jmin,
const int kmin,
const int imax,
const int jmax,
const int kmax,
int* is_periodic = NULL );
virtual ~StructuredElementSeq();
ScdElementData* sdata()
{
return reinterpret_cast< ScdElementData* >( data() );
}
ScdElementData const* sdata() const
{
return reinterpret_cast< const ScdElementData* >( data() );
}
//! get handle of vertex at i, j, k
EntityHandle get_vertex( const int i, const int j, const int k ) const
{
return get_vertex( HomCoord( i, j, k ) );
}
//! get handle of vertex at homogeneous coords
inline EntityHandle get_vertex( const HomCoord& coords ) const
{
return sdata()->get_vertex( coords );
}
//! get handle of element at i, j, k
EntityHandle get_element( const int i, const int j, const int k ) const
{
return sdata()->get_element( i, j, k );
}
//! get handle of element at homogeneous coords
EntityHandle get_element( const HomCoord& coords ) const
{
return sdata()->get_element( coords.i(), coords.j(), coords.k() );
}
//! get min params for this element
const HomCoord& min_params() const
{
return sdata()->min_params();
}
void min_params( HomCoord& coords ) const
{
coords = min_params();
}
void min_params( int& i, int& j, int& k ) const
{
i = min_params().i();
j = min_params().j();
k = min_params().k();
}
//! get max params for this element
const HomCoord& max_params() const
{
return sdata()->max_params();
}
void max_params( HomCoord& coords ) const
{
coords = max_params();
}
void max_params( int& i, int& j, int& k ) const
{
i = max_params().i();
j = max_params().j();
k = max_params().k();
}
//! get the number of vertices in each direction, inclusive
void param_extents( int& di, int& dj, int& dk ) const
{
sdata()->param_extents( di, dj, dk );
}
//! given a handle, get the corresponding parameters
ErrorCode get_params( const EntityHandle ehandle, int& i, int& j, int& k ) const
{
return sdata()->get_params( ehandle, i, j, k );
}
//! convenience functions for parameter extents
int i_min() const
{
return min_params().i();
}
int j_min() const
{
return min_params().j();
}
int k_min() const
{
return min_params().k();
}
int i_max() const
{
return max_params().i();
}
int j_max() const
{
return max_params().j();
}
int k_max() const
{
return max_params().k();
}
//! test the bounding vertex sequences and determine whether they fully
//! define the vertices covering this element block's parameter space
inline bool boundary_complete() const
{
return sdata()->boundary_complete();
}
//! test whether this sequence contains these parameters
bool contains( const int i, const int j, const int k ) const
{
return sdata()->contains( HomCoord( i, j, k ) );
}
inline bool contains( const HomCoord& coords ) const
{
return sdata()->contains( coords );
}
//! get connectivity of an entity given entity's parameters
ErrorCode get_params_connectivity( const int i,
const int j,
const int k,
std::vector< EntityHandle >& connectivity ) const
{
return sdata()->get_params_connectivity( i, j, k, connectivity );
}
//! Return whether box is periodic in i
/** Return whether box is periodic in i
* \return True if box is periodic in i direction
*/
int is_periodic_i() const
{
return sdata()->is_periodic_i();
};
//! Return whether box is periodic in j
/** Return whether box is periodic in j
* \return True if box is periodic in j direction
*/
int is_periodic_j() const
{
return sdata()->is_periodic_j();
};
//! Return whether box is periodic in i and j
/** Return whether box is periodic in i and j
* \param is_periodic_ij Non-zero if periodic in i [0] or j [1]
*/
void is_periodic( int is_periodic_ij[2] ) const
{
sdata()->is_periodic( is_periodic_ij );
};
/***************** Methods from ElementSequence *****************/
virtual ErrorCode get_connectivity( EntityHandle handle,<--- Function in derived class<--- Function in derived class<--- Function in derived class
std::vector< EntityHandle >& connect,
bool topological = false ) const;
virtual ErrorCode get_connectivity( EntityHandle handle,<--- Function in derived class<--- Function in derived class<--- Function in derived class
EntityHandle const*& connect,
int& connect_length,
bool topological = false,
std::vector< EntityHandle >* storage = 0 ) const;
virtual ErrorCode set_connectivity( EntityHandle handle, EntityHandle const* connect, int connect_length );<--- Function in derived class<--- Function in derived class<--- Function in derived class
virtual EntityHandle* get_connectivity_array();<--- Function in derived class<--- Function in derived class<--- Function in derived class
/***************** Methods from EntitySequence *****************/
/* Replace the ElementSequence implementation of this method with
* one that always returns zero, because we cannot re-use handles
* that are within a ScdElementData
*/
virtual int values_per_entity() const;<--- Function in derived class<--- Function in derived class<--- Function in derived class
virtual EntitySequence* split( EntityHandle here );<--- Function in derived class<--- Function in derived class<--- Function in derived class
virtual SequenceData* create_data_subset( EntityHandle start_handle, EntityHandle end_handle ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class
virtual void get_const_memory_use( unsigned long& bytes_per_entity, unsigned long& size_of_sequence ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class
protected:
StructuredElementSeq( StructuredElementSeq& split_from, EntityHandle here ) : ElementSequence( split_from, here ) {}
};
} // namespace moab
#endif
|