LArVoxelID.h

Go to the documentation of this file.

#ifndef sim_LArVoxelID_h
#define sim_LArVoxelID_h

#include <TLorentzVector.h>
#include <TVector3.h>

#include <vector>
#include <functional> // so we can redefine less<> below
#include <iostream>

namespace sim {

  class LArVoxelID 
  {
  public:
    // What is an appropriate storage class for an element of the bin
    // ID?  Probably a regular integer is the only thing we can use; a
    // "short int" can only accept values up to +/-32767, and a large
    // LAr TPC will probably contain more bins on a single axis than
    // that.

    // Construct a voxel identifier given the pre-computed bins.  This
    // one is provided for completeness, but it's not the one I
    // anticipate the clients will use.  Note that it's also serves
    // as the no-argument constructor that ROOT requires for I/O.
    LArVoxelID( const int x = 0, 
                const int y = 0, 
                const int z = 0, 
                const int t = 0 );

    // The constructors that I expect most clients to use: Given the
    // (x,y,z,t) in units of (distance,time) of a particle, compute
    // the voxel identifier.  Note that units are ambiguous there; they
    // have to be consistent between those used by LArVoxelCalculator
    // and the Monte Carlo, but this class does not enforce that
    // consistency.
    explicit LArVoxelID( const TLorentzVector& v );
    LArVoxelID( const double x, 
                const double y, 
                const double z, 
                const double t );

    // Destructor.
    virtual ~LArVoxelID();

  private:
    // Implement the bin ID as a "tuple" of four numbers, one bin for
    // each (x,y,z,t) axis.

    std::vector<int> fbins; // (x,y,z,t) bins.

#ifndef __GCCXML__

  public:
    // Accessors for the bin values.  I don't expect these to be used
    // often, but include them for completeness.
    int XBin() const; 
    int YBin() const; 
    int ZBin() const; 
    int TBin() const; 

    // The accessors I expect to be used: The values of the
    // co-ordinates at the bin centers.
    double X() const;
    double Y() const;
    double Z() const;
    double T() const;

    // Alternative accessor: Pretend the LArVoxelID is a vector that
    // takes subscripts, and returns the bin centers of the axis in
    // the square brackets (x=0, y=1, z=2, t=3).
    double operator[]( const int ) const;

    // Conversion function from LArVoxelID to a TLorentzVector.  This
    // lets you do something like:
    //    sim::LArVoxelID larVoxelID = ... // whatever
    //    TLorentzVector v = TLorentzVector( larVoxelID );
    operator TLorentzVector() const;

    // The three-vector version of the above conversion; e.g.:
    //    sim::LArVoxelID larVoxelID = ... // whatever
    //    TLVector3 v = TVector3( larVoxelID );
    operator TVector3() const;

    // The comparison operator.  This a key function, since it
    // establishes the sort order of the voxels in a list.
    bool operator<( const LArVoxelID& ) const;

    // Test for equality.  Handy, but not usually necessary.
    bool operator==( const LArVoxelID& ) const;

    friend std::ostream& operator<< ( std::ostream& output, const LArVoxelID& );

#endif
    
  };

} // sim 

#ifndef __GCCXML__

inline int sim::LArVoxelID::XBin() const { return fbins[0]; }
inline int sim::LArVoxelID::YBin() const { return fbins[1]; }
inline int sim::LArVoxelID::ZBin() const { return fbins[2]; }
inline int sim::LArVoxelID::TBin() const { return fbins[3]; }

// A potentially handy definition: At this stage, I'm not sure
// whether I'm going to be keeping a list based on LArVoxelID or on
// LArVoxelID*.  We've already defined operator<(LArVoxelID,LArVoxelID),
// that is, how to compare two LArVoxelID objects; by default that
// also defines std::less<LArVoxelID>, which is what the STL containers
// use for comparisons.

// The following defines std::less<LArVoxelID*>, that is, how to
// compare two LArVoxelID*: by looking at the objects, not at the
// pointer addresses.  The result is that, e.g., a
// map<LArVoxelID*,double> will be sorted in the order I expect.

namespace std {
  template <> 
  class less<sim::LArVoxelID*>
  {
  public:
    bool operator()( const sim::LArVoxelID* lhs, const sim::LArVoxelID* rhs )
    {
      return (*lhs) < (*rhs);
    }
  };
} // std

#endif

#endif // sim_LArVoxelID_h