/[escript]/trunk/escript/src/AbstractDomain.h
ViewVC logotype

Contents of /trunk/escript/src/AbstractDomain.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2644 - (show annotations)
Wed Sep 2 04:14:03 2009 UTC (10 years, 2 months ago) by jfenwick
File MIME type: text/plain
File size: 12573 byte(s)
Add unit tests for saveDataCSV which should be ready for use now.
Keyword args are now output in sorted order.

Removed some unneeded functions.
1
2 /*******************************************************
3 *
4 * Copyright (c) 2003-2009 by University of Queensland
5 * Earth Systems Science Computational Center (ESSCC)
6 * http://www.uq.edu.au/esscc
7 *
8 * Primary Business: Queensland, Australia
9 * Licensed under the Open Software License version 3.0
10 * http://www.opensource.org/licenses/osl-3.0.php
11 *
12 *******************************************************/
13
14
15 #if !defined escript_AbstractDomain_20040609_H
16 #define escript_AbstractDomain_20040609_H
17
18 #include "system_dep.h"
19
20 #include <vector>
21 #include <string>
22 #include <map>
23 #include <boost/python/dict.hpp>
24 #include <boost/python/list.hpp>
25 #include "paso/Paso_MPI.h"
26
27
28 #include "Pointers.h"
29
30 namespace escript {
31 // class forward declarations
32 class Data;
33 /**
34 \brief
35 Base class for all escript domains.
36
37 Description:
38 Base class for all escript domains.
39 */
40
41 class AbstractDomain;
42
43 typedef POINTER_WRAPPER_CLASS(AbstractDomain) Domain_ptr;
44 typedef POINTER_WRAPPER_CLASS(const AbstractDomain) const_Domain_ptr;
45
46 class AbstractDomain : public REFCOUNT_BASE_CLASS(AbstractDomain){
47
48 public:
49
50 /**
51 \brief Returns smart pointer which is managing this object.
52 If one does not exist yet it creates one.
53
54 Note: This is _not_ equivalent to weak_ptr::lock.
55 */
56 ESCRIPT_DLL_API
57 Domain_ptr getPtr();
58 ESCRIPT_DLL_API
59 const_Domain_ptr getPtr() const;
60
61 // structure holding values for X, size and normal
62 typedef int StatusType;
63 struct ValueBuffer
64 {
65 StatusType m_status;
66 boost::shared_ptr<Data> m_data;
67 };
68 typedef struct ValueBuffer ValueBuffer;
69
70 //
71 // map from function space type code to value buffer
72 typedef std::map<int, ValueBuffer> BufferMapType;
73
74
75 /**
76 \brief
77 Default constructor for AbstractDomain.
78
79 Description:
80 Default constructor for AbstractDomain. As the name suggests
81 this is intended to be an abstract base class but by making it
82 constructable we avoid a boost.python wrapper class. A call to
83 almost any of the base class functions will throw an exception
84 as they are not intended to be used directly, but are overridden
85 by the underlying solver package which escript is linked to.
86
87 By default, this class is overridden by the class NullDomain.
88
89 Preconditions:
90 Describe any preconditions.
91
92 Throws:
93 Describe any exceptions thrown.
94 */
95 ESCRIPT_DLL_API
96 AbstractDomain();
97
98 /**
99 \brief
100 Destructor for AbstractDomain.
101
102 Description:
103 Destructor for AbstractDomain.
104 */
105 ESCRIPT_DLL_API
106 virtual ~AbstractDomain();
107
108 /**
109 \brief
110 return the number of processors used for this domain
111 */
112 ESCRIPT_DLL_API
113 virtual int getMPISize() const;
114 /**
115 \brief
116 return the number MPI rank of this processor
117 */
118
119 ESCRIPT_DLL_API
120 virtual int getMPIRank() const;
121
122 /**
123 \brief
124 If compiled for MPI then execute an MPI_Barrier, else do nothing
125 */
126
127 ESCRIPT_DLL_API
128 virtual void MPIBarrier() const;
129 /**
130 \brief
131 Return true if on MPI master, else false
132 */
133
134 ESCRIPT_DLL_API
135 virtual bool onMasterProcessor() const;
136
137 /**
138 \brief get the communicator for this domain.
139 Returns 0 on non-MPI builds
140 Routine must be implemented by the DomainAdapter
141 */
142 ESCRIPT_DLL_API
143 virtual
144 #ifdef PASO_MPI
145 MPI_Comm
146 #else
147 unsigned int
148 #endif
149 getMPIComm() const;
150
151 /**
152 \brief
153 Returns true if the given integer is a valid function space type
154 for this domain.
155 */
156 ESCRIPT_DLL_API
157 virtual bool isValidFunctionSpaceType(int functionSpaceType) const;
158
159 /**
160 \brief
161 Return a description for this domain.
162 */
163 ESCRIPT_DLL_API
164 virtual std::string getDescription() const;
165
166 /**
167 \brief
168 Return a description for the given function space type code.
169 */
170 ESCRIPT_DLL_API
171 virtual std::string functionSpaceTypeAsString(int functionSpaceType) const;
172
173 /**
174 \brief
175 Returns the spatial dimension of the domain.
176
177 This has to be implemented by the actual Domain adapter.
178 */
179 ESCRIPT_DLL_API
180 virtual int getDim() const;
181
182 /**
183 \brief
184 Return true if given domains are equal.
185 */
186 ESCRIPT_DLL_API
187 virtual bool operator==(const AbstractDomain& other) const;
188 ESCRIPT_DLL_API
189 virtual bool operator!=(const AbstractDomain& other) const;
190
191 /**
192 \brief
193 Writes the domain to an external file filename.
194
195 This has to be implemented by the actual Domain adapter.
196 */
197 ESCRIPT_DLL_API
198 virtual void write(const std::string& filename) const;
199
200 /**
201 \brief
202 dumps the domain to an external file filename.
203
204 This has to be implemented by the actual Domain adapter.
205 */
206 ESCRIPT_DLL_API
207 virtual void dump(const std::string& filename) const;
208
209 /**
210 \brief
211 Return the number of data points per sample, and the number of samples as a pair.
212
213 This has to be implemented by the actual Domain adapter.
214
215 \param functionSpaceCode Input - Code for the function space type.
216 \return pair, first - number of data points per sample, second - number of samples
217 */
218 ESCRIPT_DLL_API
219 virtual std::pair<int,int> getDataShape(int functionSpaceCode) const;
220
221 /**
222 \brief
223 Return the tag key for the given sample number.
224 \param functionSpaceType Input - The function space type.
225 \param sampleNo Input - The sample number.
226 */
227 ESCRIPT_DLL_API
228 virtual int getTagFromSampleNo(int functionSpaceType, int sampleNo) const;
229
230 /**
231 \brief
232 sets a map from a clear tag name to a tag key
233 \param name Input - tag name.
234 \param tag Input - tag key.
235 */
236 ESCRIPT_DLL_API
237 virtual void setTagMap(const std::string& name, int tag);
238
239 /**
240 \brief
241 Return the tag key for tag name.
242 \param name Input - tag name
243 */
244 ESCRIPT_DLL_API
245 virtual int getTag(const std::string& name) const;
246
247 /**
248 \brief
249 Returns True if name is a defined tag name
250 \param name Input - tag name
251 */
252 ESCRIPT_DLL_API
253 virtual bool isValidTagName(const std::string& name) const;
254
255 /**
256 \brief
257 Returns all tag names in a single string sperated by commas
258 */
259 ESCRIPT_DLL_API
260 virtual std::string showTagNames() const;
261
262 /**
263 \brief
264 Return a borrowed pointer to the sample reference number id list
265 \param functionSpaceType Input - The function space type.
266 */
267 ESCRIPT_DLL_API
268 virtual const int* borrowSampleReferenceIDs(int functionSpaceType) const;
269
270 /**
271 \brief
272 Assigns new location to the domain.
273
274 This has to be implemented by the actual Domain adapter.
275 */
276 ESCRIPT_DLL_API
277 virtual void setNewX(const escript::Data& arg);
278
279 /**
280 \brief
281 Interpolates data given on source onto target where source and target have to be given on the same domain.
282
283 This has to be implemented by the actual Domain adapter.
284 */
285 ESCRIPT_DLL_API
286 virtual void interpolateOnDomain(escript::Data& target,const escript::Data& source) const;
287 ESCRIPT_DLL_API
288 virtual bool probeInterpolationOnDomain(int functionSpaceType_source,int functionSpaceType_target) const;
289
290 /**
291 \brief given a vector of FunctionSpace type codes, pass back a code which then can all be interpolated to.
292 \note This method must be called on the domain which the FunctionSpaces point to
293 \return true is result is valid, false if not
294 */
295 ESCRIPT_DLL_API
296 virtual
297 bool
298 commonFunctionSpace(const std::vector<int>& fs, int& resultcode) const;
299
300 /**
301 \brief
302 Interpolates data given on source onto target where source and target are given on different domains.
303
304 This has to be implemented by the actual Domain adapter.
305 */
306 ESCRIPT_DLL_API
307 virtual void interpolateACross(escript::Data& target, const escript::Data& source) const;
308 ESCRIPT_DLL_API
309 virtual bool probeInterpolationACross(int functionSpaceType_source,const AbstractDomain& targetDomain, int functionSpaceType_target) const;
310
311 /**
312 \brief
313 Returns locations in the domain. The function space is chosen appropriately.
314 */
315 ESCRIPT_DLL_API
316 virtual escript::Data getX() const;
317
318 /**
319 \brief
320 Return boundary normals. The function space is chosen appropriately.
321 */
322 ESCRIPT_DLL_API
323 virtual escript::Data getNormal() const;
324
325 /**
326 \brief
327 Returns the local size of samples. The function space is chosen appropriately.
328 */
329 ESCRIPT_DLL_API
330 virtual escript::Data getSize() const;
331
332 /**
333 \brief
334 Copies the location of data points on the domain into out.
335 The actual function space to be considered
336 is defined by out. out has to be defined on this.
337
338 This has to be implemented by the actual Domain adapter.
339 */
340 ESCRIPT_DLL_API
341 virtual void setToX(escript::Data& out) const;
342
343 /**
344 \brief
345 Copies the surface normals at data points into out.
346 The actual function space to be considered
347 is defined by out. out has to be defined on this.
348
349 This has to be implemented by the actual Domain adapter.
350 */
351 ESCRIPT_DLL_API
352 virtual void setToNormal(escript::Data& out) const;
353
354 /**
355 \brief
356 Copies the size of samples into out. The actual
357 function space to be considered
358 is defined by out. out has to be defined on this.
359
360 This has to be implemented by the actual Domain adapter.
361 */
362 ESCRIPT_DLL_API
363 virtual void setToSize(escript::Data& out) const;
364
365 /**
366 \brief
367 Copies the gradient of arg into grad. The actual function space to be considered
368 for the gradient is defined by grad. arg and grad have to be defined on this.
369
370 This has to be implemented by the actual Domain adapter.
371 */
372 ESCRIPT_DLL_API
373 virtual void setToGradient(escript::Data& grad, const escript::Data& arg) const;
374 /**
375 \brief
376 Saves a dictonary of Data objects to an OpenDX input file. The keywords are used as identifier
377
378 This has to be implemented by the actual Domain adapter.
379 */
380 ESCRIPT_DLL_API
381 virtual void saveDX(const std::string& filename,const boost::python::dict& arg) const;
382
383 /**
384 \brief
385 Saves a dictonary of Data objects to an VTK XML input file. The keywords are used as identifier.
386 metadata is string representing some meta data to be added. metadata_schema assign schema to namespaces used in the meta data.
387
388 This has to be implemented by the actual Domain adapter.
389 */
390 ESCRIPT_DLL_API
391 virtual void saveVTK(const std::string& filename,const boost::python::dict& arg, const std::string& metadata, const std::string& metadata_schema) const;
392
393 /**
394 \brief True if this rank owns the sample(id)
395 Must be implemented by the Domain adapter
396 */
397 ESCRIPT_DLL_API
398 virtual bool ownSample(int fs_code, index_t id) const;
399
400 /**
401 \brief assigns new tag newTag to all samples of functionspace with a positive
402 value of mask for any its sample point.
403
404 */
405 ESCRIPT_DLL_API
406 virtual void setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const;
407
408 /**
409 \brief
410 returns true if data on this domain and a function space of type functionSpaceCode has to
411 considered as cell centered data.
412
413 This has to be implemented by the actual Domain adapter.
414 */
415 ESCRIPT_DLL_API
416 virtual bool isCellOriented(int functionSpaceCode) const;
417
418 /**
419 \brief
420 Returns a status indicator of the domain. The status identifier should be unique over
421 the live time if the object but may be updated if changes to the domain happen, e.g.
422 modifications to its geometry.
423
424 This has to be implemented by the actual Domain adapter.
425 */
426 ESCRIPT_DLL_API
427 virtual StatusType getStatus() const;
428
429 /**
430 \brief
431 Throw a standard exception. This function is called if any attempt
432 is made to use a base class function.
433 */
434 ESCRIPT_DLL_API
435 void throwStandardException(const std::string& functionName) const;
436
437 /**
438 \brief
439 return the number of tags in use and a pointer to an array with the number of tags in use
440 */
441 ESCRIPT_DLL_API
442 virtual int getNumberOfTagsInUse(int functionSpaceCode) const;
443
444 ESCRIPT_DLL_API
445 virtual const int* borrowListOfTagsInUse(int functionSpaceCode) const;
446
447 /**
448 \brief Checks if this domain allows tags for the specified functionSpaceCode.
449 */
450 ESCRIPT_DLL_API
451 virtual bool canTag(int functionspacecode) const;
452
453 protected:
454
455 private:
456
457 // buffer for coordinates used by function spaces
458 BufferMapType m_x_buffer;
459
460 // buffer for normal vectors used by function spaces
461 BufferMapType m_normal_buffer;
462
463 // buffer for normal element size used by function spaces
464 BufferMapType m_size_buffer;
465
466 };
467
468 } // end of namespace
469
470 #endif

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26