/[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 2458 by jfenwick, Wed Jun 3 06:18:21 2009 UTC revision 2459 by jfenwick, Thu Jun 4 06:17:54 2009 UTC
# Line 88  using namespace escript; Line 88  using namespace escript;
88  namespace  namespace
89  {  {
90    
91    template <class ARR>
92    inline
93    boost::python::tuple
94    pointToTuple1(const DataTypes::ShapeType& shape, ARR v, unsigned long offset)
95    {
96        using namespace boost::python;
97        using boost::python::tuple;
98        using boost::python::list;
99    
100        list l;
101        unsigned int dim=shape[0];
102        for (size_t i=0;i<dim;++i)
103        {
104        l.append(v[i+offset]);
105        }
106        return tuple(l);
107    }
108    
109    template <class ARR>
110    inline
111    boost::python::tuple
112    pointToTuple2(const DataTypes::ShapeType& shape, ARR v, unsigned long offset)
113    {
114        using namespace boost::python;
115        using boost::python::tuple;
116        using boost::python::list;
117    
118        unsigned int shape0=shape[0];
119        unsigned int shape1=shape[1];
120        list lj;
121        for (size_t j=0;j<shape0;++j)
122        {
123            list li;
124        for (size_t i=0;i<shape1;++i)
125        {
126            li.append(v[offset+DataTypes::getRelIndex(shape,j,i)]);
127        }
128        lj.append(tuple(li));
129        }
130        return tuple(lj);
131    }
132    
133    template <class ARR>
134    inline
135    boost::python::tuple
136    pointToTuple3(const DataTypes::ShapeType& shape, ARR v, unsigned long offset)
137    {
138        using namespace boost::python;
139        using boost::python::tuple;
140        using boost::python::list;
141    
142        unsigned int shape0=shape[0];
143        unsigned int shape1=shape[1];
144        unsigned int shape2=shape[2];
145    
146        list lk;
147        for (size_t k=0;k<shape0;++k)
148        {
149            list lj;
150        for (size_t j=0;j<shape1;++j)
151        {
152            list li;
153            for (size_t i=0;i<shape2;++i)
154            {
155                    li.append(v[DataTypes::getRelIndex(shape,k,j,i)]);
156                }
157            lj.append(tuple(li));
158            }
159            lk.append(tuple(lj));
160        }
161        return tuple(lk);
162    }
163    
164    template <class ARR>
165    inline
166    boost::python::tuple
167    pointToTuple4(const DataTypes::ShapeType& shape, ARR v, unsigned long offset)
168    {
169        using namespace boost::python;
170        using boost::python::tuple;
171        using boost::python::list;
172    
173        unsigned int shape0=shape[0];
174        unsigned int shape1=shape[1];
175        unsigned int shape2=shape[2];
176        unsigned int shape3=shape[3];
177    
178        list ll;
179        for (size_t l=0;l<shape0;++l)
180        {
181            list lk;
182        for (size_t k=0;k<shape1;++k)
183        {
184                list lj;
185                for (size_t j=0;j<shape2;++j)
186                {
187                    list li;
188                    for (size_t i=0;i<shape3;++i)
189                    {
190                        li.append(v[DataTypes::getRelIndex(shape,l,k,j,i)]);
191                    }
192                    lj.append(tuple(li));
193                }
194                lk.append(tuple(lj));
195        }
196            ll.append(tuple(lk));
197        }
198        return tuple(ll);
199    }
200    
201    
202  // This should be safer once the DataC RO changes have been brought in  // This should be safer once the DataC RO changes have been brought in
203  template <class ARR>  template <class ARR>
204  boost::python::tuple  boost::python::tuple
# Line 102  pointToTuple( const DataTypes::ShapeType Line 213  pointToTuple( const DataTypes::ShapeType
213     }     }
214     else if (rank==1)     else if (rank==1)
215     {     {
216      list l;          return pointToTuple1(shape,v,0);
     for (size_t i=0;i<shape[0];++i)  
     {  
        l.append(v[i]);  
     }  
     return tuple(l);  
217     }     }
218     else if (rank==2)     else if (rank==2)
219     {     {
220      list lj;      return pointToTuple2(shape,v,0);
     for (size_t j=0;j<shape[0];++j)  
     {  
        list li;  
        for (size_t i=0;i<shape[1];++i)  
        {  
           li.append(v[DataTypes::getRelIndex(shape,j,i)]);  
        }  
        lj.append(tuple(li));  
     }  
     return tuple(lj);  
221     }     }
222     else if (rank==3)     else if (rank==3)
223     {     {
224      list lk;      return pointToTuple3(shape,v,0);
     for (size_t k=0;k<shape[0];++k)  
     {  
        list lj;  
        for (size_t j=0;j<shape[1];++j)  
        {  
         list li;  
         for (size_t i=0;i<shape[2];++i)  
         {  
            li.append(v[DataTypes::getRelIndex(shape,k,j,i)]);  
         }  
         lj.append(tuple(li));  
        }  
        lk.append(tuple(lj));  
     }  
     return tuple(lk);  
225     }     }
226     else if (rank==4)     else if (rank==4)
227     {     {
228      list ll;      return pointToTuple4(shape,v,0);
     for (size_t l=0;l<shape[0];++l)  
     {  
        list lk;  
        for (size_t k=0;k<shape[1];++k)  
        {  
         list lj;  
         for (size_t j=0;j<shape[2];++j)  
         {  
             list li;  
             for (size_t i=0;i<shape[3];++i)  
             {  
                li.append(v[DataTypes::getRelIndex(shape,l,k,j,i)]);  
             }  
             lj.append(tuple(li));  
         }  
         lk.append(tuple(lj));  
        }  
        ll.append(tuple(lk));  
     }  
     return tuple(ll);  
229     }     }
230     else     else
231       throw DataException("Unknown rank in pointToTuple.");       throw DataException("Unknown rank in pointToTuple.");
# Line 207  Data::Data(double value, Line 268  Data::Data(double value,
268      : m_shared(false), m_lazy(false)      : m_shared(false), m_lazy(false)
269  {  {
270    int len = DataTypes::noValues(dataPointShape);    int len = DataTypes::noValues(dataPointShape);
   
271    DataVector temp_data(len,value,len);    DataVector temp_data(len,value,len);
 //   DataArrayView temp_dataView(temp_data, dataPointShape);  
   
 //   initialise(temp_dataView, what, expanded);  
272    initialise(temp_data, dataPointShape, what, expanded);    initialise(temp_data, dataPointShape, what, expanded);
   
273    m_protected=false;    m_protected=false;
274  }  }
275    
276  Data::Data(const Data& inData)  Data::Data(const Data& inData)
277      : m_shared(false), m_lazy(false)      : m_shared(false), m_lazy(false)
278  {  {
 //   m_data=inData.m_data;  
279    set_m_data(inData.m_data);    set_m_data(inData.m_data);
280    m_protected=inData.isProtected();    m_protected=inData.isProtected();
281  }  }
# Line 242  Data::Data(const Data& inData, Line 297  Data::Data(const Data& inData,
297    //    //
298    // Create Data which is a slice of another Data    // Create Data which is a slice of another Data
299    DataAbstract* tmp = dat->getSlice(region);    DataAbstract* tmp = dat->getSlice(region);
 //   m_data=DataAbstract_ptr(tmp);  
300    set_m_data(DataAbstract_ptr(tmp));    set_m_data(DataAbstract_ptr(tmp));
301    m_protected=false;    m_protected=false;
302    
# Line 257  Data::Data(const Data& inData, Line 311  Data::Data(const Data& inData,
311      throw DataException("Error - will not interpolate for instances of DataEmpty.");      throw DataException("Error - will not interpolate for instances of DataEmpty.");
312    }    }
313    if (inData.getFunctionSpace()==functionspace) {    if (inData.getFunctionSpace()==functionspace) {
 //     m_data=inData.m_data;  
314      set_m_data(inData.m_data);      set_m_data(inData.m_data);
315    }    }
316    else    else
# Line 1008  Data::getDataPointSize() const Line 1061  Data::getDataPointSize() const
1061    return m_data->getNoValues();    return m_data->getNoValues();
1062  }  }
1063    
1064    
1065  DataTypes::ValueType::size_type  DataTypes::ValueType::size_type
1066  Data::getLength() const  Data::getLength() const
1067  {  {
1068    return m_data->getLength();    return m_data->getLength();
1069  }  }
1070    
1071    // does not return tuples for scalars
1072    // There is no parallelism here ... elements need to be added in the correct order.
1073    //   If we could presize the list and then fill in the elements it might work
1074    //   This would need setting elements to be threadsafe.
1075    //   Having mulitple C threads calling into one interpreter is aparently a no-no.
1076    const boost::python::object
1077    Data::toListOfTuples(bool scalarastuple)
1078    {
1079        using namespace boost::python;
1080        if (get_MPISize()>1)
1081        {
1082            throw DataException("::toListOfTuples is not available for MPI with more than one process.");
1083        }
1084        unsigned int rank=getDataPointRank();
1085        unsigned int size=getDataPointSize();
1086        boost::python::list res;
1087        int npoints=getNumDataPoints();
1088        expand();           // This will also resolve if required
1089        const DataTypes::ValueType& vec=getReady()->getVectorRO();
1090        if (rank==0)
1091        {
1092            long count;
1093            if (scalarastuple)
1094            {
1095                for (count=0;count<npoints;++count)
1096                {
1097                    res.append(make_tuple(vec[count]));
1098                }
1099            }
1100            else
1101            {
1102                for (count=0;count<npoints;++count)
1103                {
1104                    res.append(vec[count]);
1105                }
1106            }
1107        }
1108        else if (rank==1)
1109        {
1110            size_t count;
1111            size_t offset=0;
1112            for (count=0;count<npoints;++count,offset+=size)
1113            {
1114            // need to pull a pointer to the start of the element (also need a way to skip to the next element)
1115                res.append(pointToTuple1(getDataPointShape(), vec, offset));
1116            }
1117        }
1118        else if (rank==2)
1119        {
1120            size_t count;
1121            size_t offset=0;
1122            for (count=0;count<npoints;++count,offset+=size)
1123            {
1124            // need to pull a pointer to the start of the element (also need a way to skip to the next element)
1125                res.append(pointToTuple2(getDataPointShape(), vec, offset));
1126            }
1127        }
1128        else if (rank==3)
1129        {
1130            size_t count;
1131            size_t offset=0;
1132            for (count=0;count<npoints;++count,offset+=size)
1133            {
1134            // need to pull a pointer to the start of the element (also need a way to skip to the next element)
1135                res.append(pointToTuple3(getDataPointShape(), vec, offset));
1136            }
1137        }
1138        else if (rank==4)
1139        {
1140            size_t count;
1141            size_t offset=0;
1142            for (count=0;count<npoints;++count,offset+=size)
1143            {
1144            // need to pull a pointer to the start of the element (also need a way to skip to the next element)
1145                res.append(pointToTuple4(getDataPointShape(), vec, offset));
1146            }
1147        }
1148        else
1149        {
1150            throw DataException("Unknown rank in ::toListOfTuples()");
1151        }
1152        return res;
1153    }
1154    
1155  const boost::python::object  const boost::python::object
1156  Data::getValueOfDataPointAsTuple(int dataPointNo)  Data::getValueOfDataPointAsTuple(int dataPointNo)
1157  {  {

Legend:
Removed from v.2458  
changed lines
  Added in v.2459

  ViewVC Help
Powered by ViewVC 1.1.26