00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #ifndef BARE_FIELD_H
00012 #define BARE_FIELD_H
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "Field/LField.h"
00024 #include "Field/IndexedBareField.h"
00025 #include "Field/GuardCellSizes.h"
00026 #include "Field/FieldLoc.h"
00027 #include "Field/BareFieldIterator.h"
00028 #include "FieldLayout/FieldLayout.h"
00029 #include "FieldLayout/FieldLayoutUser.h"
00030 #include "PETE/IpplExpressions.h"
00031 #include "Index/SIndex.h"
00032 #include "SubField/SubBareField.h"
00033 #include "Utility/IpplInfo.h"
00034 #include "Utility/PAssert.h"
00035 #include "Utility/Unique.h"
00036 #include "Utility/my_auto_ptr.h"
00037 #include "Utility/vmap.h"
00038
00039 #ifdef IPPL_USE_STANDARD_HEADERS
00040 #include <iostream>
00041 using namespace std;
00042 #else
00043 #include <iostream.h>
00044 #endif
00045
00046 #include <stdlib.h>
00047
00048
00049 class Index;
00050 template<unsigned Dim> class NDIndex;
00051 template<unsigned Dim> class FieldLayout;
00052 template<class T, unsigned Dim> class LField;
00053 template<class T, unsigned Dim> class BareField;
00054 template<class T, unsigned Dim>
00055 ostream& operator<<(ostream&, const BareField<T,Dim>&);
00056
00057
00058 template<class T, unsigned Dim>
00059 class BareField : public FieldLayoutUser,
00060 public PETE_Expr< BareField<T,Dim> >
00061 {
00062
00063 public:
00064
00065 typedef T T_t;
00066 typedef FieldLayout<Dim> Layout_t;
00067 typedef LField<T,Dim> LField_t;
00068 enum { Dim_u = Dim };
00069
00070 public:
00071
00072
00073
00074
00075 BareField();
00076
00077
00078 BareField(const BareField<T,Dim>&);
00079
00080
00081 BareField(Layout_t &);
00082 BareField(Layout_t &, const GuardCellSizes<Dim>&);
00083
00084
00085 ~BareField();
00086
00087
00088
00089
00090 void initialize(Layout_t &);
00091 void initialize(Layout_t &, const GuardCellSizes<Dim>&);
00092
00093
00094 typedef vmap< typename Unique::type, my_auto_ptr< LField<T,Dim> > >
00095 ac_id_larray;
00096 typedef typename ac_id_larray::iterator iterator_if;
00097 typedef typename ac_id_larray::const_iterator const_iterator_if;
00098 typedef typename LField<T,Dim>::iterator LFI;
00099
00100
00101 typedef BareFieldIterator<T,Dim> iterator;
00102
00103
00104 iterator_if begin_if() { return Locals_ac.begin(); }
00105 iterator_if end_if() { return Locals_ac.end(); }
00106 const_iterator_if begin_if() const { return Locals_ac.begin(); }
00107 const_iterator_if end_if() const { return Locals_ac.end(); }
00108 typename ac_id_larray::size_type size_if() const { return Locals_ac.size(); }
00109
00110
00111 virtual void fillGuardCells(bool reallyFill = true) const;
00112
00113
00114 void setGuardCells(const T&) const;
00115
00116
00117 void accumGuardCells();
00118
00119
00120 bool isDirty() const { return dirty_m; }
00121 void setDirtyFlag() { if (IpplInfo::deferGuardCellFills) dirty_m = true; }
00122 void clearDirtyFlag() { dirty_m = false; }
00123
00124
00125
00126 void fillGuardCellsIfNotDirty() const
00127 {
00128 if (!isDirty())
00129 fillGuardCells();
00130 else
00131 fillGuardCells(false);
00132 }
00133
00134
00135 Layout_t &getLayout() const
00136 {
00137 PAssert(Layout != 0);
00138 return *Layout;
00139 }
00140
00141
00142
00143
00144 IndexedBareField<T,Dim,1> operator[](const Index& idx);
00145 IndexedBareField<T,Dim,1> operator[](int i);
00146 IndexedBareField<T,Dim,Dim> operator[](const NDIndex<Dim>& nidx);
00147 SubBareField<T,Dim,SIndex<Dim> > operator[](const SIndex<Dim>&);
00148
00149
00150 const GuardCellSizes<Dim>& getGC() const { return Gc; }
00151 const GuardCellSizes<Dim>& getGuardCellSizes() const { return Gc; }
00152 unsigned leftGuard(unsigned d) const { return getGC().left(d); }
00153 unsigned rightGuard(unsigned d) const { return getGC().right(d); }
00154
00155 const Index& getIndex(unsigned d) const {return getLayout().getDomain()[d];}
00156 const NDIndex<Dim>& getDomain() const { return getLayout().getDomain(); }
00157
00158
00159 const BareField<T,Dim>& operator=(T x)
00160 {
00161 assign(*this,x);
00162 return *this;
00163 }
00164
00165
00166 const BareField<T,Dim>&
00167 operator=(const BareField<T,Dim>& x)
00168 {
00169 assign(*this,x);
00170 return *this;
00171 }
00172
00173 template<class X>
00174 const BareField<T,Dim>&
00175 operator=(const BareField<X,Dim>& x)
00176 {
00177 assign(*this,x);
00178 return *this;
00179 }
00180
00181
00182 template<class B>
00183 const BareField<T,Dim>&
00184 operator=(const PETE_Expr<B>& x)
00185 {
00186 assign(*this,x);
00187 return *this;
00188 }
00189
00190
00191
00192
00193
00194
00195 bool compressible() const
00196 {
00197 return compressible_m;
00198 }
00199
00200
00201
00202 double CompressedFraction() const;
00203
00204
00205
00206 void Compress() const;
00207 void Uncompress() const;
00208
00209
00210
00211 void setCompression(bool compress)
00212 {
00213 if (!Ippl::noFieldCompression) {
00214 compressible_m = compress;
00215 if (compress)
00216 Compress();
00217 else
00218 Uncompress();
00219 }
00220 }
00221
00222
00223
00224
00225
00226
00227 virtual void Repartition(UserList *);
00228
00229
00230 virtual void notifyUserOfDelete(UserList *);
00231
00232
00233
00234
00235
00236
00237
00238 iterator begin() const
00239 {
00240 return iterator(const_cast<BareField<T,Dim> &>(*this));
00241 }
00242
00243
00244
00245 iterator end() const
00246 {
00247 return iterator();
00248 }
00249
00250
00251
00252
00253 iterator beginLoc(const FieldLoc<Dim> &loc) const
00254 {
00255 return iterator(loc, const_cast<BareField<T,Dim> &>(*this));
00256 }
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266 void prepareForScalarCode(bool tryfill = true)
00267 {
00268
00269 setCompression(false);
00270
00271
00272 if (tryfill && isDirty())
00273 fillGuardCells(true);
00274
00275
00276 INCIPPLSTAT(incBeginScalarCodes);
00277 }
00278
00279
00280
00281
00282
00283
00284 void finishScalarCode(bool modified = true)
00285 {
00286
00287
00288
00289
00290
00291
00292 if (modified)
00293 {
00294 setDirtyFlag();
00295 fillGuardCellsIfNotDirty();
00296 }
00297
00298
00299 setCompression(true);
00300
00301
00302 INCIPPLSTAT(incEndScalarCodes);
00303 }
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313 T& localElement(const NDIndex<Dim>&) const;
00314
00315
00316
00317 void getsingle(const NDIndex<Dim>&, T&) const;
00318
00319
00320
00321
00322
00323 void write(ostream&);
00324 void write(char*) const;
00325 void writeb(char*) const;
00326
00327
00328
00329
00330
00331 enum { IsExpr = 0 };
00332 typedef iterator PETE_Expr_t;
00333 iterator MakeExpression() const { return begin(); }
00334
00335 protected:
00336
00337 ac_id_larray Locals_ac;
00338
00339 private:
00340 friend class BareFieldIterator<T,Dim>;
00341
00342
00343 void setup();
00344
00345
00346 Layout_t *Layout;
00347
00348
00349 GuardCellSizes<Dim> Gc;
00350
00351
00352
00353
00354 void getsingle_bc(const NDIndex<Dim>&, T&) const;
00355
00356
00357 bool dirty_m;
00358
00359
00360 bool compressible_m;
00361 };
00362
00364
00365
00366
00367
00368
00369 template< class T, unsigned Dim >
00370 inline
00371 BareField<T,Dim>::
00372 BareField()
00373 : Layout(0),
00374 Gc( GuardCellSizes<Dim>(0U) ),
00375 compressible_m(!Ippl::noFieldCompression)
00376 {
00377 }
00378
00379
00380
00381
00382
00383
00384 template< class T, unsigned Dim >
00385 inline
00386 BareField<T,Dim>::
00387 BareField(Layout_t & l)
00388 : Layout(&l),
00389 Gc( GuardCellSizes<Dim>(0U) ),
00390 compressible_m(!Ippl::noFieldCompression)
00391 {
00392 setup();
00393 }
00394
00395
00396
00397
00398
00399
00400 template< class T, unsigned Dim >
00401 inline
00402 BareField<T,Dim>::
00403 BareField(Layout_t & l, const GuardCellSizes<Dim>& g)
00404 : Layout(&l),
00405 Gc(g),
00406 compressible_m(!Ippl::noFieldCompression)
00407 {
00408 setup();
00409 }
00410
00411
00413
00414 template< class T, unsigned Dim >
00415 inline IndexedBareField<T,Dim,1>
00416 BareField<T,Dim>::operator[](const Index& idx)
00417 {
00418 return IndexedBareField<T,Dim,1>(*this,idx);
00419 }
00420
00421 template< class T, unsigned Dim >
00422 inline IndexedBareField<T,Dim,1>
00423 BareField<T,Dim>::operator[](int i)
00424 {
00425 return IndexedBareField<T,Dim,1>(*this,i);
00426 }
00427
00428 template< class T, unsigned Dim >
00429 inline IndexedBareField<T,Dim,Dim>
00430 BareField<T,Dim>::operator[](const NDIndex<Dim>& nidx)
00431 {
00432 return IndexedBareField<T,Dim,Dim>(*this,nidx);
00433 }
00434
00435 template< class T, unsigned Dim >
00436 inline SubBareField<T,Dim,SIndex<Dim> >
00437 BareField<T,Dim>::operator[](const SIndex<Dim>& s)
00438 {
00439 return SubBareField<T,Dim,SIndex<Dim> >(*this, s);
00440 }
00441
00442 template< class T, unsigned Dim >
00443 inline
00444 ostream& operator<<(ostream& out, const BareField<T,Dim>& a)
00445 {
00446 TAU_TYPE_STRING(taustr, "ostream (ostream, " + CT(a) + " )" );
00447 TAU_PROFILE("operator<<()", taustr, TAU_FIELD | TAU_IO);
00448
00449 BareField<T,Dim>& nca = const_cast<BareField<T,Dim>&>(a);
00450 nca.write(out);
00451 return out;
00452 }
00453
00454
00456
00457 #include "Field/BareField.cpp"
00458
00459 #endif // BARE_FIELD_H
00460
00461
00462
00463
00464
00465