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

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

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

  ViewVC Help
Powered by ViewVC 1.1.26