/[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 113 by jgs, Mon Feb 28 07:06:33 2005 UTC revision 121 by jgs, Fri May 6 04:26:16 2005 UTC
# Line 18  Line 18 
18  #include "escript/Data/Data.h"  #include "escript/Data/Data.h"
19    
20  #include <iostream>  #include <iostream>
21    #include <fstream>
22  #include <algorithm>  #include <algorithm>
23  #include <vector>  #include <vector>
24  #include <exception>  #include <exception>
# Line 29  Line 30 
30  #include <boost/python/long.hpp>  #include <boost/python/long.hpp>
31    
32  #include "escript/Data/DataException.h"  #include "escript/Data/DataException.h"
   
33  #include "escript/Data/DataExpanded.h"  #include "escript/Data/DataExpanded.h"
34  #include "escript/Data/DataConstant.h"  #include "escript/Data/DataConstant.h"
35  #include "escript/Data/DataTagged.h"  #include "escript/Data/DataTagged.h"
# 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
448    Data::convertToNumArray()
449    {
450      //
451      // determine the total number of data points
452      int numSamples = getNumSamples();
453      int numDataPointsPerSample = getNumDataPointsPerSample();
454      int numDataPoints = numSamples * numDataPointsPerSample;
455    
456      //
457      // determine the rank and shape of each data point
458      int dataPointRank = getDataPointRank();
459      DataArrayView::ShapeType dataPointShape = getDataPointShape();
460    
461      //
462      // create the numeric array to be returned
463      boost::python::numeric::array numArray(0.0);
464    
465      //
466      // the rank of the returned numeric array will be the rank of
467      // the data points, plus one. Where the rank of the array is n,
468      // the last n-1 dimensions will be equal to the shape of the
469      // data points, whilst the first dimension will be equal to the
470      // total number of data points. Thus the array will consist of
471      // a serial vector of the data points.
472      int arrayRank = dataPointRank + 1;
473      DataArrayView::ShapeType arrayShape;
474      arrayShape.push_back(numDataPoints);
475      for (int d=0; d<dataPointRank; d++) {
476         arrayShape.push_back(dataPointShape[d]);
477      }
478    
479      //
480      // resize the numeric array to the shape just calculated
481      if (arrayRank==1) {
482        numArray.resize(arrayShape[0]);
483      }
484      if (arrayRank==2) {
485        numArray.resize(arrayShape[0],arrayShape[1]);
486      }
487      if (arrayRank==3) {
488        numArray.resize(arrayShape[0],arrayShape[1],arrayShape[2]);
489      }
490      if (arrayRank==4) {
491        numArray.resize(arrayShape[0],arrayShape[1],arrayShape[2],arrayShape[3]);
492      }
493      if (arrayRank==5) {
494        numArray.resize(arrayShape[0],arrayShape[1],arrayShape[2],arrayShape[3],arrayShape[4]);
495      }
496    
497      //
498      // loop through each data point in turn, loading the values for that data point
499      // into the numeric array.
500      int dataPoint = 0;
501      for (int sampleNo = 0; sampleNo < numSamples; sampleNo++) {
502        for (int dataPointNo = 0; dataPointNo < numDataPointsPerSample; dataPointNo++) {
503          DataArrayView dataPointView = getDataPoint(sampleNo, dataPointNo);
504          if (dataPointRank==0) {
505            numArray[dataPoint]=dataPointView();
506          }
507          if (dataPointRank==1) {
508            for (int i=0; i<dataPointShape[0]; i++) {
509              numArray[dataPoint][i]=dataPointView(i);
510            }
511          }
512          if (dataPointRank==2) {
513            for (int i=0; i<dataPointShape[0]; i++) {
514              for (int j=0; j<dataPointShape[1]; j++) {
515                numArray[dataPoint][i][j] = dataPointView(i,j);
516              }
517            }
518          }
519          if (dataPointRank==3) {
520            for (int i=0; i<dataPointShape[0]; i++) {
521              for (int j=0; j<dataPointShape[1]; j++) {
522                for (int k=0; k<dataPointShape[2]; k++) {
523                  numArray[dataPoint][i][j][k]=dataPointView(i,j,k);
524                }
525              }
526            }
527          }
528          if (dataPointRank==4) {
529            for (int i=0; i<dataPointShape[0]; i++) {
530              for (int j=0; j<dataPointShape[1]; j++) {
531                for (int k=0; k<dataPointShape[2]; k++) {
532                  for (int l=0; l<dataPointShape[3]; l++) {
533                    numArray[dataPoint][i][j][k][l]=dataPointView(i,j,k,l);
534                  }
535                }
536              }
537            }
538          }
539          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    
739      //
740      // return the loaded array
741      return numArray;
742    }
743    
744  boost::python::numeric::array  boost::python::numeric::array
745  Data::integrate() const  Data::integrate() const
746  {  {
# Line 585  Data::Lsup() const Line 883  Data::Lsup() const
883  }  }
884    
885  double  double
886    Data::Linf() const
887    {
888      //
889      // set the initial absolute minimum value to max double
890      return algorithm(DataAlgorithmAdapter<AbsMin>(numeric_limits<double>::max()));
891    }
892    
893    double
894  Data::sup() const  Data::sup() const
895  {  {
896    //    //
# Line 616  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 1042  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 1099  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  
1450  void  void
1451  Data::setTaggedValue(int tagKey,  Data::archiveData(const std::string fileName)
                      const DataArrayView& value)  
1452  {  {
1453      cout << "Archiving Data object to: " << fileName << endl;
1454    
1455    //    //
1456    // Ensure underlying data object is of type DataTagged    // Determine type of this Data object
1457    tag();    int dataType = -1;
1458    
1459    if (!isTagged()) {    if (isEmpty()) {
1460      throw DataException("Error - DataTagged conversion failed!!");      dataType = 0;
1461        cout << "\tdataType: DataEmpty" << endl;
1462    }    }
1463                                                                                                                    if (isConstant()) {
1464        dataType = 1;
1465        cout << "\tdataType: DataConstant" << endl;
1466      }
1467      if (isTagged()) {
1468        dataType = 2;
1469        cout << "\tdataType: DataTagged" << endl;
1470      }
1471      if (isExpanded()) {
1472        dataType = 3;
1473        cout << "\tdataType: DataExpanded" << endl;
1474      }
1475      if (dataType == -1) {
1476        throw DataException("archiveData Error: undefined dataType");
1477      }
1478    
1479    //    //
1480    // Call DataAbstract::setTaggedValue    // Collect data items common to all Data types
1481    m_data->setTaggedValue(tagKey,value);    int noSamples = getNumSamples();
1482      int noDPPSample = getNumDataPointsPerSample();
1483      int functionSpaceType = getFunctionSpace().getTypeCode();
1484      int dataPointRank = getDataPointRank();
1485      int dataPointSize = getDataPointSize();
1486      int dataLength = getLength();
1487      DataArrayView::ShapeType dataPointShape = getDataPointShape();
1488      int referenceNumbers[noSamples];
1489      for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1490        referenceNumbers[sampleNo] = getFunctionSpace().getReferenceNoFromSampleNo(sampleNo);
1491      }
1492      int tagNumbers[noSamples];
1493      if (isTagged()) {
1494        for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1495          tagNumbers[sampleNo] = getFunctionSpace().getTagFromSampleNo(sampleNo);
1496        }
1497      }
1498    
1499      cout << "\tnoSamples: " << noSamples << " noDPPSample: " << noDPPSample << endl;
1500      cout << "\tfunctionSpaceType: " << functionSpaceType << endl;
1501      cout << "\trank: " << dataPointRank << " size: " << dataPointSize << " length: " << dataLength << endl;
1502    
1503      //
1504      // Flatten Shape to an array of integers suitable for writing to file
1505      int flatShape[4] = {0,0,0,0};
1506      cout << "\tshape: < ";
1507      for (int dim=0; dim<dataPointRank; dim++) {
1508        flatShape[dim] = dataPointShape[dim];
1509        cout << dataPointShape[dim] << " ";
1510      }
1511      cout << ">" << endl;
1512    
1513      //
1514      // Write common data items to archive file
1515      ofstream archiveFile;
1516      archiveFile.open(fileName.data(), ios::out);
1517    
1518      if (!archiveFile.good()) {
1519        throw DataException("archiveData Error: problem opening archive file");
1520      }
1521    
1522      archiveFile.write(reinterpret_cast<char *>(&dataType),sizeof(int));
1523      archiveFile.write(reinterpret_cast<char *>(&noSamples),sizeof(int));
1524      archiveFile.write(reinterpret_cast<char *>(&noDPPSample),sizeof(int));
1525      archiveFile.write(reinterpret_cast<char *>(&functionSpaceType),sizeof(int));
1526      archiveFile.write(reinterpret_cast<char *>(&dataPointRank),sizeof(int));
1527      archiveFile.write(reinterpret_cast<char *>(&dataPointSize),sizeof(int));
1528      archiveFile.write(reinterpret_cast<char *>(&dataLength),sizeof(int));
1529      for (int dim = 0; dim < 4; dim++) {
1530        archiveFile.write(reinterpret_cast<char *>(&flatShape[dim]),sizeof(int));
1531      }
1532      for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1533        archiveFile.write(reinterpret_cast<char *>(&referenceNumbers[sampleNo]),sizeof(int));
1534      }
1535      if (isTagged()) {
1536        for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1537          archiveFile.write(reinterpret_cast<char *>(&tagNumbers[sampleNo]),sizeof(int));
1538        }
1539      }
1540    
1541      if (!archiveFile.good()) {
1542        throw DataException("archiveData Error: problem writing to archive file");
1543      }
1544    
1545      archiveFile.close();
1546    
1547      if (!archiveFile.good()) {
1548        throw DataException("archiveData Error: problem closing archive file");
1549      }
1550    
1551      //
1552      // Collect and archive underlying data values for each Data type
1553      switch (dataType) {
1554        case 0:
1555          // DataEmpty
1556          break;
1557        case 1:
1558          // DataConstant
1559          break;
1560        case 2:
1561          // DataTagged
1562          break;
1563        case 3:
1564          // DataExpanded
1565          break;
1566      }
1567    
1568    }
1569    
1570    void
1571    Data::extractData(const std::string fileName,
1572                      const FunctionSpace& fspace)
1573    {
1574      //
1575      // Can only extract Data to an object which is initially DataEmpty
1576      if (!isEmpty()) {
1577        throw DataException("extractData Error: can only extract to DataEmpty object");
1578      }
1579    
1580      cout << "Extracting Data object from: " << fileName << endl;
1581    
1582      int dataType;
1583      int noSamples;
1584      int noDPPSample;
1585      int functionSpaceType;
1586      int dataPointRank;
1587      int dataPointSize;
1588      int dataLength;
1589      DataArrayView::ShapeType dataPointShape;
1590      int flatShape[4];
1591    
1592      //
1593      // Open the archive file and read common data items
1594      ifstream archiveFile;
1595      archiveFile.open(fileName.data(), ios::in);
1596    
1597      if (!archiveFile.good()) {
1598        throw DataException("extractData Error: problem opening archive file");
1599      }
1600    
1601      archiveFile.read(reinterpret_cast<char *>(&dataType),sizeof(int));
1602      archiveFile.read(reinterpret_cast<char *>(&noSamples),sizeof(int));
1603      archiveFile.read(reinterpret_cast<char *>(&noDPPSample),sizeof(int));
1604      archiveFile.read(reinterpret_cast<char *>(&functionSpaceType),sizeof(int));
1605      archiveFile.read(reinterpret_cast<char *>(&dataPointRank),sizeof(int));
1606      archiveFile.read(reinterpret_cast<char *>(&dataPointSize),sizeof(int));
1607      archiveFile.read(reinterpret_cast<char *>(&dataLength),sizeof(int));
1608      for (int dim = 0; dim < 4; dim++) {
1609        archiveFile.read(reinterpret_cast<char *>(&flatShape[dim]),sizeof(int));
1610        if (flatShape[dim]>0) {
1611          dataPointShape.push_back(flatShape[dim]);
1612        }
1613      }
1614      int referenceNumbers[noSamples];
1615      for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1616        archiveFile.read(reinterpret_cast<char *>(&referenceNumbers[sampleNo]),sizeof(int));
1617      }
1618      int tagNumbers[noSamples];
1619      if (dataType==2) {
1620        for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1621          archiveFile.read(reinterpret_cast<char *>(&tagNumbers[sampleNo]),sizeof(int));
1622        }
1623      }
1624    
1625      if (!archiveFile.good()) {
1626        throw DataException("extractData Error: problem reading from archive file");
1627      }
1628    
1629      archiveFile.close();
1630    
1631      if (!archiveFile.good()) {
1632        throw DataException("extractData Error: problem closing archive file");
1633      }
1634    
1635      switch (dataType) {
1636        case 0:
1637          cout << "\tdataType: DataEmpty" << endl;
1638          break;
1639        case 1:
1640          cout << "\tdataType: DataConstant" << endl;
1641          break;
1642        case 2:
1643          cout << "\tdataType: DataTagged" << endl;
1644          break;
1645        case 3:
1646          cout << "\tdataType: DataExpanded" << endl;
1647          break;
1648        default:
1649          throw DataException("extractData Error: undefined dataType read from archive file");
1650          break;
1651      }
1652    
1653      cout << "\tnoSamples: " << noSamples << " noDPPSample: " << noDPPSample << endl;
1654      cout << "\tfunctionSpaceType: " << functionSpaceType << endl;
1655      cout << "\trank: " << dataPointRank << " size: " << dataPointSize << " length: " << dataLength << endl;
1656      cout << "\tshape: < ";
1657      for (int dim = 0; dim < dataPointRank; dim++) {
1658        cout << dataPointShape[dim] << " ";
1659      }
1660      cout << ">" << endl;
1661    
1662      //
1663      // Verify that supplied FunctionSpace object is compatible with this Data object.
1664      if ( (fspace.getTypeCode()!=functionSpaceType) ||
1665           (fspace.getNumSamples()!=noSamples) ||
1666           (fspace.getNumDPPSample()!=noDPPSample)
1667         ) {
1668        throw DataException("extractData Error: incompatible FunctionSpace");
1669      }
1670      for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1671        if (referenceNumbers[sampleNo] != fspace.getReferenceNoFromSampleNo(sampleNo)) {
1672          throw DataException("extractData Error: incompatible FunctionSpace");
1673        }
1674      }
1675      if (dataType==2) {
1676        for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1677          if (tagNumbers[sampleNo] != fspace.getTagFromSampleNo(sampleNo)) {
1678            throw DataException("extractData Error: incompatible FunctionSpace");
1679          }
1680        }
1681      }
1682    
1683      //
1684      // Construct a DataVector to hold underlying data values
1685      DataVector dataVec(dataLength);
1686    
1687      //
1688      // Load this DataVector with the appropriate values
1689      switch (dataType) {
1690        case 0:
1691          // DataEmpty
1692          break;
1693        case 1:
1694          // DataConstant
1695          break;
1696        case 2:
1697          // DataTagged
1698          break;
1699        case 3:
1700          // DataExpanded
1701          break;
1702      }
1703    
1704      //
1705      // Construct an appropriate Data object
1706      DataAbstract* tempData;
1707      switch (dataType) {
1708        case 0:
1709          // DataEmpty
1710          tempData=new DataEmpty();
1711          break;
1712        case 1:
1713          // DataConstant
1714          tempData=new DataConstant(fspace,dataPointShape,dataVec);
1715          break;
1716        case 2:
1717          // DataTagged
1718          tempData=new DataTagged(fspace,dataPointShape,tagNumbers,dataVec);
1719          break;
1720        case 3:
1721          // DataExpanded
1722          tempData=new DataExpanded(fspace,dataPointShape,dataVec);
1723          break;
1724      }
1725      shared_ptr<DataAbstract> temp_data(tempData);
1726      m_data=temp_data;
1727    
1728  }  }
 */  
1729    
1730  ostream& escript::operator<<(ostream& o, const Data& data)  ostream& escript::operator<<(ostream& o, const Data& data)
1731  {  {

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

  ViewVC Help
Powered by ViewVC 1.1.26