RootCore Packages: /cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/ParticleJetTools/ParticleJetTools/ParticleToJetAssociator.h Source File

00001 /* **************************************************************************
00002    ParticleToJetAssociator.h  -  Description
00003    -------------------
00004 begin   : 10.09.04
00005 authors : Kyle Cranmer
00006 email   : kyle.cranmer@cern.ch
00007 
00008 comments: A. Wildauer: 27.01.2005 rewritten into an AlgTool
00009 
00010  ***************************************************************************/
00011 
00012 #ifndef PARTICLEJETTOOLS_PARTICLETOJETASSOCIATOR_H
00013 #define PARTICLEJETTOOLS_PARTICLETOJETASSOCIATOR_H
00014 
00015 #include "AsgTools/AsgTool.h"
00016 #include "AsgTools/ToolHandle.h"
00017 //#include "AnalysisTools/AnalysisTools.h"
00018 // #include "JetEvent/JetCollection.h"
00019 // #include "JetEvent/JetAssociationBase.h"
00020 
00021 #include "xAODJet/Jet.h"
00022 
00023 #include <vector>
00024 #include <list>
00025 #include <string>
00026 
00027 namespace Analysis
00028 {
00029 
00030 typedef std::string             NameType;
00031 typedef std::vector<xAOD::Jet*> jetcollection_t;
00032 
00033 #ifndef ROOTCORE
00034   static const InterfaceID IID_ParticleToJetAssociator("Analysis::ParticleToJetAssociator", 1, 0);
00035 #endif
00036 typedef std::vector<std::string> StringVector;
00037 
00043 class ParticleToJetAssociator : public asg::AsgTool {
00044     ASG_TOOL_CLASS0(ParticleToJetAssociator)
00045     public:
00046 
00048         ParticleToJetAssociator(const std::string& name);
00049         virtual ~ParticleToJetAssociator();
00050 
00052 #ifndef ROOTCORE
00053         static const InterfaceID& interfaceID() { return IID_ParticleToJetAssociator; };
00054 #endif
00055 
00057         StatusCode initialize();
00059         StatusCode finalize();
00060 
00061         // template<typename ConstituentType, typename coll> void associateParticlesToJets(
00062         //                       JetCollection* SGParticleJetContainer,
00063         //                       const coll* particleContainer,
00064         //                       const std::string& constituentName
00065         //              );
00066 
00067         // For the new way
00068         // FF: return the vector of associations 
00069         template<typename ConstituentType, typename coll>
00070             std::vector<ConstituentType*>
00071             associateParticlesToJets(jetcollection_t* theJets,
00072                     const coll* particleContainer,
00073                     const std::string& constituentName);
00074 
00075         inline double getConeSize(double pt) {      
00076             return (m_coneSizeFitPar1 + exp(m_coneSizeFitPar2 + m_coneSizeFitPar3*pt));
00077         }
00078 
00079     private:
00080 //        ToolHandle<AnalysisTools> m_analysisTools;
00081         double m_trackCone;         
00082         bool   m_useVariableSizedTrackCone;   
00083         double m_coneSizeFitPar1;           
00084         double m_coneSizeFitPar2;
00085         double m_coneSizeFitPar3;
00086         bool   m_shareTracks;           
00087 }; // End class
00088 
00089 
00090 //  template<typename ConstituentType, typename coll> inline 
00091 //    void ParticleToJetAssociator::associateParticlesToJets( JetCollection* SGParticleJetContainer,
00092 //                              const coll* particleContainer,
00093 //                              const std::string& constituentName
00094 //                              ) {
00095 
00096 //  ATH_MSG_VERBOSE("Number of Jets      : " << SGParticleJetContainer->size());
00097 //  if(SGParticleJetContainer->size()<1) return;
00098 //  ATH_MSG_VERBOSE("Number of Particles of Type " << constituentName << " : " << particleContainer->size());
00099 
00100 //  // every jet needs TrackConstiuents (do it like this to avoid const clashes
00101 //  // in ParticleJet::constituent(const std::string& key ) CONST
00102 //  std::vector<ConstituentType*> vecTrackConst;
00103 //  for (JetCollection::iterator itr = SGParticleJetContainer->begin();
00104 //       itr != SGParticleJetContainer->end(); ++itr) {
00105 //    NameType name(constituentName);
00106 //    vecTrackConst.push_back(new ConstituentType(name));
00107 //  }
00108 
00109 //  int index(0);
00110 //  if(!m_shareTracks) {
00111 //    // Case 1: associate a track to only one jet:
00112 //    // loop through track particles and add to closest jet
00113 //    typename coll::const_iterator tpItr = particleContainer->begin();
00114 //    double deltaRMatch;
00115 //    for (; tpItr!=particleContainer->end() ; tpItr++) {
00116 //  double pt = (*tpItr)->pt();
00117 //  ATH_MSG_VERBOSE("Particle-Jet association (no sharing). Jet pT= " << pt);
00118 //  bool findAMatch = m_analysisTools->matchR((*tpItr), SGParticleJetContainer, index, deltaRMatch);
00119 //  ATH_MSG_VERBOSE(" matching: find= " << findAMatch << " dR=" << deltaRMatch);
00120 //  double trackCone = m_trackCone;
00121 //  if( m_useVariableSizedTrackCone ) {
00122 //    trackCone = this->getConeSize(SGParticleJetContainer->at(index)->pt());
00123 //    ATH_MSG_VERBOSE("Using Variable Sized Cone of " << trackCone); 
00124 //  } else {
00125 //    ATH_MSG_VERBOSE("Using Fixed Sized Cone of " << trackCone);
00126 //  }
00127 //  if (findAMatch && deltaRMatch < trackCone ) {
00128 //    vecTrackConst[index]->set_association(particleContainer, (*tpItr), 0.);
00129 //    ATH_MSG_VERBOSE(" added constituent to Jet " << index);
00130 //  }
00131 //    }
00132 
00133 //  } else {
00134 //    // Case 2: can associate a track to many jets:
00135 //    // loop on jets and tracks
00136 //    JetCollection::const_iterator jetItr = SGParticleJetContainer->begin();
00137 //    JetCollection::const_iterator jetEnd = SGParticleJetContainer->end();
00138 //    for(; jetItr!=jetEnd; jetItr++) {
00139 //      typename coll::const_iterator tpItr = particleContainer->begin();
00140 //      typename coll::const_iterator tpEnd = particleContainer->end();
00141 //      for(; tpItr!=tpEnd; tpItr++) {
00142 //  double dR = m_analysisTools->deltaR( (*jetItr), (*tpItr) );
00143 //  double trackCone = m_trackCone;
00144 //  if( m_useVariableSizedTrackCone ) {
00145 //    trackCone = this->getConeSize((*jetItr)->pt());
00146 //    ATH_MSG_VERBOSE("Using Variable Sized Cone of " << trackCone); 
00147 //  } else {
00148 //    ATH_MSG_VERBOSE("Using Fixed Sized Cone of " << trackCone);
00149 //  }
00150 //  if(dR<trackCone) {
00151 //    ATH_MSG_VERBOSE( "Particle-jet association (with sharing): "
00152 //         << " jet pt,phi,eta= " << (*jetItr)->pt() << " " << (*jetItr)->phi() << " " << (*jetItr)->eta()
00153 //         << " trk pt,phi,eta= " << (*tpItr)->pt() << " " << (*tpItr)->phi() << " " << (*tpItr)->eta() );
00154 //    vecTrackConst[index]->set_association( particleContainer, (*tpItr), 0);
00155 //  }
00156 //      }
00157 //      index++;
00158 //    }
00159 //  }
00160 //  index=0;
00161 //  for (JetCollection::iterator itr = SGParticleJetContainer->begin();
00162 //       itr != SGParticleJetContainer->end(); ++itr) {
00163 //    (*itr)->setAssociation(vecTrackConst[index]);
00164 //    index++;
00165 //  }
00166 //  return;
00167 // }
00168 
00169 // For the new way
00170 template<typename ConstituentType, typename coll>
00171     inline std::vector<ConstituentType*>
00172     ParticleToJetAssociator::associateParticlesToJets(jetcollection_t* theJets,
00173             const coll* particleContainer,
00174             const std::string& constituentName) {
00175 
00176         std::vector<ConstituentType*> vecTrackConst;
00177         ATH_MSG_VERBOSE("Number of Jets      : " << theJets->size());
00178         if (theJets->size()<1) return vecTrackConst;
00179         ATH_MSG_VERBOSE("Number of Particles of Type " << constituentName << " : " << particleContainer->size());
00180 
00181         for (jetcollection_t::iterator itr = theJets->begin(); itr != theJets->end(); ++itr) {
00182             //    NameType name(constituentName);
00183             vecTrackConst.push_back(new ConstituentType);
00184         }
00185 
00186         int index(0);
00187         if(!m_shareTracks) {
00188             // Case 1: associate a track to only one jet:
00189             // loop through track particles and add to closest jet
00190             typename coll::const_iterator tpItr = particleContainer->begin();
00191             for (; tpItr!=particleContainer->end() ; tpItr++) {
00192                 double pt = (*tpItr)->pt();
00193                 double deltaRMatch(1000);
00194                 ATH_MSG_VERBOSE("Particle-Jet association (no sharing). Jet pT= " << pt);
00195                 bool findAMatch = false;
00196                 int i(0);
00197                 xAOD::Jet *theJet = 0;
00198                 for (jetcollection_t::iterator itr = theJets->begin(); itr != theJets->end(); ++itr) {
00199                     double r = (*itr)->p4().DeltaR((*tpItr)->p4());
00200                     if ( r < deltaRMatch ) {
00201                         deltaRMatch = r;
00202                         index = i;
00203                         findAMatch = true;
00204                         theJet = (*itr);
00205                     }
00206                     i++;
00207                 }
00208 
00209                 ATH_MSG_VERBOSE(" matching: find= " << findAMatch << " dR=" << deltaRMatch);
00210                 double trackCone = m_trackCone;
00211                 if( m_useVariableSizedTrackCone ) {
00212                     if(0 != theJet) trackCone = getConeSize(theJet->pt());
00213                     ATH_MSG_VERBOSE("Using Variable Sized Cone of " << trackCone); 
00214                 } else {
00215                     ATH_MSG_VERBOSE("Using Fixed Sized Cone of " << trackCone);
00216                 }
00217                 if (findAMatch && deltaRMatch < trackCone ) {
00218                     // FF: changed this to assume an STL container or at least push_back() functionality
00219                     //     note that this does not have any mechanism for updating particle weights etc.
00220                     // vecTrackConst[index]->set_association(particleContainer, (*tpItr), 0.);
00221                     vecTrackConst[index]->push_back(*tpItr);
00222                     ATH_MSG_VERBOSE(" added constituent to Jet " << index);
00223                 }
00224             }
00225         } else {
00226             // Case 2: can associate a track to many jets:
00227             // loop on jets and tracks
00228             jetcollection_t::iterator jetItr = theJets->begin();
00229             jetcollection_t::iterator jetEnd = theJets->end();
00230             for(; jetItr!=jetEnd; jetItr++) {
00231                 typename coll::const_iterator tpItr = particleContainer->begin();
00232                 typename coll::const_iterator tpEnd = particleContainer->end();
00233                 for(; tpItr!=tpEnd; tpItr++) {
00234                     double dR = (*jetItr)->p4().DeltaR((*tpItr)->p4());
00235                     double trackCone = m_trackCone;
00236                     if( m_useVariableSizedTrackCone ) {
00237                         trackCone = getConeSize((*jetItr)->pt());
00238                         ATH_MSG_VERBOSE("Using Variable Sized Cone of " << trackCone); 
00239                     } else {
00240                         ATH_MSG_VERBOSE("Using Fixed Sized Cone of " << trackCone);
00241                     }
00242                     if(dR<trackCone) {
00243                         ATH_MSG_VERBOSE("Particle-jet association (with sharing): "
00244                                 << " jet pt,phi,eta= " << (*jetItr)->pt() << " " << (*jetItr)->phi() << " " << (*jetItr)->eta()
00245                                 << " trk pt,phi,eta= " << (*tpItr)->pt() << " " << (*tpItr)->phi() << " " << (*tpItr)->eta());
00246                         // FF: changed this to assume an STL container or at least push_back() functionality
00247                         //     note that this does not have any mechanism for updating particle weights etc.
00248                         // vecTrackConst[index]->set_association( particleContainer, (*tpItr), 0);
00249                         vecTrackConst[index]->push_back(*tpItr);
00250                     }
00251                 }
00252                 index++;
00253             }
00254         }
00255         // FF: the code below cannot be used for xAOD::Jet
00256         // index=0;
00257         // for (jetcollection_t::iterator itr = theJets->begin(); itr != theJets->end(); ++itr) {
00258         //     (*itr)->setAssociation( vecTrackConst[index] );
00259         //     index++;
00260         //   } 
00261 
00262         return vecTrackConst;
00263     }
00264 
00265 
00266 } // End namespace
00267 #endif