escript/src/FunctionSpace.cpp


/* $Id$ */

/*******************************************************
 *
 *           Copyright 2003-2007 by ACceSS MNRF
 *       Copyright 2007 by University of Queensland
 *
 *                http://esscc.uq.edu.au
 *        Primary Business: Queensland, Australia
 *  Licensed under the Open Software License version 3.0
 *     http://www.opensource.org/licenses/osl-3.0.php
 *
 *******************************************************/

#include "FunctionSpace.h" 
#include "FunctionSpaceException.h"
#include "Data.h" 
#include "DataFactory.h" 

#include <iostream>
#include <sstream>

using namespace std;

namespace escript {

//
// Create a null domain for use with any default-constructed function space
NullDomain const FunctionSpace::nullDomainValue;

FunctionSpace::FunctionSpace():
  m_domain(static_cast<const AbstractDomain*>(&nullDomainValue)),
  m_functionSpaceType(nullDomainValue.getFunctionCode())
{
}

FunctionSpace::FunctionSpace(const AbstractDomain& domain,
                             int functionSpaceType):
  m_domain(dynamic_cast<const AbstractDomain*>(&domain)),
  m_functionSpaceType(functionSpaceType)
{
  if (!m_domain->isValidFunctionSpaceType(functionSpaceType)) {
    std::stringstream temp;
    temp << "Invalid function space type: " << functionSpaceType 
     << " for domain: " << m_domain->getDescription();
    throw FunctionSpaceException(temp.str());
  }
}

std::pair<int,int>
FunctionSpace::getDataShape() const
{
  return m_domain->getDataShape(m_functionSpaceType);
}

int
FunctionSpace::getTypeCode() const 
{
  return  m_functionSpaceType;
}

const
AbstractDomain&
FunctionSpace::getDomain() const
{
  return *m_domain;
}

const std::string &
FunctionSpace::toString() const
{
  std::stringstream temp;
  temp << m_domain->functionSpaceTypeAsString(m_functionSpaceType)
       << " on " << m_domain->getDescription();

  type_str = temp.str();

  return type_str;
}


#ifdef DEBUG_PY_STRINGS
PyObject *
FunctionSpace::toPyString() const
{
  boost::python::to_python_value<const std::string &> cvtr;
  std::stringstream temp;

  temp << m_domain->functionSpaceTypeAsString(m_functionSpaceType)
       << " on " << m_domain->getDescription();

  //toString();
  type_str = temp.str();

  return cvtr(type_str);
}
#endif


int
FunctionSpace::getTagFromSampleNo(int sampleNo) const
{
  return m_domain->getTagFromSampleNo(m_functionSpaceType,sampleNo);
}

int
FunctionSpace::getTagFromDataPointNo(int dataPointNo) const
{
  //
  // Get the number of samples and data-points per sample
  int numSamples = getNumSamples();
  int numDataPointsPerSample = getNumDPPSample();
  int numDataPoints = numSamples * numDataPointsPerSample;

  if (numDataPointsPerSample==0) {
    throw DataException("FunctionSpace::getTagFromDataPointNo error: no data-points associated with this object.");
  }

  if (dataPointNo<0 || dataPointNo>numDataPoints) {
    throw DataException("FunctionSpace::getTagFromDataPointNo error: invalid data-point number supplied.");
  }

  //
  // Determine the sample number which corresponds to this data-point number
  int sampleNo = dataPointNo / numDataPointsPerSample;

  //
  // Determine the tag number which corresponds to this sample number
  int tagNo = getTagFromSampleNo(sampleNo);

  //
  // return the tag number
  return(tagNo);
}

int*
FunctionSpace::borrowSampleReferenceIDs() const
{
  return m_domain->borrowSampleReferenceIDs(m_functionSpaceType);
}

FunctionSpace&
FunctionSpace::operator=(const FunctionSpace& other)
{
  // explicitly defined assignment operator to emphasise pointer copy
  m_functionSpaceType=other.m_functionSpaceType;
  m_domain=other.m_domain;
  return *this;
}

bool
FunctionSpace::operator==(const FunctionSpace& other) const
{
  return ((*(other.m_domain)==*(m_domain)) && (other.m_functionSpaceType==m_functionSpaceType));
}

bool
FunctionSpace::operator!=(const FunctionSpace& other) const
{
  return !(operator==(other));
}

escript::Data
FunctionSpace::getX() const 
{
  Data out=escript::Vector(0,*this,true);
  getDomain().setToX(out);
  out.setProtection();
  return out;
}

escript::Data
FunctionSpace::getNormal() const
{
  Data out=escript::Vector(0,*this,true);
  getDomain().setToNormal(out);
  out.setProtection();
  return out;
}

escript::Data
FunctionSpace::getSize() const
{
  Data out=escript::Scalar(0,*this,true);
  getDomain().setToSize(out);
  out.setProtection();
  return out;
}

void
FunctionSpace::setTags(const int newTag, const escript::Data& mask) const
{
   if (mask.getFunctionSpace()== *this) {
          m_domain->setTags(m_functionSpaceType,newTag,mask);
   } else {
          throw FunctionSpaceException("illegal function space of mask.");
   }
}

}  // end of namespace
1
2	/* $Id$ */
3
4	/*******************************************************
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	#include "FunctionSpace.h"
17	#include "FunctionSpaceException.h"
18	#include "Data.h"
19	#include "DataFactory.h"
20
21	#include <iostream>
22	#include <sstream>
23
24	using namespace std;
25
26	namespace escript {
27
28	//
29	// Create a null domain for use with any default-constructed function space
30	NullDomain const FunctionSpace::nullDomainValue;
31
32	FunctionSpace::FunctionSpace():
33	m_domain(static_cast<const AbstractDomain*>(&nullDomainValue)),
34	m_functionSpaceType(nullDomainValue.getFunctionCode())
35	{
36	}
37
38	FunctionSpace::FunctionSpace(const AbstractDomain& domain,
39	int functionSpaceType):
40	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	<< " for domain: " << m_domain->getDescription();
47	throw FunctionSpaceException(temp.str());
48	}
49	}
50
51	std::pair<int,int>
52	FunctionSpace::getDataShape() const
53	{
54	return m_domain->getDataShape(m_functionSpaceType);
55	}
56
57	int
58	FunctionSpace::getTypeCode() const
59	{
60	return m_functionSpaceType;
61	}
62
63	const
64	AbstractDomain&
65	FunctionSpace::getDomain() const
66	{
67	return *m_domain;
68	}
69
70	const std::string &
71	FunctionSpace::toString() const
72	{
73	std::stringstream temp;
74	temp << m_domain->functionSpaceTypeAsString(m_functionSpaceType)
75	<< " on " << m_domain->getDescription();
76
77	type_str = temp.str();
78
79	return type_str;
80	}
81
82
83	#ifdef DEBUG_PY_STRINGS
84	PyObject *
85	FunctionSpace::toPyString() const
86	{
87	boost::python::to_python_value<const std::string &> cvtr;
88	std::stringstream temp;
89
90	temp << m_domain->functionSpaceTypeAsString(m_functionSpaceType)
91	<< " on " << m_domain->getDescription();
92
93	//toString();
94	type_str = temp.str();
95
96	return cvtr(type_str);
97	}
98	#endif
99
100
101	int
102	FunctionSpace::getTagFromSampleNo(int sampleNo) const
103	{
104	return m_domain->getTagFromSampleNo(m_functionSpaceType,sampleNo);
105	}
106
107	int
108	FunctionSpace::getTagFromDataPointNo(int dataPointNo) const
109	{
110	//
111	// Get the number of samples and data-points per sample
112	int numSamples = getNumSamples();
113	int numDataPointsPerSample = getNumDPPSample();
114	int numDataPoints = numSamples * numDataPointsPerSample;
115
116	if (numDataPointsPerSample==0) {
117	throw DataException("FunctionSpace::getTagFromDataPointNo error: no data-points associated with this object.");
118	}
119
120	if (dataPointNo<0 \|\| dataPointNo>numDataPoints) {
121	throw DataException("FunctionSpace::getTagFromDataPointNo error: invalid data-point number supplied.");
122	}
123
124	//
125	// Determine the sample number which corresponds to this data-point number
126	int sampleNo = dataPointNo / numDataPointsPerSample;
127
128	//
129	// Determine the tag number which corresponds to this sample number
130	int tagNo = getTagFromSampleNo(sampleNo);
131
132	//
133	// return the tag number
134	return(tagNo);
135	}
136
137	int*
138	FunctionSpace::borrowSampleReferenceIDs() const
139	{
140	return m_domain->borrowSampleReferenceIDs(m_functionSpaceType);
141	}
142
143	FunctionSpace&
144	FunctionSpace::operator=(const FunctionSpace& other)
145	{
146	// explicitly defined assignment operator to emphasise pointer copy
147	m_functionSpaceType=other.m_functionSpaceType;
148	m_domain=other.m_domain;
149	return *this;
150	}
151
152	bool
153	FunctionSpace::operator==(const FunctionSpace& other) const
154	{
155	return (((other.m_domain)==(m_domain)) && (other.m_functionSpaceType==m_functionSpaceType));
156	}
157
158	bool
159	FunctionSpace::operator!=(const FunctionSpace& other) const
160	{
161	return !(operator==(other));
162	}
163
164	escript::Data
165	FunctionSpace::getX() const
166	{
167	Data out=escript::Vector(0,*this,true);
168	getDomain().setToX(out);
169	out.setProtection();
170	return out;
171	}
172
173	escript::Data
174	FunctionSpace::getNormal() const
175	{
176	Data out=escript::Vector(0,*this,true);
177	getDomain().setToNormal(out);
178	out.setProtection();
179	return out;
180	}
181
182	escript::Data
183	FunctionSpace::getSize() const
184	{
185	Data out=escript::Scalar(0,*this,true);
186	getDomain().setToSize(out);
187	out.setProtection();
188	return out;
189	}
190
191	void
192	FunctionSpace::setTags(const int newTag, const escript::Data& mask) const
193	{
194	if (mask.getFunctionSpace()== *this) {
195	m_domain->setTags(m_functionSpaceType,newTag,mask);
196	} else {
197	throw FunctionSpaceException("illegal function space of mask.");
198	}
199	}
200
201	} // end of namespace
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision