PIDHandler.h

Go to the documentation of this file.

#ifndef PIDHandler_h
#define PIDHandler_h 1

#include "UTIL/CollectionParameterMap.h"

#include "EVENT/LCCollection.h"
#include "Exceptions.h"

#include "IMPL/ParticleIDImpl.h"
#include "IMPL/ReconstructedParticleImpl.h"

#include <lcio.h>

#include <string>

namespace UTIL{
  
  
  class PIDHandler {

    typedef CollectionParameterMap CPM ;
    typedef std::map< int, EVENT::StringVec > PNM ;
    typedef  std::map< CPM::map_type::mapped_type , CPM::map_type::key_type > CPMINV ;


  public:  
    PIDHandler() = default ;
    PIDHandler(const PIDHandler& ) = delete ;
    PIDHandler& operator=(const PIDHandler& ) = delete ;
    
    PIDHandler( const EVENT::LCCollection* col ) ;
    
    PIDHandler( EVENT::LCCollection* col ) ;


    ~PIDHandler() ;

    int addAlgorithm( const std::string& algoName, const EVENT::StringVec& parameterNames ) ;
    
    int getAlgorithmID( const std::string& algoName ) ;
    
    const std::string& getAlgorithmName(  int algoID ) ;

    int getParameterIndex( int algorithmID, const std::string& pName ) ;
      
    const EVENT::ParticleID& getParticleID( EVENT::LCObject* particle , int algorithmID ) ;
    

    EVENT::ParticleIDVec getParticleIDs( EVENT::LCObject* p , int id ) ;


    void setParticleIDUsed( IMPL::ReconstructedParticleImpl* particle , int algorithmID  ) ;


    const EVENT::StringVec&  getParameterNames( int algorithmID  ) ;
    
    const EVENT::IntVec& getAlgorithmIDs() ;


    void setParticleID( EVENT::LCObject* p ,
                        int userType,
                        int PDG,
                        float likelihood,
                        int algorithmID,
                        const EVENT::FloatVec& params
                        ) ;

  protected:

    int nextID() { return ++_maxID ; }
    void init( const EVENT::LCCollection* col ) ;


    EVENT::LCCollection* _col{NULL} ;
    CPM _cpm{} ;
    int _type{0} ; 
    int _maxID{0} ;
    PNM _pNames{} ; 
    CPMINV _cpmInv{} ;
    EVENT::IntVec _ids{} ;

  } ; 
  

  class UnknownAlgorithm : public EVENT::Exception {
    
  protected:
    UnknownAlgorithm() {  /*no_op*/ ; } 
  public: 
    virtual ~UnknownAlgorithm() { /*no_op*/; } 
    
    UnknownAlgorithm( std::string text ){
      message = "lcio::UnknownAlgorithm: " + text ;
    }
  }; 
 



} // namespace
#endif