/[escript]/branches/arrexp_2137_win_merge/escript/src/DataVector.cpp
ViewVC logotype

Annotation of /branches/arrexp_2137_win_merge/escript/src/DataVector.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2119 - (hide annotations)
Tue Dec 2 06:06:04 2008 UTC (10 years, 9 months ago) by jfenwick
Original Path: branches/arrexp_trunk2098/escript/src/DataVector.cpp
File size: 7312 byte(s)
Branch commit.
Threading Wrapped Array through the code.
1 jgs 117
2 ksteube 1312 /*******************************************************
3 ksteube 1811 *
4     * Copyright (c) 2003-2008 by University of Queensland
5     * Earth Systems Science Computational Center (ESSCC)
6     * http://www.uq.edu.au/esscc
7     *
8     * Primary Business: Queensland, Australia
9     * Licensed under the Open Software License version 3.0
10     * http://www.opensource.org/licenses/osl-3.0.php
11     *
12     *******************************************************/
13 ksteube 1312
14 ksteube 1811
15 jgs 474 #include "DataVector.h"
16 jgs 117
17 jgs 477 #include "Taipan.h"
18     #include "DataException.h"
19 jfenwick 1796 #include <boost/python/extract.hpp>
20     #include "DataTypes.h"
21 jfenwick 2119 #include "WrappedArray.h"
22 jgs 477
23     #include <cassert>
24    
25 jgs 117 using namespace std;
26 jgs 121 using namespace escript;
27 jfenwick 1796 using namespace boost::python;
28 jgs 117
29     namespace escript {
30    
31 jgs 121 Taipan arrayManager;
32    
33 gross 797 void releaseUnusedMemory()
34     {
35     arrayManager.release_unused_arrays();
36     }
37    
38    
39 jgs 121 DataVector::DataVector() :
40     m_size(0),
41     m_dim(0),
42 jfenwick 1977 m_N(0),
43     m_array_data(0)
44 jgs 121 {
45 jgs 117 }
46    
47 jgs 121 DataVector::DataVector(const DataVector& other) :
48     m_size(other.m_size),
49     m_dim(other.m_dim),
50 jfenwick 1977 m_N(other.m_N),
51     m_array_data(0)
52 jgs 121 {
53     m_array_data = arrayManager.new_array(m_dim,m_N);
54 jgs 122 int i;
55     #pragma omp parallel for private(i) schedule(static)
56     for (i=0; i<m_size; i++) {
57 jgs 121 m_array_data[i] = other.m_array_data[i];
58     }
59 jgs 117 }
60    
61 jgs 121 DataVector::DataVector(const DataVector::size_type size,
62     const DataVector::value_type val,
63     const DataVector::size_type blockSize) :
64     m_size(size),
65 jfenwick 1977 m_dim(blockSize),
66     m_array_data(0)
67 jgs 121 {
68     resize(size, val, blockSize);
69 jgs 117 }
70    
71 jgs 121 DataVector::~DataVector()
72     {
73     // dispose of data array
74 jgs 151 if (m_array_data!=0) {
75     arrayManager.delete_array(m_array_data);
76     }
77 jgs 121
78     // clear data members
79     m_size = -1;
80     m_dim = -1;
81     m_N = -1;
82     m_array_data = 0;
83 jgs 117 }
84    
85 jgs 121 void
86     DataVector::resize(const DataVector::size_type newSize,
87     const DataVector::value_type newValue,
88     const DataVector::size_type newBlockSize)
89     {
90     assert(m_size >= 0);
91    
92 jgs 151 if ( newBlockSize == 0) {
93 ksteube 1250 throw DataException("DataVector: invalid blockSize specified (newBlockSize)");
94 jgs 151 }
95    
96 jgs 121 if ( (newSize % newBlockSize) != 0) {
97     throw DataException("DataVector: invalid blockSize specified");
98     }
99    
100 jgs 151 if (m_array_data!=0) {
101     arrayManager.delete_array(m_array_data);
102     }
103 jgs 121
104     m_size = newSize;
105     m_dim = newBlockSize;
106     m_N = newSize / newBlockSize;
107     m_array_data = arrayManager.new_array(m_dim,m_N);
108    
109 jgs 122 int i;
110     #pragma omp parallel for private(i) schedule(static)
111     for (i=0; i<m_size; i++) {
112     m_array_data[i] = newValue;
113 jgs 121 }
114     }
115    
116     DataVector&
117     DataVector::operator=(const DataVector& other)
118     {
119     assert(m_size >= 0);
120    
121 jgs 151 if (m_array_data!=0) {
122     arrayManager.delete_array(m_array_data);
123     }
124 jgs 121
125     m_size = other.m_size;
126     m_dim = other.m_dim;
127     m_N = other.m_N;
128    
129     m_array_data = arrayManager.new_array(m_dim,m_N);
130 jgs 122 int i;
131     #pragma omp parallel for private(i) schedule(static)
132     for (i=0; i<m_size; i++) {
133 jgs 121 m_array_data[i] = other.m_array_data[i];
134     }
135    
136     return *this;
137     }
138    
139     bool
140     DataVector::operator==(const DataVector& other) const
141     {
142     assert(m_size >= 0);
143    
144     if (m_size!=other.m_size) {
145     return false;
146     }
147     if (m_dim!=other.m_dim) {
148     return false;
149     }
150     if (m_N!=other.m_N) {
151     return false;
152     }
153     for (int i=0; i<m_size; i++) {
154     if (m_array_data[i] != other.m_array_data[i]) {
155     return false;
156     }
157     }
158     return true;
159     }
160    
161     bool
162     DataVector::operator!=(const DataVector& other) const
163     {
164     return !(*this==other);
165     }
166    
167 jfenwick 1796
168     void
169 jfenwick 2119 DataVector::copyFromArray(const WrappedArray& value)
170     {
171     using DataTypes::ValueType;
172     if (m_array_data!=0) {
173     arrayManager.delete_array(m_array_data);
174     }
175     DataTypes::ShapeType tempShape=value.getShape();
176     DataVector::size_type nelements=DataTypes::noValues(tempShape);
177    
178     m_array_data = arrayManager.new_array(1,nelements);
179    
180     int si=0,sj=0,sk=0,sl=0; // bounds for each dimension of the shape
181    
182    
183     if (value.getRank()==0) {
184     m_array_data[0]=value.getElt();
185     } else if (value.getRank()==1) {
186     si=tempShape[0];
187     for (ValueType::size_type i=0;i<si;i++) {
188     m_array_data[i]=value.getElt(i);
189     }
190     } else if (value.getRank()==2) {
191     si=tempShape[0];
192     sj=tempShape[1];
193     for (ValueType::size_type i=0;i<si;i++) {
194     for (ValueType::size_type j=0;j<sj;j++) {
195     m_array_data[DataTypes::getRelIndex(tempShape,i,j)]=value.getElt(i,j);
196     }
197     }
198     } else if (value.getRank()==3) {
199     si=tempShape[0];
200     sj=tempShape[1];
201     sk=tempShape[2];
202     for (ValueType::size_type i=0;i<si;i++) {
203     for (ValueType::size_type j=0;j<sj;j++) {
204     for (ValueType::size_type k=0;k<sk;k++) {
205     m_array_data[DataTypes::getRelIndex(tempShape,i,j,k)]=value.getElt(i,j,k);
206     }
207     }
208     }
209     } else if (value.getRank()==4) {
210     si=tempShape[0];
211     sj=tempShape[1];
212     sk=tempShape[2];
213     sl=tempShape[3];
214     for (ValueType::size_type i=0;i<si;i++) {
215     for (ValueType::size_type j=0;j<sj;j++) {
216     for (ValueType::size_type k=0;k<sk;k++) {
217     for (ValueType::size_type l=0;l<sl;l++) {
218     m_array_data[DataTypes::getRelIndex(tempShape,i,j,k,l)]=value.getElt(i,j,k,l);
219     }
220     }
221     }
222     }
223     }
224     m_size=nelements; // total amount of elements
225     m_dim=m_size; // elements per sample
226     m_N=1; // number of samples
227     }
228    
229     void
230 jfenwick 1796 DataVector::copyFromNumArray(const boost::python::numeric::array& value)
231 jgs 123 {
232 jfenwick 1796 using DataTypes::ValueType;
233     if (m_array_data!=0) {
234     arrayManager.delete_array(m_array_data);
235 jgs 123 }
236    
237    
238 jfenwick 1796 m_array_data = arrayManager.new_array(1,value.nelements());
239    
240     int si=0,sj=0,sk=0,sl=0; // bounds for each dimension of the shape
241     DataTypes::ShapeType tempShape;
242     for (int i=0; i<value.getrank(); i++) {
243     tempShape.push_back(extract<int>(value.getshape()[i]));
244 jgs 123 }
245    
246 jfenwick 1796 if (value.getrank()==0) {
247     m_array_data[0]=extract<double>(value[value.getshape()]);
248     } else if (value.getrank()==1) {
249     si=tempShape[0];
250     for (ValueType::size_type i=0;i<si;i++) {
251     m_array_data[i]=extract<double>(value[i]);
252     }
253     } else if (value.getrank()==2) {
254     si=tempShape[0];
255     sj=tempShape[1];
256     for (ValueType::size_type i=0;i<si;i++) {
257     for (ValueType::size_type j=0;j<sj;j++) {
258     m_array_data[DataTypes::getRelIndex(tempShape,i,j)]=extract<double>(value[i][j]);
259     }
260     }
261     } else if (value.getrank()==3) {
262     si=tempShape[0];
263     sj=tempShape[1];
264     sk=tempShape[2];
265     for (ValueType::size_type i=0;i<si;i++) {
266     for (ValueType::size_type j=0;j<sj;j++) {
267     for (ValueType::size_type k=0;k<sk;k++) {
268     m_array_data[DataTypes::getRelIndex(tempShape,i,j,k)]=extract<double>(value[i][j][k]);
269     }
270     }
271     }
272     } else if (value.getrank()==4) {
273     si=tempShape[0];
274     sj=tempShape[1];
275     sk=tempShape[2];
276     sl=tempShape[3];
277     for (ValueType::size_type i=0;i<si;i++) {
278     for (ValueType::size_type j=0;j<sj;j++) {
279     for (ValueType::size_type k=0;k<sk;k++) {
280     for (ValueType::size_type l=0;l<sl;l++) {
281     m_array_data[DataTypes::getRelIndex(tempShape,i,j,k,l)]=extract<double>(value[i][j][k][l]);
282     }
283     }
284     }
285     }
286     }
287     m_size=value.nelements(); // total amount of elements
288     m_dim=m_size; // elements per sample
289     m_N=1; // number of samples
290 jgs 123 }
291 jfenwick 1796
292 jgs 123
293    
294 jgs 117 } // end of namespace

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26