escript/src/DataConstant.cpp

//$Id$
/*
 ************************************************************
 *          Copyright 2006 by ACcESS MNRF                   *
 *                                                          *
 *              http://www.access.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 "DataConstant.h"
#include "DataException.h"
#include "esysUtils/EsysAssert.h"

#include <iostream>
#include <boost/python/extract.hpp>

using namespace std;

namespace escript {

DataConstant::DataConstant(const boost::python::numeric::array& value,
                           const FunctionSpace& what)
  : DataAbstract(what)
{
  DataArray temp(value);
  //
  // copy the data in the correct format
  m_data=temp.getData();
  //
  // create the view of the data
  DataArrayView tempView(m_data,temp.getView().getShape());
  setPointDataView(tempView);
}

DataConstant::DataConstant(const DataArrayView& value,
                           const FunctionSpace& what)
  : DataAbstract(what)
{
  //
  // copy the data in the correct format
  m_data=value.getData();
  //
  // create the view of the data
  DataArrayView tempView(m_data,value.getShape());
  setPointDataView(tempView);
}

DataConstant::DataConstant(const DataConstant& other)
  : DataAbstract(other.getFunctionSpace())
{
  // 
  // copy the data in the correct format
  m_data=other.m_data;
  //
  // create the view of the data
  DataArrayView tempView(m_data,other.getPointDataView().getShape());
  setPointDataView(tempView);
}

DataConstant::DataConstant(const DataConstant& other,
                           const DataArrayView::RegionType& region)
  : DataAbstract(other.getFunctionSpace())
{
  //
  // get the shape of the slice to copy from
  DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
  //
  // allocate space for this new DataConstant's data
  int len = DataArrayView::noValues(shape);
  m_data.resize(len,0.,len);
  //
  // create a view of the data with the correct shape
  DataArrayView tempView(m_data,shape);
  DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
  //
  // load the view with the data from the slice
  tempView.copySlice(other.getPointDataView(),region_loop_range);
  setPointDataView(tempView);
}

DataConstant::DataConstant(const FunctionSpace& what,
                           const DataArrayView::ShapeType &shape,
                           const DataArrayView::ValueType &data)
  : DataAbstract(what)
{
  //
  // copy the data in the correct format
  m_data=data;
  //
  // create the view of the data
  DataArrayView tempView(m_data,shape);
  setPointDataView(tempView);
}

string
DataConstant::toString() const
{
  return getPointDataView().toString("");
}

DataArrayView::ValueType::size_type
DataConstant::getPointOffset(int sampleNo,
                             int dataPointNo) const
{
  EsysAssert((validSamplePointNo(dataPointNo) && validSampleNo(sampleNo)),
              "Invalid index, sampleNo: " << sampleNo << " dataPointNo: " << dataPointNo);
  //
  // Whatever the coord's always return the same value as this is constant data.
  return 0;
}

DataArrayView::ValueType::size_type
DataConstant::getLength() const
{
  return m_data.size();
}

DataArrayView
DataConstant::getDataPoint(int sampleNo,
                           int dataPointNo)
{
  EsysAssert((validSamplePointNo(dataPointNo) && validSampleNo(sampleNo)),
             "Invalid index, sampleNo: " << sampleNo << " dataPointNo: " << dataPointNo);
  //
  // Whatever the coord's always return the same value as this is constant data.
  return getPointDataView();
}
  
DataAbstract*
DataConstant::getSlice(const DataArrayView::RegionType& region) const
{
  return new DataConstant(*this,region);
}

void
DataConstant::setSlice(const DataAbstract* value,
                       const DataArrayView::RegionType& region) 
{
  const DataConstant* tempDataConst=dynamic_cast<const DataConstant*>(value);
  if (tempDataConst==0) {
    throw DataException("Programming error - casting to DataConstant.");
  }
  // 
  DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
  DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
  //
  // check shape:
  if (getPointDataView().getRank()!=region.size()) {
    throw DataException("Error - Invalid slice region.");
  }
  if (tempDataConst->getPointDataView().getRank()>0 && !value->getPointDataView().checkShape(shape)) {
    throw DataException (value->getPointDataView().createShapeErrorMessage(
                "Error - Couldn't copy slice due to shape mismatch.",shape));
  }
  //
  getPointDataView().copySliceFrom(tempDataConst->getPointDataView(),region_loop_range);
}

void
DataConstant::reshapeDataPoint(const DataArrayView::ShapeType& shape) 
{
  if (getPointDataView().getRank()!=0) {
    stringstream temp;
    temp << "Error - Can only reshape Data with data points of rank 0. "
         << "This Data has data points with rank: " << getPointDataView().getRank();
    throw DataException(temp.str());
  }
  int len = DataArrayView::noValues(shape);
  m_data.resize(len,getPointDataView()(),len);
  DataArrayView newView(m_data,shape);
  setPointDataView(newView);
}

int
DataConstant::archiveData(ofstream& archiveFile,
                          const DataArrayView::ValueType::size_type noValues) const
{
  return(m_data.archiveData(archiveFile, noValues));
}

int
DataConstant::extractData(ifstream& archiveFile,
                          const DataArrayView::ValueType::size_type noValues)
{
  return(m_data.extractData(archiveFile, noValues));
}

void
DataConstant::symmetric(DataAbstract* ev)
{
  DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
  if (temp_ev==0) {
    throw DataException("Error - DataConstant::symmetric: casting to DataConstant failed (propably a programming error).");
  }
  DataArrayView& thisView=getPointDataView();
  DataArrayView& evView=ev->getPointDataView();
  DataArrayView::symmetric(thisView,0,evView,0);
}

void
DataConstant::nonsymmetric(DataAbstract* ev)
{
  DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
  if (temp_ev==0) {
    throw DataException("Error - DataConstant::nonsymmetric: casting to DataConstant failed (propably a programming error).");
  }
  DataArrayView& thisView=getPointDataView();
  DataArrayView& evView=ev->getPointDataView();
  DataArrayView::nonsymmetric(thisView,0,evView,0);
}

void
DataConstant::trace(DataAbstract* ev, int axis_offset)
{
  DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
  if (temp_ev==0) {
    throw DataException("Error - DataConstant::trace: casting to DataConstant failed (propably a programming error).");
  }
  DataArrayView& thisView=getPointDataView();
  DataArrayView& evView=ev->getPointDataView();
  DataArrayView::trace(thisView,0,evView,0,axis_offset);
}

void
DataConstant::swapaxes(DataAbstract* ev, int axis0, int axis1)
{
  DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
  if (temp_ev==0) {
    throw DataException("Error - DataConstant::swapaxes: casting to DataConstant failed (propably a programming error).");
  }
  DataArrayView& thisView=getPointDataView();
  DataArrayView& evView=ev->getPointDataView();
  DataArrayView::swapaxes(thisView,0,evView,0,axis0,axis1);
}

void
DataConstant::transpose(DataAbstract* ev, int axis_offset)
{
  DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
  if (temp_ev==0) {
    throw DataException("Error - DataConstant::transpose: casting to DataConstant failed (propably a programming error).");
  }
  DataArrayView& thisView=getPointDataView();
  DataArrayView& evView=ev->getPointDataView();
  DataArrayView::transpose(thisView,0,evView,0,axis_offset);
}

void
DataConstant::eigenvalues(DataAbstract* ev)
{
  DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
  if (temp_ev==0) {
    throw DataException("Error - DataConstant::eigenvalues: casting to DataConstant failed (propably a programming error).");
  }
  DataArrayView& thisView=getPointDataView();
  DataArrayView& evView=ev->getPointDataView();
  DataArrayView::eigenvalues(thisView,0,evView,0);
}
void
DataConstant::eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol)
{
  DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
  if (temp_ev==0) {
    throw DataException("Error - DataConstant::eigenvalues_and_eigenvectors: casting to DataConstant failed (propably a programming error).");
  }
  DataConstant* temp_V=dynamic_cast<DataConstant*>(V);
  if (temp_V==0) {
    throw DataException("Error - DataConstant::eigenvalues_and_eigenvectors: casting to DataConstant failed (propably a programming error).");
  }
  DataArrayView thisView=getPointDataView();
  DataArrayView evView=ev->getPointDataView();
  DataArrayView VView=V->getPointDataView();

  DataArrayView::eigenvalues_and_eigenvectors(thisView,0,evView,0,VView,tol);
}


}  // end of namespace
1	//$Id$
2	/*
3	************************************************************
4	* Copyright 2006 by ACcESS MNRF *
5	* *
6	* http://www.access.edu.au *
7	* Primary Business: Queensland, Australia *
8	* Licensed under the Open Software License version 3.0 *
9	* http://www.opensource.org/licenses/osl-3.0.php *
10	* *
11	************************************************************
12	*/
13
14	#include "DataConstant.h"
15	#include "DataException.h"
16	#include "esysUtils/EsysAssert.h"
17
18	#include <iostream>
19	#include <boost/python/extract.hpp>
20
21	using namespace std;
22
23	namespace escript {
24
25	DataConstant::DataConstant(const boost::python::numeric::array& value,
26	const FunctionSpace& what)
27	: DataAbstract(what)
28	{
29	DataArray temp(value);
30	//
31	// copy the data in the correct format
32	m_data=temp.getData();
33	//
34	// create the view of the data
35	DataArrayView tempView(m_data,temp.getView().getShape());
36	setPointDataView(tempView);
37	}
38
39	DataConstant::DataConstant(const DataArrayView& value,
40	const FunctionSpace& what)
41	: DataAbstract(what)
42	{
43	//
44	// copy the data in the correct format
45	m_data=value.getData();
46	//
47	// create the view of the data
48	DataArrayView tempView(m_data,value.getShape());
49	setPointDataView(tempView);
50	}
51
52	DataConstant::DataConstant(const DataConstant& other)
53	: DataAbstract(other.getFunctionSpace())
54	{
55	//
56	// copy the data in the correct format
57	m_data=other.m_data;
58	//
59	// create the view of the data
60	DataArrayView tempView(m_data,other.getPointDataView().getShape());
61	setPointDataView(tempView);
62	}
63
64	DataConstant::DataConstant(const DataConstant& other,
65	const DataArrayView::RegionType& region)
66	: DataAbstract(other.getFunctionSpace())
67	{
68	//
69	// get the shape of the slice to copy from
70	DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
71	//
72	// allocate space for this new DataConstant's data
73	int len = DataArrayView::noValues(shape);
74	m_data.resize(len,0.,len);
75	//
76	// create a view of the data with the correct shape
77	DataArrayView tempView(m_data,shape);
78	DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
79	//
80	// load the view with the data from the slice
81	tempView.copySlice(other.getPointDataView(),region_loop_range);
82	setPointDataView(tempView);
83	}
84
85	DataConstant::DataConstant(const FunctionSpace& what,
86	const DataArrayView::ShapeType &shape,
87	const DataArrayView::ValueType &data)
88	: DataAbstract(what)
89	{
90	//
91	// copy the data in the correct format
92	m_data=data;
93	//
94	// create the view of the data
95	DataArrayView tempView(m_data,shape);
96	setPointDataView(tempView);
97	}
98
99	string
100	DataConstant::toString() const
101	{
102	return getPointDataView().toString("");
103	}
104
105	DataArrayView::ValueType::size_type
106	DataConstant::getPointOffset(int sampleNo,
107	int dataPointNo) const
108	{
109	EsysAssert((validSamplePointNo(dataPointNo) && validSampleNo(sampleNo)),
110	"Invalid index, sampleNo: " << sampleNo << " dataPointNo: " << dataPointNo);
111	//
112	// Whatever the coord's always return the same value as this is constant data.
113	return 0;
114	}
115
116	DataArrayView::ValueType::size_type
117	DataConstant::getLength() const
118	{
119	return m_data.size();
120	}
121
122	DataArrayView
123	DataConstant::getDataPoint(int sampleNo,
124	int dataPointNo)
125	{
126	EsysAssert((validSamplePointNo(dataPointNo) && validSampleNo(sampleNo)),
127	"Invalid index, sampleNo: " << sampleNo << " dataPointNo: " << dataPointNo);
128	//
129	// Whatever the coord's always return the same value as this is constant data.
130	return getPointDataView();
131	}
132
133	DataAbstract*
134	DataConstant::getSlice(const DataArrayView::RegionType& region) const
135	{
136	return new DataConstant(*this,region);
137	}
138
139	void
140	DataConstant::setSlice(const DataAbstract* value,
141	const DataArrayView::RegionType& region)
142	{
143	const DataConstant* tempDataConst=dynamic_cast<const DataConstant*>(value);
144	if (tempDataConst==0) {
145	throw DataException("Programming error - casting to DataConstant.");
146	}
147	//
148	DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
149	DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
150	//
151	// check shape:
152	if (getPointDataView().getRank()!=region.size()) {
153	throw DataException("Error - Invalid slice region.");
154	}
155	if (tempDataConst->getPointDataView().getRank()>0 && !value->getPointDataView().checkShape(shape)) {
156	throw DataException (value->getPointDataView().createShapeErrorMessage(
157	"Error - Couldn't copy slice due to shape mismatch.",shape));
158	}
159	//
160	getPointDataView().copySliceFrom(tempDataConst->getPointDataView(),region_loop_range);
161	}
162
163	void
164	DataConstant::reshapeDataPoint(const DataArrayView::ShapeType& shape)
165	{
166	if (getPointDataView().getRank()!=0) {
167	stringstream temp;
168	temp << "Error - Can only reshape Data with data points of rank 0. "
169	<< "This Data has data points with rank: " << getPointDataView().getRank();
170	throw DataException(temp.str());
171	}
172	int len = DataArrayView::noValues(shape);
173	m_data.resize(len,getPointDataView()(),len);
174	DataArrayView newView(m_data,shape);
175	setPointDataView(newView);
176	}
177
178	int
179	DataConstant::archiveData(ofstream& archiveFile,
180	const DataArrayView::ValueType::size_type noValues) const
181	{
182	return(m_data.archiveData(archiveFile, noValues));
183	}
184
185	int
186	DataConstant::extractData(ifstream& archiveFile,
187	const DataArrayView::ValueType::size_type noValues)
188	{
189	return(m_data.extractData(archiveFile, noValues));
190	}
191
192	void
193	DataConstant::symmetric(DataAbstract* ev)
194	{
195	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
196	if (temp_ev==0) {
197	throw DataException("Error - DataConstant::symmetric: casting to DataConstant failed (propably a programming error).");
198	}
199	DataArrayView& thisView=getPointDataView();
200	DataArrayView& evView=ev->getPointDataView();
201	DataArrayView::symmetric(thisView,0,evView,0);
202	}
203
204	void
205	DataConstant::nonsymmetric(DataAbstract* ev)
206	{
207	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
208	if (temp_ev==0) {
209	throw DataException("Error - DataConstant::nonsymmetric: casting to DataConstant failed (propably a programming error).");
210	}
211	DataArrayView& thisView=getPointDataView();
212	DataArrayView& evView=ev->getPointDataView();
213	DataArrayView::nonsymmetric(thisView,0,evView,0);
214	}
215
216	void
217	DataConstant::trace(DataAbstract* ev, int axis_offset)
218	{
219	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
220	if (temp_ev==0) {
221	throw DataException("Error - DataConstant::trace: casting to DataConstant failed (propably a programming error).");
222	}
223	DataArrayView& thisView=getPointDataView();
224	DataArrayView& evView=ev->getPointDataView();
225	DataArrayView::trace(thisView,0,evView,0,axis_offset);
226	}
227
228	void
229	DataConstant::swapaxes(DataAbstract* ev, int axis0, int axis1)
230	{
231	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
232	if (temp_ev==0) {
233	throw DataException("Error - DataConstant::swapaxes: casting to DataConstant failed (propably a programming error).");
234	}
235	DataArrayView& thisView=getPointDataView();
236	DataArrayView& evView=ev->getPointDataView();
237	DataArrayView::swapaxes(thisView,0,evView,0,axis0,axis1);
238	}
239
240	void
241	DataConstant::transpose(DataAbstract* ev, int axis_offset)
242	{
243	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
244	if (temp_ev==0) {
245	throw DataException("Error - DataConstant::transpose: casting to DataConstant failed (propably a programming error).");
246	}
247	DataArrayView& thisView=getPointDataView();
248	DataArrayView& evView=ev->getPointDataView();
249	DataArrayView::transpose(thisView,0,evView,0,axis_offset);
250	}
251
252	void
253	DataConstant::eigenvalues(DataAbstract* ev)
254	{
255	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
256	if (temp_ev==0) {
257	throw DataException("Error - DataConstant::eigenvalues: casting to DataConstant failed (propably a programming error).");
258	}
259	DataArrayView& thisView=getPointDataView();
260	DataArrayView& evView=ev->getPointDataView();
261	DataArrayView::eigenvalues(thisView,0,evView,0);
262	}
263	void
264	DataConstant::eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol)
265	{
266	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
267	if (temp_ev==0) {
268	throw DataException("Error - DataConstant::eigenvalues_and_eigenvectors: casting to DataConstant failed (propably a programming error).");
269	}
270	DataConstant* temp_V=dynamic_cast<DataConstant*>(V);
271	if (temp_V==0) {
272	throw DataException("Error - DataConstant::eigenvalues_and_eigenvectors: casting to DataConstant failed (propably a programming error).");
273	}
274	DataArrayView thisView=getPointDataView();
275	DataArrayView evView=ev->getPointDataView();
276	DataArrayView VView=V->getPointDataView();
277
278	DataArrayView::eigenvalues_and_eigenvectors(thisView,0,evView,0,VView,tol);
279	}
280
281
282	} // end of namespace
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision