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

Diff of /trunk/escript/src/Data.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 119 by jgs, Tue Apr 12 04:45:05 2005 UTC revision 122 by jgs, Thu Jun 9 05:38:05 2005 UTC
# Line 35  Line 35 
35  #include "escript/Data/DataTagged.h"  #include "escript/Data/DataTagged.h"
36  #include "escript/Data/DataEmpty.h"  #include "escript/Data/DataEmpty.h"
37  #include "escript/Data/DataArray.h"  #include "escript/Data/DataArray.h"
 #include "escript/Data/DataAlgorithm.h"  
38  #include "escript/Data/FunctionSpaceFactory.h"  #include "escript/Data/FunctionSpaceFactory.h"
39  #include "escript/Data/AbstractContinuousDomain.h"  #include "escript/Data/AbstractContinuousDomain.h"
40  #include "escript/Data/UnaryFuncs.h"  #include "escript/Data/UnaryFuncs.h"
# Line 185  Data::getDataC() const Line 184  Data::getDataC() const
184    return temp;    return temp;
185  }  }
186    
187  tuple  const boost::python::tuple
188  Data::getShapeTuple() const  Data::getShapeTuple() const
189  {  {
190    const DataArrayView::ShapeType& shape=getDataPointShape();    const DataArrayView::ShapeType& shape=getDataPointShape();
# Line 443  Data::getDataPointShape() const Line 442  Data::getDataPointShape() const
442    return getPointDataView().getShape();    return getPointDataView().getShape();
443  }  }
444    
445    const
446  boost::python::numeric::array  boost::python::numeric::array
447  Data::convertToNumArray()  Data::convertToNumArray()
448  {  {
449    //    //
450    // determine the current number of data points    // determine the total number of data points
451    int numSamples = getNumSamples();    int numSamples = getNumSamples();
452    int numDataPointsPerSample = getNumDataPointsPerSample();    int numDataPointsPerSample = getNumDataPointsPerSample();
453    int numDataPoints = numSamples * numDataPointsPerSample;    int numDataPoints = numSamples * numDataPointsPerSample;
# Line 499  Data::convertToNumArray() Line 499  Data::convertToNumArray()
499    int dataPoint = 0;    int dataPoint = 0;
500    for (int sampleNo = 0; sampleNo < numSamples; sampleNo++) {    for (int sampleNo = 0; sampleNo < numSamples; sampleNo++) {
501      for (int dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {      for (int dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
   
502        DataArrayView dataPointView = getDataPoint(sampleNo, dataPointNo);        DataArrayView dataPointView = getDataPoint(sampleNo, dataPointNo);
   
503        if (dataPointRank==0) {        if (dataPointRank==0) {
504          numArray[dataPoint]=dataPointView();          numArray[dataPoint]=dataPointView();
505        }        }
   
506        if (dataPointRank==1) {        if (dataPointRank==1) {
507          for (int i=0; i<dataPointShape[0]; i++) {          for (int i=0; i<dataPointShape[0]; i++) {
508            numArray[dataPoint][i]=dataPointView(i);            numArray[dataPoint][i]=dataPointView(i);
509          }          }
510        }        }
   
511        if (dataPointRank==2) {        if (dataPointRank==2) {
512          for (int i=0; i<dataPointShape[0]; i++) {          for (int i=0; i<dataPointShape[0]; i++) {
513            for (int j=0; j<dataPointShape[1]; j++) {            for (int j=0; j<dataPointShape[1]; j++) {
# Line 519  Data::convertToNumArray() Line 515  Data::convertToNumArray()
515            }            }
516          }          }
517        }        }
   
518        if (dataPointRank==3) {        if (dataPointRank==3) {
519          for (int i=0; i<dataPointShape[0]; i++) {          for (int i=0; i<dataPointShape[0]; i++) {
520            for (int j=0; j<dataPointShape[1]; j++) {            for (int j=0; j<dataPointShape[1]; j++) {
# Line 529  Data::convertToNumArray() Line 524  Data::convertToNumArray()
524            }            }
525          }          }
526        }        }
   
527        if (dataPointRank==4) {        if (dataPointRank==4) {
528          for (int i=0; i<dataPointShape[0]; i++) {          for (int i=0; i<dataPointShape[0]; i++) {
529            for (int j=0; j<dataPointShape[1]; j++) {            for (int j=0; j<dataPointShape[1]; j++) {
# Line 541  Data::convertToNumArray() Line 535  Data::convertToNumArray()
535            }            }
536          }          }
537        }        }
   
538        dataPoint++;        dataPoint++;
539        }
540      }
541    
542      //
543      // return the loaded array
544      return numArray;
545    }
546    
547    const
548    boost::python::numeric::array
549    Data::convertToNumArrayFromSampleNo(int sampleNo)
550    {
551      //
552      // Check a valid sample number has been supplied
553      if (sampleNo >= getNumSamples()) {
554        throw DataException("Error - Data::convertToNumArray: invalid sampleNo.");
555      }
556    
557      //
558      // determine the number of data points per sample
559      int numDataPointsPerSample = getNumDataPointsPerSample();
560    
561      //
562      // determine the rank and shape of each data point
563      int dataPointRank = getDataPointRank();
564      DataArrayView::ShapeType dataPointShape = getDataPointShape();
565    
566      //
567      // create the numeric array to be returned
568      boost::python::numeric::array numArray(0.0);
569    
570      //
571      // the rank of the returned numeric array will be the rank of
572      // the data points, plus one. Where the rank of the array is n,
573      // the last n-1 dimensions will be equal to the shape of the
574      // data points, whilst the first dimension will be equal to the
575      // total number of data points. Thus the array will consist of
576      // a serial vector of the data points.
577      int arrayRank = dataPointRank + 1;
578      DataArrayView::ShapeType arrayShape;
579      arrayShape.push_back(numDataPointsPerSample);
580      for (int d=0; d<dataPointRank; d++) {
581         arrayShape.push_back(dataPointShape[d]);
582      }
583    
584      //
585      // resize the numeric array to the shape just calculated
586      if (arrayRank==1) {
587        numArray.resize(arrayShape[0]);
588      }
589      if (arrayRank==2) {
590        numArray.resize(arrayShape[0],arrayShape[1]);
591      }
592      if (arrayRank==3) {
593        numArray.resize(arrayShape[0],arrayShape[1],arrayShape[2]);
594      }
595      if (arrayRank==4) {
596        numArray.resize(arrayShape[0],arrayShape[1],arrayShape[2],arrayShape[3]);
597      }
598      if (arrayRank==5) {
599        numArray.resize(arrayShape[0],arrayShape[1],arrayShape[2],arrayShape[3],arrayShape[4]);
600      }
601    
602      //
603      // loop through each data point in turn, loading the values for that data point
604      // into the numeric array.
605      for (int dataPoint = 0; dataPoint < numDataPointsPerSample; dataPoint++) {
606        DataArrayView dataPointView = getDataPoint(sampleNo, dataPoint);
607        if (dataPointRank==0) {
608          numArray[dataPoint]=dataPointView();
609        }
610        if (dataPointRank==1) {
611          for (int i=0; i<dataPointShape[0]; i++) {
612            numArray[dataPoint][i]=dataPointView(i);
613          }
614        }
615        if (dataPointRank==2) {
616          for (int i=0; i<dataPointShape[0]; i++) {
617            for (int j=0; j<dataPointShape[1]; j++) {
618              numArray[dataPoint][i][j] = dataPointView(i,j);
619            }
620          }
621        }
622        if (dataPointRank==3) {
623          for (int i=0; i<dataPointShape[0]; i++) {
624            for (int j=0; j<dataPointShape[1]; j++) {
625              for (int k=0; k<dataPointShape[2]; k++) {
626                numArray[dataPoint][i][j][k]=dataPointView(i,j,k);
627              }
628            }
629          }
630        }
631        if (dataPointRank==4) {
632          for (int i=0; i<dataPointShape[0]; i++) {
633            for (int j=0; j<dataPointShape[1]; j++) {
634              for (int k=0; k<dataPointShape[2]; k++) {
635                for (int l=0; l<dataPointShape[3]; l++) {
636                  numArray[dataPoint][i][j][k][l]=dataPointView(i,j,k,l);
637                }
638              }
639            }
640          }
641        }
642      }
643    
644      //
645      // return the loaded array
646      return numArray;
647    }
648    
649    const
650    boost::python::numeric::array
651    Data::convertToNumArrayFromDPNo(int sampleNo,
652                                    int dataPointNo)
653    {
654      //
655      // Check a valid sample number has been supplied
656      if (sampleNo >= getNumSamples()) {
657        throw DataException("Error - Data::convertToNumArray: invalid sampleNo.");
658      }
659    
660      //
661      // Check a valid data point number has been supplied
662      if (dataPointNo >= getNumDataPointsPerSample()) {
663        throw DataException("Error - Data::convertToNumArray: invalid dataPointNo.");
664      }
665    
666      //
667      // determine the rank and shape of each data point
668      int dataPointRank = getDataPointRank();
669      DataArrayView::ShapeType dataPointShape = getDataPointShape();
670    
671      //
672      // create the numeric array to be returned
673      boost::python::numeric::array numArray(0.0);
674    
675      //
676      // the shape of the returned numeric array will be the same
677      // as that of the data point
678      int arrayRank = dataPointRank;
679      DataArrayView::ShapeType arrayShape = dataPointShape;
680    
681      //
682      // resize the numeric array to the shape just calculated
683      if (arrayRank==0) {
684        numArray.resize(1);
685      }
686      if (arrayRank==1) {
687        numArray.resize(arrayShape[0]);
688      }
689      if (arrayRank==2) {
690        numArray.resize(arrayShape[0],arrayShape[1]);
691      }
692      if (arrayRank==3) {
693        numArray.resize(arrayShape[0],arrayShape[1],arrayShape[2]);
694      }
695      if (arrayRank==4) {
696        numArray.resize(arrayShape[0],arrayShape[1],arrayShape[2],arrayShape[3]);
697      }
698    
699      //
700      // load the values for the data point into the numeric array.
701      DataArrayView dataPointView = getDataPoint(sampleNo, dataPointNo);
702      if (dataPointRank==0) {
703        numArray[0]=dataPointView();
704      }
705      if (dataPointRank==1) {
706        for (int i=0; i<dataPointShape[0]; i++) {
707          numArray[i]=dataPointView(i);
708        }
709      }
710      if (dataPointRank==2) {
711        for (int i=0; i<dataPointShape[0]; i++) {
712          for (int j=0; j<dataPointShape[1]; j++) {
713            numArray[i][j] = dataPointView(i,j);
714          }
715        }
716      }
717      if (dataPointRank==3) {
718        for (int i=0; i<dataPointShape[0]; i++) {
719          for (int j=0; j<dataPointShape[1]; j++) {
720            for (int k=0; k<dataPointShape[2]; k++) {
721              numArray[i][j][k]=dataPointView(i,j,k);
722            }
723          }
724        }
725      }
726      if (dataPointRank==4) {
727        for (int i=0; i<dataPointShape[0]; i++) {
728          for (int j=0; j<dataPointShape[1]; j++) {
729            for (int k=0; k<dataPointShape[2]; k++) {
730              for (int l=0; l<dataPointShape[3]; l++) {
731                numArray[i][j][k][l]=dataPointView(i,j,k,l);
732              }
733            }
734          }
735      }      }
736    }    }
737    
# Line 733  Data::minval() const Line 921  Data::minval() const
921    return dp_algorithm(DataAlgorithmAdapter<FMin>(numeric_limits<double>::max()));    return dp_algorithm(DataAlgorithmAdapter<FMin>(numeric_limits<double>::max()));
922  }  }
923    
924    const boost::python::tuple
925    Data::mindp() const
926    {
927      Data temp=minval();
928    
929      int numSamples=temp.getNumSamples();
930      int numDPPSample=temp.getNumDataPointsPerSample();
931    
932      int i,j,lowi=0,lowj=0;
933      double min=numeric_limits<double>::max();
934    
935      for (i=0; i<numSamples; i++) {
936        for (j=0; j<numDPPSample; j++) {
937          double next=temp.getDataPoint(i,j)();
938          if (next<min) {
939            min=next;
940            lowi=i;
941            lowj=j;
942          }
943        }
944      }
945    
946      return make_tuple(lowi,lowj);
947    }
948    
949  Data  Data
950  Data::length() const  Data::length() const
951  {  {
# Line 1159  Data::setTaggedValue(int tagKey, Line 1372  Data::setTaggedValue(int tagKey,
1372  }  }
1373    
1374  void  void
1375    Data::setTaggedValueFromCPP(int tagKey,
1376                                const DataArrayView& value)
1377    {
1378      //
1379      // Ensure underlying data object is of type DataTagged
1380      tag();
1381    
1382      if (!isTagged()) {
1383        throw DataException("Error - DataTagged conversion failed!!");
1384      }
1385                                                                                                                  
1386      //
1387      // Call DataAbstract::setTaggedValue
1388      m_data->setTaggedValue(tagKey,value);
1389    }
1390    
1391    void
1392  Data::setRefValue(int ref,  Data::setRefValue(int ref,
1393                    const boost::python::numeric::array& value)                    const boost::python::numeric::array& value)
1394  {  {
# Line 1216  Data::getRefValue(int ref, Line 1446  Data::getRefValue(int ref,
1446    
1447  }  }
1448    
 /*  
 Note: this version removed for now. Not needed, and breaks escript.cpp  
 void  
 Data::setTaggedValue(int tagKey,  
                      const DataArrayView& value)  
 {  
   //  
   // Ensure underlying data object is of type DataTagged  
   tag();  
   
   if (!isTagged()) {  
     throw DataException("Error - DataTagged conversion failed!!");  
   }  
                                                                                                                 
   //  
   // Call DataAbstract::setTaggedValue  
   m_data->setTaggedValue(tagKey,value);  
 }  
 */  
   
1449  void  void
1450  Data::archiveData(const std::string fileName)  Data::archiveData(const std::string fileName)
1451  {  {

Legend:
Removed from v.119  
changed lines
  Added in v.122

  ViewVC Help
Powered by ViewVC 1.1.26