/******************************************************
 
    @class JetFitterTag - BTagging algorithm based on the new 
                   "JetFitter" vertexing algorithm
 
    Created - 23 March 2007
 
    @author: 
    * Giacinto Piacquadio (giacinto.piacquadio AT physik.uni-freiburg.de)
    * Christian Weiser (christian.weiser AT physik.uni-freiburg.de)
 
    --- ( University of FREIBURG ) ---
 
    (c) 2007 - ATLAS Detector Software
 
    main changes: 
    * January 2008 tagger now supports Neural Network based calculation
 
 ********************************************************/
 
 #include "JetTagTools/JetFitterTag.h"
 //#include "CLHEP/Vector/ThreeVector.h"
 //#include "CLHEP/Vector/LorentzVector.h"
 
 #include "JetTagEvent/ISvxAssociation.h"
 #include "JetEvent/Jet.h"
 #include "JetTagEvent/TrackAssociation.h"
 #include "JetTagInfo/TruthInfo.h"
 #include "JetTagTools/HistoHelperRoot.h"
 #include "Particle/TrackParticle.h"
 #include "TrkParticleBase/TrackParticleBase.h"
 //#include "Navigation/NavigationToken.h"
 #include "JetTagTools/JetFitterNtupleWriter.h"
 #include "JetTagTools/JetFitterLikelihood.h"
 #include "JetTagTools/JetFitterNNTool.h"
 #include "JetTagTools/JetFitterVariablesFactory.h"
 #include <cmath>
 #include <sstream>
 
 #include "CLHEP/Vector/LorentzVector.h"
 
 #include "VxSecVertex/VxSecVertexInfo.h"
 #include "VxSecVertex/VxJetFitterVertexInfo.h"
 #include "VxJetVertex/VxJetCandidate.h"
 #include "VxJetVertex/SelectedTracksInJet.h"
 #include "VxJetVertex/TwoTrackVerticesInJet.h"
 
 #include "JetTagInfo/JetFitterTagInfo.h"
 #include "JetTagInfo/BaseTagInfo.h"
 #include "JetTagInfo/ITagInfo.h"
 
 
 
 namespace Analysis {
 
   JetFitterTag::JetFitterTag(const std::string& t, const std::string& n, const IInterface* p)
     : AthAlgTool(t,n,p),
       m_runModus("analysis"),
       m_ntupleWriter("Analysis::JetFitterNtupleWriter"),
       m_variablesFactory("Analysis::JetFitterVariablesFactory"),
       m_likelihood("Analysis::JetFitterLikelihood"),
       m_NN("Analysis::JetFitterNNTool"),
       m_secVxFinderName("InDetJetFitterVxFinder"),
       m_useNN(false),
       m_useNNwithIP3d(false),
       m_IP3DinfoName("IP3D"),
       m_storeOnlyBaseObject(false)
   {
     
 
     
     /** number of hypotheses = 2 : b | u */
     m_hypothese.push_back("bottom");
     m_hypothese.push_back("light");
     m_hypothese.push_back("charm");
 
     
     declareInterface<ITagTool>(this);
     // global configuration:
     declareProperty("Runmodus", m_runModus);
     declareProperty("useVariables", m_useVariables);
     declareProperty("ListHypotheses",m_hypothese);
     // for making reference histograms:
     declareProperty("truthMatchingName", m_truthMatchingName = "TruthInfo");
     declareProperty("purificationDeltaR", m_purificationDeltaR = 0.8);
     declareProperty("jetPtMinRef", m_jetPtMinRef = 15.*GeV);
     declareProperty("jetCollectionList", m_jetCollectionList);
     m_jetCollectionList.push_back("Cone4H1Tower");
     m_jetCollectionList.push_back("Cone7H1Tower");
     m_jetCollectionList.push_back("Kt4H1Tower");
     m_jetCollectionList.push_back("Kt6H1Tower");
     m_jetCollectionList.push_back("Cone4H1Topo");
     m_jetCollectionList.push_back("Cone7H1Topo");
     m_jetCollectionList.push_back("Kt4H1Topo");
     m_jetCollectionList.push_back("Kt6H1Topo");
     declareProperty("jetCollectionListVeto", m_jetCollectionListVeto);
     declareProperty("useForcedCalibration",  m_doForcedCalib   = false);
     declareProperty("ForcedCalibrationName", m_ForcedCalibName = "Cone4H1Tower");
 
     // tools:
     declareProperty("JetFitterNtupleWriter",m_ntupleWriter);
     declareProperty("JetFitterVariablesFactory",m_variablesFactory);
     declareProperty("JetFitterLikelihood",m_likelihood);
     declareProperty("JetFitterNNTool",m_NN);
     declareProperty("SecVxFinderName",m_secVxFinderName);
 
     declareProperty("useNN",m_useNN);
     declareProperty("useNNWithIP3D",m_useNNwithIP3d);
     declareProperty("IP3DinfoName",m_IP3DinfoName);
 
     declareProperty("storeOnlyBaseObject",m_storeOnlyBaseObject);
     
   }
 
   JetFitterTag::~JetFitterTag() {
 
   }
 
 
   StatusCode JetFitterTag::initialize() {
 
     StatusCode sc = m_ntupleWriter.retrieve();
     if( StatusCode::SUCCESS != sc ) {
       ATH_MSG_ERROR(" creation of Analysis::JetFitterNtupleWriter : " << m_ntupleWriter << " failed.");
       return sc;
     }
 
     /** retrieving JetFitterVariablesFactory */
     sc = m_variablesFactory.retrieve();
     if( StatusCode::SUCCESS != sc ) {
       ATH_MSG_ERROR(" creation of Analysis::JetFitterVariablesFactory : " << m_variablesFactory << " failed");
       return sc;
     }
 
     if (!m_useNN)
     {
 
       /** retrieving JetFitterLikelihood */
       sc = m_likelihood.retrieve();//toolSvc->retrieveTool("Analysis::JetFitterLikelihood", "JetFitterLikelihood",m_likelihood);
       if( StatusCode::SUCCESS != sc ) {
         ATH_MSG_ERROR(" creation of Analysis::JetFitterLikelihood : " << m_likelihood << " failed");
         return sc;
       }
     }
     else
     {
        /** retrieving JetFitterNNTool */
       sc = m_NN.retrieve();
       if( StatusCode::SUCCESS != sc ) {
         ATH_MSG_ERROR(" creation of Analysis::JetFitterNNTool : " << m_NN<< " failed");
         return sc;
       }
     }
     
     
 
     // If the jet author is not know 
     // (or one wants a calibration not corresponding to the author), can force the calibration. 
     // Check that this calibration has been loaded
     if (m_doForcedCalib) {
       if (std::find( m_jetCollectionList.begin(), 
                      m_jetCollectionList.end(), 
                      m_ForcedCalibName ) == m_jetCollectionList.end()) {
         ATH_MSG_ERROR("Error, forced calibration to an unloaded one");
         return StatusCode::FAILURE;
       }
     }
 
 
     /** read in calibration histograms */
 
     //here load pdfs in analysis mode...
     if( m_runModus == "analysis" ) {
 
       std::vector<std::string>::const_iterator hypbegin=m_hypothese.begin();
       std::vector<std::string>::const_iterator hypend=m_hypothese.end();
       
       for(std::vector<std::string>::const_iterator hypiter=hypbegin;hypiter!=hypend;
           ++hypiter) {
         if (!m_useNN)
         {
           m_likelihood->initializeCalibrationFile(*hypiter);
 
 /*
   std::vector<std::string>::const_iterator strbegin=m_jetCollectionList.begin();
   std::vector<std::string>::const_iterator strend=m_jetCollectionList.end();
   
   for (std::vector<std::string>::const_iterator striter=strbegin;
   striter!=strend;++striter) 
   {
   
   m_likelihood->loadCalibration(*striter,*hypiter);
   
   }
 */
         }
       }
     }
 
 
 
     /** book calibration histograms if needed */
     if( m_runModus == "reference" ) {
 
       std::vector<std::string>::const_iterator strbegin=m_jetCollectionList.begin();
       std::vector<std::string>::const_iterator strend=m_jetCollectionList.end();
 
       for (std::vector<std::string>::const_iterator striter=strbegin;
            striter!=strend;++striter) {
 
         m_ntupleWriter->bookNtuple(*striter);
 
       }
 
     }
 
     return StatusCode::SUCCESS;
   }
 
 
   void JetFitterTag::finalizeHistos() {
   }
 
 
 
   StatusCode JetFitterTag::finalize() {
     return StatusCode::SUCCESS;
   }
 
   void JetFitterTag::tagJet(Jet& jetToTag) {
 
     /** author to know which jet algorithm: */
     std::string author = jetToTag.jetAuthor();
 
     if (std::find( m_jetCollectionListVeto.begin(), 
                    m_jetCollectionListVeto.end(), 
                    author ) != m_jetCollectionListVeto.end()) {
       ATH_MSG_DEBUG( " No Fit for " << jetToTag.jetAuthor() << " will be performed ");
       return;
     }
 
     if (m_doForcedCalib) {
       author = m_ForcedCalibName;
     } else { 
       //Check that this author is know in the calibration
       if (std::find( m_jetCollectionList.begin(), 
                      m_jetCollectionList.end(), 
                      author ) == m_jetCollectionList.end()) {
         ATH_MSG_DEBUG("Jet Algorithm " << jetToTag.jetAuthor() << " not found in the standard list");
         ATH_MSG_DEBUG("Trying to find a similar one...");
         if      (author.find("Cone4",0) != std::string::npos) author = "Cone4H1Tower";
         else if (author.find("Cone",0)  != std::string::npos) author = "Cone7H1Tower";
         else if (author.find("Kt4",0)   != std::string::npos) author = "Cone4H1Tower";
         else if (author.find("Kt6",0)   != std::string::npos) author = "Cone7H1Tower";
         else {
           ATH_MSG_DEBUG("None found, taking " << m_ForcedCalibName << " calibration");
           author = m_ForcedCalibName;
         }
       }
     }
 
     /** for the reference mode we need the true label: */
     std::string label = "N/A";
     std::string pref  = "";
     if( m_runModus == "reference" ) {
       // here we require a jet selection:
       if( jetToTag.pt()>m_jetPtMinRef && fabs(jetToTag.eta())<2.5 ) {
         // and also a truth match:
         const TruthInfo* mcinfo = jetToTag.tagInfo<TruthInfo>("TruthInfo");
         double deltaRmin(0.);
         if( mcinfo ) {
           label = mcinfo->jetTruthLabel();
           // for purification: require no b or c quark closer than dR=m_purificationDeltaR
           double deltaRtoClosestB = mcinfo->deltaRMinTo("B");
           double deltaRtoClosestC = mcinfo->deltaRMinTo("C");
           deltaRmin = deltaRtoClosestB < deltaRtoClosestC ? deltaRtoClosestB : deltaRtoClosestC;
           //JBdV 04/05/2006 purify also w.r.t tau
           double deltaRtoClosestT = mcinfo->deltaRMinTo("T");
           deltaRmin = deltaRtoClosestT < deltaRmin ? deltaRtoClosestT : deltaRmin;
         } else {
           ATH_MSG_ERROR("No TruthInfo ! Cannot run on reference mode !");
           return;
         }
 
         ATH_MSG_VERBOSE(" label " << label << " m_hypothese.size() " << m_hypothese.size());
 
         //GP here you need then to add the charm...
         if ( ( (   "B"==label || "C"==label || "N/A"==label) && m_hypothese.size()==3 ) ||
              ( ( "B"==label || "N/A"==label) && m_hypothese.size()==2 ) ) {
           if ("B"==label) {
             pref = m_hypothese[0];
           } else if ("N/A"==label) {
             pref = m_hypothese[1];
           } else if ("C" == label) {
             pref = m_hypothese[2];
           }
         }
       }
     }
 
 
     /** jet direction: */
     HepLorentzVector jetDirection(jetToTag.px(),jetToTag.py(),jetToTag.pz(),jetToTag.e());
 
     //you need in any case first to retrieve the VxJetCandidate object...
     //This should be done by the BTagTool later on...
 
     const ISvxAssociation* newSvxAssociation=jetToTag.getAssociation<ISvxAssociation>(m_secVxFinderName);
 
     if (newSvxAssociation==0) {
       ATH_MSG_DEBUG( " No JetFitter vertex found, attached to the Jet as association. Not going on with tagging...");
       return;
     }
 
     const Trk::VxSecVertexInfo* myVertexInfo=newSvxAssociation->vertexInfo();
     if (myVertexInfo==0) {
       ATH_MSG_WARNING(" Could not get the vertex info from the JetAssociation! Strange...");
       return;
     }
 
     const std::vector<Trk::VxCandidate*> & myVertices=myVertexInfo->vertices();
     Trk::VxJetCandidate* myVxJetCandidate=dynamic_cast<Trk::VxJetCandidate*>(myVertices[0]);
 
     if (myVxJetCandidate==0) {
       ATH_MSG_WARNING(" No correct VxJetCandidate could be retrieved. JetFitter is not doing any tag on this jet");
       return;
     }
 
     const Trk::VxJetFitterVertexInfo* myJetFitterInfo=dynamic_cast<const Trk::VxJetFitterVertexInfo*>(myVertexInfo);
 
     const Trk::TwoTrackVerticesInJet* myTwoTrackVertices=0;
     const Trk::SelectedTracksInJet* mySelectedTracksInJet=0;
     
     if (myJetFitterInfo!=0) 
     {
       myTwoTrackVertices=myJetFitterInfo->getTwoTrackVerticesInJet();
       if (myTwoTrackVertices==0) {
         ATH_MSG_WARNING(" No two track vertices in Jet found. Skipping...");
       }
       
       mySelectedTracksInJet=myJetFitterInfo->getSelectedTracksInJet();
       if (mySelectedTracksInJet==0) {
         ATH_MSG_WARNING(" No selected tracks in Jet found. Skipping...");
       }
     }
     else
     {
       ATH_MSG_DEBUG(" No new JetFitter Vertex Info found: normal if running JetFitter version 1.");
     }
     
     
 
     //second to calculate the information you need from it...
     JetFitterTagInfo* theVariables=m_variablesFactory->getITagInfoObject(*myVxJetCandidate,
                                                                          myTwoTrackVertices,
                                                                          mySelectedTracksInJet,
                                                                          jetToTag);
   
     //    delete myVertexInfo;
     //    myVertexInfo=0;
 
       /** fill reference histograms: */
     if( m_runModus == "reference" ) {
       m_ntupleWriter->fillNtuple(pref,jetToTag.jetAuthor(),*theVariables,jetToTag);
     }
 
     /** give information to the info class. */
     if(m_runModus=="analysis") {
       /** tagging done. Fill the JetTag and return ... */
 
       if (!m_useNN)
       {
         
         std::vector<std::string>::const_iterator hypbegin=m_hypothese.begin();
         std::vector<std::string>::const_iterator hypend=m_hypothese.end();
         
         for(std::vector<std::string>::const_iterator hypiter=hypbegin;hypiter!=hypend;
             ++hypiter) {
           m_likelihood->fillLikelihoodValues(*theVariables,author,*hypiter);
         }
 
       }
       else
       {
 
         if (m_useNNwithIP3d)
         {
           const JetTagInfoBase* pos(jetToTag.tagInfo(m_IP3DinfoName));
 
           if (pos==0) 
           {
             ATH_MSG_WARNING("Could not find IP3D tag to combine it with JetFitter. Tag name: " << m_IP3DinfoName);
           }
           else 
           {
             const std::vector<double>& prob = pos->tagLikelihood();
             double pb = prob[0];
             double pu = prob[1];
             double w  = 0.;
             if (pb <= 0. || pu <= 0.) {
               ATH_MSG_WARNING("At least one IP3D prob. null (or negative !?) for JetFitter : pb,pu = " << pb << " " << pu << ", conservatively putting the weight to 0");
             } else {
               w = log(pb/pu);
             }
 
             m_NN->fillLikelihoodValues(*theVariables,
                                        author,
                                        jetToTag.pt(),
                                        jetToTag.eta(),
                                        w);            
           }
         }
         else
         {
           m_NN->fillLikelihoodValues(*theVariables,
                                      author,
                                      jetToTag.pt(),
                                      jetToTag.eta());
         }
       }
 
 
       JetTagInfoBase* myInfoToStore=0;
       
       if (m_storeOnlyBaseObject) 
       {
         myInfoToStore=new BaseTagInfo(*theVariables);
         delete theVariables;
         theVariables=0;
       }
       else
       {
         myInfoToStore=theVariables;
       }
       
       jetToTag.addInfo(myInfoToStore);
       myInfoToStore->makeValid();
 
     }
   }
   
 }//end namespace
 
   

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.