VoxelTPC.h

#ifndef VOXELTPC_H
#define VOXELTPC_H 1

//MARLINTPC
#include "TPCVoxel.h"
#include "HitDistributor.h"

//C++
#include <map> 
#include <vector>
#include <stdexcept>

//LCIO
#include <EVENT/SimTrackerHit.h>
#include <IMPL/LCCollectionVec.h>

//GEAR
#include <gear/PadRowLayout2D.h>
#include <gearimpl/RectangularPadRowLayout.h>
#include <gearimpl/FixedPadSizeDiskLayout.h>

//MARLIN
#include <marlin/Global.h>


namespace marlintpc
{

class TPCVoxel;

class VoxelTPC
{
 public:
  VoxelTPC( gear::TPCParameters  const * tpcParameters , double lengthOfTimeBin, double inductionFactor=0 );

   ~VoxelTPC();

   struct VoxelIndex {

   VoxelIndex(int _padIndex, int _zBin, int _moduleID) : zBin(_zBin), padIndex(_padIndex), moduleID(_moduleID){}
     ~VoxelIndex(){}

     int zBin;
     int padIndex;
     int moduleID;

     bool operator()(VoxelIndex* vi1, VoxelIndex* vi2) 
     {
       return *vi1 < *vi2; 
     }

     bool operator<(VoxelIndex const vi) const 
     {
       if ( zBin == vi.zBin )
       { // the z bins are equal, use the module id to distinguish
         if ( moduleID == vi.moduleID )
         { //also the module ids are equal, use the pad index
           return padIndex < vi.padIndex;
         }
         else // use the module id
         {
           return moduleID < vi.moduleID;
         }      
       }
       else // use zBin
       {
         return zBin < vi.zBin;
       }
     }// operator < 

   };

     LCCollectionVec * getVoxelCollection( double outputLength = -1 );

    LCCollectionVec * fetchVoxelCollection( double outputLength = -1 );

    std::list< std::pair< VoxelIndex, int > > * getVoxelList( double  outputLength = -1 , bool erase = false );

    std::list< std::pair< VoxelIndex, int > > * fetchVoxelList( double  outputLength = -1 );

    void putChargeInVoxels( SimTrackerHit *hit, double sigmaTrans, double sigmaLong = 0 );

    void putChargeInVoxel( TPCVoxel const &voxel);
    
    void putChargeInVoxel( int padIndex, double zLength, int charge, int moduleID=0 );

    TPCVoxel getVoxel( int padIndex, int timeIndex, int moduleID=0 );

    std::vector<TPCVoxel> getVoxelsOnPad(int padIndex, int moduleID=0);

    std::vector<TPCVoxel> getVoxelsWithZBin(int zBin);

    void addCollection(LCCollection* voxelCol);


    void removeVoxel(TPCVoxel const &voxel);

    void removeVoxel(int padIndex, int zBin, int moduleID=0);

    void removeVoxels(std::vector<TPCVoxel> const &voxelVec);

    void removeVoxelsOnPad(int padIndex, int moduleID=0);

    void removeVoxelsWithZBin(int zBin);

    int getZBin( double zLength );


    size_t getSize();


 protected:
   
  std::map<VoxelIndex, int> _voxelMap;

  gear::TPCParameters  const * _tpcParameters;

  HitDistributor * _distributeHitPtr;

  double _lengthOfZBin;
};

} //namespace marlintpc 

#endif // VOXELTPC_H