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>
#ifdef USE_NETCDF
#include <netcdfcpp.h>
#endif

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);
}

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);
}

void
DataConstant::dump(const std::string fileName) const
{
   #ifdef PASO_MPI
   throw DataException("Error - DataConstant:: dump is not implemented for MPI yet.")
   #endif
   #ifdef USE_NETCDF
   const NcDim* ncdims[DataArrayView::maxRank];
   NcVar* var;
   int rank = getPointDataView().getRank();
   int type=  getFunctionSpace().getTypeCode();
   int ndims =0;
   long dims[DataArrayView::maxRank];
   DataArrayView::ShapeType shape = getPointDataView().getShape();
   
   // netCDF error handler
   NcError err(NcError::verbose_nonfatal);
   // Create the file.
   NcFile dataFile(fileName.c_str(), NcFile::Replace);
   // check if writing was successful
   if (!dataFile.is_valid()) 
    throw DataException("Error - DataConstant:: opening of netCDF file for output failed.");
   if (!dataFile.add_att("type","constant") ) 
    throw DataException("Error - DataConstant:: appending data type to netCDF file failed.");
   if (!dataFile.add_att("rank",rank) ) 
    throw DataException("Error - DataConstant:: appending rank attribute to netCDF file failed.");
   if (!dataFile.add_att("function_space_type",type)) 
    throw DataException("Error - DataConstant:: appending function space attribute to netCDF file failed.");

   if (rank == 0) {
      if( ! (ncdims[0] = dataFile.add_dim("l", 1)) ) 
        throw DataException("Error - DataConstant:: appending ncdimsion 0 to netCDF file failed.");
      dims[0]=1,
      ndims=1;
   } else {
       ndims=rank;
       dims[0]=shape[0];
       if (! (ncdims[0] = dataFile.add_dim("d0",shape[0])) ) 
        throw DataException("Error - DataConstant:: appending ncdimsion 0 to netCDF file failed.");
       if ( rank >1 ) {
           dims[1]=shape[1];
           if (! (ncdims[1] = dataFile.add_dim("d1",shape[1])) ) 
        throw DataException("Error - DataConstant:: appending ncdimsion 1 to netCDF file failed.");
       }
       if ( rank >2 ) {
           dims[2]=shape[2];
           if (! (ncdims[2] = dataFile.add_dim("d2", shape[2])) ) 
        throw DataException("Error - DataConstant:: appending ncdimsion 2 to netCDF file failed.");
       }
       if ( rank >3 ) {
           dims[3]=shape[3];
           if (! (ncdims[3] = dataFile.add_dim("d3", shape[3])) ) 
        throw DataException("Error - DataConstant:: appending ncdimsion 3 to netCDF file failed.");
       }
   }
   if (! ( var = dataFile.add_var("data", ncDouble, ndims, ncdims)) )
    throw DataException("Error - DataConstant:: appending variable to netCDF file failed.");
   if (! (var->put(&m_data[0],dims)) )
    throw DataException("Error - DataConstant:: copy data to netCDF buffer failed."); 
   #else
   throw DataException("Error - DataConstant:: dump is not configured with netCDF. Please contact your installation manager.");
   #endif
}

}  // 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	#ifdef USE_NETCDF
21	#include <netcdfcpp.h>
22	#endif
23
24	using namespace std;
25
26	namespace escript {
27
28	DataConstant::DataConstant(const boost::python::numeric::array& value,
29	const FunctionSpace& what)
30	: DataAbstract(what)
31	{
32	DataArray temp(value);
33	//
34	// copy the data in the correct format
35	m_data=temp.getData();
36	//
37	// create the view of the data
38	DataArrayView tempView(m_data,temp.getView().getShape());
39	setPointDataView(tempView);
40	}
41
42	DataConstant::DataConstant(const DataArrayView& value,
43	const FunctionSpace& what)
44	: DataAbstract(what)
45	{
46	//
47	// copy the data in the correct format
48	m_data=value.getData();
49	//
50	// create the view of the data
51	DataArrayView tempView(m_data,value.getShape());
52	setPointDataView(tempView);
53	}
54
55	DataConstant::DataConstant(const DataConstant& other)
56	: DataAbstract(other.getFunctionSpace())
57	{
58	//
59	// copy the data in the correct format
60	m_data=other.m_data;
61	//
62	// create the view of the data
63	DataArrayView tempView(m_data,other.getPointDataView().getShape());
64	setPointDataView(tempView);
65	}
66
67	DataConstant::DataConstant(const DataConstant& other,
68	const DataArrayView::RegionType& region)
69	: DataAbstract(other.getFunctionSpace())
70	{
71	//
72	// get the shape of the slice to copy from
73	DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
74	//
75	// allocate space for this new DataConstant's data
76	int len = DataArrayView::noValues(shape);
77	m_data.resize(len,0.,len);
78	//
79	// create a view of the data with the correct shape
80	DataArrayView tempView(m_data,shape);
81	DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
82	//
83	// load the view with the data from the slice
84	tempView.copySlice(other.getPointDataView(),region_loop_range);
85	setPointDataView(tempView);
86	}
87
88	DataConstant::DataConstant(const FunctionSpace& what,
89	const DataArrayView::ShapeType &shape,
90	const DataArrayView::ValueType &data)
91	: DataAbstract(what)
92	{
93	//
94	// copy the data in the correct format
95	m_data=data;
96	//
97	// create the view of the data
98	DataArrayView tempView(m_data,shape);
99	setPointDataView(tempView);
100	}
101
102	string
103	DataConstant::toString() const
104	{
105	return getPointDataView().toString("");
106	}
107
108	DataArrayView::ValueType::size_type
109	DataConstant::getPointOffset(int sampleNo,
110	int dataPointNo) const
111	{
112	EsysAssert((validSamplePointNo(dataPointNo) && validSampleNo(sampleNo)),
113	"Invalid index, sampleNo: " << sampleNo << " dataPointNo: " << dataPointNo);
114	//
115	// Whatever the coord's always return the same value as this is constant data.
116	return 0;
117	}
118
119	DataArrayView::ValueType::size_type
120	DataConstant::getLength() const
121	{
122	return m_data.size();
123	}
124
125	DataArrayView
126	DataConstant::getDataPoint(int sampleNo,
127	int dataPointNo)
128	{
129	EsysAssert((validSamplePointNo(dataPointNo) && validSampleNo(sampleNo)),
130	"Invalid index, sampleNo: " << sampleNo << " dataPointNo: " << dataPointNo);
131	//
132	// Whatever the coord's always return the same value as this is constant data.
133	return getPointDataView();
134	}
135
136	DataAbstract*
137	DataConstant::getSlice(const DataArrayView::RegionType& region) const
138	{
139	return new DataConstant(*this,region);
140	}
141
142	void
143	DataConstant::setSlice(const DataAbstract* value,
144	const DataArrayView::RegionType& region)
145	{
146	const DataConstant* tempDataConst=dynamic_cast<const DataConstant*>(value);
147	if (tempDataConst==0) {
148	throw DataException("Programming error - casting to DataConstant.");
149	}
150	//
151	DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
152	DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
153	//
154	// check shape:
155	if (getPointDataView().getRank()!=region.size()) {
156	throw DataException("Error - Invalid slice region.");
157	}
158	if (tempDataConst->getPointDataView().getRank()>0 && !value->getPointDataView().checkShape(shape)) {
159	throw DataException (value->getPointDataView().createShapeErrorMessage(
160	"Error - Couldn't copy slice due to shape mismatch.",shape));
161	}
162	//
163	getPointDataView().copySliceFrom(tempDataConst->getPointDataView(),region_loop_range);
164	}
165
166	int
167	DataConstant::archiveData(ofstream& archiveFile,
168	const DataArrayView::ValueType::size_type noValues) const
169	{
170	return(m_data.archiveData(archiveFile, noValues));
171	}
172
173	int
174	DataConstant::extractData(ifstream& archiveFile,
175	const DataArrayView::ValueType::size_type noValues)
176	{
177	return(m_data.extractData(archiveFile, noValues));
178	}
179
180	void
181	DataConstant::symmetric(DataAbstract* ev)
182	{
183	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
184	if (temp_ev==0) {
185	throw DataException("Error - DataConstant::symmetric: casting to DataConstant failed (propably a programming error).");
186	}
187	DataArrayView& thisView=getPointDataView();
188	DataArrayView& evView=ev->getPointDataView();
189	DataArrayView::symmetric(thisView,0,evView,0);
190	}
191
192	void
193	DataConstant::nonsymmetric(DataAbstract* ev)
194	{
195	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
196	if (temp_ev==0) {
197	throw DataException("Error - DataConstant::nonsymmetric: casting to DataConstant failed (propably a programming error).");
198	}
199	DataArrayView& thisView=getPointDataView();
200	DataArrayView& evView=ev->getPointDataView();
201	DataArrayView::nonsymmetric(thisView,0,evView,0);
202	}
203
204	void
205	DataConstant::trace(DataAbstract* ev, int axis_offset)
206	{
207	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
208	if (temp_ev==0) {
209	throw DataException("Error - DataConstant::trace: casting to DataConstant failed (propably a programming error).");
210	}
211	DataArrayView& thisView=getPointDataView();
212	DataArrayView& evView=ev->getPointDataView();
213	DataArrayView::trace(thisView,0,evView,0,axis_offset);
214	}
215
216	void
217	DataConstant::swapaxes(DataAbstract* ev, int axis0, int axis1)
218	{
219	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
220	if (temp_ev==0) {
221	throw DataException("Error - DataConstant::swapaxes: casting to DataConstant failed (propably a programming error).");
222	}
223	DataArrayView& thisView=getPointDataView();
224	DataArrayView& evView=ev->getPointDataView();
225	DataArrayView::swapaxes(thisView,0,evView,0,axis0,axis1);
226	}
227
228	void
229	DataConstant::transpose(DataAbstract* ev, int axis_offset)
230	{
231	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
232	if (temp_ev==0) {
233	throw DataException("Error - DataConstant::transpose: casting to DataConstant failed (propably a programming error).");
234	}
235	DataArrayView& thisView=getPointDataView();
236	DataArrayView& evView=ev->getPointDataView();
237	DataArrayView::transpose(thisView,0,evView,0,axis_offset);
238	}
239
240	void
241	DataConstant::eigenvalues(DataAbstract* ev)
242	{
243	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
244	if (temp_ev==0) {
245	throw DataException("Error - DataConstant::eigenvalues: casting to DataConstant failed (propably a programming error).");
246	}
247	DataArrayView& thisView=getPointDataView();
248	DataArrayView& evView=ev->getPointDataView();
249	DataArrayView::eigenvalues(thisView,0,evView,0);
250	}
251	void
252	DataConstant::eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol)
253	{
254	DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
255	if (temp_ev==0) {
256	throw DataException("Error - DataConstant::eigenvalues_and_eigenvectors: casting to DataConstant failed (propably a programming error).");
257	}
258	DataConstant* temp_V=dynamic_cast<DataConstant*>(V);
259	if (temp_V==0) {
260	throw DataException("Error - DataConstant::eigenvalues_and_eigenvectors: casting to DataConstant failed (propably a programming error).");
261	}
262	DataArrayView thisView=getPointDataView();
263	DataArrayView evView=ev->getPointDataView();
264	DataArrayView VView=V->getPointDataView();
265
266	DataArrayView::eigenvalues_and_eigenvectors(thisView,0,evView,0,VView,tol);
267	}
268
269	void
270	DataConstant::dump(const std::string fileName) const
271	{
272	#ifdef PASO_MPI
273	throw DataException("Error - DataConstant:: dump is not implemented for MPI yet.")
274	#endif
275	#ifdef USE_NETCDF
276	const NcDim* ncdims[DataArrayView::maxRank];
277	NcVar* var;
278	int rank = getPointDataView().getRank();
279	int type= getFunctionSpace().getTypeCode();
280	int ndims =0;
281	long dims[DataArrayView::maxRank];
282	DataArrayView::ShapeType shape = getPointDataView().getShape();
283
284	// netCDF error handler
285	NcError err(NcError::verbose_nonfatal);
286	// Create the file.
287	NcFile dataFile(fileName.c_str(), NcFile::Replace);
288	// check if writing was successful
289	if (!dataFile.is_valid())
290	throw DataException("Error - DataConstant:: opening of netCDF file for output failed.");
291	if (!dataFile.add_att("type","constant") )
292	throw DataException("Error - DataConstant:: appending data type to netCDF file failed.");
293	if (!dataFile.add_att("rank",rank) )
294	throw DataException("Error - DataConstant:: appending rank attribute to netCDF file failed.");
295	if (!dataFile.add_att("function_space_type",type))
296	throw DataException("Error - DataConstant:: appending function space attribute to netCDF file failed.");
297
298	if (rank == 0) {
299	if( ! (ncdims[0] = dataFile.add_dim("l", 1)) )
300	throw DataException("Error - DataConstant:: appending ncdimsion 0 to netCDF file failed.");
301	dims[0]=1,
302	ndims=1;
303	} else {
304	ndims=rank;
305	dims[0]=shape[0];
306	if (! (ncdims[0] = dataFile.add_dim("d0",shape[0])) )
307	throw DataException("Error - DataConstant:: appending ncdimsion 0 to netCDF file failed.");
308	if ( rank >1 ) {
309	dims[1]=shape[1];
310	if (! (ncdims[1] = dataFile.add_dim("d1",shape[1])) )
311	throw DataException("Error - DataConstant:: appending ncdimsion 1 to netCDF file failed.");
312	}
313	if ( rank >2 ) {
314	dims[2]=shape[2];
315	if (! (ncdims[2] = dataFile.add_dim("d2", shape[2])) )
316	throw DataException("Error - DataConstant:: appending ncdimsion 2 to netCDF file failed.");
317	}
318	if ( rank >3 ) {
319	dims[3]=shape[3];
320	if (! (ncdims[3] = dataFile.add_dim("d3", shape[3])) )
321	throw DataException("Error - DataConstant:: appending ncdimsion 3 to netCDF file failed.");
322	}
323	}
324	if (! ( var = dataFile.add_var("data", ncDouble, ndims, ncdims)) )
325	throw DataException("Error - DataConstant:: appending variable to netCDF file failed.");
326	if (! (var->put(&m_data[0],dims)) )
327	throw DataException("Error - DataConstant:: copy data to netCDF buffer failed.");
328	#else
329	throw DataException("Error - DataConstant:: dump is not configured with netCDF. Please contact your installation manager.");
330	#endif
331	}
332
333	} // end of namespace
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision