00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #ifndef INDEXED_BARE_FIELD_H
00012 #define INDEXED_BARE_FIELD_H
00013
00014
00015 #include "Field/FieldLoc.h"
00016 #include "Utility/PAssert.h"
00017 #include "PETE/IpplExpressions.h"
00018
00019 #ifdef IPPL_USE_STANDARD_HEADERS
00020 #include <iostream>
00021 using namespace std;
00022 #else
00023 #include <iostream.h>
00024 #endif
00025
00026 #include "Field/BareFieldIterator.h"
00027
00028
00029
00030
00031 class Index;
00032 template<unsigned Dim> class NDIndex;
00033 template<class T, unsigned Dim> class LField;
00034 template<class T, unsigned Dim> class BareField;
00035 template<class T, unsigned Dim, unsigned Brackets> class IndexedBareField;
00036 template<class T, unsigned Dim, unsigned Brackets>
00037 ostream& operator<<(ostream&, const IndexedBareField<T,Dim,Brackets>&);
00038
00039
00040
00041
00042
00043
00044
00045 template<unsigned D> class DimTag {};
00046
00047
00048
00049 template<class T, unsigned Dim>
00050 class IndexedBareFieldIterator : public BareField<T,Dim>::iterator
00051 {
00052 public:
00053 enum { Dim_u = Dim };
00054 typedef T return_type;
00055
00056
00057 IndexedBareFieldIterator()
00058 {
00059 }
00060
00061
00062
00063 IndexedBareFieldIterator(BareField<T,Dim>& df, const NDIndex<Dim> &idx)
00064 : BareField<T,Dim>::iterator(df), I(idx)
00065 {
00066
00067
00068 beginLField();
00069 }
00070
00071
00072 ~IndexedBareFieldIterator()
00073 {
00074 }
00075
00076
00077 const NDIndex<Dim>& getDomain() const
00078 {
00079 return I;
00080 }
00081
00082
00083 const BareField<T,Dim>& getBareField() const { return *(this->MyBareField); }
00084 BareField<T,Dim>& getBareField() { return *(this->MyBareField); }
00085
00086
00087 template<unsigned D1, class T1>
00088 void FillGCIfNecessary(const BareField<T1,D1> &lhs) const
00089 {
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099 if (this->GetBareField().isDirty())
00100 {
00101 if ( isStencil(lhs.getDomain(), getDomain()) ||
00102 !(lhs.getLayout() == getBareField().getLayout()) )
00103 {
00104 BareField<T,Dim> &bf =
00105 const_cast<BareField<T,Dim>&>(this->GetBareField());
00106 bf.fillGuardCells();
00107 }
00108 }
00109 }
00110
00111
00112
00113
00114
00115
00116 template<unsigned int D2>
00117 bool
00118 plugBase(const NDIndex<D2>& i)
00119 {
00120 TAU_TYPE_STRING(taustr, "bool (" + CT(*this) + ", " + CT(i) + ", DimTag<D1> )" );
00121 TAU_PROFILE("plugBase()", taustr, TAU_FIELD);
00122
00123
00124
00125
00126 NDIndex<Dim> plugged ( I.plugBase(i) );
00127
00128
00129
00130 typedef typename BareField<T,Dim>::iterator_if BFI;
00131 BFI e = BareFieldIterator<T,Dim>::MyBareField->end_if();
00132 for (BFI lf_i = BareFieldIterator<T,Dim>::MyBareField->begin_if(); lf_i != e ; ++lf_i) {
00133 if ( (*lf_i).second->getAllocated().contains( plugged ) ) {
00134
00135 BareFieldIterator<T,Dim>::CurrentLField = lf_i;
00136 (CompressedBrickIterator<T,Dim>&)(*this) = (*lf_i).second->begin(plugged);
00137 return true;
00138 }
00139 }
00140
00141 return false;
00142 }
00143
00144
00145
00146
00147 void SetCurrentLocation(const FieldLoc<Dim>& loc)
00148 {
00149 BareField<T,Dim>::SetCurrentLocation(loc);
00150 if (!this->done()) {
00151 FieldLoc<Dim> checkloc;
00152 GetCurrentLocation(checkloc);
00153 PAssert(I.contains(checkloc.getDomain()));
00154 }
00155 }
00156
00157
00158 IndexedBareFieldIterator<T,Dim>& operator++()
00159 {
00160 CompressedBrickIterator<T,Dim>::operator++();
00161 if (*this == (*BareFieldIterator<T,Dim>::CurrentLField).second->end())
00162 general_increment();
00163 return *this;
00164 }
00165
00166
00167
00168
00169 void beginLField()
00170 {
00171
00172
00173 CompressedBrickIterator<T,Dim> *c=(CompressedBrickIterator<T,Dim>*)this;
00174
00175
00176 while (!this->done() && ! I.touches((*BareFieldIterator<T,Dim>::CurrentLField).second->getOwned()))
00177 this->nextLField();
00178
00179
00180
00181
00182
00183
00184 if (!this->done())
00185 *c = (*BareFieldIterator<T,Dim>::CurrentLField).second->begin(
00186 I.intersect((*BareFieldIterator<T,Dim>::CurrentLField).second->getOwned()));
00187 else
00188 BareFieldIterator<T,Dim>::LFIndex = (-1);
00189 }
00190
00191 protected:
00192
00193 NDIndex<Dim> I;
00194
00195
00196 void general_increment()
00197 {
00198 this->nextLField();
00199 beginLField();
00200 }
00201 };
00202
00203
00204
00205 template < class T, unsigned Dim, unsigned Brackets >
00206 class IndexedBareField : public PETE_Expr< IndexedBareField<T,Dim,Brackets> >
00207 {
00208
00209 friend class IndexedBareField<T,Dim,Brackets-1>;
00210 friend class BareField<T,Dim>;
00211
00212 public:
00213
00214 typedef T T_t;
00215 enum { Dim_u = Dim };
00216 typedef IndexedBareFieldIterator<T,Dim> iterator;
00217
00218 IndexedBareField<T,Dim,Brackets+1> operator[](const Index& idx)
00219 {
00220 CTAssert(Brackets<Dim);
00221 return IndexedBareField<T,Dim,Brackets+1> (A,Indexes,idx);
00222 }
00223
00224 IndexedBareField<T,Dim,Brackets+1> operator[](int i)
00225 {
00226 CTAssert(Brackets<Dim);
00227 return IndexedBareField<T,Dim,Brackets+1> (A,Indexes,Index(i,i));
00228 }
00229
00230 IndexedBareField<T,Dim,Brackets+1> operator[](const NDIndex<Dim>& ndidx)
00231 {
00232 CTAssert(Brackets<Dim);
00233 return IndexedBareField<T,Dim,Brackets+1> (A,Indexes,ndidx);
00234 }
00235
00236 void operator=(T x)
00237 {
00238 typedef PETE_Scalar<T> S;
00239 assign(*this,x);
00240 }
00241
00242 IndexedBareField<T,Dim,Brackets>&
00243 operator=(const IndexedBareField<T,Dim,Brackets>& x)
00244 {
00245 CTAssert(Dim==Brackets);
00246 assign(*this,x);
00247 return *this;
00248 }
00249
00250 template<class X, unsigned Dim1, unsigned Brackets1>
00251 IndexedBareField<T,Dim,Brackets>&
00252 operator=(const IndexedBareField<X,Dim1,Brackets1>& x)
00253 {
00254 CTAssert(Dim1==Brackets1);
00255 assign(*this,x);
00256 return *this;
00257 }
00258
00259 IndexedBareField<T,Dim,Brackets>&
00260 operator=(const Index& x)
00261 {
00262 assign(*this,x);
00263 return *this;
00264 }
00265
00266 template<class B>
00267 IndexedBareField<T,Dim,Brackets>&
00268 operator=(const PETE_Expr<B>& x)
00269 {
00270 assign(*this,x);
00271 return *this;
00272 }
00273
00274 const NDIndex<Dim>& getDomain() const { return Indexes; }
00275 BareField<T,Dim>& getBareField() { return A; }
00276 const BareField<T,Dim>& getBareField() const { return A; }
00277
00278
00279
00280
00281 PETE_TUTree< OpParens<int>, iterator >
00282 operator()(int arg)
00283 {
00284 CTAssert(Dim==Brackets);
00285 typedef PETE_TUTree< OpParens<int> , iterator > Elem_t;
00286 return Elem_t(arg,begin());
00287 }
00288 PETE_TUTree< OpParens< pair<int,int> >, iterator >
00289 operator()(int a1, int a2)
00290 {
00291 CTAssert(Dim==Brackets);
00292 typedef PETE_TUTree< OpParens< pair<int,int> > , iterator > Elem_t;
00293 return Elem_t(pair<int,int>(a1,a2),begin());
00294 }
00295
00296
00297
00298
00299 T get();
00300
00301
00302 iterator begin() const { return iterator( A, Indexes ); }
00303 iterator end() const { return iterator(); }
00304
00305
00306 void write(ostream&);
00307
00308
00309 enum { IsExpr = 0 };
00310 typedef iterator PETE_Expr_t;
00311 iterator MakeExpression() const { return begin(); }
00312
00313 protected:
00314 BareField<T,Dim> &A;
00315 NDIndex<Brackets> Indexes;
00316
00317
00318
00319 IndexedBareField(BareField<T,Dim> &a, const Index& idx)
00320 : A(a), Indexes(idx) {}
00321 IndexedBareField(BareField<T,Dim> &a, int i)
00322 : A(a), Indexes(Index(i,i)) {}
00323 IndexedBareField(BareField<T,Dim> &a,const NDIndex<Brackets-1>& idx, const Index& i)
00324 : A(a), Indexes(idx,i) {}
00325
00326
00327 IndexedBareField(BareField<T,Dim> &a, const NDIndex<Dim>& ndidx)
00328 : A(a), Indexes(ndidx) {}
00329
00330
00331 void getsingle(T&);
00332 };
00333
00334
00335 template < class T, unsigned Dim, unsigned Brackets >
00336 inline
00337 ostream& operator<<(ostream& out, const IndexedBareField<T,Dim,Brackets>& i) {
00338 TAU_TYPE_STRING(taustr, "ostream (ostream, " + CT(i) + " )" );
00339 TAU_PROFILE("operator<<()", taustr, TAU_FIELD | TAU_IO);
00340 IndexedBareField<T,Dim,Brackets>& nci =
00341 const_cast<IndexedBareField<T,Dim,Brackets>&>(i);
00342 nci.write(out);
00343 return out;
00344 }
00345
00347
00348 #include "Field/IndexedBareField.cpp"
00349
00350 #endif // INDEXED_BARE_FIELD_H
00351
00352
00353
00354
00355
00356