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
{
  if( type_str.empty() )
  {
    std::stringstream temp;
    temp << m_domain->functionSpaceTypeAsString(m_functionSpaceType)
         << " on " << m_domain->getDescription();

    type_str = temp.str();
  }
  return type_str;
}


#ifdef DEBUG
PyObject *
FunctionSpace::toPyString() const
{
  std::stringstream temp;

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

  boost::python::to_python_value<const std::string &> cvtr;

  return cvtr(temp.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	if( type_str.empty() )
74	{
75	std::stringstream temp;
76	temp << m_domain->functionSpaceTypeAsString(m_functionSpaceType)
77	<< " on " << m_domain->getDescription();
78
79	type_str = temp.str();
80	}
81	return type_str;
82	}
83
84
85	#ifdef DEBUG
86	PyObject *
87	FunctionSpace::toPyString() const
88	{
89	std::stringstream temp;
90
91	temp << m_domain->functionSpaceTypeAsString(m_functionSpaceType)
92	<< " on " << m_domain->getDescription();
93
94	boost::python::to_python_value<const std::string &> cvtr;
95
96	return cvtr(temp.str());
97	}
98	#endif
99
100	int
101	FunctionSpace::getTagFromSampleNo(int sampleNo) const
102	{
103	return m_domain->getTagFromSampleNo(m_functionSpaceType,sampleNo);
104	}
105
106	int
107	FunctionSpace::getTagFromDataPointNo(int dataPointNo) const
108	{
109	//
110	// Get the number of samples and data-points per sample
111	int numSamples = getNumSamples();
112	int numDataPointsPerSample = getNumDPPSample();
113	int numDataPoints = numSamples * numDataPointsPerSample;
114
115	if (numDataPointsPerSample==0) {
116	throw DataException("FunctionSpace::getTagFromDataPointNo error: no data-points associated with this object.");
117	}
118
119	if (dataPointNo<0 \|\| dataPointNo>numDataPoints) {
120	throw DataException("FunctionSpace::getTagFromDataPointNo error: invalid data-point number supplied.");
121	}
122
123	//
124	// Determine the sample number which corresponds to this data-point number
125	int sampleNo = dataPointNo / numDataPointsPerSample;
126
127	//
128	// Determine the tag number which corresponds to this sample number
129	int tagNo = getTagFromSampleNo(sampleNo);
130
131	//
132	// return the tag number
133	return(tagNo);
134	}
135
136	int*
137	FunctionSpace::borrowSampleReferenceIDs() const
138	{
139	return m_domain->borrowSampleReferenceIDs(m_functionSpaceType);
140	}
141
142	FunctionSpace&
143	FunctionSpace::operator=(const FunctionSpace& other)
144	{
145	// explicitly defined assignment operator to emphasise pointer copy
146	m_functionSpaceType=other.m_functionSpaceType;
147	m_domain=other.m_domain;
148	return *this;
149	}
150
151	bool
152	FunctionSpace::operator==(const FunctionSpace& other) const
153	{
154	return (((other.m_domain)==(m_domain)) && (other.m_functionSpaceType==m_functionSpaceType));
155	}
156
157	bool
158	FunctionSpace::operator!=(const FunctionSpace& other) const
159	{
160	return !(operator==(other));
161	}
162
163	escript::Data
164	FunctionSpace::getX() const
165	{
166	Data out=escript::Vector(0,*this,true);
167	getDomain().setToX(out);
168	out.setProtection();
169	return out;
170	}
171
172	escript::Data
173	FunctionSpace::getNormal() const
174	{
175	Data out=escript::Vector(0,*this,true);
176	getDomain().setToNormal(out);
177	out.setProtection();
178	return out;
179	}
180
181	escript::Data
182	FunctionSpace::getSize() const
183	{
184	Data out=escript::Scalar(0,*this,true);
185	getDomain().setToSize(out);
186	out.setProtection();
187	return out;
188	}
189
190	void
191	FunctionSpace::setTags(const int newTag, const escript::Data& mask) const
192	{
193	if (mask.getFunctionSpace()== *this) {
194	m_domain->setTags(m_functionSpaceType,newTag,mask);
195	} else {
196	throw FunctionSpaceException("illegal function space of mask.");
197	}
198	}
199
200	} // end of namespace
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision