/[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 121 by jgs, Fri May 6 04:26:16 2005 UTC revision 151 by jgs, Thu Sep 22 01:55:00 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"
38  #include "escript/Data/DataAlgorithm.h"  #include "escript/Data/DataProf.h"
39  #include "escript/Data/FunctionSpaceFactory.h"  #include "escript/Data/FunctionSpaceFactory.h"
40  #include "escript/Data/AbstractContinuousDomain.h"  #include "escript/Data/AbstractContinuousDomain.h"
41  #include "escript/Data/UnaryFuncs.h"  #include "escript/Data/UnaryFuncs.h"
# Line 45  using namespace boost::python; Line 45  using namespace boost::python;
45  using namespace boost;  using namespace boost;
46  using namespace escript;  using namespace escript;
47    
48    #if defined DOPROF
49    //
50    // global table of profiling data for all Data objects
51    DataProf dataProfTable;
52    #endif
53    
54  Data::Data()  Data::Data()
55  {  {
56    //    //
# Line 52  Data::Data() Line 58  Data::Data()
58    DataAbstract* temp=new DataEmpty();    DataAbstract* temp=new DataEmpty();
59    shared_ptr<DataAbstract> temp_data(temp);    shared_ptr<DataAbstract> temp_data(temp);
60    m_data=temp_data;    m_data=temp_data;
61    #if defined DOPROF
62      // create entry in global profiling table for this object
63      profData = dataProfTable.newData();
64    #endif
65  }  }
66    
67  Data::Data(double value,  Data::Data(double value,
# Line 65  Data::Data(double value, Line 75  Data::Data(double value,
75    }    }
76    DataArray temp(dataPointShape,value);    DataArray temp(dataPointShape,value);
77    initialise(temp.getView(),what,expanded);    initialise(temp.getView(),what,expanded);
78    #if defined DOPROF
79      // create entry in global profiling table for this object
80      profData = dataProfTable.newData();
81    #endif
82  }  }
83    
84  Data::Data(double value,  Data::Data(double value,
# Line 75  Data::Data(double value, Line 89  Data::Data(double value,
89    DataArray temp(dataPointShape,value);    DataArray temp(dataPointShape,value);
90    pair<int,int> dataShape=what.getDataShape();    pair<int,int> dataShape=what.getDataShape();
91    initialise(temp.getView(),what,expanded);    initialise(temp.getView(),what,expanded);
92    #if defined DOPROF
93      // create entry in global profiling table for this object
94      profData = dataProfTable.newData();
95    #endif
96  }  }
97    
98  Data::Data(const Data& inData)  Data::Data(const Data& inData)
99  {  {
100    m_data=inData.m_data;    m_data=inData.m_data;
101    #if defined DOPROF
102      // create entry in global profiling table for this object
103      profData = dataProfTable.newData();
104    #endif
105  }  }
106    
107  Data::Data(const Data& inData,  Data::Data(const Data& inData,
# Line 90  Data::Data(const Data& inData, Line 112  Data::Data(const Data& inData,
112    DataAbstract* tmp = inData.m_data->getSlice(region);    DataAbstract* tmp = inData.m_data->getSlice(region);
113    shared_ptr<DataAbstract> temp_data(tmp);    shared_ptr<DataAbstract> temp_data(tmp);
114    m_data=temp_data;    m_data=temp_data;
115    #if defined DOPROF
116      // create entry in global profiling table for this object
117      profData = dataProfTable.newData();
118    #endif
119  }  }
120    
121  Data::Data(const Data& inData,  Data::Data(const Data& inData,
# Line 99  Data::Data(const Data& inData, Line 125  Data::Data(const Data& inData,
125      m_data=inData.m_data;      m_data=inData.m_data;
126    } else {    } else {
127      Data tmp(0,inData.getPointDataView().getShape(),functionspace,true);      Data tmp(0,inData.getPointDataView().getShape(),functionspace,true);
128      // Note for Lutz, Must use a reference or pointer to a derived object      // Note: Must use a reference or pointer to a derived object
129      // in order to get polymorphic behaviour. Shouldn't really      // in order to get polymorphic behaviour. Shouldn't really
130      // be able to create an instance of AbstractDomain but that was done      // be able to create an instance of AbstractDomain but that was done
131      // as a boost python work around which may no longer be required.      // as a boost:python work around which may no longer be required.
132      const AbstractDomain& inDataDomain=inData.getDomain();      const AbstractDomain& inDataDomain=inData.getDomain();
133      if  (inDataDomain==functionspace.getDomain()) {      if  (inDataDomain==functionspace.getDomain()) {
134        inDataDomain.interpolateOnDomain(tmp,inData);        inDataDomain.interpolateOnDomain(tmp,inData);
# Line 111  Data::Data(const Data& inData, Line 137  Data::Data(const Data& inData,
137      }      }
138      m_data=tmp.m_data;      m_data=tmp.m_data;
139    }    }
140    #if defined DOPROF
141      // create entry in global profiling table for this object
142      profData = dataProfTable.newData();
143    #endif
144  }  }
145    
146  Data::Data(const DataTagged::TagListType& tagKeys,  Data::Data(const DataTagged::TagListType& tagKeys,
# Line 125  Data::Data(const DataTagged::TagListType Line 155  Data::Data(const DataTagged::TagListType
155    if (expanded) {    if (expanded) {
156      expand();      expand();
157    }    }
158    #if defined DOPROF
159      // create entry in global profiling table for this object
160      profData = dataProfTable.newData();
161    #endif
162  }  }
163    
164  Data::Data(const numeric::array& value,  Data::Data(const numeric::array& value,
# Line 132  Data::Data(const numeric::array& value, Line 166  Data::Data(const numeric::array& value,
166             bool expanded)             bool expanded)
167  {  {
168    initialise(value,what,expanded);    initialise(value,what,expanded);
169    #if defined DOPROF
170      // create entry in global profiling table for this object
171      profData = dataProfTable.newData();
172    #endif
173  }  }
174    
175  Data::Data(const DataArrayView& value,  Data::Data(const DataArrayView& value,
# Line 139  Data::Data(const DataArrayView& value, Line 177  Data::Data(const DataArrayView& value,
177             bool expanded)             bool expanded)
178  {  {
179    initialise(value,what,expanded);    initialise(value,what,expanded);
180    #if defined DOPROF
181      // create entry in global profiling table for this object
182      profData = dataProfTable.newData();
183    #endif
184  }  }
185    
186  Data::Data(const object& value,  Data::Data(const object& value,
# Line 147  Data::Data(const object& value, Line 189  Data::Data(const object& value,
189  {  {
190    numeric::array asNumArray(value);    numeric::array asNumArray(value);
191    initialise(asNumArray,what,expanded);    initialise(asNumArray,what,expanded);
192    #if defined DOPROF
193      // create entry in global profiling table for this object
194      profData = dataProfTable.newData();
195    #endif
196  }  }
197    
198  Data::Data(const object& value,  Data::Data(const object& value,
# Line 167  Data::Data(const object& value, Line 213  Data::Data(const object& value,
213      // Create a DataConstant with the same sample shape as other      // Create a DataConstant with the same sample shape as other
214      initialise(temp.getView(),other.getFunctionSpace(),false);      initialise(temp.getView(),other.getFunctionSpace(),false);
215    }    }
216    #if defined DOPROF
217      // create entry in global profiling table for this object
218      profData = dataProfTable.newData();
219    #endif
220    }
221    
222    Data::~Data()
223    {
224    
225  }  }
226    
227  escriptDataC  escriptDataC
# Line 353  Data::reshapeDataPoint(const DataArrayVi Line 408  Data::reshapeDataPoint(const DataArrayVi
408  Data  Data
409  Data::wherePositive() const  Data::wherePositive() const
410  {  {
411    #if defined DOPROF
412      profData->where++;
413    #endif
414    return escript::unaryOp(*this,bind2nd(greater<double>(),0.0));    return escript::unaryOp(*this,bind2nd(greater<double>(),0.0));
415  }  }
416    
417  Data  Data
418  Data::whereNegative() const  Data::whereNegative() const
419  {  {
420    #if defined DOPROF
421      profData->where++;
422    #endif
423    return escript::unaryOp(*this,bind2nd(less<double>(),0.0));    return escript::unaryOp(*this,bind2nd(less<double>(),0.0));
424  }  }
425    
426  Data  Data
427  Data::whereNonNegative() const  Data::whereNonNegative() const
428  {  {
429    #if defined DOPROF
430      profData->where++;
431    #endif
432    return escript::unaryOp(*this,bind2nd(greater_equal<double>(),0.0));    return escript::unaryOp(*this,bind2nd(greater_equal<double>(),0.0));
433  }  }
434    
435  Data  Data
436  Data::whereNonPositive() const  Data::whereNonPositive() const
437  {  {
438    #if defined DOPROF
439      profData->where++;
440    #endif
441    return escript::unaryOp(*this,bind2nd(less_equal<double>(),0.0));    return escript::unaryOp(*this,bind2nd(less_equal<double>(),0.0));
442  }  }
443    
444  Data  Data
445  Data::whereZero() const  Data::whereZero() const
446  {  {
447    #if defined DOPROF
448      profData->where++;
449    #endif
450    return escript::unaryOp(*this,bind2nd(equal_to<double>(),0.0));    return escript::unaryOp(*this,bind2nd(equal_to<double>(),0.0));
451  }  }
452    
453  Data  Data
454  Data::whereNonZero() const  Data::whereNonZero() const
455  {  {
456    #if defined DOPROF
457      profData->where++;
458    #endif
459    return escript::unaryOp(*this,bind2nd(not_equal_to<double>(),0.0));    return escript::unaryOp(*this,bind2nd(not_equal_to<double>(),0.0));
460  }  }
461    
462  Data  Data
463  Data::interpolate(const FunctionSpace& functionspace) const  Data::interpolate(const FunctionSpace& functionspace) const
464  {  {
465    #if defined DOPROF
466      profData->interpolate++;
467    #endif
468    return Data(*this,functionspace);    return Data(*this,functionspace);
469  }  }
470    
# Line 410  Data::probeInterpolation(const FunctionS Line 486  Data::probeInterpolation(const FunctionS
486  Data  Data
487  Data::gradOn(const FunctionSpace& functionspace) const  Data::gradOn(const FunctionSpace& functionspace) const
488  {  {
489    #if defined DOPROF
490      profData->grad++;
491    #endif
492    if (functionspace.getDomain()!=getDomain())    if (functionspace.getDomain()!=getDomain())
493      throw DataException("Error - gradient cannot be calculated on different domains.");      throw DataException("Error - gradient cannot be calculated on different domains.");
494    DataArrayView::ShapeType grad_shape=getPointDataView().getShape();    DataArrayView::ShapeType grad_shape=getPointDataView().getShape();
# Line 443  Data::getDataPointShape() const Line 522  Data::getDataPointShape() const
522    return getPointDataView().getShape();    return getPointDataView().getShape();
523  }  }
524    
525    void
526    Data::fillFromNumArray(const boost::python::numeric::array num_array)
527    {
528      //
529      // check rank
530      if (num_array.getrank()<getDataPointRank())
531          throw DataException("Rank of numarray does not match Data object rank");
532    
533      //
534      // check shape of num_array
535      for (int i=0; i<getDataPointRank(); i++) {
536        if (extract<int>(num_array.getshape()[i+1])!=getDataPointShape()[i])
537           throw DataException("Shape of numarray does not match Data object rank");
538      }
539    
540      //
541      // make sure data is expanded:
542      if (!isExpanded()) {
543        expand();
544      }
545    
546      //
547      // and copy over
548      m_data->copyAll(num_array);
549    }
550    
551  const  const
552  boost::python::numeric::array  boost::python::numeric::array
553  Data::convertToNumArray()  Data::convertToNumArray()
# Line 748  Data::integrate() const Line 853  Data::integrate() const
853    int rank = getDataPointRank();    int rank = getDataPointRank();
854    DataArrayView::ShapeType shape = getDataPointShape();    DataArrayView::ShapeType shape = getDataPointShape();
855    
856    #if defined DOPROF
857      profData->integrate++;
858    #endif
859    
860    //    //
861    // calculate the integral values    // calculate the integral values
862    vector<double> integrals(getDataPointSize());    vector<double> integrals(getDataPointSize());
# Line 811  Data::integrate() const Line 920  Data::integrate() const
920  Data  Data
921  Data::sin() const  Data::sin() const
922  {  {
923    #if defined DOPROF
924      profData->unary++;
925    #endif
926    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::sin);    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::sin);
927  }  }
928    
929  Data  Data
930  Data::cos() const  Data::cos() const
931  {  {
932    #if defined DOPROF
933      profData->unary++;
934    #endif
935    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::cos);    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::cos);
936  }  }
937    
938  Data  Data
939  Data::tan() const  Data::tan() const
940  {  {
941    #if defined DOPROF
942      profData->unary++;
943    #endif
944    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::tan);    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::tan);
945  }  }
946    
947  Data  Data
948    Data::asin() const
949    {
950    #if defined DOPROF
951      profData->unary++;
952    #endif
953      return escript::unaryOp(*this,(Data::UnaryDFunPtr)::asin);
954    }
955    
956    Data
957    Data::acos() const
958    {
959    #if defined DOPROF
960      profData->unary++;
961    #endif
962      return escript::unaryOp(*this,(Data::UnaryDFunPtr)::acos);
963    }
964    
965    Data
966    Data::atan() const
967    {
968    #if defined DOPROF
969      profData->unary++;
970    #endif
971      return escript::unaryOp(*this,(Data::UnaryDFunPtr)::atan);
972    }
973    
974    Data
975    Data::sinh() const
976    {
977    #if defined DOPROF
978      profData->unary++;
979    #endif
980      return escript::unaryOp(*this,(Data::UnaryDFunPtr)::sinh);
981    }
982    
983    Data
984    Data::cosh() const
985    {
986    #if defined DOPROF
987      profData->unary++;
988    #endif
989      return escript::unaryOp(*this,(Data::UnaryDFunPtr)::cosh);
990    }
991    
992    Data
993    Data::tanh() const
994    {
995    #if defined DOPROF
996      profData->unary++;
997    #endif
998      return escript::unaryOp(*this,(Data::UnaryDFunPtr)::tanh);
999    }
1000    
1001    Data
1002    Data::asinh() const
1003    {
1004    #if defined DOPROF
1005      profData->unary++;
1006    #endif
1007      return escript::unaryOp(*this,(Data::UnaryDFunPtr)::asinh);
1008    }
1009    
1010    Data
1011    Data::acosh() const
1012    {
1013    #if defined DOPROF
1014      profData->unary++;
1015    #endif
1016      return escript::unaryOp(*this,(Data::UnaryDFunPtr)::acosh);
1017    }
1018    
1019    Data
1020    Data::atanh() const
1021    {
1022    #if defined DOPROF
1023      profData->unary++;
1024    #endif
1025      return escript::unaryOp(*this,(Data::UnaryDFunPtr)::atanh);
1026    }
1027    
1028    Data
1029  Data::log() const  Data::log() const
1030  {  {
1031    #if defined DOPROF
1032      profData->unary++;
1033    #endif
1034    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::log10);    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::log10);
1035  }  }
1036    
1037  Data  Data
1038  Data::ln() const  Data::ln() const
1039  {  {
1040    #if defined DOPROF
1041      profData->unary++;
1042    #endif
1043    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::log);    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::log);
1044  }  }
1045    
1046  Data  Data
1047  Data::sign() const  Data::sign() const
1048  {  {
1049    #if defined DOPROF
1050      profData->unary++;
1051    #endif
1052    return escript::unaryOp(*this,escript::fsign);    return escript::unaryOp(*this,escript::fsign);
1053  }  }
1054    
1055  Data  Data
1056  Data::abs() const  Data::abs() const
1057  {  {
1058    #if defined DOPROF
1059      profData->unary++;
1060    #endif
1061    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::fabs);    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::fabs);
1062  }  }
1063    
1064  Data  Data
1065  Data::neg() const  Data::neg() const
1066  {  {
1067    #if defined DOPROF
1068      profData->unary++;
1069    #endif
1070    return escript::unaryOp(*this,negate<double>());    return escript::unaryOp(*this,negate<double>());
1071  }  }
1072    
1073  Data  Data
1074  Data::pos() const  Data::pos() const
1075  {  {
1076    return (*this);  #if defined DOPROF
1077      profData->unary++;
1078    #endif
1079      Data result;
1080      // perform a deep copy
1081      result.copy(*this);
1082      return result;
1083  }  }
1084    
1085  Data  Data
1086  Data::exp() const  Data::exp() const
1087  {  {
1088    #if defined DOPROF
1089      profData->unary++;
1090    #endif
1091    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::exp);    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::exp);
1092  }  }
1093    
1094  Data  Data
1095  Data::sqrt() const  Data::sqrt() const
1096  {  {
1097    #if defined DOPROF
1098      profData->unary++;
1099    #endif
1100    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::sqrt);    return escript::unaryOp(*this,(Data::UnaryDFunPtr)::sqrt);
1101  }  }
1102    
1103  double  double
1104  Data::Lsup() const  Data::Lsup() const
1105  {  {
1106    #if defined DOPROF
1107      profData->reduction1++;
1108    #endif
1109    //    //
1110    // set the initial absolute maximum value to zero    // set the initial absolute maximum value to zero
1111    return algorithm(DataAlgorithmAdapter<AbsMax>(0));    AbsMax abs_max_func;
1112      return algorithm(abs_max_func,0);
1113  }  }
1114    
1115  double  double
1116  Data::Linf() const  Data::Linf() const
1117  {  {
1118    #if defined DOPROF
1119      profData->reduction1++;
1120    #endif
1121    //    //
1122    // set the initial absolute minimum value to max double    // set the initial absolute minimum value to max double
1123    return algorithm(DataAlgorithmAdapter<AbsMin>(numeric_limits<double>::max()));    AbsMin abs_min_func;
1124      return algorithm(abs_min_func,numeric_limits<double>::max());
1125  }  }
1126    
1127  double  double
1128  Data::sup() const  Data::sup() const
1129  {  {
1130    #if defined DOPROF
1131      profData->reduction1++;
1132    #endif
1133    //    //
1134    // set the initial maximum value to min possible double    // set the initial maximum value to min possible double
1135    return algorithm(DataAlgorithmAdapter<FMax>(numeric_limits<double>::max()*-1));    FMax fmax_func;
1136      return algorithm(fmax_func,numeric_limits<double>::max()*-1);
1137  }  }
1138    
1139  double  double
1140  Data::inf() const  Data::inf() const
1141  {  {
1142    #if defined DOPROF
1143      profData->reduction1++;
1144    #endif
1145    //    //
1146    // set the initial minimum value to max possible double    // set the initial minimum value to max possible double
1147    return algorithm(DataAlgorithmAdapter<FMin>(numeric_limits<double>::max()));    FMin fmin_func;
1148      return algorithm(fmin_func,numeric_limits<double>::max());
1149  }  }
1150    
1151  Data  Data
1152  Data::maxval() const  Data::maxval() const
1153  {  {
1154    #if defined DOPROF
1155      profData->reduction2++;
1156    #endif
1157    //    //
1158    // set the initial maximum value to min possible double    // set the initial maximum value to min possible double
1159    return dp_algorithm(DataAlgorithmAdapter<FMax>(numeric_limits<double>::max()*-1));    FMax fmax_func;
1160      return dp_algorithm(fmax_func,numeric_limits<double>::max()*-1);
1161  }  }
1162    
1163  Data  Data
1164  Data::minval() const  Data::minval() const
1165  {  {
1166    #if defined DOPROF
1167      profData->reduction2++;
1168    #endif
1169    //    //
1170    // set the initial minimum value to max possible double    // set the initial minimum value to max possible double
1171    return dp_algorithm(DataAlgorithmAdapter<FMin>(numeric_limits<double>::max()));    FMin fmin_func;
1172  }    return dp_algorithm(fmin_func,numeric_limits<double>::max());
   
 const boost::python::tuple  
 Data::mindp() const  
 {  
   Data temp=minval();  
   
   int numSamples=temp.getNumSamples();  
   int numDPPSample=temp.getNumDataPointsPerSample();  
   
   int i,j,lowi=0,lowj=0;  
   double min=numeric_limits<double>::max();  
   
   for (i=0; i<numSamples; i++) {  
     for (j=0; j<numDPPSample; j++) {  
       double next=temp.getDataPoint(i,j)();  
       if (next<min) {  
         min=next;  
         lowi=i;  
         lowj=j;  
       }  
     }  
   }  
   
   return make_tuple(lowi,lowj);  
1173  }  }
1174    
1175  Data  Data
1176  Data::length() const  Data::length() const
1177  {  {
1178    return dp_algorithm(DataAlgorithmAdapter<Length>(0));  #if defined DOPROF
1179      profData->reduction2++;
1180    #endif
1181      Length len_func;
1182      return dp_algorithm(len_func,0);
1183  }  }
1184    
1185  Data  Data
1186  Data::trace() const  Data::trace() const
1187  {  {
1188    return dp_algorithm(DataAlgorithmAdapter<Trace>(0));  #if defined DOPROF
1189      profData->reduction2++;
1190    #endif
1191      Trace trace_func;
1192      return dp_algorithm(trace_func,0);
1193  }  }
1194    
1195  Data  Data
1196  Data::transpose(int axis) const  Data::transpose(int axis) const
1197  {  {
1198    #if defined DOPROF
1199      profData->reduction2++;
1200    #endif
1201    // not implemented    // not implemented
1202    throw DataException("Error - Data::transpose not implemented yet.");    throw DataException("Error - Data::transpose not implemented yet.");
1203    return Data();    return Data();
1204  }  }
1205    
1206    const boost::python::tuple
1207    Data::mindp() const
1208    {
1209      // NB: calc_mindp had to be split off from mindp as boost::make_tuple causes an
1210      // abort (for unknown reasons) if there are openmp directives with it in the
1211      // surrounding function
1212    
1213      int SampleNo;
1214      int DataPointNo;
1215    
1216      calc_mindp(SampleNo,DataPointNo);
1217    
1218      return make_tuple(SampleNo,DataPointNo);
1219    }
1220    
1221    void
1222    Data::calc_mindp(int& SampleNo,
1223                     int& DataPointNo) const
1224    {
1225      int i,j;
1226      int lowi=0,lowj=0;
1227      double min=numeric_limits<double>::max();
1228    
1229      Data temp=minval();
1230    
1231      int numSamples=temp.getNumSamples();
1232      int numDPPSample=temp.getNumDataPointsPerSample();
1233    
1234      double next,local_min;
1235      int local_lowi,local_lowj;
1236    
1237      #pragma omp parallel private(next,local_min,local_lowi,local_lowj)
1238      {
1239        local_min=min;
1240        #pragma omp for private(i,j) schedule(static)
1241        for (i=0; i<numSamples; i++) {
1242          for (j=0; j<numDPPSample; j++) {
1243            next=temp.getDataPoint(i,j)();
1244            if (next<local_min) {
1245              local_min=next;
1246              local_lowi=i;
1247              local_lowj=j;
1248            }
1249          }
1250        }
1251        #pragma omp critical
1252        if (local_min<min) {
1253          min=local_min;
1254          lowi=local_lowi;
1255          lowj=local_lowj;
1256        }
1257      }
1258    
1259      SampleNo = lowi;
1260      DataPointNo = lowj;
1261    }
1262    
1263  void  void
1264  Data::saveDX(std::string fileName) const  Data::saveDX(std::string fileName) const
1265  {  {
# Line 984  Data::saveVTK(std::string fileName) cons Line 1277  Data::saveVTK(std::string fileName) cons
1277  Data&  Data&
1278  Data::operator+=(const Data& right)  Data::operator+=(const Data& right)
1279  {  {
1280    #if defined DOPROF
1281      profData->binary++;
1282    #endif
1283    binaryOp(right,plus<double>());    binaryOp(right,plus<double>());
1284    return (*this);    return (*this);
1285  }  }
# Line 991  Data::operator+=(const Data& right) Line 1287  Data::operator+=(const Data& right)
1287  Data&  Data&
1288  Data::operator+=(const boost::python::object& right)  Data::operator+=(const boost::python::object& right)
1289  {  {
1290    #if defined DOPROF
1291      profData->binary++;
1292    #endif
1293    binaryOp(right,plus<double>());    binaryOp(right,plus<double>());
1294    return (*this);    return (*this);
1295  }  }
# Line 998  Data::operator+=(const boost::python::ob Line 1297  Data::operator+=(const boost::python::ob
1297  Data&  Data&
1298  Data::operator-=(const Data& right)  Data::operator-=(const Data& right)
1299  {  {
1300    #if defined DOPROF
1301      profData->binary++;
1302    #endif
1303    binaryOp(right,minus<double>());    binaryOp(right,minus<double>());
1304    return (*this);    return (*this);
1305  }  }
# Line 1005  Data::operator-=(const Data& right) Line 1307  Data::operator-=(const Data& right)
1307  Data&  Data&
1308  Data::operator-=(const boost::python::object& right)  Data::operator-=(const boost::python::object& right)
1309  {  {
1310    #if defined DOPROF
1311      profData->binary++;
1312    #endif
1313    binaryOp(right,minus<double>());    binaryOp(right,minus<double>());
1314    return (*this);    return (*this);
1315  }  }
# Line 1012  Data::operator-=(const boost::python::ob Line 1317  Data::operator-=(const boost::python::ob
1317  Data&  Data&
1318  Data::operator*=(const Data& right)  Data::operator*=(const Data& right)
1319  {  {
1320    #if defined DOPROF
1321      profData->binary++;
1322    #endif
1323    binaryOp(right,multiplies<double>());    binaryOp(right,multiplies<double>());
1324    return (*this);    return (*this);
1325  }  }
# Line 1019  Data::operator*=(const Data& right) Line 1327  Data::operator*=(const Data& right)
1327  Data&  Data&
1328  Data::operator*=(const boost::python::object& right)  Data::operator*=(const boost::python::object& right)
1329  {  {
1330    #if defined DOPROF
1331      profData->binary++;
1332    #endif
1333    binaryOp(right,multiplies<double>());    binaryOp(right,multiplies<double>());
1334    return (*this);    return (*this);
1335  }  }
# Line 1026  Data::operator*=(const boost::python::ob Line 1337  Data::operator*=(const boost::python::ob
1337  Data&  Data&
1338  Data::operator/=(const Data& right)  Data::operator/=(const Data& right)
1339  {  {
1340    #if defined DOPROF
1341      profData->binary++;
1342    #endif
1343    binaryOp(right,divides<double>());    binaryOp(right,divides<double>());
1344    return (*this);    return (*this);
1345  }  }
# Line 1033  Data::operator/=(const Data& right) Line 1347  Data::operator/=(const Data& right)
1347  Data&  Data&
1348  Data::operator/=(const boost::python::object& right)  Data::operator/=(const boost::python::object& right)
1349  {  {
1350    #if defined DOPROF
1351      profData->binary++;
1352    #endif
1353    binaryOp(right,divides<double>());    binaryOp(right,divides<double>());
1354    return (*this);    return (*this);
1355  }  }
# Line 1040  Data::operator/=(const boost::python::ob Line 1357  Data::operator/=(const boost::python::ob
1357  Data  Data
1358  Data::powO(const boost::python::object& right) const  Data::powO(const boost::python::object& right) const
1359  {  {
1360    #if defined DOPROF
1361      profData->binary++;
1362    #endif
1363    Data result;    Data result;
1364    result.copy(*this);    result.copy(*this);
1365    result.binaryOp(right,(Data::BinaryDFunPtr)::pow);    result.binaryOp(right,(Data::BinaryDFunPtr)::pow);
# Line 1049  Data::powO(const boost::python::object& Line 1369  Data::powO(const boost::python::object&
1369  Data  Data
1370  Data::powD(const Data& right) const  Data::powD(const Data& right) const
1371  {  {
1372    #if defined DOPROF
1373      profData->binary++;
1374    #endif
1375    Data result;    Data result;
1376    result.copy(*this);    result.copy(*this);
1377    result.binaryOp(right,(Data::BinaryDFunPtr)::pow);    result.binaryOp(right,(Data::BinaryDFunPtr)::pow);
# Line 1056  Data::powD(const Data& right) const Line 1379  Data::powD(const Data& right) const
1379  }  }
1380    
1381  //  //
1382  // NOTE: It is essential to specify the namepsace this operator belongs to  // NOTE: It is essential to specify the namespace this operator belongs to
1383  Data  Data
1384  escript::operator+(const Data& left, const Data& right)  escript::operator+(const Data& left, const Data& right)
1385  {  {
# Line 1069  escript::operator+(const Data& left, con Line 1392  escript::operator+(const Data& left, con
1392  }  }
1393    
1394  //  //
1395  // NOTE: It is essential to specify the namepsace this operator belongs to  // NOTE: It is essential to specify the namespace this operator belongs to
1396  Data  Data
1397  escript::operator-(const Data& left, const Data& right)  escript::operator-(const Data& left, const Data& right)
1398  {  {
# Line 1082  escript::operator-(const Data& left, con Line 1405  escript::operator-(const Data& left, con
1405  }  }
1406    
1407  //  //
1408  // NOTE: It is essential to specify the namepsace this operator belongs to  // NOTE: It is essential to specify the namespace this operator belongs to
1409  Data  Data
1410  escript::operator*(const Data& left, const Data& right)  escript::operator*(const Data& left, const Data& right)
1411  {  {
# Line 1095  escript::operator*(const Data& left, con Line 1418  escript::operator*(const Data& left, con
1418  }  }
1419    
1420  //  //
1421  // NOTE: It is essential to specify the namepsace this operator belongs to  // NOTE: It is essential to specify the namespace this operator belongs to
1422  Data  Data
1423  escript::operator/(const Data& left, const Data& right)  escript::operator/(const Data& left, const Data& right)
1424  {  {
# Line 1108  escript::operator/(const Data& left, con Line 1431  escript::operator/(const Data& left, con
1431  }  }
1432    
1433  //  //
1434  // NOTE: It is essential to specify the namepsace this operator belongs to  // NOTE: It is essential to specify the namespace this operator belongs to
1435  Data  Data
1436  escript::operator+(const Data& left, const boost::python::object& right)  escript::operator+(const Data& left, const boost::python::object& right)
1437  {  {
# Line 1124  escript::operator+(const Data& left, con Line 1447  escript::operator+(const Data& left, con
1447  }  }
1448    
1449  //  //
1450  // NOTE: It is essential to specify the namepsace this operator belongs to  // NOTE: It is essential to specify the namespace this operator belongs to
1451  Data  Data
1452  escript::operator-(const Data& left, const boost::python::object& right)  escript::operator-(const Data& left, const boost::python::object& right)
1453  {  {
# Line 1140  escript::operator-(const Data& left, con Line 1463  escript::operator-(const Data& left, con
1463  }  }
1464    
1465  //  //
1466  // NOTE: It is essential to specify the namepsace this operator belongs to  // NOTE: It is essential to specify the namespace this operator belongs to
1467  Data  Data
1468  escript::operator*(const Data& left, const boost::python::object& right)  escript::operator*(const Data& left, const boost::python::object& right)
1469  {  {
# Line 1156  escript::operator*(const Data& left, con Line 1479  escript::operator*(const Data& left, con
1479  }  }
1480    
1481  //  //
1482  // NOTE: It is essential to specify the namepsace this operator belongs to  // NOTE: It is essential to specify the namespace this operator belongs to
1483  Data  Data
1484  escript::operator/(const Data& left, const boost::python::object& right)  escript::operator/(const Data& left, const boost::python::object& right)
1485  {  {
# Line 1172  escript::operator/(const Data& left, con Line 1495  escript::operator/(const Data& left, con
1495  }  }
1496    
1497  //  //
1498  // NOTE: It is essential to specify the namepsace this operator belongs to  // NOTE: It is essential to specify the namespace this operator belongs to
1499  Data  Data
1500  escript::operator+(const boost::python::object& left, const Data& right)  escript::operator+(const boost::python::object& left, const Data& right)
1501  {  {
# Line 1185  escript::operator+(const boost::python:: Line 1508  escript::operator+(const boost::python::
1508  }  }
1509    
1510  //  //
1511  // NOTE: It is essential to specify the namepsace this operator belongs to  // NOTE: It is essential to specify the namespace this operator belongs to
1512  Data  Data
1513  escript::operator-(const boost::python::object& left, const Data& right)  escript::operator-(const boost::python::object& left, const Data& right)
1514  {  {
# Line 1198  escript::operator-(const boost::python:: Line 1521  escript::operator-(const boost::python::
1521  }  }
1522    
1523  //  //
1524  // NOTE: It is essential to specify the namepsace this operator belongs to  // NOTE: It is essential to specify the namespace this operator belongs to
1525  Data  Data
1526  escript::operator*(const boost::python::object& left, const Data& right)  escript::operator*(const boost::python::object& left, const Data& right)
1527  {  {
# Line 1211  escript::operator*(const boost::python:: Line 1534  escript::operator*(const boost::python::
1534  }  }
1535    
1536  //  //
1537  // NOTE: It is essential to specify the namepsace this operator belongs to  // NOTE: It is essential to specify the namespace this operator belongs to
1538  Data  Data
1539  escript::operator/(const boost::python::object& left, const Data& right)  escript::operator/(const boost::python::object& left, const Data& right)
1540  {  {
# Line 1224  escript::operator/(const boost::python:: Line 1547  escript::operator/(const boost::python::
1547  }  }
1548    
1549  //  //
 // NOTE: It is essential to specify the namepsace this operator belongs to  
1550  //bool escript::operator==(const Data& left, const Data& right)  //bool escript::operator==(const Data& left, const Data& right)
1551  //{  //{
1552  //  /*  //  /*
# Line 1286  Data::getItem(const boost::python::objec Line 1608  Data::getItem(const boost::python::objec
1608  Data  Data
1609  Data::getSlice(const DataArrayView::RegionType& region) const  Data::getSlice(const DataArrayView::RegionType& region) const
1610  {  {
1611    #if defined DOPROF
1612      profData->slicing++;
1613    #endif
1614    return Data(*this,region);    return Data(*this,region);
1615  }  }
1616    
# Line 1302  Data::setItemD(const boost::python::obje Line 1627  Data::setItemD(const boost::python::obje
1627                 const Data& value)                 const Data& value)
1628  {  {
1629    const DataArrayView& view=getPointDataView();    const DataArrayView& view=getPointDataView();
1630    
1631    DataArrayView::RegionType slice_region=view.getSliceRegion(key);    DataArrayView::RegionType slice_region=view.getSliceRegion(key);
1632    if (slice_region.size()!=view.getRank()) {    if (slice_region.size()!=view.getRank()) {
1633      throw DataException("Error - slice size does not match Data rank.");      throw DataException("Error - slice size does not match Data rank.");
# Line 1317  void Line 1643  void
1643  Data::setSlice(const Data& value,  Data::setSlice(const Data& value,
1644                 const DataArrayView::RegionType& region)                 const DataArrayView::RegionType& region)
1645  {  {
1646    #if defined DOPROF
1647      profData->slicing++;
1648    #endif
1649    Data tempValue(value);    Data tempValue(value);
1650    typeMatchLeft(tempValue);    typeMatchLeft(tempValue);
1651    typeMatchRight(tempValue);    typeMatchRight(tempValue);
# Line 1389  Data::setTaggedValueFromCPP(int tagKey, Line 1718  Data::setTaggedValueFromCPP(int tagKey,
1718    m_data->setTaggedValue(tagKey,value);    m_data->setTaggedValue(tagKey,value);
1719  }  }
1720    
1721    int
1722    Data::getTagNumber(int dpno)
1723    {
1724      return m_data->getTagNumber(dpno);
1725    }
1726    
1727  void  void
1728  Data::setRefValue(int ref,  Data::setRefValue(int ref,
1729                    const boost::python::numeric::array& value)                    const boost::python::numeric::array& value)
# Line 1428  Data::getRefValue(int ref, Line 1763  Data::getRefValue(int ref,
1763    DataArrayView valueView = valueDataArray.getView();    DataArrayView valueView = valueDataArray.getView();
1764    
1765    if (rank==0) {    if (rank==0) {
1766      throw DataException("Data::getRefValue error: only rank 1 data handled for now.");        boost::python::numeric::array temp_numArray(valueView());
1767          value = temp_numArray;
1768    }    }
1769    if (rank==1) {    if (rank==1) {
1770      for (int i=0; i < shape[0]; i++) {      for (int i=0; i < shape[0]; i++) {
# Line 1436  Data::getRefValue(int ref, Line 1772  Data::getRefValue(int ref,
1772      }      }
1773    }    }
1774    if (rank==2) {    if (rank==2) {
1775      throw DataException("Data::getRefValue error: only rank 1 data handled for now.");      for (int i=0; i < shape[0]; i++) {
1776          for (int j=0; j < shape[1]; j++) {
1777            value[i][j] = valueView(i,j);
1778          }
1779        }
1780    }    }
1781    if (rank==3) {    if (rank==3) {
1782      throw DataException("Data::getRefValue error: only rank 1 data handled for now.");      for (int i=0; i < shape[0]; i++) {
1783          for (int j=0; j < shape[1]; j++) {
1784            for (int k=0; k < shape[2]; k++) {
1785              value[i][j][k] = valueView(i,j,k);
1786            }
1787          }
1788        }
1789    }    }
1790    if (rank==4) {    if (rank==4) {
1791      throw DataException("Data::getRefValue error: only rank 1 data handled for now.");      for (int i=0; i < shape[0]; i++) {
1792          for (int j=0; j < shape[1]; j++) {
1793            for (int k=0; k < shape[2]; k++) {
1794              for (int l=0; l < shape[3]; l++) {
1795                value[i][j][k][l] = valueView(i,j,k,l);
1796              }
1797            }
1798          }
1799        }
1800    }    }
1801    
1802  }  }
# Line 1472  Data::archiveData(const std::string file Line 1826  Data::archiveData(const std::string file
1826      dataType = 3;      dataType = 3;
1827      cout << "\tdataType: DataExpanded" << endl;      cout << "\tdataType: DataExpanded" << endl;
1828    }    }
1829    
1830    if (dataType == -1) {    if (dataType == -1) {
1831      throw DataException("archiveData Error: undefined dataType");      throw DataException("archiveData Error: undefined dataType");
1832    }    }
# Line 1511  Data::archiveData(const std::string file Line 1866  Data::archiveData(const std::string file
1866    cout << ">" << endl;    cout << ">" << endl;
1867    
1868    //    //
1869    // Write common data items to archive file    // Open archive file
1870    ofstream archiveFile;    ofstream archiveFile;
1871    archiveFile.open(fileName.data(), ios::out);    archiveFile.open(fileName.data(), ios::out);
1872    
# Line 1519  Data::archiveData(const std::string file Line 1874  Data::archiveData(const std::string file
1874      throw DataException("archiveData Error: problem opening archive file");      throw DataException("archiveData Error: problem opening archive file");
1875    }    }
1876    
1877      //
1878      // Write common data items to archive file
1879    archiveFile.write(reinterpret_cast<char *>(&dataType),sizeof(int));    archiveFile.write(reinterpret_cast<char *>(&dataType),sizeof(int));
1880    archiveFile.write(reinterpret_cast<char *>(&noSamples),sizeof(int));    archiveFile.write(reinterpret_cast<char *>(&noSamples),sizeof(int));
1881    archiveFile.write(reinterpret_cast<char *>(&noDPPSample),sizeof(int));    archiveFile.write(reinterpret_cast<char *>(&noDPPSample),sizeof(int));
# Line 1542  Data::archiveData(const std::string file Line 1899  Data::archiveData(const std::string file
1899      throw DataException("archiveData Error: problem writing to archive file");      throw DataException("archiveData Error: problem writing to archive file");
1900    }    }
1901    
   archiveFile.close();  
   
   if (!archiveFile.good()) {  
     throw DataException("archiveData Error: problem closing archive file");  
   }  
   
1902    //    //
1903    // Collect and archive underlying data values for each Data type    // Archive underlying data values for each Data type
1904      int noValues;
1905    switch (dataType) {    switch (dataType) {
1906      case 0:      case 0:
1907        // DataEmpty        // DataEmpty
1908          noValues = 0;
1909          archiveFile.write(reinterpret_cast<char *>(&noValues),sizeof(int));
1910          cout << "\tnoValues: " << noValues << endl;
1911        break;        break;
1912      case 1:      case 1:
1913        // DataConstant        // DataConstant
1914          noValues = m_data->getLength();
1915          archiveFile.write(reinterpret_cast<char *>(&noValues),sizeof(int));
1916          cout << "\tnoValues: " << noValues << endl;
1917          if (m_data->archiveData(archiveFile,noValues)) {
1918            throw DataException("archiveData Error: problem writing data to archive file");
1919          }
1920        break;        break;
1921      case 2:      case 2:
1922        // DataTagged        // DataTagged
1923          noValues = m_data->getLength();
1924          archiveFile.write(reinterpret_cast<char *>(&noValues),sizeof(int));
1925          cout << "\tnoValues: " << noValues << endl;
1926          if (m_data->archiveData(archiveFile,noValues)) {
1927            throw DataException("archiveData Error: problem writing data to archive file");
1928          }
1929        break;        break;
1930      case 3:      case 3:
1931        // DataExpanded        // DataExpanded
1932          noValues = m_data->getLength();
1933          archiveFile.write(reinterpret_cast<char *>(&noValues),sizeof(int));
1934          cout << "\tnoValues: " << noValues << endl;
1935          if (m_data->archiveData(archiveFile,noValues)) {
1936            throw DataException("archiveData Error: problem writing data to archive file");
1937          }
1938        break;        break;
1939    }    }
1940    
1941      if (!archiveFile.good()) {
1942        throw DataException("archiveData Error: problem writing data to archive file");
1943      }
1944    
1945      //
1946      // Close archive file
1947      archiveFile.close();
1948    
1949      if (!archiveFile.good()) {
1950        throw DataException("archiveData Error: problem closing archive file");
1951      }
1952    
1953  }  }
1954    
1955  void  void
# Line 1590  Data::extractData(const std::string file Line 1975  Data::extractData(const std::string file
1975    int flatShape[4];    int flatShape[4];
1976    
1977    //    //
1978    // Open the archive file and read common data items    // Open the archive file
1979    ifstream archiveFile;    ifstream archiveFile;
1980    archiveFile.open(fileName.data(), ios::in);    archiveFile.open(fileName.data(), ios::in);
1981    
# Line 1598  Data::extractData(const std::string file Line 1983  Data::extractData(const std::string file
1983      throw DataException("extractData Error: problem opening archive file");      throw DataException("extractData Error: problem opening archive file");
1984    }    }
1985    
1986      //
1987      // Read common data items from archive file
1988    archiveFile.read(reinterpret_cast<char *>(&dataType),sizeof(int));    archiveFile.read(reinterpret_cast<char *>(&dataType),sizeof(int));
1989    archiveFile.read(reinterpret_cast<char *>(&noSamples),sizeof(int));    archiveFile.read(reinterpret_cast<char *>(&noSamples),sizeof(int));
1990    archiveFile.read(reinterpret_cast<char *>(&noDPPSample),sizeof(int));    archiveFile.read(reinterpret_cast<char *>(&noDPPSample),sizeof(int));
# Line 1626  Data::extractData(const std::string file Line 2013  Data::extractData(const std::string file
2013      throw DataException("extractData Error: problem reading from archive file");      throw DataException("extractData Error: problem reading from archive file");
2014    }    }
2015    
2016    archiveFile.close();    //
2017      // Verify the values just read from the archive file
   if (!archiveFile.good()) {  
     throw DataException("extractData Error: problem closing archive file");  
   }  
   
2018    switch (dataType) {    switch (dataType) {
2019      case 0:      case 0:
2020        cout << "\tdataType: DataEmpty" << endl;        cout << "\tdataType: DataEmpty" << endl;
# Line 1686  Data::extractData(const std::string file Line 2069  Data::extractData(const std::string file
2069    
2070    //    //
2071    // Load this DataVector with the appropriate values    // Load this DataVector with the appropriate values
2072      int noValues;
2073      archiveFile.read(reinterpret_cast<char *>(&noValues),sizeof(int));
2074      cout << "\tnoValues: " << noValues << endl;
2075    switch (dataType) {    switch (dataType) {
2076      case 0:      case 0:
2077        // DataEmpty        // DataEmpty
2078          if (noValues != 0) {
2079            throw DataException("extractData Error: problem reading data from archive file");
2080          }
2081        break;        break;
2082      case 1:      case 1:
2083        // DataConstant        // DataConstant
2084          if (dataVec.extractData(archiveFile,noValues)) {
2085            throw DataException("extractData Error: problem reading data from archive file");
2086          }
2087        break;        break;
2088      case 2:      case 2:
2089        // DataTagged        // DataTagged
2090          if (dataVec.extractData(archiveFile,noValues)) {
2091            throw DataException("extractData Error: problem reading data from archive file");
2092          }
2093        break;        break;
2094      case 3:      case 3:
2095        // DataExpanded        // DataExpanded
2096          if (dataVec.extractData(archiveFile,noValues)) {
2097            throw DataException("extractData Error: problem reading data from archive file");
2098          }
2099        break;        break;
2100    }    }
2101    
2102      if (!archiveFile.good()) {
2103        throw DataException("extractData Error: problem reading from archive file");
2104      }
2105    
2106      //
2107      // Close archive file
2108      archiveFile.close();
2109    
2110      if (!archiveFile.good()) {
2111        throw DataException("extractData Error: problem closing archive file");
2112      }
2113    
2114    //    //
2115    // Construct an appropriate Data object    // Construct an appropriate Data object
2116    DataAbstract* tempData;    DataAbstract* tempData;
# Line 1724  Data::extractData(const std::string file Line 2134  Data::extractData(const std::string file
2134    }    }
2135    shared_ptr<DataAbstract> temp_data(tempData);    shared_ptr<DataAbstract> temp_data(tempData);
2136    m_data=temp_data;    m_data=temp_data;
   
2137  }  }
2138    
2139  ostream& escript::operator<<(ostream& o, const Data& data)  ostream& escript::operator<<(ostream& o, const Data& data)

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

  ViewVC Help
Powered by ViewVC 1.1.26