#include "JetTagTools/BasicTrackGradeFactory.h"
 #include "GaudiKernel/MsgStream.h"
 
 #include "JetTagInfo/TrackGrade.h"
 
 #include "TrkTrackSummary/TrackSummary.h"
 #include "TrkToolInterfaces/ITrackSummaryTool.h"
 #include "JetTagInfo/TrackGradesDefinition.h"
 
 #include "TrkTrack/Track.h"
 #include "TrkParticleBase/TrackParticleBase.h"
 
 
 namespace Analysis
 {
 
 BasicTrackGradeFactory::BasicTrackGradeFactory( const std::string& t, const std::string& n, const IInterface* p ) :
         AlgTool( t, n, p ),
         m_trackSumTool("Trk::TrackSummaryTool"),
         m_trackSumToolAvailable(false)
 {
 
     declareProperty("useSharedHitInfo", m_useSharedHitInfo = false);
     declareProperty("nSharedBLayer", m_nSharedBLayer = 0);
     declareProperty("nSharedPix", m_nSharedPix = 0);
     declareProperty("nSharedSct", m_nSharedSct = 1);
     declareProperty("nSharedSi", m_nSharedSi = 999);
 
     declareProperty("TrackSummaryTool",m_trackSumTool);
 
     declareInterface<ITrackGradeFactory>( this );
 }
 
 BasicTrackGradeFactory::~BasicTrackGradeFactory()
 {}
 
 StatusCode BasicTrackGradeFactory::initialize()
 {
 
   MsgStream log(msgSvc(), name());
   
   std::vector<TrackGrade> myGrades;
 
   if (!m_useSharedHitInfo)
   {
     myGrades.push_back(TrackGrade(0,std::string("Good")));
   }
   else
   {
     myGrades.push_back(TrackGrade(0,std::string("Good")));
     myGrades.push_back(TrackGrade(1,std::string("Shared")));
   }
   
   m_trackGradesDefinition=TrackGradesDefinition(myGrades);
 
   m_trackSumToolAvailable=false;
   if (!m_trackSumTool.empty()) {
     if(m_trackSumTool.retrieve().isFailure())
       {
         log<<MSG::INFO<<"#BTAG# Unable to retrieve. OK if running on AOD. "<<m_trackSumTool<<endreq;
       }
     else
       {
         log<<MSG::INFO<<"#BTAG# Track summary tool retrieved"<<endreq;  
         m_trackSumToolAvailable=true;
       }
   }
 
   return StatusCode::SUCCESS;
 }
 
 StatusCode BasicTrackGradeFactory::finalize()
 {
     return StatusCode::SUCCESS;
 }
 
 TrackGrade* BasicTrackGradeFactory::getGrade(const Trk::Track & track,const HepLorentzVector &) const
 {
  
  
 // first ask track for summary
   const Trk::TrackSummary* summary =track.trackSummary();
   
   if (summary == 0)
   {
     if (m_trackSumToolAvailable) 
     {
       // ugly but one needs to cast the const away because the method needs to update the track (the tool is a friend of track)
       Trk::Track& nonConstTrack = const_cast<Trk::Track&>(track);
       m_trackSumTool->updateTrack(nonConstTrack);
       summary = nonConstTrack.trackSummary();
     }
     else 
     {
       MsgStream log(msgSvc(), name());
       log << MSG::DEBUG <<
           "#BTAG# No Track Summary Tool available. " << 
           "This should be the case only when running on AOD" << endreq;
     }
   }
   
   if (summary==0)
   {
     MsgStream log(msgSvc(), name());
     log << MSG::WARNING << "#BTAG# No track summary available for the track... Contact the developer! " << endreq;
     return 0;
   }
   
   return getGrade(*summary);
   
 }
 
 TrackGrade* BasicTrackGradeFactory::getGrade(const Trk::TrackParticleBase & myTPBase,const HepLorentzVector &) const
 {
 
   //number of hits, silicon hits, b-layer
   const Trk::TrackSummary* summary = myTPBase.trackSummary();
       
   if (0==summary ) { 
     MsgStream log(msgSvc(),name());
     log << MSG::WARNING << "#BTAG# Track preselection: cannot create a track summary (but useTrackSummary is true). Selection failed." << endreq;
     return 0;
   }
 
   return getGrade(*summary);
 
 }
 
 
 const TrackGradesDefinition & BasicTrackGradeFactory::getTrackGradesDefinition() const
 {
   return m_trackGradesDefinition;
 }
 
 
 
 //TrackGrade* BasicTrackGradeFactory::getGrade(const Trk::MeasuredPerigee &,
 //                                             const Trk::TrackSummary & trackSummary,
 //                                             const Trk::FitQuality &,
 //                                             const HepLorentzVector & jetMomentum) const
 TrackGrade* BasicTrackGradeFactory::getGrade(const Trk::TrackSummary & trackSummary) const
 {
 
   bool sharedClass(false);
 
   if (m_useSharedHitInfo)
   {
 
     int nbs = trackSummary.get(Trk::numberOfBLayerSharedHits); if(nbs < 0) nbs = 0;
     int nps = trackSummary.get(Trk::numberOfPixelSharedHits); if(nps < 0) nps = 0;
     int nss = trackSummary.get(Trk::numberOfSCTSharedHits); if(nss < 0) nss = 0;
     int nsht =  nps+nss ;
     
     
     
     if(nbs>m_nSharedBLayer) {
       sharedClass = true;
     }
     if(nps>m_nSharedPix) {
       sharedClass = true;
     }
     if(nss>m_nSharedSct) {
       sharedClass = true;
     }
     if(nsht>m_nSharedSi) {
       sharedClass = true;
     }
   }
   
   const TrackGrade * gradeToReturn(0);
 
   if (sharedClass)
   {
 //    gradeToReturn=trackGradesDefinition.getGrade(std::string("Shared"));
     gradeToReturn=m_trackGradesDefinition.getGrade(1);
   }
   else
   {
 //    gradeToReturn=trackGradesDefinition.getGrade(std::string("Good"));
     gradeToReturn=m_trackGradesDefinition.getGrade(0);
   }
       
   if (gradeToReturn==0)
   {
     MsgStream log(msgSvc(),name());
     log << MSG::ERROR << "#BTAG# Grade not found. Internal error... " << endreq;
   }
 
   return new TrackGrade(*gradeToReturn);
   
 }
  
 }
 

Due to the LXR bug, the updates fail sometimes to remove references to deleted files. The Saturday's full rebuilds fix these problems
This page was automatically generated by the LXR engine.