LArVoxelID.cxx

Go to the documentation of this file.

#include "larsim/Simulation/LArVoxelID.h"
#include "larsim/Simulation/LArVoxelCalculator.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include <TLorentzVector.h>

#include <iostream>

namespace sim {

  //----------------------------------------------------------------------------
  LArVoxelID::LArVoxelID( const int x, 
                          const int y, 
                          const int z, 
                          const int t )
  {
    fbins = std::vector<int>(4);
    fbins[0] = x;
    fbins[1] = y;
    fbins[2] = z;
    fbins[3] = t;

  }

  //----------------------------------------------------------------------------
  LArVoxelID::LArVoxelID( const TLorentzVector& coord )
  {
    // Copy each axis from the vector and convert it to a bin.
    fbins = std::vector<int>(4);
    art::ServiceHandle<sim::LArVoxelCalculator> voxelCalc;
    for ( Ssiz_t a = 0; a != 4; ++a ){
      fbins[a] = voxelCalc->AxisToBin( a, coord[a] );
    }
  }

  //----------------------------------------------------------------------------
  LArVoxelID::LArVoxelID( const double x, const double y, const double z, const double t )
  {
    art::ServiceHandle<sim::LArVoxelCalculator> voxelCalc;

    // Convert each axis into its corresponding bin.
    fbins = std::vector<int>(4);
    fbins[0] = voxelCalc->XAxisToBin( x );
    fbins[1] = voxelCalc->YAxisToBin( y );
    fbins[2] = voxelCalc->ZAxisToBin( z );
    fbins[3] = voxelCalc->TAxisToBin( t );
  }

  //----------------------------------------------------------------------------
  LArVoxelID::~LArVoxelID() {}

  //----------------------------------------------------------------------------
  double LArVoxelID::X() const 
  { 
    art::ServiceHandle<sim::LArVoxelCalculator> voxelCalc;
    return voxelCalc->XBinToAxis(fbins[0]);
  }

  //----------------------------------------------------------------------------
  double LArVoxelID::Y() const 
  { 
    art::ServiceHandle<sim::LArVoxelCalculator> voxelCalc;
    return voxelCalc->YBinToAxis(fbins[1]);
  }

  //----------------------------------------------------------------------------
  double LArVoxelID::Z() const 
  { 
    art::ServiceHandle<sim::LArVoxelCalculator> voxelCalc;
    return voxelCalc->ZBinToAxis(fbins[2]);
  }

  //----------------------------------------------------------------------------
  double LArVoxelID::T() const 
  { 
    art::ServiceHandle<sim::LArVoxelCalculator> voxelCalc;
    return voxelCalc->TBinToAxis(fbins[3]);
  }

  //----------------------------------------------------------------------------
  double LArVoxelID::operator[]( const int i ) const
  {
    switch (i){
    case 0:
      return X(); break;
    case 1:
      return Y(); break;
    case 2:
      return Z(); break;
    case 3:
      return T(); break;
    }
    // I suppose I should put some error processing here; for now
    // I'll just return zero.
    return 0;
  }

  //----------------------------------------------------------------------------
  std::ostream& operator<< ( std::ostream& output, const LArVoxelID& id )
  {
    output << "(" << id.X()
           << "," << id.Y()
           << "," << id.Z()
           << "," << id.T()
           << ")";

    return output;
  }

  //----------------------------------------------------------------------------
  bool LArVoxelID::operator<( const LArVoxelID& other ) const 
  {
    // What is a good sort order for voxels in the list?  I'm not sure.
    // For now, pick an ordering but be prepared to change it: sort by
    // T, Z, X, then Y.

    if ( fbins[3] < other.fbins[3] ) return true;

    if ( fbins[3] == other.fbins[3] ){
      if ( fbins[2] < other.fbins[2] ) return true;
      
      if ( fbins[2] == other. fbins[2] ){
        if ( fbins[0] < other.fbins[0] ) return true;
        
        if ( fbins[0] == other.fbins[0] ){
          if ( fbins[1] < other.fbins[1] ) return true;
        }
      }
    }
    
    return false;
  }
  
  //----------------------------------------------------------------------------
  bool LArVoxelID::operator==( const LArVoxelID& other ) const 
  {
    if ( fbins[0] == other.fbins[0]  &&
         fbins[1] == other.fbins[1]  &&
         fbins[2] == other.fbins[2]  &&
         fbins[3] == other.fbins[3] )
      return true;

    return false;
  }

  //----------------------------------------------------------------------------
  LArVoxelID::operator TLorentzVector() const
  { 
    return TLorentzVector( X(), Y(), Z(), T() ); 
  }

  //----------------------------------------------------------------------------
  LArVoxelID::operator TVector3() const
  { 
    return TVector3( X(), Y(), Z() ); 
  }
  

} // namespace sim