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

Annotation of /trunk/escript/src/DataExpanded.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 964 - (hide annotations)
Tue Feb 13 05:10:26 2007 UTC (12 years, 8 months ago) by gross
File size: 22584 byte(s)
The set/getRefVal functions of Data objects have been removed (mainly to avoid later problems with MPI).
Moreover, a faster access to the reference id of samples has been introduced. I don't think that anybody will
profit form this at this stage but it will allow a faster dump of data objects.


1 jgs 102 // $Id$
2 jgs 82 /*
3 elspeth 615 ************************************************************
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 jgs 82 */
13    
14 jgs 480 #include "DataExpanded.h"
15 jgs 474 #include "DataException.h"
16     #include "DataConstant.h"
17     #include "DataTagged.h"
18 jgs 82
19     #include <boost/python/extract.hpp>
20    
21     using namespace std;
22     using namespace boost::python;
23     using namespace boost;
24    
25     namespace escript {
26    
27 jgs 102 DataExpanded::DataExpanded(const boost::python::numeric::array& value,
28     const FunctionSpace& what)
29     : DataAbstract(what)
30     {
31     DataArrayView::ShapeType tempShape;
32     //
33 jgs 117 // extract the shape of the python numarray
34     for (int i=0; i<value.getrank(); i++) {
35 jgs 102 tempShape.push_back(extract<int>(value.getshape()[i]));
36 jgs 82 }
37 jgs 117 //
38     // initialise the data array for this object
39 jgs 102 initialise(tempShape,what.getNumSamples(),what.getNumDPPSample());
40     //
41     // copy the given value to every data point
42     copy(value);
43     }
44 jgs 82
45 jgs 102 DataExpanded::DataExpanded(const DataExpanded& other)
46     : DataAbstract(other.getFunctionSpace()),
47     m_data(other.m_data)
48 jgs 117 {
49 jgs 102 //
50     // create the view for the data
51     DataArrayView temp(m_data.getData(),other.getPointDataView().getShape());
52     setPointDataView(temp);
53     }
54 jgs 82
55 jgs 102 DataExpanded::DataExpanded(const DataConstant& other)
56     : DataAbstract(other.getFunctionSpace())
57 jgs 117 {
58     //
59     // initialise the data array for this object
60 jgs 102 initialise(other.getPointDataView().getShape(),other.getNumSamples(),other.getNumDPPSample());
61     //
62 jgs 117 // DataConstant only has one value, copy this to every data point
63 jgs 102 copy(other.getPointDataView());
64     }
65 jgs 82
66 jgs 102 DataExpanded::DataExpanded(const DataTagged& other)
67     : DataAbstract(other.getFunctionSpace())
68 jgs 117 {
69     //
70 jgs 119 // initialise the data array for this object
71 jgs 102 initialise(other.getPointDataView().getShape(),other.getNumSamples(),other.getNumDPPSample());
72 jgs 117 //
73     // for each data point in this object, extract and copy the corresponding data
74     // value from the given DataTagged object
75 jgs 102 int i,j;
76     DataArrayView::ValueType::size_type numRows=m_data.getNumRows();
77     DataArrayView::ValueType::size_type numCols=m_data.getNumCols();
78 jgs 122 #pragma omp parallel for private(i,j) schedule(static)
79 jgs 117 for (i=0;i<numRows;i++) {
80     for (j=0;j<numCols;j++) {
81 jgs 102 try {
82 jgs 122 getPointDataView().copy(getPointOffset(i,j),
83     other.getPointDataView(),
84     other.getPointOffset(i,j));
85 jgs 82 }
86 jgs 102 catch (std::exception& e) {
87     cout << e.what() << endl;
88     }
89 jgs 82 }
90     }
91 jgs 102 }
92 jgs 82
93 jgs 102 DataExpanded::DataExpanded(const DataExpanded& other,
94     const DataArrayView::RegionType& region)
95     : DataAbstract(other.getFunctionSpace())
96     {
97     //
98     // get the shape of the slice
99     DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
100     //
101     // initialise this Data object to the shape of the slice
102     initialise(shape,other.getNumSamples(),other.getNumDPPSample());
103     //
104 jgs 117 // copy the data
105 jgs 108 DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
106 jgs 102 DataArrayView::ValueType::size_type numRows=m_data.getNumRows();
107     DataArrayView::ValueType::size_type numCols=m_data.getNumCols();
108     int i,j;
109 jgs 122 #pragma omp parallel for private(i,j) schedule(static)
110 jgs 117 for (i=0;i<numRows;i++) {
111     for (j=0;j<numCols;j++) {
112 jgs 102 try {
113 jgs 122 getPointDataView().copySlice(getPointOffset(i,j),
114     other.getPointDataView(),
115     other.getPointOffset(i,j),
116     region_loop_range);
117 jgs 82 }
118 jgs 102 catch (std::exception& e) {
119     cout << e.what() << endl;
120     }
121 jgs 82 }
122     }
123 jgs 102 }
124 jgs 82
125 jgs 102 DataExpanded::DataExpanded(const DataArrayView& value,
126     const FunctionSpace& what)
127     : DataAbstract(what)
128     {
129 jgs 117 //
130     // get the shape of the given data value
131 jgs 102 DataArrayView::ShapeType tempShape=value.getShape();
132 jgs 117 //
133     // initialise this Data object to the shape of the given data value
134 jgs 102 initialise(tempShape,what.getNumSamples(),what.getNumDPPSample());
135 jgs 117 //
136     // copy the given value to every data point
137 jgs 102 copy(value);
138     }
139 jgs 82
140 jgs 119 DataExpanded::DataExpanded(const FunctionSpace& what,
141     const DataArrayView::ShapeType &shape,
142     const DataArrayView::ValueType &data)
143     : DataAbstract(what)
144     {
145     //
146 jgs 160 // create the view of the data
147     initialise(shape,what.getNumSamples(),what.getNumDPPSample());
148     //
149 jgs 119 // copy the data in the correct format
150     m_data.getData()=data;
151     }
152    
153 jgs 102 DataExpanded::~DataExpanded()
154     {
155     }
156 jgs 82
157 jgs 102 DataAbstract*
158     DataExpanded::getSlice(const DataArrayView::RegionType& region) const
159     {
160     return new DataExpanded(*this,region);
161     }
162    
163     void
164     DataExpanded::setSlice(const DataAbstract* value,
165     const DataArrayView::RegionType& region)
166     {
167     const DataExpanded* tempDataExp=dynamic_cast<const DataExpanded*>(value);
168     if (tempDataExp==0) {
169     throw DataException("Programming error - casting to DataExpanded.");
170     }
171 jgs 108 //
172 jgs 117 // get shape of slice
173 jgs 108 DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
174     DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
175     //
176 jgs 117 // check shape
177 jgs 102 if (getPointDataView().getRank()!=region.size()) {
178     throw DataException("Error - Invalid slice region.");
179     }
180 woo409 757 if (tempDataExp->getPointDataView().getRank()>0 && !value->getPointDataView().checkShape(shape)) {
181 jgs 102 throw DataException (value->getPointDataView().createShapeErrorMessage(
182 jgs 108 "Error - Couldn't copy slice due to shape mismatch.",shape));
183 jgs 102 }
184     //
185 jgs 117 // copy the data from the slice into this object
186 jgs 102 DataArrayView::ValueType::size_type numRows=m_data.getNumRows();
187     DataArrayView::ValueType::size_type numCols=m_data.getNumCols();
188     int i, j;
189 jgs 122 #pragma omp parallel for private(i,j) schedule(static)
190 jgs 102 for (i=0;i<numRows;i++) {
191     for (j=0;j<numCols;j++) {
192 jgs 122 getPointDataView().copySliceFrom(getPointOffset(i,j),
193     tempDataExp->getPointDataView(),
194     tempDataExp->getPointOffset(i,j),
195     region_loop_range);
196 jgs 82 }
197     }
198 jgs 102 }
199 jgs 82
200 jgs 102 void
201     DataExpanded::copy(const DataArrayView& value)
202     {
203     //
204 jgs 117 // copy a single value to every data point in this object
205 jgs 102 int nRows=m_data.getNumRows();
206     int nCols=m_data.getNumCols();
207 jgs 117 int i,j;
208 jgs 122 #pragma omp parallel for private(i,j) schedule(static)
209 jgs 117 for (i=0;i<nRows;i++) {
210     for (j=0;j<nCols;j++) {
211 jgs 102 // NOTE: An exception may be thown from this call if
212     // DOASSERT is on which of course will play
213     // havoc with the omp threads. Run single threaded
214     // if using DOASSERT.
215     getPointDataView().copy(m_data.index(i,j),value);
216 jgs 82 }
217     }
218 jgs 102 }
219 jgs 82
220 jgs 102 void
221     DataExpanded::copy(const boost::python::numeric::array& value)
222     {
223     //
224 jgs 117 // first convert the numarray into a DataArray object
225 jgs 102 DataArray temp(value);
226     //
227 jgs 117 // check the input shape matches this shape
228 jgs 102 if (!getPointDataView().checkShape(temp.getView().getShape())) {
229     throw DataException(getPointDataView().createShapeErrorMessage(
230     "Error - (DataExpanded) Cannot copy due to shape mismatch.",
231     temp.getView().getShape()));
232 jgs 82 }
233 jgs 102 //
234 jgs 117 // now copy over the data
235 jgs 102 copy(temp.getView());
236     }
237 jgs 82
238 jgs 102 void
239     DataExpanded::initialise(const DataArrayView::ShapeType& shape,
240     int noSamples,
241     int noDataPointsPerSample)
242     {
243     //
244 jgs 117 // resize data array to the required size
245 jgs 102 m_data.resize(noSamples,noDataPointsPerSample,DataArrayView::noValues(shape));
246     //
247 jgs 117 // create the data view of the data array
248 jgs 102 DataArrayView temp(m_data.getData(),shape);
249     setPointDataView(temp);
250     }
251 jgs 82
252 jgs 102 string
253     DataExpanded::toString() const
254     {
255     stringstream temp;
256 gross 856 FunctionSpace fs=getFunctionSpace();
257 jgs 102 //
258     // create a temporary view as the offset will be changed
259     DataArrayView tempView(getPointDataView().getData(),getPointDataView().getShape(),getPointDataView().getOffset());
260 jgs 117 for (int i=0;i<m_data.getNumRows();i++) {
261     for (int j=0;j<m_data.getNumCols();j++) {
262 jgs 102 tempView.setOffset(m_data.index(i,j));
263     stringstream suffix;
264 gross 964 suffix << "( id: " << i << ", ref: " << fs.getReferenceIDOfSample(i) << ", pnt: " << j << ")";
265 jgs 102 temp << tempView.toString(suffix.str());
266     if (!(i==(m_data.getNumRows()-1) && j==(m_data.getNumCols()-1))) {
267     temp << endl;
268 jgs 82 }
269     }
270     }
271 jgs 102 return temp.str();
272     }
273 jgs 82
274 jgs 102 DataArrayView::ValueType::size_type
275     DataExpanded::getPointOffset(int sampleNo,
276     int dataPointNo) const
277     {
278     return m_data.index(sampleNo,dataPointNo);
279     }
280 jgs 82
281 jgs 102 DataArrayView
282     DataExpanded::getDataPoint(int sampleNo,
283     int dataPointNo)
284     {
285     DataArrayView temp(m_data.getData(),getPointDataView().getShape(),m_data.index(sampleNo,dataPointNo));
286     return temp;
287     }
288 jgs 82
289 jgs 102 DataArrayView::ValueType::size_type
290     DataExpanded::getLength() const
291     {
292 jgs 117 return m_data.size();
293 jgs 102 }
294 jgs 82
295 jgs 123 int
296     DataExpanded::archiveData(ofstream& archiveFile,
297     const DataArrayView::ValueType::size_type noValues) const
298     {
299     return(m_data.archiveData(archiveFile, noValues));
300     }
301    
302     int
303     DataExpanded::extractData(ifstream& archiveFile,
304     const DataArrayView::ValueType::size_type noValues)
305     {
306     return(m_data.extractData(archiveFile, noValues));
307     }
308    
309 gross 921 void
310 gross 922 DataExpanded::copyToDataPoint(const int sampleNo, const int dataPointNo, const double value) {
311     //
312     // Get the number of samples and data-points per sample.
313     int numSamples = getNumSamples();
314     int numDataPointsPerSample = getNumDPPSample();
315     int dataPointRank = getPointDataView().getRank();
316     ShapeType dataPointShape = getPointDataView().getShape();
317     if (numSamples*numDataPointsPerSample > 0) {
318     //TODO: global error handling
319 trankine 924 if ((sampleNo >= numSamples) || (sampleNo < 0 )) {
320 gross 922 throw DataException("Error - DataExpanded::copyDataPoint invalid sampleNo.");
321     }
322 trankine 924 if ((dataPointNo >= numDataPointsPerSample) || (dataPointNo < 0)) {
323 gross 922 throw DataException("Error - DataExpanded::copyDataPoint invalid dataPointNoInSample.");
324     }
325     DataArrayView dataPointView = getDataPoint(sampleNo, dataPointNo);
326     if (dataPointRank==0) {
327     dataPointView()=value;
328     } else if (dataPointRank==1) {
329     for (int i=0; i<dataPointShape[0]; i++) {
330     dataPointView(i)=value;
331     }
332     } else if (dataPointRank==2) {
333     for (int i=0; i<dataPointShape[0]; i++) {
334     for (int j=0; j<dataPointShape[1]; j++) {
335     dataPointView(i,j)=value;
336     }
337     }
338     } else if (dataPointRank==3) {
339     for (int i=0; i<dataPointShape[0]; i++) {
340     for (int j=0; j<dataPointShape[1]; j++) {
341     for (int k=0; k<dataPointShape[2]; k++) {
342     dataPointView(i,j,k)=value;
343     }
344     }
345     }
346     } else if (dataPointRank==4) {
347     for (int i=0; i<dataPointShape[0]; i++) {
348     for (int j=0; j<dataPointShape[1]; j++) {
349     for (int k=0; k<dataPointShape[2]; k++) {
350     for (int l=0; l<dataPointShape[3]; l++) {
351     dataPointView(i,j,k,l)=value;
352     }
353     }
354     }
355     }
356     }
357     }
358     }
359     void
360 gross 921 DataExpanded::copyToDataPoint(const int sampleNo, const int dataPointNo, const boost::python::numeric::array& value) {
361     //
362     // Get the number of samples and data-points per sample.
363     int numSamples = getNumSamples();
364     int numDataPointsPerSample = getNumDPPSample();
365     int dataPointRank = getPointDataView().getRank();
366     ShapeType dataPointShape = getPointDataView().getShape();
367     //
368     // check rank:
369     if (value.getrank()!=dataPointRank)
370     throw DataException("Rank of numarray does not match Data object rank");
371     if (numSamples*numDataPointsPerSample > 0) {
372     //TODO: global error handling
373 trankine 924 if ((sampleNo >= numSamples) || (sampleNo < 0 )) {
374 gross 921 throw DataException("Error - DataExpanded::copyDataPoint invalid sampleNo.");
375     }
376 trankine 924 if ((dataPointNo >= numDataPointsPerSample) || (dataPointNo < 0)) {
377 gross 921 throw DataException("Error - DataExpanded::copyDataPoint invalid dataPointNoInSample.");
378     }
379     DataArrayView dataPointView = getDataPoint(sampleNo, dataPointNo);
380     if (dataPointRank==0) {
381     dataPointView()=extract<double>(value[0]);
382     } else if (dataPointRank==1) {
383     for (int i=0; i<dataPointShape[0]; i++) {
384     dataPointView(i)=extract<double>(value[i]);
385     }
386     } else if (dataPointRank==2) {
387     for (int i=0; i<dataPointShape[0]; i++) {
388     for (int j=0; j<dataPointShape[1]; j++) {
389     dataPointView(i,j)=extract<double>(value[i][j]);
390     }
391     }
392     } else if (dataPointRank==3) {
393     for (int i=0; i<dataPointShape[0]; i++) {
394     for (int j=0; j<dataPointShape[1]; j++) {
395     for (int k=0; k<dataPointShape[2]; k++) {
396     dataPointView(i,j,k)=extract<double>(value[i][j][k]);
397     }
398     }
399     }
400     } else if (dataPointRank==4) {
401     for (int i=0; i<dataPointShape[0]; i++) {
402     for (int j=0; j<dataPointShape[1]; j++) {
403     for (int k=0; k<dataPointShape[2]; k++) {
404     for (int l=0; l<dataPointShape[3]; l++) {
405     dataPointView(i,j,k,l)=extract<double>(value[i][j][k][l]);
406     }
407     }
408     }
409     }
410     }
411     }
412     }
413 jgs 126 void
414     DataExpanded::copyAll(const boost::python::numeric::array& value) {
415     //
416     // Get the number of samples and data-points per sample.
417     int numSamples = getNumSamples();
418     int numDataPointsPerSample = getNumDPPSample();
419     int dataPointRank = getPointDataView().getRank();
420     ShapeType dataPointShape = getPointDataView().getShape();
421     //
422     // check rank:
423     if (value.getrank()!=dataPointRank+1)
424     throw DataException("Rank of numarray does not match Data object rank");
425     if (value.getshape()[0]!=numSamples*numDataPointsPerSample)
426     throw DataException("leading dimension of numarray is too small");
427     //
428     int dataPoint = 0;
429     for (int sampleNo = 0; sampleNo < numSamples; sampleNo++) {
430     for (int dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
431     DataArrayView dataPointView = getDataPoint(sampleNo, dataPointNo);
432     if (dataPointRank==0) {
433     dataPointView()=extract<double>(value[dataPoint]);
434     } else if (dataPointRank==1) {
435     for (int i=0; i<dataPointShape[0]; i++) {
436     dataPointView(i)=extract<double>(value[dataPoint][i]);
437     }
438     } else if (dataPointRank==2) {
439     for (int i=0; i<dataPointShape[0]; i++) {
440     for (int j=0; j<dataPointShape[1]; j++) {
441     dataPointView(i,j)=extract<double>(value[dataPoint][i][j]);
442     }
443     }
444     } else if (dataPointRank==3) {
445     for (int i=0; i<dataPointShape[0]; i++) {
446     for (int j=0; j<dataPointShape[1]; j++) {
447     for (int k=0; k<dataPointShape[2]; k++) {
448     dataPointView(i,j,k)=extract<double>(value[dataPoint][i][j][k]);
449     }
450     }
451     }
452     } else if (dataPointRank==4) {
453     for (int i=0; i<dataPointShape[0]; i++) {
454     for (int j=0; j<dataPointShape[1]; j++) {
455     for (int k=0; k<dataPointShape[2]; k++) {
456     for (int l=0; l<dataPointShape[3]; l++) {
457     dataPointView(i,j,k,l)=extract<double>(value[dataPoint][i][j][k][l]);
458     }
459     }
460     }
461     }
462     }
463     dataPoint++;
464     }
465     }
466     }
467 gross 580 void
468 ksteube 775 DataExpanded::symmetric(DataAbstract* ev)
469     {
470     int sampleNo,dataPointNo;
471     int numSamples = getNumSamples();
472     int numDataPointsPerSample = getNumDPPSample();
473     DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
474     if (temp_ev==0) {
475     throw DataException("Error - DataExpanded::symmetric: casting to DataExpanded failed (propably a programming error).");
476     }
477     DataArrayView& thisView=getPointDataView();
478     DataArrayView& evView=ev->getPointDataView();
479     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
480     for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
481     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
482     DataArrayView::symmetric(thisView,getPointOffset(sampleNo,dataPointNo),
483     evView,ev->getPointOffset(sampleNo,dataPointNo));
484     }
485     }
486     }
487     void
488     DataExpanded::nonsymmetric(DataAbstract* ev)
489     {
490     int sampleNo,dataPointNo;
491     int numSamples = getNumSamples();
492     int numDataPointsPerSample = getNumDPPSample();
493     DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
494     if (temp_ev==0) {
495     throw DataException("Error - DataExpanded::nonsymmetric: casting to DataExpanded failed (propably a programming error).");
496     }
497     DataArrayView& thisView=getPointDataView();
498     DataArrayView& evView=ev->getPointDataView();
499     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
500     for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
501     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
502     DataArrayView::nonsymmetric(thisView,getPointOffset(sampleNo,dataPointNo),
503     evView,ev->getPointOffset(sampleNo,dataPointNo));
504     }
505     }
506     }
507     void
508 gross 800 DataExpanded::trace(DataAbstract* ev, int axis_offset)
509 ksteube 775 {
510     int sampleNo,dataPointNo;
511     int numSamples = getNumSamples();
512     int numDataPointsPerSample = getNumDPPSample();
513     DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
514     if (temp_ev==0) {
515 gross 800 throw DataException("Error - DataExpanded::trace: casting to DataExpanded failed (propably a programming error).");
516 ksteube 775 }
517     DataArrayView& thisView=getPointDataView();
518     DataArrayView& evView=ev->getPointDataView();
519     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
520     for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
521     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
522 gross 800 DataArrayView::trace(thisView,getPointOffset(sampleNo,dataPointNo),
523 ksteube 775 evView,ev->getPointOffset(sampleNo,dataPointNo),axis_offset);
524     }
525     }
526     }
527 gross 800
528 ksteube 775 void
529     DataExpanded::transpose(DataAbstract* ev, int axis_offset)
530     {
531     int sampleNo,dataPointNo;
532     int numSamples = getNumSamples();
533     int numDataPointsPerSample = getNumDPPSample();
534     DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
535     if (temp_ev==0) {
536     throw DataException("Error - DataExpanded::transpose: casting to DataExpanded failed (propably a programming error).");
537     }
538     DataArrayView& thisView=getPointDataView();
539     DataArrayView& evView=ev->getPointDataView();
540     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
541     for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
542     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
543     DataArrayView::transpose(thisView,getPointOffset(sampleNo,dataPointNo),
544     evView,ev->getPointOffset(sampleNo,dataPointNo),axis_offset);
545     }
546     }
547     }
548 gross 800
549 ksteube 775 void
550 gross 804 DataExpanded::swapaxes(DataAbstract* ev, int axis0, int axis1)
551 gross 800 {
552     int sampleNo,dataPointNo;
553     int numSamples = getNumSamples();
554     int numDataPointsPerSample = getNumDPPSample();
555     DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
556     if (temp_ev==0) {
557 gross 804 throw DataException("Error - DataExpanded::swapaxes: casting to DataExpanded failed (propably a programming error).");
558 gross 800 }
559     DataArrayView& thisView=getPointDataView();
560     DataArrayView& evView=ev->getPointDataView();
561     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
562     for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
563     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
564 gross 804 DataArrayView::swapaxes(thisView,getPointOffset(sampleNo,dataPointNo),
565     evView,ev->getPointOffset(sampleNo,dataPointNo),axis0,axis1);
566 gross 800 }
567     }
568     }
569     void
570 gross 580 DataExpanded::eigenvalues(DataAbstract* ev)
571     {
572 gross 584 int sampleNo,dataPointNo;
573 gross 580 int numSamples = getNumSamples();
574     int numDataPointsPerSample = getNumDPPSample();
575     DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
576     if (temp_ev==0) {
577     throw DataException("Error - DataExpanded::eigenvalues: casting to DataExpanded failed (propably a programming error).");
578     }
579     DataArrayView& thisView=getPointDataView();
580     DataArrayView& evView=ev->getPointDataView();
581     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
582 gross 584 for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
583     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
584 gross 580 DataArrayView::eigenvalues(thisView,getPointOffset(sampleNo,dataPointNo),
585     evView,ev->getPointOffset(sampleNo,dataPointNo));
586     }
587     }
588     }
589     void
590     DataExpanded::eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol)
591     {
592     int numSamples = getNumSamples();
593     int numDataPointsPerSample = getNumDPPSample();
594 gross 584 int sampleNo,dataPointNo;
595 gross 580 DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
596     if (temp_ev==0) {
597     throw DataException("Error - DataExpanded::eigenvalues_and_eigenvectors: casting to DataExpanded failed (propably a programming error).");
598     }
599     DataExpanded* temp_V=dynamic_cast<DataExpanded*>(V);
600     if (temp_V==0) {
601     throw DataException("Error - DataExpanded::eigenvalues_and_eigenvectors: casting to DataExpanded failed (propably a programming error).");
602     }
603     DataArrayView& thisView=getPointDataView();
604     DataArrayView& evView=ev->getPointDataView();
605     DataArrayView& VView=V->getPointDataView();
606     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
607 gross 584 for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
608     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
609 gross 580 DataArrayView::eigenvalues_and_eigenvectors(thisView,getPointOffset(sampleNo,dataPointNo),
610     evView,ev->getPointOffset(sampleNo,dataPointNo),
611     VView,V->getPointOffset(sampleNo,dataPointNo),
612     tol);
613     }
614     }
615     }
616    
617 gross 950 void
618     DataExpanded::dump(const std::string fileName) const
619     {
620     throw DataException("Error - DataExpanded:: dump: not implemented.");
621     }
622    
623    
624 jgs 82 } // end of namespace

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26