/[escript]/trunk/escript/src/FunctionSpace.cpp
ViewVC logotype

Annotation of /trunk/escript/src/FunctionSpace.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1802 - (hide annotations)
Tue Sep 23 01:03:29 2008 UTC (11 years, 4 months ago) by jfenwick
File size: 6210 byte(s)
Added canTag methods to FunctionSpace and AbstractDomain (and its 
offspring).
This checks to see if the domain supports tags for the given type of 
function space.

Constructors for DataTagged now throw exceptions if you attempt to make 
a DataTagged with a FunctionSpace which does not support tags.
To allow the default constructor to work, NullDomain has a single 
functioncode which "supports" tagging.

Fixed a bug in DataTagged::toString and DataTypes::pointToString.

Added FunctionSpace::getListOfTagsSTL.

algorithm(DataTagged, BinaryFunction) in DataAlgorithm now only 
processes tags known to be in use.
This fixes mantis issue #0000186.

Added comment to Data.h intro warning about holding references if the 
underlying DataAbstract changes.

_python_ unit tests have been updated to test TaggedData with invalid 
FunctionSpaces and to give the correct answers to Lsup etc.


1 ksteube 1312
2 jgs 115 /* $Id$ */
3 jgs 82
4 ksteube 1312 /*******************************************************
5     *
6     * Copyright 2003-2007 by ACceSS MNRF
7     * Copyright 2007 by University of Queensland
8     *
9     * http://esscc.uq.edu.au
10     * Primary Business: Queensland, Australia
11     * Licensed under the Open Software License version 3.0
12     * http://www.opensource.org/licenses/osl-3.0.php
13     *
14     *******************************************************/
15    
16 jgs 480 #include "FunctionSpace.h"
17 jgs 474 #include "FunctionSpaceException.h"
18     #include "Data.h"
19     #include "DataFactory.h"
20 jgs 82
21     #include <iostream>
22     #include <sstream>
23    
24 jgs 121 using namespace std;
25 jgs 149
26 jgs 82 namespace escript {
27    
28     //
29 jgs 149 // Create a null domain for use with any default-constructed function space
30 trankine 1426 NullDomain const FunctionSpace::nullDomainValue;
31 jgs 82
32     FunctionSpace::FunctionSpace():
33 trankine 1426 m_domain(static_cast<const AbstractDomain*>(&nullDomainValue)),
34     m_functionSpaceType(nullDomainValue.getFunctionCode())
35 jgs 82 {
36     }
37    
38 jgs 117 FunctionSpace::FunctionSpace(const AbstractDomain& domain,
39     int functionSpaceType):
40 jgs 82 m_domain(dynamic_cast<const AbstractDomain*>(&domain)),
41     m_functionSpaceType(functionSpaceType)
42     {
43     if (!m_domain->isValidFunctionSpaceType(functionSpaceType)) {
44     std::stringstream temp;
45     temp << "Invalid function space type: " << functionSpaceType
46 jgs 149 << " for domain: " << m_domain->getDescription();
47 jgs 82 throw FunctionSpaceException(temp.str());
48     }
49     }
50    
51 jgs 117 std::pair<int,int>
52     FunctionSpace::getDataShape() const
53 jgs 82 {
54     return m_domain->getDataShape(m_functionSpaceType);
55     }
56    
57 jgs 117 int
58     FunctionSpace::getTypeCode() const
59 jgs 82 {
60     return m_functionSpaceType;
61     }
62    
63 jgs 117 const
64     AbstractDomain&
65     FunctionSpace::getDomain() const
66 jgs 82 {
67     return *m_domain;
68     }
69    
70 phornby 1628 std::string
71 jgs 117 FunctionSpace::toString() const
72 jgs 82 {
73     std::stringstream temp;
74 ksteube 1312 temp << m_domain->functionSpaceTypeAsString(m_functionSpaceType)
75     << " on " << m_domain->getDescription();
76 trankine 1426
77 phornby 1628 return temp.str();
78 jgs 82 }
79    
80 trankine 1426
81     #ifdef DEBUG_PY_STRINGS
82     PyObject *
83     FunctionSpace::toPyString() const
84     {
85     boost::python::to_python_value<const std::string &> cvtr;
86     std::stringstream temp;
87    
88     temp << m_domain->functionSpaceTypeAsString(m_functionSpaceType)
89     << " on " << m_domain->getDescription();
90    
91 phornby 1628 return cvtr(temp.str());
92 trankine 1426 }
93     #endif
94    
95    
96 jgs 117 int
97     FunctionSpace::getTagFromSampleNo(int sampleNo) const
98 jgs 82 {
99     return m_domain->getTagFromSampleNo(m_functionSpaceType,sampleNo);
100     }
101    
102 jgs 117 int
103 jgs 149 FunctionSpace::getTagFromDataPointNo(int dataPointNo) const
104     {
105     //
106     // Get the number of samples and data-points per sample
107     int numSamples = getNumSamples();
108     int numDataPointsPerSample = getNumDPPSample();
109     int numDataPoints = numSamples * numDataPointsPerSample;
110    
111     if (numDataPointsPerSample==0) {
112     throw DataException("FunctionSpace::getTagFromDataPointNo error: no data-points associated with this object.");
113     }
114    
115     if (dataPointNo<0 || dataPointNo>numDataPoints) {
116     throw DataException("FunctionSpace::getTagFromDataPointNo error: invalid data-point number supplied.");
117     }
118    
119     //
120     // Determine the sample number which corresponds to this data-point number
121     int sampleNo = dataPointNo / numDataPointsPerSample;
122    
123     //
124     // Determine the tag number which corresponds to this sample number
125     int tagNo = getTagFromSampleNo(sampleNo);
126    
127     //
128     // return the tag number
129     return(tagNo);
130     }
131    
132 gross 1718 int FunctionSpace::getReferenceIDFromDataPointNo(int dataPointNo) const
133     {
134     //
135     // Get the number of samples and data-points per sample
136     int numSamples = getNumSamples();
137     int numDataPointsPerSample = getNumDPPSample();
138     int*referenceIDs= borrowSampleReferenceIDs();
139     int numDataPoints = numSamples * numDataPointsPerSample;
140    
141     if (numDataPointsPerSample==0) {
142     throw DataException("FunctionSpace::getReferenceIDFromDataPointNo error: no data-points associated with this object.");
143     }
144     if (dataPointNo<0 || dataPointNo>numDataPoints) {
145     throw DataException("FunctionSpace::getReferenceIDFromDataPointNo error: invalid data-point number supplied.");
146     }
147     int sampleNo = dataPointNo / numDataPointsPerSample;
148     return referenceIDs[sampleNo];
149     }
150    
151 gross 964 int*
152     FunctionSpace::borrowSampleReferenceIDs() const
153 jgs 110 {
154 gross 964 return m_domain->borrowSampleReferenceIDs(m_functionSpaceType);
155 jgs 110 }
156    
157 jgs 117 FunctionSpace&
158     FunctionSpace::operator=(const FunctionSpace& other)
159 jgs 82 {
160     // explicitly defined assignment operator to emphasise pointer copy
161     m_functionSpaceType=other.m_functionSpaceType;
162     m_domain=other.m_domain;
163     return *this;
164     }
165    
166 jgs 117 bool
167     FunctionSpace::operator==(const FunctionSpace& other) const
168 jgs 82 {
169 jgs 121 return ((*(other.m_domain)==*(m_domain)) && (other.m_functionSpaceType==m_functionSpaceType));
170 jgs 82 }
171    
172 jgs 117 bool
173     FunctionSpace::operator!=(const FunctionSpace& other) const
174 jgs 82 {
175 jgs 121 return !(operator==(other));
176 jgs 82 }
177    
178 jgs 117 escript::Data
179     FunctionSpace::getX() const
180 jgs 82 {
181     Data out=escript::Vector(0,*this,true);
182     getDomain().setToX(out);
183 gross 783 out.setProtection();
184 jgs 82 return out;
185     }
186    
187 jgs 117 escript::Data
188     FunctionSpace::getNormal() const
189 jgs 82 {
190     Data out=escript::Vector(0,*this,true);
191     getDomain().setToNormal(out);
192 gross 783 out.setProtection();
193 jgs 82 return out;
194     }
195    
196 jgs 117 escript::Data
197     FunctionSpace::getSize() const
198 jgs 82 {
199     Data out=escript::Scalar(0,*this,true);
200     getDomain().setToSize(out);
201 gross 783 out.setProtection();
202 jgs 82 return out;
203     }
204    
205 gross 767 void
206     FunctionSpace::setTags(const int newTag, const escript::Data& mask) const
207     {
208     if (mask.getFunctionSpace()== *this) {
209     m_domain->setTags(m_functionSpaceType,newTag,mask);
210     } else {
211     throw FunctionSpaceException("illegal function space of mask.");
212     }
213     }
214    
215 gross 1716 int
216     FunctionSpace::getNumberOfTagsInUse() const
217     {
218     return m_domain->getNumberOfTagsInUse(m_functionSpaceType);
219     }
220    
221     int*
222     FunctionSpace::borrowListOfTagsInUse() const
223     {
224     return m_domain->borrowListOfTagsInUse(m_functionSpaceType);
225     }
226    
227 jfenwick 1802 std::list<int>
228     FunctionSpace::getListOfTagsSTL() const
229     {
230     std::list<int> taglist;
231     int i;
232     int* tags=borrowListOfTagsInUse();
233     for (i=0;i<getNumberOfTagsInUse();++i) taglist.push_back(tags[i]);
234     return taglist;
235     }
236 gross 1716
237    
238     boost::python::list
239     FunctionSpace::getListOfTags() const
240     {
241     boost::python::list taglist;
242     int i;
243     int* tags=borrowListOfTagsInUse();
244     for (i=0;i<getNumberOfTagsInUse();++i) taglist.append(tags[i]);
245     return taglist;
246     }
247    
248 jfenwick 1802 bool
249     FunctionSpace::canTag() const
250     {
251     return m_domain->canTag(m_functionSpaceType);
252     }
253    
254 jgs 82 } // end of namespace

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26