/[escript]/trunk/escript/src/DataConstant.cpp
ViewVC logotype

Contents of /trunk/escript/src/DataConstant.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 800 - (show annotations)
Tue Aug 8 11:23:18 2006 UTC (13 years, 3 months ago) by gross
File size: 9141 byte(s)
new function _swap. Python wrapper + testing is still missing.


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::swap(DataAbstract* ev, int axis_offset)
230 {
231 DataConstant* temp_ev=dynamic_cast<DataConstant*>(ev);
232 if (temp_ev==0) {
233 throw DataException("Error - DataConstant::swap: casting to DataConstant failed (propably a programming error).");
234 }
235 DataArrayView& thisView=getPointDataView();
236 DataArrayView& evView=ev->getPointDataView();
237 DataArrayView::swap(thisView,0,evView,0,axis_offset);
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

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26