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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 921 - (hide annotations)
Fri Jan 5 00:54:37 2007 UTC (12 years, 7 months ago) by gross
File size: 22334 byte(s)
I have done some clarification on functions that allow to access individual data point values in a Data object. 
The term "data point number" is always local on a MPI process and referes to the value (data_point_in_sample, sample)
as a single identifyer (data_point_in_sample + sample * number_data_points_per_sample). a "global data point number"
referes to a tuple of a processour id and local data point number.

The function convertToNumArrayFromSampleNo has been removed now and convertToNumArrayFromDPNo renamed to getValueOfDataPoint.
There are two new functions:

   getNumberOfDataPoints
   setValueOfDataPoint

This allows you to do things like:

  in=Data(..)
  out=Data(..)
   for i in xrange(in.getNumberOfDataPoints())
       in_loc=in.getValueOfDataPoint(i)
       out_loc=< some operations on in_loc>
       out.setValueOfDataPoint(i,out_loc)


Also mindp  is renamed to  minGlobalDataPoint and there is a new function getValueOfGlobalDataPoint. While in MPI the functions getNumberOfDataPoints and getValueOfDataPoint are working locally on each process (so the code above is executed in parallel).
the latter allows getting a single value across all processors. 


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 856 suffix << "( id: " << i << ", ref: " << fs.getReferenceNoFromSampleNo(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 110 void
296     DataExpanded::setRefValue(int ref,
297     const DataArray& value)
298     {
299     //
300 jgs 113 // Get the number of samples and data-points per sample.
301 jgs 110 int numSamples = getNumSamples();
302     int numDPPSample = getNumDPPSample();
303    
304     //
305 jgs 113 // Determine the sample number which corresponds to this reference number.
306 jgs 110 int sampleNo = -1;
307     int tempRef = -1;
308     for (int n=0; n<numSamples; n++) {
309     tempRef = getFunctionSpace().getReferenceNoFromSampleNo(n);
310     if (tempRef == ref) {
311     sampleNo = n;
312     break;
313     }
314     }
315     if (sampleNo == -1) {
316     throw DataException("DataExpanded::setRefValue error: invalid ref number supplied.");
317     }
318    
319 jgs 113 for (int n=0; n<numDPPSample; n++) {
320     //
321 jgs 126 // Get *each* data-point in the sample in turn.
322 jgs 113 DataArrayView pointView = getDataPoint(sampleNo, n);
323     //
324     // Assign the values in the DataArray to this data-point.
325     pointView.copy(value.getView());
326     }
327 jgs 110 }
328    
329     void
330     DataExpanded::getRefValue(int ref,
331     DataArray& value)
332     {
333     //
334 jgs 113 // Get the number of samples and data-points per sample.
335 jgs 110 int numSamples = getNumSamples();
336     int numDPPSample = getNumDPPSample();
337    
338     //
339 jgs 113 // Determine the sample number which corresponds to this reference number
340 jgs 110 int sampleNo = -1;
341     int tempRef = -1;
342     for (int n=0; n<numSamples; n++) {
343     tempRef = getFunctionSpace().getReferenceNoFromSampleNo(n);
344     if (tempRef == ref) {
345     sampleNo = n;
346     break;
347     }
348     }
349     if (sampleNo == -1) {
350     throw DataException("DataExpanded::getRefValue error: invalid ref number supplied.");
351     }
352    
353 jgs 113 //
354 jgs 126 // Get the *first* data-point associated with this sample number.
355 jgs 110 DataArrayView pointView = getDataPoint(sampleNo, 0);
356    
357     //
358     // Load the values from this data-point into the DataArray
359     value.getView().copy(pointView);
360     }
361    
362 jgs 123 int
363     DataExpanded::archiveData(ofstream& archiveFile,
364     const DataArrayView::ValueType::size_type noValues) const
365     {
366     return(m_data.archiveData(archiveFile, noValues));
367     }
368    
369     int
370     DataExpanded::extractData(ifstream& archiveFile,
371     const DataArrayView::ValueType::size_type noValues)
372     {
373     return(m_data.extractData(archiveFile, noValues));
374     }
375    
376 gross 921 void
377     DataExpanded::copyToDataPoint(const int sampleNo, const int dataPointNo, const boost::python::numeric::array& value) {
378     //
379     // Get the number of samples and data-points per sample.
380     int numSamples = getNumSamples();
381     int numDataPointsPerSample = getNumDPPSample();
382     int dataPointRank = getPointDataView().getRank();
383     ShapeType dataPointShape = getPointDataView().getShape();
384     //
385     // check rank:
386     if (value.getrank()!=dataPointRank)
387     throw DataException("Rank of numarray does not match Data object rank");
388     if (numSamples*numDataPointsPerSample > 0) {
389     //TODO: global error handling
390     if (sampleNo >= numSamples or sampleNo < 0 ) {
391     throw DataException("Error - DataExpanded::copyDataPoint invalid sampleNo.");
392     }
393     if (dataPointNo >= numDataPointsPerSample or dataPointNo < 0) {
394     throw DataException("Error - DataExpanded::copyDataPoint invalid dataPointNoInSample.");
395     }
396     DataArrayView dataPointView = getDataPoint(sampleNo, dataPointNo);
397     if (dataPointRank==0) {
398     dataPointView()=extract<double>(value[0]);
399     } else if (dataPointRank==1) {
400     for (int i=0; i<dataPointShape[0]; i++) {
401     dataPointView(i)=extract<double>(value[i]);
402     }
403     } else if (dataPointRank==2) {
404     for (int i=0; i<dataPointShape[0]; i++) {
405     for (int j=0; j<dataPointShape[1]; j++) {
406     dataPointView(i,j)=extract<double>(value[i][j]);
407     }
408     }
409     } else if (dataPointRank==3) {
410     for (int i=0; i<dataPointShape[0]; i++) {
411     for (int j=0; j<dataPointShape[1]; j++) {
412     for (int k=0; k<dataPointShape[2]; k++) {
413     dataPointView(i,j,k)=extract<double>(value[i][j][k]);
414     }
415     }
416     }
417     } else if (dataPointRank==4) {
418     for (int i=0; i<dataPointShape[0]; i++) {
419     for (int j=0; j<dataPointShape[1]; j++) {
420     for (int k=0; k<dataPointShape[2]; k++) {
421     for (int l=0; l<dataPointShape[3]; l++) {
422     dataPointView(i,j,k,l)=extract<double>(value[i][j][k][l]);
423     }
424     }
425     }
426     }
427     }
428     }
429     }
430 jgs 126 void
431     DataExpanded::copyAll(const boost::python::numeric::array& value) {
432     //
433     // Get the number of samples and data-points per sample.
434     int numSamples = getNumSamples();
435     int numDataPointsPerSample = getNumDPPSample();
436     int dataPointRank = getPointDataView().getRank();
437     ShapeType dataPointShape = getPointDataView().getShape();
438     //
439     // check rank:
440     if (value.getrank()!=dataPointRank+1)
441     throw DataException("Rank of numarray does not match Data object rank");
442     if (value.getshape()[0]!=numSamples*numDataPointsPerSample)
443     throw DataException("leading dimension of numarray is too small");
444     //
445     int dataPoint = 0;
446     for (int sampleNo = 0; sampleNo < numSamples; sampleNo++) {
447     for (int dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
448     DataArrayView dataPointView = getDataPoint(sampleNo, dataPointNo);
449     if (dataPointRank==0) {
450     dataPointView()=extract<double>(value[dataPoint]);
451     } else if (dataPointRank==1) {
452     for (int i=0; i<dataPointShape[0]; i++) {
453     dataPointView(i)=extract<double>(value[dataPoint][i]);
454     }
455     } else if (dataPointRank==2) {
456     for (int i=0; i<dataPointShape[0]; i++) {
457     for (int j=0; j<dataPointShape[1]; j++) {
458     dataPointView(i,j)=extract<double>(value[dataPoint][i][j]);
459     }
460     }
461     } else if (dataPointRank==3) {
462     for (int i=0; i<dataPointShape[0]; i++) {
463     for (int j=0; j<dataPointShape[1]; j++) {
464     for (int k=0; k<dataPointShape[2]; k++) {
465     dataPointView(i,j,k)=extract<double>(value[dataPoint][i][j][k]);
466     }
467     }
468     }
469     } else if (dataPointRank==4) {
470     for (int i=0; i<dataPointShape[0]; i++) {
471     for (int j=0; j<dataPointShape[1]; j++) {
472     for (int k=0; k<dataPointShape[2]; k++) {
473     for (int l=0; l<dataPointShape[3]; l++) {
474     dataPointView(i,j,k,l)=extract<double>(value[dataPoint][i][j][k][l]);
475     }
476     }
477     }
478     }
479     }
480     dataPoint++;
481     }
482     }
483     }
484 gross 580 void
485 ksteube 775 DataExpanded::symmetric(DataAbstract* ev)
486     {
487     int sampleNo,dataPointNo;
488     int numSamples = getNumSamples();
489     int numDataPointsPerSample = getNumDPPSample();
490     DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
491     if (temp_ev==0) {
492     throw DataException("Error - DataExpanded::symmetric: casting to DataExpanded failed (propably a programming error).");
493     }
494     DataArrayView& thisView=getPointDataView();
495     DataArrayView& evView=ev->getPointDataView();
496     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
497     for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
498     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
499     DataArrayView::symmetric(thisView,getPointOffset(sampleNo,dataPointNo),
500     evView,ev->getPointOffset(sampleNo,dataPointNo));
501     }
502     }
503     }
504     void
505     DataExpanded::nonsymmetric(DataAbstract* ev)
506     {
507     int sampleNo,dataPointNo;
508     int numSamples = getNumSamples();
509     int numDataPointsPerSample = getNumDPPSample();
510     DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
511     if (temp_ev==0) {
512     throw DataException("Error - DataExpanded::nonsymmetric: casting to DataExpanded failed (propably a programming error).");
513     }
514     DataArrayView& thisView=getPointDataView();
515     DataArrayView& evView=ev->getPointDataView();
516     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
517     for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
518     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
519     DataArrayView::nonsymmetric(thisView,getPointOffset(sampleNo,dataPointNo),
520     evView,ev->getPointOffset(sampleNo,dataPointNo));
521     }
522     }
523     }
524     void
525 gross 800 DataExpanded::trace(DataAbstract* ev, int axis_offset)
526 ksteube 775 {
527     int sampleNo,dataPointNo;
528     int numSamples = getNumSamples();
529     int numDataPointsPerSample = getNumDPPSample();
530     DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
531     if (temp_ev==0) {
532 gross 800 throw DataException("Error - DataExpanded::trace: casting to DataExpanded failed (propably a programming error).");
533 ksteube 775 }
534     DataArrayView& thisView=getPointDataView();
535     DataArrayView& evView=ev->getPointDataView();
536     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
537     for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
538     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
539 gross 800 DataArrayView::trace(thisView,getPointOffset(sampleNo,dataPointNo),
540 ksteube 775 evView,ev->getPointOffset(sampleNo,dataPointNo),axis_offset);
541     }
542     }
543     }
544 gross 800
545 ksteube 775 void
546     DataExpanded::transpose(DataAbstract* ev, int axis_offset)
547     {
548     int sampleNo,dataPointNo;
549     int numSamples = getNumSamples();
550     int numDataPointsPerSample = getNumDPPSample();
551     DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
552     if (temp_ev==0) {
553     throw DataException("Error - DataExpanded::transpose: casting to DataExpanded failed (propably a programming error).");
554     }
555     DataArrayView& thisView=getPointDataView();
556     DataArrayView& evView=ev->getPointDataView();
557     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
558     for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
559     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
560     DataArrayView::transpose(thisView,getPointOffset(sampleNo,dataPointNo),
561     evView,ev->getPointOffset(sampleNo,dataPointNo),axis_offset);
562     }
563     }
564     }
565 gross 800
566 ksteube 775 void
567 gross 804 DataExpanded::swapaxes(DataAbstract* ev, int axis0, int axis1)
568 gross 800 {
569     int sampleNo,dataPointNo;
570     int numSamples = getNumSamples();
571     int numDataPointsPerSample = getNumDPPSample();
572     DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
573     if (temp_ev==0) {
574 gross 804 throw DataException("Error - DataExpanded::swapaxes: casting to DataExpanded failed (propably a programming error).");
575 gross 800 }
576     DataArrayView& thisView=getPointDataView();
577     DataArrayView& evView=ev->getPointDataView();
578     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
579     for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
580     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
581 gross 804 DataArrayView::swapaxes(thisView,getPointOffset(sampleNo,dataPointNo),
582     evView,ev->getPointOffset(sampleNo,dataPointNo),axis0,axis1);
583 gross 800 }
584     }
585     }
586     void
587 gross 580 DataExpanded::eigenvalues(DataAbstract* ev)
588     {
589 gross 584 int sampleNo,dataPointNo;
590 gross 580 int numSamples = getNumSamples();
591     int numDataPointsPerSample = getNumDPPSample();
592     DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
593     if (temp_ev==0) {
594     throw DataException("Error - DataExpanded::eigenvalues: casting to DataExpanded failed (propably a programming error).");
595     }
596     DataArrayView& thisView=getPointDataView();
597     DataArrayView& evView=ev->getPointDataView();
598     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
599 gross 584 for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
600     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
601 gross 580 DataArrayView::eigenvalues(thisView,getPointOffset(sampleNo,dataPointNo),
602     evView,ev->getPointOffset(sampleNo,dataPointNo));
603     }
604     }
605     }
606     void
607     DataExpanded::eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol)
608     {
609     int numSamples = getNumSamples();
610     int numDataPointsPerSample = getNumDPPSample();
611 gross 584 int sampleNo,dataPointNo;
612 gross 580 DataExpanded* temp_ev=dynamic_cast<DataExpanded*>(ev);
613     if (temp_ev==0) {
614     throw DataException("Error - DataExpanded::eigenvalues_and_eigenvectors: casting to DataExpanded failed (propably a programming error).");
615     }
616     DataExpanded* temp_V=dynamic_cast<DataExpanded*>(V);
617     if (temp_V==0) {
618     throw DataException("Error - DataExpanded::eigenvalues_and_eigenvectors: casting to DataExpanded failed (propably a programming error).");
619     }
620     DataArrayView& thisView=getPointDataView();
621     DataArrayView& evView=ev->getPointDataView();
622     DataArrayView& VView=V->getPointDataView();
623     #pragma omp parallel for private(sampleNo,dataPointNo) schedule(static)
624 gross 584 for (sampleNo = 0; sampleNo < numSamples; sampleNo++) {
625     for (dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
626 gross 580 DataArrayView::eigenvalues_and_eigenvectors(thisView,getPointOffset(sampleNo,dataPointNo),
627     evView,ev->getPointOffset(sampleNo,dataPointNo),
628     VView,V->getPointOffset(sampleNo,dataPointNo),
629     tol);
630     }
631     }
632     }
633    
634 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