Chombo + EB + MF: IVSFABI.H Source File

00001 #ifdef CH_LANG_CC
00002 /*
00003  *      _______              __
00004  *     / ___/ /  ___  __ _  / /  ___
00005  *    / /__/ _ \/ _ \/  V \/ _ \/ _ \
00006  *    \___/_//_/\___/_/_/_/_.__/\___/
00007  *    Please refer to Copyright.txt, in Chombo's root directory.
00008  */
00009 #endif
00010 
00011 #ifndef _IVSFABI_H_
00012 #define _IVSFABI_H_
00013 
00014 #include "MayDay.H"
00015 #include "IntVectSet.H"
00016 #include "parstream.H"
00017 #include "SPMD.H"
00018 #include "DebugOut.H"
00019 #include "SPMD.H"
00020 #include "NamespaceHeader.H"
00021 
00022 template <class T>
00023 bool IVSFAB<T>::s_verbose = false;
00024 
00025 template <class T>
00026 void
00027 IVSFAB<T>::setVerbose(bool a_verbose)
00028 {
00029   s_verbose = a_verbose;
00030 }
00031 /*************/
00032 template <class T> inline
00033 const IntVectSet&
00034 IVSFAB<T>::getIVS() const
00035 {
00036   return m_ivs;
00037 }
00038 /******************/
00039 template <class T> inline
00040 IVSFAB<T>::IVSFAB()
00041 {
00042   setDefaultValues();
00043 }
00044 /******************/
00045 template <class T> inline
00046 IVSFAB<T>::~IVSFAB()
00047 {
00048   clear();
00049 }
00050 /******************/
00051 template <class T> inline
00052 IVSFAB<T>::IVSFAB(const IntVectSet& a_ivsin,
00053                         const int&        a_nvarin)
00054 {
00055   setDefaultValues();
00056   define(a_ivsin, a_nvarin);
00057 }
00058 /******************/
00059 template <class T> inline
00060 void
00061 IVSFAB<T>::define(const IntVectSet& a_ivsin,
00062                      const int& a_nvarin)
00063 {
00064   clear();
00065   m_isDefined = true;
00066   CH_assert(a_nvarin > 0);
00067   m_ivs = a_ivsin;
00068   m_nComp = a_nvarin;
00069   m_nIvs = 0;
00070   if (!a_ivsin.isEmpty())
00071     {
00072       Box minbox = a_ivsin.minBox();
00073       m_ivmap.resize(minbox, 1);
00074       IVSIterator ivsit(a_ivsin);
00075       for (ivsit.reset(); ivsit.ok(); ++ivsit)
00076         {
00077           const IntVect& iv = ivsit();
00078           m_ivmap(iv,0) = m_nIvs;
00079           m_nIvs++;
00080         }
00081 
00082       if ( (m_nIvs > 0) && m_nComp > 0)
00083         {
00084           m_dataPtr = new T[m_nComp*m_nIvs];
00085         }
00086       else
00087         {
00088           m_dataPtr = NULL;
00089         }
00090     }
00091   else
00092     {
00093       m_dataPtr = NULL;
00094     }
00095   if (m_nIvs > 0)
00096     {
00097       //set up face low and high vectors
00098       for (int dir = 0; dir < CH_SPACEDIM; ++dir)
00099         {
00100           m_loVect[dir] = 1;
00101           m_hiVect[dir] = 1;
00102         }
00103       m_hiVect[0] = m_nIvs;
00104 
00105     }
00106   else
00107     {
00108       m_loVect = IntVect::Unit;
00109       m_hiVect = IntVect::Zero;
00110       m_dataPtr = NULL;
00111     }
00112 
00113 }
00114 /******************/
00115 template <class T> inline
00116 void
00117 IVSFAB<T>::setVal(const T& a_value)
00118 {
00119   CH_assert(isDefined());
00120   for (int ivec = 0; ivec < m_nIvs*m_nComp; ivec++)
00121     m_dataPtr[ivec] = a_value;
00122 }
00123 /******************/
00124 template <class T> inline
00125 void
00126 IVSFAB<T>::copy(const Box& a_fromBox,
00127                    const Interval& a_dstInterval,
00128                    const Box& a_toBox,
00129                    const IVSFAB<T>& a_src,
00130                    const Interval& a_srcInterval)
00131 {
00132   CH_assert(a_fromBox == a_toBox);
00133   CH_assert(isDefined());
00134   CH_assert(a_src.isDefined());
00135   CH_assert(a_srcInterval.size() == a_dstInterval.size());
00136   CH_assert(a_dstInterval.begin() >= 0);
00137   CH_assert(a_srcInterval.begin() >= 0);
00138   CH_assert(a_dstInterval.end()   < m_nComp);
00139   CH_assert(a_srcInterval.end()   < a_src.m_nComp);
00140 
00141   if ((!m_ivs.isEmpty()) && (!a_src.m_ivs.isEmpty()))
00142     {
00143       Box intBox = a_fromBox;
00144       IntVectSet ivsIntersect = m_ivs;
00145       ivsIntersect &= a_src.m_ivs; //how did this ever work without this line?
00146       ivsIntersect &= intBox;  //
00147       IVSFAB<T>& thisFAB = *this;
00148       int compSize = a_srcInterval.size();
00149       for (IVSIterator ivit(ivsIntersect); ivit.ok(); ++ivit)
00150         {
00151           const IntVect& iv = ivit();
00152           for (int icomp = 0; icomp < compSize; icomp++)
00153             {
00154               int isrccomp = a_srcInterval.begin() + icomp;
00155               int idstcomp = a_dstInterval.begin() + icomp;
00156               thisFAB(iv, idstcomp) = a_src(iv, isrccomp);
00157             }
00158         }
00159     }
00160 }
00161 /******************/
00162 
00163 template <> inline
00164 int IVSFAB<Real>::size(const Box& a_region,
00165                        const Interval& a_comps) const
00166 {
00167   // size of actual data plus size of count ..
00168   // specialization for T=Real.
00169   IntVectSet subset = m_ivs & a_region;
00170   int numberThings = subset.numPts();
00171   return numberThings*sizeof(Real)*a_comps.size() + sizeof(int);
00172 }
00173 
00174 template <class T> inline
00175 int IVSFAB<T>::size(const Box& a_region,
00176                        const Interval& a_comps) const
00177 {
00178   // Note:  it is assumed that there is one component.
00179   //        and, that all "T" have equal size.
00180   // message includes count ...
00181   CH_assert( a_comps.begin() == 0 && a_comps.end() == 0 );
00182   IntVectSet subset = m_ivs & a_region;
00183   int numberThings = subset.numPts();
00184   T dummy;
00185   int sizeofThing = dummy.linearSize();
00186   int retval = numberThings*sizeofThing + sizeof(int);
00187   return retval;
00188 }
00189 
00190 
00191 /********************/
00192 template <> inline void IVSFAB<Real>::linearOut(void* a_buf,
00193                              const Box& a_region,
00194                              const Interval& a_comps) const
00195 {
00196   IntVectSet subset = m_ivs & a_region;
00197   int count = subset.numPts();
00198   int* iptr = (int*)a_buf;
00199   *iptr++ = count;
00200   Real* rptr = (Real*)iptr;
00201   for ( IVSIterator ivsit(subset); ivsit.ok(); ++ivsit )
00202   {
00203     const IntVect& iv = ivsit();
00204     for ( int c=a_comps.begin(); c<=a_comps.end(); c++ )
00205     {
00206       int iloc = getIndex(iv, c);
00207       *rptr++ = m_dataPtr[iloc];
00208     }
00209   }
00210   CH_assert( ((char*)rptr) - ((char*)a_buf) == size(a_region,a_comps) );
00211 }
00212 
00213 template <class T> inline
00214 void IVSFAB<T>::linearOut(void* a_buf,
00215                              const Box& a_region,
00216                              const Interval& a_comps) const
00217 {
00218   // Note:  it is assumed that there is one component.
00219   //        and all "T" have equal size.
00220   // message includes count
00221   IntVectSet subset = m_ivs & a_region;
00222   int count = subset.numPts();
00223   int *iptr = (int*)a_buf;
00224   *iptr++ = count;
00225   T dummy;
00226   int Tsz = dummy.linearSize();
00227   char* cptr = (char*)iptr;
00228   for ( IVSIterator ivsit(subset); ivsit.ok(); ++ivsit )
00229   {
00230     const IntVect& iv = ivsit();
00231     int iloc = getIndex(iv, 0); // assume 1 component ...
00232     m_dataPtr[iloc].linearOut( (void*)cptr );
00233     cptr += Tsz;
00234   }
00235   CH_assert( a_comps.begin() == 0 && a_comps.end() == 0 );
00236   CH_assert( cptr - ((char*)a_buf) == size(a_region,a_comps) );
00237 }
00238 /********************/
00239 template <> inline void IVSFAB<Real>::linearIn(void* a_buf, const Box& a_region, const Interval& a_comps)
00240 {
00241   // message includes count
00242   IntVectSet subset = m_ivs & a_region;
00243   int count_expected = subset.numPts();
00244   int *iptr = (int*)a_buf;
00245   int count_received = *iptr++;
00246   if ( count_expected != count_received )
00247     {
00248       MayDay::Error("IVSFAB::linearin: counts do not match");
00249     }
00250   Real* rptr = (Real*)iptr;
00251   for ( IVSIterator ivsit(subset); ivsit.ok(); ++ivsit )
00252   {
00253     const IntVect& iv = ivsit();
00254     for ( int c=a_comps.begin(); c<=a_comps.end(); c++ )
00255     {
00256       int iloc = getIndex(iv, c);
00257       m_dataPtr[iloc] = *rptr++;
00258     }
00259   }
00260   CH_assert( ((char*)rptr) - ((char*)a_buf) == size(a_region,a_comps) );
00261 }
00262 
00263 template <class T> inline
00264 void IVSFAB<T>::linearIn(void* a_buf, const Box& a_region, const Interval& a_comps)
00265 {
00266   // Note:  it is assumed that there is one component.
00267   //        and all "T" have same size
00268   // message includes count
00269   IntVectSet subset = m_ivs & a_region;
00270   int count_expected = subset.numPts();
00271   int *iptr = (int*)a_buf;
00272   int count_received = *iptr++;
00273   CH_assert( count_expected == count_received );
00274   T dummy;
00275   int Tsz = dummy.linearSize();
00276   char* cptr = (char*)iptr;
00277   for ( IVSIterator ivsit(subset); ivsit.ok(); ++ivsit )
00278   {
00279     const IntVect& iv = ivsit();
00280     int iloc = getIndex(iv, 0);
00281     m_dataPtr[iloc].linearIn( (void*)cptr );
00282     cptr += Tsz;
00283   }
00284   CH_assert( a_comps.begin() == 0 && a_comps.end() == 0 );
00285   CH_assert( cptr - ((char*)a_buf) == size(a_region,a_comps) );
00286 }
00287 
00288 template <class T> inline
00289 int
00290 IVSFAB<T>::getIndex(const IntVect& a_iv, const int& a_comp) const
00291 {
00292   CH_assert(isDefined());
00293   CH_assert(m_ivs.contains(a_iv));
00294   CH_assert((a_comp >= 0) && (a_comp < m_nComp));
00295 
00296   int ioffset = m_ivmap(a_iv, 0);
00297   CH_assert(ioffset >= 0);
00298   CH_assert(ioffset < m_nIvs);
00299   //now add offset from componentnitude
00300   ioffset += m_nIvs*a_comp;
00301   return ioffset;
00302 }
00303 /********************/
00304 template <class T> inline
00305 void
00306 IVSFAB<T>::clear()
00307 {
00308   m_nComp = 0;
00309   m_nIvs = 0;
00310   m_ivs.makeEmpty();
00311   m_ivmap.clear();
00312   if (m_dataPtr != NULL)
00313     {
00314       delete[] m_dataPtr;
00315       m_dataPtr = NULL;
00316     }
00317   m_isDefined = false;
00318 }
00319 /*************************/
00320 template <class T> inline
00321 bool
00322 IVSFAB<T>::isDefined() const
00323 {
00324   return (m_isDefined);
00325 }
00326 /*************************/
00327 template <class T> inline
00328 int
00329 IVSFAB<T>::numIvs() const
00330 {
00331   return m_nIvs;
00332 }
00333 /*************************/
00334 template <class T> inline
00335 int
00336 IVSFAB<T>::nComp() const
00337 {
00338   return m_nComp;
00339 }
00340 /*************************/
00341 template <class T> inline
00342 T&
00343 IVSFAB<T>::operator() (const IntVect& a_ndin,
00344                        const int& a_comp)
00345 {
00346   CH_assert(isDefined());
00347   CH_assert(a_comp >= 0);
00348   CH_assert(a_comp < m_nComp);
00349   int iloc = getIndex(a_ndin, a_comp);
00350   return(m_dataPtr[iloc]);
00351 }
00352 /**************************/
00353 template <class T> inline
00354 const T&
00355 IVSFAB<T>::operator() (const IntVect& a_ndin,
00356                        const int& a_comp) const
00357 {
00358   CH_assert(isDefined());
00359   CH_assert(a_comp >= 0);
00360   CH_assert(a_comp < m_nComp);
00361   int iloc = getIndex(a_ndin, a_comp);
00362   return(m_dataPtr[iloc]);
00363 }
00364 /******************/
00365 template <class T> inline
00366 const T*
00367 IVSFAB<T>::dataPtr(const int& a_comp) const
00368 {
00369   CH_assert(isDefined());
00370   CH_assert(a_comp >= 0);
00371   CH_assert(a_comp < m_nComp);
00372   return m_dataPtr + a_comp*m_nIvs;
00373 }
00374 /******************/
00375 template <class T> inline
00376 T*
00377 IVSFAB<T>::dataPtr(const int& a_comp)
00378 {
00379   CH_assert(isDefined());
00380   CH_assert(a_comp >= 0);
00381   CH_assert(a_comp < m_nComp);
00382   return m_dataPtr + a_comp*m_nIvs;
00383 }
00384 /******************/
00385 template <class T> inline
00386 const int*
00387 IVSFAB<T>::loVect() const
00388 {
00389   return m_loVect.getVect();
00390 }
00391 /******************/
00392 template <class T> inline
00393 const int*
00394 IVSFAB<T>::hiVect() const
00395 {
00396   return m_hiVect.getVect();
00397 }
00398 /******************/
00399 template <class T> inline
00400 void
00401 IVSFAB<T>::setDefaultValues()
00402 {
00403   m_isDefined = false;
00404   m_dataPtr = NULL;
00405   m_nIvs = 0;
00406   m_nComp = 0;
00407   m_loVect = IntVect::Unit;
00408   m_hiVect = IntVect::Zero;
00409 }
00410 /******************/
00411 template <class T> inline
00412 IVSFAB<T>&
00413 IVSFAB<T>::operator= (const IVSFAB<T>& a_input)
00414 {
00415   MayDay::Error("IVSFAB operator = not defined");
00416   return *this;
00417 }
00418 /******************/
00419 template <class T> inline
00420 IVSFAB<T>::IVSFAB (const IVSFAB<T>& a_input)
00421 {
00422   MayDay::Error("IVSFAB copy constructor not defined");
00423 }
00424 
00425 #include "NamespaceFooter.H"
00426 #endif