escript/src/DataAbstract.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 "DataAbstract.h"
#include "DataException.h"

using namespace std;

namespace escript {

DataAbstract::DataAbstract(const FunctionSpace& what):
    m_noDataPointsPerSample(what.getNumDPPSample()),
    m_noSamples(what.getNumSamples()),
    m_functionSpace(what),
    m_rank(0)
{
    setShape(DataTypes::ShapeType());
}

DataAbstract::~DataAbstract() 
{
}

void
DataAbstract::setPointDataView(const DataArrayView& input)
{
    m_pointDataView.reset(new DataArrayView(input.getData(),input.getShape(),input.getOffset()));

    // until we get rid of m_pointDataView, we need to keep m_shape in sync
    setShape(input.getShape());
}

// perhaps this should be a constructor parameter
void
DataAbstract::setShape(const DataTypes::ShapeType& s)
{
   m_shape=s;
   m_rank=DataTypes::getRank(s);
   m_novalues=DataTypes::noValues(s);
}


void
DataAbstract::resetPointDataView()
{
    m_pointDataView.reset(new DataArrayView());
    m_shape.clear();
    m_rank=0;
    m_novalues=1;
}

void
DataAbstract::operandCheck(const DataAbstract& right) const
{
    if ((right.getNumDPPSample()!=getNumDPPSample()) ||
    (right.getNumSamples()!=getNumSamples()) ||
    (right.getFunctionSpace()!=getFunctionSpace())) {
      stringstream temp;
      temp << "Error - Right hand argument sample shape or function space "
       << "incompatible with left." << endl 
       << "LHS: (" << getNumSamples() << ","
       << getNumDPPSample() << ") " << getFunctionSpace().toString() 
       << endl
       << "RHS: (" << right.getNumSamples() << "," 
       << right.getNumDPPSample() << ") " 
       << right.getFunctionSpace().toString();
      throw DataException(temp.str());
    }

    //
    // Check the shape of the point data, a rank of 0(scalar) is okay
    if (!((right.getPointDataView().getRank()==0) || 
      (right.getPointDataView().getShape()==getPointDataView().getShape())))
      {
        stringstream temp;
    temp << "Error - Right hand argument point data shape: " 
         << DataTypes::shapeToString(right.getPointDataView().getShape())
         << " doesn't match left: " 
         << DataTypes::shapeToString(getPointDataView().getShape());
    throw DataException(temp.str());
      }
}

void
DataAbstract::dump(const std::string fileName) const
{
    throw DataException("Error - DataAbstract:: dump: not implemented.");
}


DataAbstract::ValueType::value_type*
DataAbstract::getSampleDataByTag(int tag)
{
    throw DataException("Error - DataAbstract::getSampleDataByTag: Data type does not have tag values.");
}

void
DataAbstract::setTaggedValue(int tagKey,
                             const DataArrayView& value)
{
    throw DataException("Error - DataAbstract::setTaggedValue: Data type does not have tag values.");
}

void  
DataAbstract::setTaggedValue(int tagKey,
           const DataTypes::ShapeType& pointshape,
               const DataTypes::ValueType& value,
           int dataOffset)
{
    throw DataException("Error - DataAbstract::setTaggedValue: Data type does not have tag values.");
}


int
DataAbstract::getTagNumber(int dpno)
{
    throw DataException("Error - DataAbstract::getTagNumber: Data type cannot be accessed by tag values.");
    return (0);
}

int
DataAbstract::archiveData(ofstream& archiveFile,
                          const ValueType::size_type noValues) const
{
  return 0;
}

int
DataAbstract::extractData(ifstream& archiveFile,
                          const ValueType::size_type noValues)
{
  return 0;
}

void
DataAbstract::copyAll(const boost::python::numeric::array& value)
{
    throw DataException("Error - DataAbstract::copying data from numarray objects is not supported.");
}
void
DataAbstract::copyToDataPoint(const int sampleNo, const int dataPointNo, const double value)
{
    throw DataException("Error - DataAbstract::copying data from double value to a single data point is not supported.");
}
void
DataAbstract::copyToDataPoint(const int sampleNo, const int dataPointNo, const boost::python::numeric::array& value)
{
    throw DataException("Error - DataAbstract::copying data from numarray objects to a single data point is not supported.");
}

void
DataAbstract::symmetric(DataAbstract* ev) 
{
    throw DataException("Error - DataAbstract::symmetric is not supported.");
}

void
DataAbstract::nonsymmetric(DataAbstract* ev) 
{
    throw DataException("Error - DataAbstract::nonsymmetric is not supported.");
}

void
DataAbstract::trace(DataAbstract* ev, int axis_offset) 
{
    throw DataException("Error - DataAbstract::trace is not supported.");
}

void
DataAbstract::swapaxes(DataAbstract* ev, int axis0, int axis1)
{
    throw DataException("Error - DataAbstract::component swapaxes is not supported.");
}
void
DataAbstract::transpose(DataAbstract* ev, int axis_offset) 
{
    throw DataException("Error - DataAbstract::transpose is not supported.");
}

void
DataAbstract::eigenvalues(DataAbstract* ev) 
{
    throw DataException("Error - DataAbstract::eigenvalues is not supported.");
}
void
DataAbstract::eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol)
{
    throw DataException("Error - DataAbstract::eigenvalues_and_eigenvectors is not supported.");

}
void
DataAbstract::setToZero() 
{
    throw DataException("Error - DataAbstract:: cannot set values to zero.");
}

void
DataAbstract::reorderByReferenceIDs(int *reference_ids)
{
}


}  // 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 "DataAbstract.h"
17	#include "DataException.h"
18
19	using namespace std;
20
21	namespace escript {
22
23	DataAbstract::DataAbstract(const FunctionSpace& what):
24	m_noDataPointsPerSample(what.getNumDPPSample()),
25	m_noSamples(what.getNumSamples()),
26	m_functionSpace(what),
27	m_rank(0)
28	{
29	setShape(DataTypes::ShapeType());
30	}
31
32	DataAbstract::~DataAbstract()
33	{
34	}
35
36	void
37	DataAbstract::setPointDataView(const DataArrayView& input)
38	{
39	m_pointDataView.reset(new DataArrayView(input.getData(),input.getShape(),input.getOffset()));
40
41	// until we get rid of m_pointDataView, we need to keep m_shape in sync
42	setShape(input.getShape());
43	}
44
45	// perhaps this should be a constructor parameter
46	void
47	DataAbstract::setShape(const DataTypes::ShapeType& s)
48	{
49	m_shape=s;
50	m_rank=DataTypes::getRank(s);
51	m_novalues=DataTypes::noValues(s);
52	}
53
54
55	void
56	DataAbstract::resetPointDataView()
57	{
58	m_pointDataView.reset(new DataArrayView());
59	m_shape.clear();
60	m_rank=0;
61	m_novalues=1;
62	}
63
64	void
65	DataAbstract::operandCheck(const DataAbstract& right) const
66	{
67	if ((right.getNumDPPSample()!=getNumDPPSample()) \|\|
68	(right.getNumSamples()!=getNumSamples()) \|\|
69	(right.getFunctionSpace()!=getFunctionSpace())) {
70	stringstream temp;
71	temp << "Error - Right hand argument sample shape or function space "
72	<< "incompatible with left." << endl
73	<< "LHS: (" << getNumSamples() << ","
74	<< getNumDPPSample() << ") " << getFunctionSpace().toString()
75	<< endl
76	<< "RHS: (" << right.getNumSamples() << ","
77	<< right.getNumDPPSample() << ") "
78	<< right.getFunctionSpace().toString();
79	throw DataException(temp.str());
80	}
81
82	//
83	// Check the shape of the point data, a rank of 0(scalar) is okay
84	if (!((right.getPointDataView().getRank()==0) \|\|
85	(right.getPointDataView().getShape()==getPointDataView().getShape())))
86	{
87	stringstream temp;
88	temp << "Error - Right hand argument point data shape: "
89	<< DataTypes::shapeToString(right.getPointDataView().getShape())
90	<< " doesn't match left: "
91	<< DataTypes::shapeToString(getPointDataView().getShape());
92	throw DataException(temp.str());
93	}
94	}
95
96	void
97	DataAbstract::dump(const std::string fileName) const
98	{
99	throw DataException("Error - DataAbstract:: dump: not implemented.");
100	}
101
102
103
104	DataAbstract::ValueType::value_type*
105	DataAbstract::getSampleDataByTag(int tag)
106	{
107	throw DataException("Error - DataAbstract::getSampleDataByTag: Data type does not have tag values.");
108	}
109
110	void
111	DataAbstract::setTaggedValue(int tagKey,
112	const DataArrayView& value)
113	{
114	throw DataException("Error - DataAbstract::setTaggedValue: Data type does not have tag values.");
115	}
116
117	void
118	DataAbstract::setTaggedValue(int tagKey,
119	const DataTypes::ShapeType& pointshape,
120	const DataTypes::ValueType& value,
121	int dataOffset)
122	{
123	throw DataException("Error - DataAbstract::setTaggedValue: Data type does not have tag values.");
124	}
125
126
127	int
128	DataAbstract::getTagNumber(int dpno)
129	{
130	throw DataException("Error - DataAbstract::getTagNumber: Data type cannot be accessed by tag values.");
131	return (0);
132	}
133
134	int
135	DataAbstract::archiveData(ofstream& archiveFile,
136	const ValueType::size_type noValues) const
137	{
138	return 0;
139	}
140
141	int
142	DataAbstract::extractData(ifstream& archiveFile,
143	const ValueType::size_type noValues)
144	{
145	return 0;
146	}
147
148	void
149	DataAbstract::copyAll(const boost::python::numeric::array& value)
150	{
151	throw DataException("Error - DataAbstract::copying data from numarray objects is not supported.");
152	}
153	void
154	DataAbstract::copyToDataPoint(const int sampleNo, const int dataPointNo, const double value)
155	{
156	throw DataException("Error - DataAbstract::copying data from double value to a single data point is not supported.");
157	}
158	void
159	DataAbstract::copyToDataPoint(const int sampleNo, const int dataPointNo, const boost::python::numeric::array& value)
160	{
161	throw DataException("Error - DataAbstract::copying data from numarray objects to a single data point is not supported.");
162	}
163
164	void
165	DataAbstract::symmetric(DataAbstract* ev)
166	{
167	throw DataException("Error - DataAbstract::symmetric is not supported.");
168	}
169
170	void
171	DataAbstract::nonsymmetric(DataAbstract* ev)
172	{
173	throw DataException("Error - DataAbstract::nonsymmetric is not supported.");
174	}
175
176	void
177	DataAbstract::trace(DataAbstract* ev, int axis_offset)
178	{
179	throw DataException("Error - DataAbstract::trace is not supported.");
180	}
181
182	void
183	DataAbstract::swapaxes(DataAbstract* ev, int axis0, int axis1)
184	{
185	throw DataException("Error - DataAbstract::component swapaxes is not supported.");
186	}
187	void
188	DataAbstract::transpose(DataAbstract* ev, int axis_offset)
189	{
190	throw DataException("Error - DataAbstract::transpose is not supported.");
191	}
192
193	void
194	DataAbstract::eigenvalues(DataAbstract* ev)
195	{
196	throw DataException("Error - DataAbstract::eigenvalues is not supported.");
197	}
198	void
199	DataAbstract::eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol)
200	{
201	throw DataException("Error - DataAbstract::eigenvalues_and_eigenvectors is not supported.");
202
203	}
204	void
205	DataAbstract::setToZero()
206	{
207	throw DataException("Error - DataAbstract:: cannot set values to zero.");
208	}
209
210	void
211	DataAbstract::reorderByReferenceIDs(int *reference_ids)
212	{
213	}
214
215
216
217
218	} // end of namespace
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision