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

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

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

revision 117 by jgs, Fri Apr 1 05:48:57 2005 UTC revision 122 by jgs, Thu Jun 9 05:38:05 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"
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  
1449  void  void
1450  Data::setTaggedValue(int tagKey,  Data::archiveData(const std::string fileName)
                      const DataArrayView& value)  
1451  {  {
1452      cout << "Archiving Data object to: " << fileName << endl;
1453    
1454    //    //
1455    // Ensure underlying data object is of type DataTagged    // Determine type of this Data object
1456    tag();    int dataType = -1;
1457    
1458    if (!isTagged()) {    if (isEmpty()) {
1459      throw DataException("Error - DataTagged conversion failed!!");      dataType = 0;
1460        cout << "\tdataType: DataEmpty" << endl;
1461    }    }
1462                                                                                                                    if (isConstant()) {
1463        dataType = 1;
1464        cout << "\tdataType: DataConstant" << endl;
1465      }
1466      if (isTagged()) {
1467        dataType = 2;
1468        cout << "\tdataType: DataTagged" << endl;
1469      }
1470      if (isExpanded()) {
1471        dataType = 3;
1472        cout << "\tdataType: DataExpanded" << endl;
1473      }
1474      if (dataType == -1) {
1475        throw DataException("archiveData Error: undefined dataType");
1476      }
1477    
1478    //    //
1479    // Call DataAbstract::setTaggedValue    // Collect data items common to all Data types
1480    m_data->setTaggedValue(tagKey,value);    int noSamples = getNumSamples();
1481      int noDPPSample = getNumDataPointsPerSample();
1482      int functionSpaceType = getFunctionSpace().getTypeCode();
1483      int dataPointRank = getDataPointRank();
1484      int dataPointSize = getDataPointSize();
1485      int dataLength = getLength();
1486      DataArrayView::ShapeType dataPointShape = getDataPointShape();
1487      int referenceNumbers[noSamples];
1488      for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1489        referenceNumbers[sampleNo] = getFunctionSpace().getReferenceNoFromSampleNo(sampleNo);
1490      }
1491      int tagNumbers[noSamples];
1492      if (isTagged()) {
1493        for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1494          tagNumbers[sampleNo] = getFunctionSpace().getTagFromSampleNo(sampleNo);
1495        }
1496      }
1497    
1498      cout << "\tnoSamples: " << noSamples << " noDPPSample: " << noDPPSample << endl;
1499      cout << "\tfunctionSpaceType: " << functionSpaceType << endl;
1500      cout << "\trank: " << dataPointRank << " size: " << dataPointSize << " length: " << dataLength << endl;
1501    
1502      //
1503      // Flatten Shape to an array of integers suitable for writing to file
1504      int flatShape[4] = {0,0,0,0};
1505      cout << "\tshape: < ";
1506      for (int dim=0; dim<dataPointRank; dim++) {
1507        flatShape[dim] = dataPointShape[dim];
1508        cout << dataPointShape[dim] << " ";
1509      }
1510      cout << ">" << endl;
1511    
1512      //
1513      // Write common data items to archive file
1514      ofstream archiveFile;
1515      archiveFile.open(fileName.data(), ios::out);
1516    
1517      if (!archiveFile.good()) {
1518        throw DataException("archiveData Error: problem opening archive file");
1519      }
1520    
1521      archiveFile.write(reinterpret_cast<char *>(&dataType),sizeof(int));
1522      archiveFile.write(reinterpret_cast<char *>(&noSamples),sizeof(int));
1523      archiveFile.write(reinterpret_cast<char *>(&noDPPSample),sizeof(int));
1524      archiveFile.write(reinterpret_cast<char *>(&functionSpaceType),sizeof(int));
1525      archiveFile.write(reinterpret_cast<char *>(&dataPointRank),sizeof(int));
1526      archiveFile.write(reinterpret_cast<char *>(&dataPointSize),sizeof(int));
1527      archiveFile.write(reinterpret_cast<char *>(&dataLength),sizeof(int));
1528      for (int dim = 0; dim < 4; dim++) {
1529        archiveFile.write(reinterpret_cast<char *>(&flatShape[dim]),sizeof(int));
1530      }
1531      for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1532        archiveFile.write(reinterpret_cast<char *>(&referenceNumbers[sampleNo]),sizeof(int));
1533      }
1534      if (isTagged()) {
1535        for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1536          archiveFile.write(reinterpret_cast<char *>(&tagNumbers[sampleNo]),sizeof(int));
1537        }
1538      }
1539    
1540      if (!archiveFile.good()) {
1541        throw DataException("archiveData Error: problem writing to archive file");
1542      }
1543    
1544      archiveFile.close();
1545    
1546      if (!archiveFile.good()) {
1547        throw DataException("archiveData Error: problem closing archive file");
1548      }
1549    
1550      //
1551      // Collect and archive underlying data values for each Data type
1552      switch (dataType) {
1553        case 0:
1554          // DataEmpty
1555          break;
1556        case 1:
1557          // DataConstant
1558          break;
1559        case 2:
1560          // DataTagged
1561          break;
1562        case 3:
1563          // DataExpanded
1564          break;
1565      }
1566    
1567    }
1568    
1569    void
1570    Data::extractData(const std::string fileName,
1571                      const FunctionSpace& fspace)
1572    {
1573      //
1574      // Can only extract Data to an object which is initially DataEmpty
1575      if (!isEmpty()) {
1576        throw DataException("extractData Error: can only extract to DataEmpty object");
1577      }
1578    
1579      cout << "Extracting Data object from: " << fileName << endl;
1580    
1581      int dataType;
1582      int noSamples;
1583      int noDPPSample;
1584      int functionSpaceType;
1585      int dataPointRank;
1586      int dataPointSize;
1587      int dataLength;
1588      DataArrayView::ShapeType dataPointShape;
1589      int flatShape[4];
1590    
1591      //
1592      // Open the archive file and read common data items
1593      ifstream archiveFile;
1594      archiveFile.open(fileName.data(), ios::in);
1595    
1596      if (!archiveFile.good()) {
1597        throw DataException("extractData Error: problem opening archive file");
1598      }
1599    
1600      archiveFile.read(reinterpret_cast<char *>(&dataType),sizeof(int));
1601      archiveFile.read(reinterpret_cast<char *>(&noSamples),sizeof(int));
1602      archiveFile.read(reinterpret_cast<char *>(&noDPPSample),sizeof(int));
1603      archiveFile.read(reinterpret_cast<char *>(&functionSpaceType),sizeof(int));
1604      archiveFile.read(reinterpret_cast<char *>(&dataPointRank),sizeof(int));
1605      archiveFile.read(reinterpret_cast<char *>(&dataPointSize),sizeof(int));
1606      archiveFile.read(reinterpret_cast<char *>(&dataLength),sizeof(int));
1607      for (int dim = 0; dim < 4; dim++) {
1608        archiveFile.read(reinterpret_cast<char *>(&flatShape[dim]),sizeof(int));
1609        if (flatShape[dim]>0) {
1610          dataPointShape.push_back(flatShape[dim]);
1611        }
1612      }
1613      int referenceNumbers[noSamples];
1614      for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1615        archiveFile.read(reinterpret_cast<char *>(&referenceNumbers[sampleNo]),sizeof(int));
1616      }
1617      int tagNumbers[noSamples];
1618      if (dataType==2) {
1619        for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1620          archiveFile.read(reinterpret_cast<char *>(&tagNumbers[sampleNo]),sizeof(int));
1621        }
1622      }
1623    
1624      if (!archiveFile.good()) {
1625        throw DataException("extractData Error: problem reading from archive file");
1626      }
1627    
1628      archiveFile.close();
1629    
1630      if (!archiveFile.good()) {
1631        throw DataException("extractData Error: problem closing archive file");
1632      }
1633    
1634      switch (dataType) {
1635        case 0:
1636          cout << "\tdataType: DataEmpty" << endl;
1637          break;
1638        case 1:
1639          cout << "\tdataType: DataConstant" << endl;
1640          break;
1641        case 2:
1642          cout << "\tdataType: DataTagged" << endl;
1643          break;
1644        case 3:
1645          cout << "\tdataType: DataExpanded" << endl;
1646          break;
1647        default:
1648          throw DataException("extractData Error: undefined dataType read from archive file");
1649          break;
1650      }
1651    
1652      cout << "\tnoSamples: " << noSamples << " noDPPSample: " << noDPPSample << endl;
1653      cout << "\tfunctionSpaceType: " << functionSpaceType << endl;
1654      cout << "\trank: " << dataPointRank << " size: " << dataPointSize << " length: " << dataLength << endl;
1655      cout << "\tshape: < ";
1656      for (int dim = 0; dim < dataPointRank; dim++) {
1657        cout << dataPointShape[dim] << " ";
1658      }
1659      cout << ">" << endl;
1660    
1661      //
1662      // Verify that supplied FunctionSpace object is compatible with this Data object.
1663      if ( (fspace.getTypeCode()!=functionSpaceType) ||
1664           (fspace.getNumSamples()!=noSamples) ||
1665           (fspace.getNumDPPSample()!=noDPPSample)
1666         ) {
1667        throw DataException("extractData Error: incompatible FunctionSpace");
1668      }
1669      for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1670        if (referenceNumbers[sampleNo] != fspace.getReferenceNoFromSampleNo(sampleNo)) {
1671          throw DataException("extractData Error: incompatible FunctionSpace");
1672        }
1673      }
1674      if (dataType==2) {
1675        for (int sampleNo=0; sampleNo<noSamples; sampleNo++) {
1676          if (tagNumbers[sampleNo] != fspace.getTagFromSampleNo(sampleNo)) {
1677            throw DataException("extractData Error: incompatible FunctionSpace");
1678          }
1679        }
1680      }
1681    
1682      //
1683      // Construct a DataVector to hold underlying data values
1684      DataVector dataVec(dataLength);
1685    
1686      //
1687      // Load this DataVector with the appropriate values
1688      switch (dataType) {
1689        case 0:
1690          // DataEmpty
1691          break;
1692        case 1:
1693          // DataConstant
1694          break;
1695        case 2:
1696          // DataTagged
1697          break;
1698        case 3:
1699          // DataExpanded
1700          break;
1701      }
1702    
1703      //
1704      // Construct an appropriate Data object
1705      DataAbstract* tempData;
1706      switch (dataType) {
1707        case 0:
1708          // DataEmpty
1709          tempData=new DataEmpty();
1710          break;
1711        case 1:
1712          // DataConstant
1713          tempData=new DataConstant(fspace,dataPointShape,dataVec);
1714          break;
1715        case 2:
1716          // DataTagged
1717          tempData=new DataTagged(fspace,dataPointShape,tagNumbers,dataVec);
1718          break;
1719        case 3:
1720          // DataExpanded
1721          tempData=new DataExpanded(fspace,dataPointShape,dataVec);
1722          break;
1723      }
1724      shared_ptr<DataAbstract> temp_data(tempData);
1725      m_data=temp_data;
1726    
1727  }  }
 */  
1728    
1729  ostream& escript::operator<<(ostream& o, const Data& data)  ostream& escript::operator<<(ostream& o, const Data& data)
1730  {  {

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

  ViewVC Help
Powered by ViewVC 1.1.26