IndexTM.H

Go to the documentation of this file.

#ifdef CH_LANG_CC
/*
*      _______              __
*     / ___/ /  ___  __ _  / /  ___
*    / /__/ _ \/ _ \/  V \/ _ \/ _ \
*    \___/_//_/\___/_/_/_/_.__/\___/
*    Please refer to Copyright.txt, in Chombo's root directory.
*/
#endif

#ifndef _INDEXTM_H_
#define _INDEXTM_H_

//
// This code supports the chombotomization-of-Tempest project.
//
// What we have here (and in IndexTMI.H) specifically is a templatized
// unification of IntVect and RealVect.
//
// Author: Ted
//


#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include "SPACE.H"
#include "REAL.H"
#include "Misc.H"
#include "GenericArithmetic.H"
#include "NamespaceHeader.H"

class HDF5Handle;

template<typename T, int N> class IndexTM;
template<typename T, int N> IndexTM<T,N> min(const IndexTM<T,N>& p1,
                                             const IndexTM<T,N>& p2);
template<typename T, int N> IndexTM<T,N> max(const IndexTM<T,N>& p1,
                                             const IndexTM<T,N>& p2);
template<typename T, int N> IndexTM<T,N> scale(const IndexTM<T,N>& p,
                                               T                   s);
//template<typename T, int N> IndexTM<T,N> scale(T                   s,
//                                               const IndexTM<T,N>& p );
template<typename T, int N> IndexTM<T,N> reflect(const IndexTM<T,N>& a,
                                                 T                   ref_ix,
                                                 int                 idir);
template<typename T, int N> IndexTM<T,N> diagShift(const IndexTM<T,N>& p,
                                                   T                   s);
template<typename T, int N> IndexTM<T,N> coarsen(const IndexTM<T,N>& p,
                                                 T                   s);
template<typename T, int N> IndexTM<T,N> coarsen(const IndexTM<T,N>& p1,
                                                 const IndexTM<T,N>& p2);
template<typename T, int N> std::ostream& operator<<(std::ostream&       os,
                                                     const IndexTM<T,N>& iv);
template<typename T, int N> std::istream& operator>>(std::istream& os,
                                                     IndexTM<T,N>& iv);


template<typename T, int N> IndexTM<T,N> BASISV_TM(int dir);

template<typename T, int N=CH_SPACEDIM> class IndexTM
  : public GenericArithmeticable< T,IndexTM<T,N> >
{
public:


  IndexTM() : GenericArithmeticable< T, IndexTM<T,N> >( this )
  {}


  ~IndexTM()
  {}

  // Each of these, in its implementation, has a STATIC_ASSERT to check that
  // N is the same as the number of arguments:
  explicit IndexTM( T i );
  IndexTM( T i, T j );
  IndexTM( T i, T j, T k );
  IndexTM( T i, T j, T k, T m );
  IndexTM( T i, T j, T k, T m, T n );
  IndexTM( T i, T j, T k, T m, T n, T p );



  explicit IndexTM (const T* a);


  IndexTM (const IndexTM& rhs);

  IndexTM copy() const {return *this;}

//operator IndexTM<Real,N>();


  IndexTM& operator= (const IndexTM& rhs);


  inline
  T& operator[] (int i);


  inline
  T operator[] (int i) const;


  void setVal (int i,
               T val);


  void setAll(T val);



  const T* getVect () const;


  const T*  dataPtr() const;


  T*  dataPtr();



  bool operator== (const IndexTM& p) const;


  bool operator!= (const IndexTM& p) const;


  bool lexLT (const IndexTM& s) const;


  bool lexGT (const IndexTM& s) const;



  IndexTM operator+ () const;


  IndexTM operator- () const;

  T dotProduct( const IndexTM& a_rhs ) const;


  T sum () const;


  T product () const;

  template<typename OP> bool operatorCompare(const IndexTM<T,N>&, const OP&) const;
  template<typename OP> IndexTM<T,N>& operatorOpEquals(
    const IndexTM<T,N>&, const OP&);
  template<typename OP> IndexTM<T,N>& operatorOpEquals(const T&, const OP&);


  IndexTM& reciprocal();



  int minDir(bool a_doAbs) const;


  int maxDir(bool a_doAbs) const;




  IndexTM& min (const IndexTM& p);


  IndexTM& max (const IndexTM& p);


  IndexTM& scale (T s);


  IndexTM& reflect(T ref_ix,
                   int idir);


  IndexTM& shift (int coord,
                  T s);


  IndexTM& shift (const IndexTM& iv);


  IndexTM& diagShift (T s);


  IndexTM& coarsen (const IndexTM& p);


  IndexTM& coarsen (T p);



  void printOn (std::ostream& os) const;


  void p() const;


  void dumpOn (std::ostream& os) const;


  friend std::ostream& operator<< <>(std::ostream&       os,
                                     const IndexTM& iv);


  friend std::istream& operator>> <> (std::istream& os,
                                      IndexTM& iv);


  static const IndexTM Zero;

  static const IndexTM Unit;

  static int InitStatics();


  void linearIn( const void* inBuf );
  void linearOut( void* outBuf ) const;

protected:
  friend class HDF5Handle;

  T vect[N];
};


template<typename T> struct IndexTraits
{
    static bool const isInt=false;
    static bool const isReal=false;
};
template<> struct IndexTraits<int>
{
    static bool const isInt=true;
    static bool const isReal=false;
};
template<> struct IndexTraits<Real>
{
    static bool const isInt=false;
    static bool const isReal=true;
};

//
// Static initialization.  Gotta make sure there are no static object
// definitions above here (except possibly stuff in headers).  Otherwise,
// the danger is that some static object's constructor calls IndexTM::Zero or
// IndexTM::Unit -- the very things the following definition is supposed to
// initialize.
//
static int s_dummyForIntVectH1( IndexTM<int,1>::InitStatics() );
static int s_dummyForIntVectH2( IndexTM<int,2>::InitStatics() );
static int s_dummyForIntVectH3( IndexTM<int,3>::InitStatics() );
static int s_dummyForIntVectH4( IndexTM<int,4>::InitStatics() );
static int s_dummyForIntVectH5( IndexTM<int,5>::InitStatics() );
static int s_dummyForIntVectH6( IndexTM<int,6>::InitStatics() );
static int s_dummyForRealVectH1( IndexTM<Real,1>::InitStatics() );
static int s_dummyForRealVectH2( IndexTM<Real,2>::InitStatics() );
static int s_dummyForRealVectH3( IndexTM<Real,3>::InitStatics() );
static int s_dummyForRealVectH4( IndexTM<Real,4>::InitStatics() );
static int s_dummyForRealVectH5( IndexTM<Real,5>::InitStatics() );
static int s_dummyForRealVectH6( IndexTM<Real,6>::InitStatics() );

#include "NamespaceFooter.H"
#include "IndexTMI.H"

#endif // include guard

---