/[escript]/trunk/bruce/src/Bruce/Bruce.h
ViewVC logotype

Contents of /trunk/bruce/src/Bruce/Bruce.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 155 - (show annotations)
Wed Nov 9 02:02:19 2005 UTC (13 years, 9 months ago) by jgs
File MIME type: text/plain
File size: 8277 byte(s)
move all directories from trunk/esys2 into trunk and remove esys2

1 // $Id$
2 /*
3 ******************************************************************************
4 * *
5 * COPYRIGHT ACcESS 2005 - All Rights Reserved *
6 * *
7 * This software is the property of ACcESS. No part of this code *
8 * may be copied in any form or by any means without the expressed written *
9 * consent of ACcESS. Copying, use or modification of this software *
10 * by any unauthorised person is illegal unless that person has a software *
11 * license agreement with ACcESS. *
12 * *
13 ******************************************************************************
14 */
15
16 #if !defined bruce_Bruce_20050829_H
17 #define bruce_Bruce_20050829_H
18
19 #include "escript/Data/AbstractContinuousDomain.h"
20 #include "escript/Data/FunctionSpaceFactory.h"
21 #include "escript/Data/FunctionSpace.h"
22 #include "escript/Data/Data.h"
23
24 #include <string>
25 #include <vector>
26
27 namespace bruce {
28
29 /**
30 \brief
31 Bruce implements a structured AbstractContinuousDomain.
32
33 Description:
34 Bruce implements a structured AbstractContinuousDomain.
35 */
36
37 class Bruce : public escript::AbstractContinuousDomain {
38
39 public:
40
41 //
42 // Codes for function space types supported
43 static const int ContinuousFunction; // data is on the nodes
44 static const int Function; // data is on the cell centres
45
46 //
47 // Type of FunctionSpaceNamesMap
48 typedef std::map<int, std::string> FunctionSpaceNamesMapType;
49
50 //
51 // Types for the dimension vectors
52 typedef std::vector<double> DimVec;
53
54 /**
55 \brief
56 Default constructor for Bruce.
57
58 Description:
59 Default constructor for Bruce.
60 Creates a null Bruce object.
61 */
62 Bruce();
63
64 /**
65 \brief
66 Constructor for Bruce.
67
68 Description:
69 Constructor for Bruce.
70
71 The point "origin" specifies the location of the origin
72 of the domain specified by this object. The dimensionality of this
73 point determines the dimensionality of the space the domain occupies.
74
75 The vectors v0,v1,v2 specify the axis in
76 of the domain of this Bruce object. If v2 is an empty vector, this
77 object is a two dimensional domain. If v1 is also an empty vector,
78 this object is a one dimensional domain. If v0 is also an empty
79 vector, this is a point domain.
80
81 The integers n0,n1,n2 specify the dumber of data-points along each
82 axis in the domain.
83 */
84 Bruce(DimVec v0, DimVec v1, DimVec v2,
85 int n0, int n1, int n2,
86 DimVec origin);
87
88 /**
89 \brief
90 Copy constructor.
91 */
92 Bruce(const Bruce& other);
93
94 /**
95 \brief
96 Destructor for Bruce.
97 */
98 ~Bruce();
99
100 /**
101 \brief
102 Return this as an AbstractContinuousDomain.
103 */
104 inline
105 const AbstractContinuousDomain&
106 asAbstractContinuousDomain() const
107 {
108 return *(static_cast<const AbstractContinuousDomain*>(this));
109 }
110
111 /**
112 \brief
113 Return this as an AbstractDomain.
114 */
115 inline
116 const AbstractDomain&
117 asAbstractDomain() const
118 {
119 return *(static_cast<const AbstractDomain*>(this));
120 }
121
122 /**
123 \brief
124 Return a description for this domain.
125 */
126 virtual
127 inline
128 std::string
129 getDescription() const
130 {
131 return "Bruce";
132 }
133
134 /**
135 \brief
136 Returns true if the given integer is a valid function space type
137 for this domain.
138 */
139 virtual
140 bool
141 isValidFunctionSpaceType(int functionSpaceCode) const;
142
143 /**
144 \brief
145 Return a description for the given function space type code.
146 */
147 virtual
148 std::string
149 functionSpaceTypeAsString(int functionSpaceCode) const;
150
151 /**
152 \brief
153 Return a continuous FunctionSpace code.
154 */
155 virtual
156 inline
157 int
158 getContinuousFunctionCode() const
159 {
160 return ContinuousFunction;
161 }
162
163 /**
164 \brief
165 Return a function FunctionSpace code.
166 */
167 virtual
168 inline
169 int
170 getFunctionCode() const
171 {
172 return Function;
173 }
174
175 /**
176 \brief
177 Return the spatial dimension of the mesh.
178 */
179 virtual
180 inline
181 int
182 getDim() const
183 {
184 return m_origin.size();
185 }
186
187 /**
188 \brief
189 Return the number of data points per sample, and the number of samples
190 needed to represent data on parts of the mesh.
191 */
192 virtual
193 std::pair<int,int>
194 getDataShape(int functionSpaceCode) const;
195
196 /**
197 \brief
198 Return the number of samples
199 needed to represent data on parts of the mesh.
200 */
201 int
202 getNumSamples(int functionSpaceCode) const;
203
204 /**
205 \brief
206 Return the number of data-points per sample
207 needed to represent data on parts of the mesh.
208 */
209 inline
210 int
211 getNumDataPointsPerSample(int functionSpaceCode) const
212 {
213 return 1;
214 }
215
216 /**
217 \brief
218 Returns the locations in the domain of the FEM nodes.
219 */
220 virtual
221 escript::Data
222 getX() const;
223
224 /**
225 \brief
226 Copies the location of data points on the domain into out.
227 */
228 virtual
229 void
230 setToX(escript::Data& out) const;
231
232 /**
233 \brief
234 Returns the element size.
235 */
236 virtual
237 escript::Data
238 getSize() const;
239
240 /**
241 \brief
242 Copies the size of samples into out.
243 */
244 virtual
245 void
246 setToSize(escript::Data& out) const;
247
248 /**
249 \brief
250 Copies the gradient of arg into grad. The actual function space to be considered
251 for the gradient is defined by grad. arg and grad have to be defined on this.
252 */
253 virtual
254 void
255 setToGradient(escript::Data& grad,
256 const escript::Data& arg) const;
257
258 /**
259 \brief
260 Comparison operators.
261 */
262 virtual bool operator==(const AbstractDomain& other) const;
263 virtual bool operator!=(const AbstractDomain& other) const;
264
265 /*
266 \brief
267 Return the tag key for the given sample number.
268 NB: tags are not implemented on Bruce, so this method always returns 0.
269 */
270 virtual
271 inline
272 int
273 getTagFromSampleNo(int functionSpaceCode,
274 int sampleNo) const
275 {
276 return 0;
277 }
278
279 /**
280 \brief
281 Return the reference number of the given sample number.
282 */
283 virtual
284 int
285 getReferenceNoFromSampleNo(int functionSpaceCode,
286 int sampleNo) const;
287
288 /**
289 \brief
290 Saves a dictionary of Data objects to a VTK XML input file.
291 The dictionary consists of pairs of Data objects plus a name
292 for each. Each Data object must be defined on this domain.
293 */
294 virtual
295 void
296 saveVTK(const std::string& filename,
297 const boost::python::dict& dataDict) const;
298
299 /**
300 \brief
301 Interpolates data given on source onto target where source and target
302 have to be given on the same domain.
303 */
304 virtual
305 void
306 interpolateOnDomain(escript::Data& target,
307 const escript::Data& source) const;
308
309 virtual
310 bool
311 probeInterpolationOnDomain(int functionSpaceType_source,
312 int functionSpaceType_target) const;
313
314 /**
315 \brief
316 Interpolates data given on source onto target where source and target
317 are given on different domains.
318 */
319 virtual
320 void
321 interpolateACross(escript::Data& target,
322 const escript::Data& source) const;
323
324 virtual
325 bool
326 probeInterpolationACross(int functionSpaceType_source,
327 const AbstractDomain& targetDomain,
328 int functionSpaceType_target) const;
329
330 protected:
331
332 /**
333 \brief
334 Build the table of function space type names.
335 */
336 void
337 setFunctionSpaceTypeNames();
338
339 /**
340 \brief
341 Ensure the parameters supplied to the constructor are valid.
342 */
343 bool
344 checkParameters();
345
346 /**
347 \brief
348 Check if all components of vector are zero.
349 */
350 static
351 bool
352 isZero(DimVec vec);
353
354 private:
355
356 //
357 // vectors describing axis of the domain
358 DimVec m_v0, m_v1, m_v2;
359
360 //
361 // number of data points in each axial direction of the domain
362 int m_n0, m_n1, m_n2;
363
364 //
365 // the coordinates of the origin of the domain
366 DimVec m_origin;
367
368 //
369 // map from FunctionSpace codes to names
370 static FunctionSpaceNamesMapType m_functionSpaceTypeNames;
371
372 };
373
374 } // end of namespace
375
376 #endif

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26