/[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 2213 - (hide annotations)
Wed Jan 14 00:23:39 2009 UTC (10 years, 8 months ago) by jfenwick
File size: 5747 byte(s)
In preparation for merging to trunk

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 2124 void
168     DataVector::copyFromArrayToOffset(const WrappedArray& value, size_type offset)
169 jfenwick 2119 {
170     using DataTypes::ValueType;
171 jfenwick 2124 const DataTypes::ShapeType& tempShape=value.getShape();
172     size_type len=DataTypes::noValues(tempShape);
173     if (offset+len>size())
174     {
175     cerr << "offset=" << offset << " len=" << len << " >= " << size() << endl;
176     throw DataException("Error - not enough room for that DataPoint at that offset.");
177 jfenwick 2119 }
178 jfenwick 2124 size_t si=0,sj=0,sk=0,sl=0;
179     switch (value.getRank())
180     {
181     case 0:
182     m_array_data[offset]=value.getElt();
183     break;
184     case 1:
185     for (size_t i=0;i<tempShape[0];++i)
186     {
187     m_array_data[offset+i]=value.getElt(i);
188     }
189     break;
190     case 2:
191 jfenwick 2119 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 jfenwick 2124 m_array_data[offset+DataTypes::getRelIndex(tempShape,i,j)]=value.getElt(i,j);
196 jfenwick 2119 }
197     }
198 jfenwick 2124 break;
199     case 3:
200 jfenwick 2119 si=tempShape[0];
201     sj=tempShape[1];
202     sk=tempShape[2];
203     for (ValueType::size_type i=0;i<si;i++) {
204     for (ValueType::size_type j=0;j<sj;j++) {
205     for (ValueType::size_type k=0;k<sk;k++) {
206 jfenwick 2124 m_array_data[offset+DataTypes::getRelIndex(tempShape,i,j,k)]=value.getElt(i,j,k);
207 jfenwick 2119 }
208     }
209     }
210 jfenwick 2124 break;
211     case 4:
212 jfenwick 2119 si=tempShape[0];
213     sj=tempShape[1];
214     sk=tempShape[2];
215     sl=tempShape[3];
216     for (ValueType::size_type i=0;i<si;i++) {
217     for (ValueType::size_type j=0;j<sj;j++) {
218     for (ValueType::size_type k=0;k<sk;k++) {
219     for (ValueType::size_type l=0;l<sl;l++) {
220 jfenwick 2124 m_array_data[offset+DataTypes::getRelIndex(tempShape,i,j,k,l)]=value.getElt(i,j,k,l);
221 jfenwick 2119 }
222     }
223     }
224     }
225 jfenwick 2124 break;
226     default:
227     ostringstream oss;
228     oss << "Error - unknown rank. Rank=" << value.getRank();
229     throw DataException(oss.str());
230     }
231 jfenwick 2119 }
232    
233 jfenwick 2124
234 jfenwick 2119 void
235 jfenwick 2124 DataVector::copyFromArray(const WrappedArray& value)
236     {
237     using DataTypes::ValueType;
238     if (m_array_data!=0) {
239     arrayManager.delete_array(m_array_data);
240     }
241     DataTypes::ShapeType tempShape=value.getShape();
242     DataVector::size_type nelements=DataTypes::noValues(tempShape);
243     m_array_data = arrayManager.new_array(1,nelements);
244     m_size=nelements; // total amount of elements
245     m_dim=m_size; // elements per sample
246     m_N=1; // number of samples
247     copyFromArrayToOffset(value,0);
248     }
249    
250 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