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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 154 - (hide annotations)
Mon Nov 7 05:51:17 2005 UTC (14 years, 11 months ago) by jgs
Original Path: trunk/esys2/bruce/src/Bruce/Bruce.h
File MIME type: text/plain
File size: 8277 byte(s)
Merge of development branch dev-02 back to main trunk on 2005-11-07

1 jgs 149 // $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 jgs 151
16 jgs 149 #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 jgs 150 #include <vector>
26 jgs 149
27     namespace bruce {
28    
29     /**
30     \brief
31 jgs 151 Bruce implements a structured AbstractContinuousDomain.
32 jgs 149
33     Description:
34 jgs 151 Bruce implements a structured AbstractContinuousDomain.
35 jgs 149 */
36    
37     class Bruce : public escript::AbstractContinuousDomain {
38    
39     public:
40    
41     //
42     // Codes for function space types supported
43 jgs 154 static const int ContinuousFunction; // data is on the nodes
44     static const int Function; // data is on the cell centres
45 jgs 149
46 jgs 150 //
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 jgs 149 /**
55     \brief
56 jgs 150 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 jgs 149 Constructor for Bruce.
67    
68     Description:
69     Constructor for Bruce.
70 jgs 150
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 jgs 149 */
84 jgs 150 Bruce(DimVec v0, DimVec v1, DimVec v2,
85     int n0, int n1, int n2,
86     DimVec origin);
87 jgs 149
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 jgs 150 return *(static_cast<const AbstractContinuousDomain*>(this));
109 jgs 149 }
110    
111     /**
112     \brief
113     Return this as an AbstractDomain.
114     */
115     inline
116     const AbstractDomain&
117     asAbstractDomain() const
118     {
119 jgs 150 return *(static_cast<const AbstractDomain*>(this));
120 jgs 149 }
121    
122     /**
123     \brief
124 jgs 150 Return a description for this domain.
125     */
126     virtual
127 jgs 151 inline
128 jgs 150 std::string
129 jgs 151 getDescription() const
130     {
131     return "Bruce";
132     }
133 jgs 150
134     /**
135     \brief
136 jgs 149 Returns true if the given integer is a valid function space type
137     for this domain.
138     */
139     virtual
140     bool
141 jgs 150 isValidFunctionSpaceType(int functionSpaceCode) const;
142 jgs 149
143     /**
144     \brief
145 jgs 150 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 jgs 151 inline
157 jgs 150 int
158 jgs 151 getContinuousFunctionCode() const
159     {
160     return ContinuousFunction;
161     }
162 jgs 150
163     /**
164     \brief
165     Return a function FunctionSpace code.
166     */
167     virtual
168 jgs 151 inline
169 jgs 150 int
170 jgs 151 getFunctionCode() const
171     {
172     return Function;
173     }
174 jgs 150
175     /**
176     \brief
177 jgs 149 Return the spatial dimension of the mesh.
178     */
179     virtual
180 jgs 151 inline
181 jgs 149 int
182 jgs 151 getDim() const
183     {
184     return m_origin.size();
185     }
186 jgs 149
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 jgs 154 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 jgs 149 Returns the locations in the domain of the FEM nodes.
219     */
220     virtual
221     escript::Data
222     getX() const;
223    
224     /**
225     \brief
226 jgs 150 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 jgs 149 Returns the element size.
235     */
236     virtual
237     escript::Data
238     getSize() const;
239    
240     /**
241     \brief
242 jgs 150 Copies the size of samples into out.
243     */
244     virtual
245     void
246     setToSize(escript::Data& out) const;
247    
248     /**
249     \brief
250 jgs 154 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 jgs 149 Comparison operators.
261     */
262     virtual bool operator==(const AbstractDomain& other) const;
263     virtual bool operator!=(const AbstractDomain& other) const;
264    
265 jgs 153 /*
266     \brief
267     Return the tag key for the given sample number.
268 jgs 154 NB: tags are not implemented on Bruce, so this method always returns 0.
269 jgs 153 */
270     virtual
271 jgs 154 inline
272 jgs 153 int
273 jgs 154 getTagFromSampleNo(int functionSpaceCode,
274     int sampleNo) const
275     {
276     return 0;
277     }
278 jgs 153
279     /**
280     \brief
281     Return the reference number of the given sample number.
282     */
283     virtual
284     int
285 jgs 154 getReferenceNoFromSampleNo(int functionSpaceCode,
286     int sampleNo) const;
287 jgs 153
288 jgs 154 /**
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 jgs 153
299 jgs 154 /**
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 jgs 149 protected:
331    
332 jgs 150 /**
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 jgs 151 static
351 jgs 150 bool
352 jgs 151 isZero(DimVec vec);
353 jgs 150
354 jgs 149 private:
355    
356 jgs 150 //
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 jgs 149 };
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