escript/src/AbstractDomain.cpp


/*******************************************************
*
* Copyright (c) 2003-2008 by University of Queensland
* Earth Systems Science Computational Center (ESSCC)
* http://www.uq.edu.au/esscc
*
* Primary Business: Queensland, Australia
* Licensed under the Open Software License version 3.0
* http://www.opensource.org/licenses/osl-3.0.php
*
*******************************************************/


#include "AbstractDomain.h" 
#include "DomainException.h"
#include "Data.h"
#include "paso/Paso_MPI.h"

using namespace std;

namespace escript {


Domain_ptr AbstractDomain::getPtr()
{
  if (_internal_weak_this.expired())
  {
    return Domain_ptr(this);    
  }
  else
  {
    return shared_from_this();
  }
}

const_Domain_ptr AbstractDomain::getPtr() const 
{
  if (_internal_weak_this.expired())
  {
    return const_Domain_ptr(this);
  }
  else
  {
    return shared_from_this();
  }
}

AbstractDomain::AbstractDomain() {
}

AbstractDomain::~AbstractDomain() {
}

int AbstractDomain::getMPISize() const
{
   return 1;
}
int AbstractDomain::getMPIRank() const
{
   return 0;
}
void AbstractDomain::MPIBarrier() const
{
   return;
}
bool AbstractDomain::onMasterProcessor() const
{
   return true;
}


void AbstractDomain::throwStandardException(const std::string& functionName) const
{
  throw DomainException("Error - Base class function: " + functionName + " should not be called. Programming error.");
}

bool AbstractDomain::isValidFunctionSpaceType(int functionSpaceType) const
{
  throwStandardException("AbstractDomain::isValidFunctionSpaceType");
  return false;
}

std::string AbstractDomain::getDescription() const
{
  throwStandardException("AbstractDomain::getDescription");
  return "";
}

std::string AbstractDomain::functionSpaceTypeAsString(int functionSpaceType) const
{
  throwStandardException("AbstractDomain::functionSpaceTypeAsString");
  return "";
}

int AbstractDomain::getDim() const
{
  throwStandardException("AbstractDomain::getDim");
  return 0;
}

void AbstractDomain::write(const std::string& filename) const
{
  throwStandardException("AbstractDomain::write");
  return;
}
void AbstractDomain::dump(const std::string& filename) const
{
  throwStandardException("AbstractDomain::dump");
  return;
}

std::pair<int,int> AbstractDomain::getDataShape(int functionSpaceCode) const
{
  throwStandardException("AbstractDomain::getDataShape");
  return std::pair<int,int>(0,0);
}

int AbstractDomain::getTagFromSampleNo(int functionSpaceType, int sampleNo) const
{
  throwStandardException("AbstractDomain::getTagFromSampleNo");
  return 0;
}

int* AbstractDomain::borrowSampleReferenceIDs(int functionSpaceType) const
{
  throwStandardException("AbstractDomain::borrowSampleReferenceIDs");
  return 0;
}

void AbstractDomain::setNewX(const escript::Data& arg)
{
  throwStandardException("AbstractDomain::setNewX");
  return;
}

void AbstractDomain::interpolateOnDomain(escript::Data& target,const escript::Data& source) const
{
  throwStandardException("AbstractDomain::interpolateOnDomain");
  return;
}
void AbstractDomain::interpolateACross(escript::Data& target, const escript::Data& source) const
{
  throwStandardException("AbstractDomain::interpolateACross");
  return;
}

escript::Data AbstractDomain::getX() const
{
  throwStandardException("AbstractDomain::getX");
  return Data();
}

escript::Data AbstractDomain::getNormal() const
{
  throwStandardException("AbstractDomain::getNormal");
  return Data();
}

escript::Data AbstractDomain::getSize() const
{
  throwStandardException("AbstractDomain::getSize");
  return Data();
}

void AbstractDomain::setToX(escript::Data& out) const
{
  throwStandardException("AbstractDomain::setToX");
  return;
}

void AbstractDomain::setToNormal(escript::Data& out) const
{
  throwStandardException("AbstractDomain::setToNormal");
  return;
}

void AbstractDomain::setToSize(escript::Data& out) const
{
  throwStandardException("AbstractDomain::setToSize");
  return;
}

void AbstractDomain::setToGradient(escript::Data& grad, const escript::Data& arg) const
{
  throwStandardException("AbstractDomain::setToGradient");
  return;
}

void AbstractDomain::setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const
{
  throwStandardException("AbstractDomain::setTags");
  return;
}

void AbstractDomain::saveDX(const std::string& filename,const boost::python::dict& arg) const 
{
  throwStandardException("AbstractDomain::saveDX");
  return;
}

void AbstractDomain::saveVTK(const std::string& filename,const boost::python::dict& arg) const 
{
  throwStandardException("AbstractDomain::saveVTK");
  return;
}

bool AbstractDomain::probeInterpolationOnDomain(int functionSpaceType_source,int functionSpaceType_target) const
{
  throwStandardException("AbstractDomain::probeInterpolationOnDomain");
  return false;
}

bool AbstractDomain::probeInterpolationACross(int functionSpaceType_source,const AbstractDomain& targetDomain, int functionSpaceType_target) const 
{
  throwStandardException("AbstractDomain::probeInterpolationACross");
  return false;
}

bool AbstractDomain::isCellOriented(int functionSpaceCode) const
{
  throwStandardException("AbstractDomain::isCellOriented");
  return false;
}

bool AbstractDomain::operator==(const AbstractDomain& other) const
{
  throwStandardException("AbstractDomain::operator==");
  return false;
}
bool AbstractDomain::operator!=(const AbstractDomain& other) const
{
  throwStandardException("AbstractDomain::operator!=");
  return false;
}

AbstractDomain::StatusType AbstractDomain::getStatus() const 
{
  throwStandardException("AbstractDomain::getStatus");
  return 0;
}
void AbstractDomain::setTagMap(const std::string& name,  int tag)
{
  throwStandardException("AbstractDomain::set TagMap is not implemented.");
}
int AbstractDomain::getTag(const std::string& name) const
{
  throwStandardException("AbstractDomain::getTag is not implemented.");
  return 0;
}

bool AbstractDomain::isValidTagName(const std::string& name) const
{
  return false;
}

std::string AbstractDomain::showTagNames() const
{
  throwStandardException("AbstractDomain::showTagNames is not implemented.");
  return string();
}

int AbstractDomain::getNumberOfTagsInUse(int functionSpaceCode) const
{
  throwStandardException("AbstractDomain::getNumberOfTagsInUse is not implemented.");
  return 0;
}
int* AbstractDomain::borrowListOfTagsInUse(int functionSpaceCode) const
{
  throwStandardException("AbstractDomain::borrowListOfTagsInUse is not implemented.");
  return NULL;
}


bool AbstractDomain::canTag(int functionspacecode) const
{
  throwStandardException("AbstractDomain::canTag is not implemented.");
  return false;
}


} // end of namespace
1	ksteube	1312
2			/*******************************************************
3	ksteube	1811	*
4			* Copyright (c) 2003-2008 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	ksteube	1312
14	ksteube	1811
15	jgs	474	#include "AbstractDomain.h"
16			#include "DomainException.h"
17	jgs	480	#include "Data.h"
18	ksteube	1800	#include "paso/Paso_MPI.h"
19	jgs	480
20	jgs	121	using namespace std;
21	jgs	149
22	jgs	82	namespace escript {
23
24	jfenwick	1872
25			Domain_ptr AbstractDomain::getPtr()
26			{
27			if (_internal_weak_this.expired())
28			{
29			return Domain_ptr(this);
30			}
31			else
32			{
33			return shared_from_this();
34			}
35			}
36
37			const_Domain_ptr AbstractDomain::getPtr() const
38			{
39			if (_internal_weak_this.expired())
40			{
41			return const_Domain_ptr(this);
42			}
43			else
44			{
45			return shared_from_this();
46			}
47			}
48
49	jgs	82	AbstractDomain::AbstractDomain() {
50			}
51
52			AbstractDomain::~AbstractDomain() {
53			}
54
55	ksteube	1312	int AbstractDomain::getMPISize() const
56			{
57			return 1;
58			}
59			int AbstractDomain::getMPIRank() const
60			{
61			return 0;
62			}
63	ksteube	1877	void AbstractDomain::MPIBarrier() const
64			{
65			return;
66			}
67			bool AbstractDomain::onMasterProcessor() const
68			{
69			return true;
70			}
71	ksteube	1312
72
73	ksteube	1877
74	jgs	82	void AbstractDomain::throwStandardException(const std::string& functionName) const
75			{
76	jgs	115	throw DomainException("Error - Base class function: " + functionName + " should not be called. Programming error.");
77	jgs	82	}
78
79			bool AbstractDomain::isValidFunctionSpaceType(int functionSpaceType) const
80			{
81			throwStandardException("AbstractDomain::isValidFunctionSpaceType");
82			return false;
83			}
84
85			std::string AbstractDomain::getDescription() const
86			{
87			throwStandardException("AbstractDomain::getDescription");
88			return "";
89			}
90
91			std::string AbstractDomain::functionSpaceTypeAsString(int functionSpaceType) const
92			{
93			throwStandardException("AbstractDomain::functionSpaceTypeAsString");
94			return "";
95			}
96
97			int AbstractDomain::getDim() const
98			{
99			throwStandardException("AbstractDomain::getDim");
100			return 0;
101			}
102
103			void AbstractDomain::write(const std::string& filename) const
104			{
105			throwStandardException("AbstractDomain::write");
106			return;
107			}
108	ksteube	1312	void AbstractDomain::dump(const std::string& filename) const
109			{
110			throwStandardException("AbstractDomain::dump");
111			return;
112			}
113	jgs	82
114			std::pair<int,int> AbstractDomain::getDataShape(int functionSpaceCode) const
115			{
116			throwStandardException("AbstractDomain::getDataShape");
117			return std::pair<int,int>(0,0);
118			}
119
120			int AbstractDomain::getTagFromSampleNo(int functionSpaceType, int sampleNo) const
121			{
122			throwStandardException("AbstractDomain::getTagFromSampleNo");
123			return 0;
124			}
125
126	gross	964	int* AbstractDomain::borrowSampleReferenceIDs(int functionSpaceType) const
127	jgs	110	{
128	gross	964	throwStandardException("AbstractDomain::borrowSampleReferenceIDs");
129	jgs	110	return 0;
130			}
131
132	jgs	82	void AbstractDomain::setNewX(const escript::Data& arg)
133			{
134			throwStandardException("AbstractDomain::setNewX");
135			return;
136			}
137
138			void AbstractDomain::interpolateOnDomain(escript::Data& target,const escript::Data& source) const
139			{
140			throwStandardException("AbstractDomain::interpolateOnDomain");
141			return;
142			}
143			void AbstractDomain::interpolateACross(escript::Data& target, const escript::Data& source) const
144			{
145			throwStandardException("AbstractDomain::interpolateACross");
146			return;
147			}
148
149	jgs	102	escript::Data AbstractDomain::getX() const
150			{
151			throwStandardException("AbstractDomain::getX");
152			return Data();
153			}
154
155			escript::Data AbstractDomain::getNormal() const
156			{
157			throwStandardException("AbstractDomain::getNormal");
158			return Data();
159			}
160	jgs	115
161	jgs	102	escript::Data AbstractDomain::getSize() const
162			{
163			throwStandardException("AbstractDomain::getSize");
164			return Data();
165			}
166	jgs	115
167	jgs	82	void AbstractDomain::setToX(escript::Data& out) const
168			{
169			throwStandardException("AbstractDomain::setToX");
170			return;
171			}
172
173			void AbstractDomain::setToNormal(escript::Data& out) const
174			{
175			throwStandardException("AbstractDomain::setToNormal");
176			return;
177			}
178	jgs	115
179	jgs	82	void AbstractDomain::setToSize(escript::Data& out) const
180			{
181			throwStandardException("AbstractDomain::setToSize");
182			return;
183			}
184
185			void AbstractDomain::setToGradient(escript::Data& grad, const escript::Data& arg) const
186			{
187			throwStandardException("AbstractDomain::setToGradient");
188			return;
189			}
190
191	gross	767	void AbstractDomain::setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const
192			{
193			throwStandardException("AbstractDomain::setTags");
194			return;
195			}
196
197	jgs	153	void AbstractDomain::saveDX(const std::string& filename,const boost::python::dict& arg) const
198	jgs	82	{
199			throwStandardException("AbstractDomain::saveDX");
200			return;
201			}
202
203	jgs	153	void AbstractDomain::saveVTK(const std::string& filename,const boost::python::dict& arg) const
204	jgs	110	{
205			throwStandardException("AbstractDomain::saveVTK");
206			return;
207			}
208
209	jgs	82	bool AbstractDomain::probeInterpolationOnDomain(int functionSpaceType_source,int functionSpaceType_target) const
210			{
211			throwStandardException("AbstractDomain::probeInterpolationOnDomain");
212			return false;
213			}
214
215			bool AbstractDomain::probeInterpolationACross(int functionSpaceType_source,const AbstractDomain& targetDomain, int functionSpaceType_target) const
216			{
217			throwStandardException("AbstractDomain::probeInterpolationACross");
218			return false;
219			}
220
221			bool AbstractDomain::isCellOriented(int functionSpaceCode) const
222			{
223			throwStandardException("AbstractDomain::isCellOriented");
224			return false;
225			}
226
227			bool AbstractDomain::operator==(const AbstractDomain& other) const
228			{
229	jgs	121	throwStandardException("AbstractDomain::operator==");
230			return false;
231	jgs	82	}
232			bool AbstractDomain::operator!=(const AbstractDomain& other) const
233			{
234	jgs	121	throwStandardException("AbstractDomain::operator!=");
235			return false;
236	jgs	82	}
237
238	gross	797	AbstractDomain::StatusType AbstractDomain::getStatus() const
239			{
240			throwStandardException("AbstractDomain::getStatus");
241			return 0;
242			}
243	gross	1044	void AbstractDomain::setTagMap(const std::string& name, int tag)
244			{
245			throwStandardException("AbstractDomain::set TagMap is not implemented.");
246			}
247			int AbstractDomain::getTag(const std::string& name) const
248			{
249			throwStandardException("AbstractDomain::getTag is not implemented.");
250			return 0;
251			}
252	gross	797
253	gross	1044	bool AbstractDomain::isValidTagName(const std::string& name) const
254			{
255			return false;
256			}
257	gross	797
258	gross	1044	std::string AbstractDomain::showTagNames() const
259			{
260			throwStandardException("AbstractDomain::showTagNames is not implemented.");
261			return string();
262			}
263
264	gross	1716	int AbstractDomain::getNumberOfTagsInUse(int functionSpaceCode) const
265			{
266			throwStandardException("AbstractDomain::getNumberOfTagsInUse is not implemented.");
267			return 0;
268			}
269			int* AbstractDomain::borrowListOfTagsInUse(int functionSpaceCode) const
270			{
271			throwStandardException("AbstractDomain::borrowListOfTagsInUse is not implemented.");
272			return NULL;
273			}
274	gross	1044
275
276	jfenwick	1802	bool AbstractDomain::canTag(int functionspacecode) const
277			{
278			throwStandardException("AbstractDomain::canTag is not implemented.");
279			return false;
280			}
281	gross	1716
282
283
284	jgs	115	} // end of namespace
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision