'CMakeLists.txt' (PanTauInterfaces-00-05-03)

Reconstruction/PanTau/PanTauInterfaces/CMakeLists.txt

+################################################################################
+# Package: PanTauInterfaces
+################################################################################
+
+# Declare the package name:
+atlas_subdir( PanTauInterfaces )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+                          Event/NavFourMom
+                          Event/xAOD/xAODPFlow
+                          Event/xAOD/xAODTau
+                          GaudiKernel
+                          Reconstruction/PanTau/PanTauEvent )
+
+# External dependencies:
+find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
+
+# Install files from the package:
+atlas_install_headers( PanTauInterfaces )
+

Reconstruction/PanTau/PanTauInterfaces/PanTauInterfaces/ITool_DecayModeDeterminator.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PANTAUINTERFACES_ITOOL_DECAYMODEDETERMINATOR_H
+#define PANTAUINTERFACES_ITOOL_DECAYMODEDETERMINATOR_H
+// Gaudi
+#include "GaudiKernel/IAlgTool.h"
+
+
+#include <string>
+
+
+namespace PanTau {
+    class PanTauSeed;
+}
+
+
+namespace PanTau {
+
+
+
+    static const InterfaceID IID_ITool_DecayModeDeterminator("PanTau::ITool_DecayModeDeterminator", 1,0);
+
+    /** @class ITool_DecayModeDeterminator
+        @brief Interface for Tool_DecayModeDeterminator
+        @author Christian Limbach (limbach@physik.uni-bonn.de)
+    */
+
+
+    class ITool_DecayModeDeterminator : virtual public IAlgTool {
+        public:
+            static const InterfaceID& interfaceID();
+            
+            virtual StatusCode determineDecayMode(PanTau::PanTauSeed* inSeed) const = 0;
+    };
+    
+
+    inline const InterfaceID& PanTau::ITool_DecayModeDeterminator::interfaceID() {
+        return IID_ITool_DecayModeDeterminator;
+    }
+
+}
+#endif //PANTAUINTERFACES_ITOOL_INFORMATIONSTORE_H
+

Reconstruction/PanTau/PanTauInterfaces/PanTauInterfaces/ITool_DetailsArranger.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PANTAUINTERFACES_ITOOL_DETAILSARRANGER_H
+#define PANTAUINTERFACES_ITOOL_DETAILSARRANGER_H
+
+#include "GaudiKernel/IAlgTool.h"
+
+
+namespace PanTau {
+    class PanTauSeed;
+}
+
+namespace Analysis {
+    class TauDetailsContainer;
+}
+
+
+namespace PanTau {
+
+    static const InterfaceID IID_ITool_DetailsArranger("PanTau::ITool_DetailsArranger", 1, 0);
+
+    /** @class ITool_DetailsArranger
+        @brief Interface for PID from tau seeds.
+
+        @author Sebastian Fleischmann
+        @author Christian Limbach
+    */
+    class ITool_DetailsArranger : virtual public IAlgTool {
+        public:
+            static const InterfaceID& interfaceID( ) ;
+
+            virtual StatusCode arrangeDetails(PanTau::PanTauSeed* inSeed) = 0;//, Analysis::TauDetailsContainer* detailsCont) = 0;
+            
+    };
+
+    
+    inline const InterfaceID& PanTau::ITool_DetailsArranger::interfaceID() {
+        return IID_ITool_DetailsArranger;
+    }
+
+
+}
+#endif // PANTAUINTERFACES_ITAUDISCRIMINANTTOOL_H

Reconstruction/PanTau/PanTauInterfaces/PanTauInterfaces/ITool_FeatureExtractor.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PANTAUINTERFACES_ITOOL_FEATUREEXTRACTOR_H
+#define PANTAUINTERFACES_ITOOL_FEATUREEXTRACTOR_H
+
+#include "GaudiKernel/IAlgTool.h"
+
+
+
+namespace PanTau {
+    class TauFeature;
+    class PanTauSeed;
+}
+
+
+namespace PanTau {
+    static const InterfaceID IID_ITool_FeatureExtractor("PanTau::ITool_FeatureExtractor", 1, 0);
+
+    /** @class ITool_FeatureExtractor
+        @brief Interface for extracting features from tau seeds.
+
+        @author Christian Limbach
+        @author Sebastian Fleischmann
+    */
+    
+    class ITool_FeatureExtractor : virtual public IAlgTool {
+    public:
+        static const InterfaceID& interfaceID( ) ;
+        
+        
+        //get the features for an input seed
+        virtual StatusCode calculateFeatures(PanTau::PanTauSeed* inSeed) = 0;
+        
+        
+    };
+
+    inline const InterfaceID& PanTau::ITool_FeatureExtractor::interfaceID() {
+        return IID_ITool_FeatureExtractor;
+    }
+
+
+}
+#endif // PANTAUINTERFACES_ITOOL_FEATUREEXTRACTOR_H

Reconstruction/PanTau/PanTauInterfaces/PanTauInterfaces/ITool_FourMomentumCalculator.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PANTAUINTERFACES_ITOOL_FOURMOMENTUMCALCULATOR_H
+#define PANTAUINTERFACES_ITOOL_FOURMOMENTUMCALCULATOR_H
+// Gaudi
+#include "GaudiKernel/IAlgTool.h"
+
+
+#include <string>
+
+
+namespace PanTau {
+    class PanTauSeed;
+}
+
+
+namespace PanTau {
+
+
+
+    static const InterfaceID IID_ITool_FourMomentumCalculator("PanTau::ITool_FourMomentumCalculator", 1,0);
+
+    /** @class ITool_FourMomentumCalculator
+        @brief Interface for Tool_FourMomentumCalculator
+        @author Christian Limbach (limbach@physik.uni-bonn.de)
+    */
+
+
+    class ITool_FourMomentumCalculator : virtual public IAlgTool {
+        public:
+            static const InterfaceID& interfaceID();
+            
+            virtual StatusCode calculateFourMomentum(PanTau::PanTauSeed* inSeed) const = 0;
+    };
+    
+
+    inline const InterfaceID& PanTau::ITool_FourMomentumCalculator::interfaceID() {
+        return IID_ITool_FourMomentumCalculator;
+    }
+
+}
+#endif //PANTAUINTERFACES_ITOOL_INFORMATIONSTORE_H
+

Reconstruction/PanTau/PanTauInterfaces/PanTauInterfaces/ITool_HelperFunctions.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PANTAUINTERFACES_ITOOL_HELPERFUNCTIONS_H
+#define PANTAUINTERFACES_ITOOL_HELPERFUNCTIONS_H
+// Gaudi
+#include "GaudiKernel/IAlgTool.h"
+#include "NavFourMom/INavigable4MomentumCollection.h"
+
+#include "TMatrix.h"
+#include <vector>
+
+#include "xAODTau/TauJet.h"
+#include "xAODPFlow/PFO.h"
+
+namespace CLHEP {
+    class HepLorentzVector;
+    class Hep3Vector;
+}
+
+namespace PanTau {
+    class TauConstituent;
+}
+
+// namespace xAOD {
+//     class PFO;
+//     class TauJet;
+// }
+
+class TVector3;
+class eflowObject;
+
+namespace PanTau {
+
+
+
+    static const InterfaceID IID_ITool_HelperFunctions("PanTau::ITool_HelperFunctions", 1,0);
+
+    /** @class ITool_HelperFunctions
+        @brief Interface for Tool_HelperFunctions
+        @author Christian Limbach (limbach@physik.uni-bonn.de)
+    */
+
+
+    class ITool_HelperFunctions : virtual public IAlgTool {
+        public:
+            static const InterfaceID& interfaceID();
+            
+            virtual void dumpFourMomentum(CLHEP::HepLorentzVector FourMom) const = 0;
+            virtual void dumpTauConstituent(PanTau::TauConstituent* tauConstituent) const = 0;
+            
+            virtual TauConstituent* getNeutralConstWithLargestAngle(CLHEP::HepLorentzVector                 charged, 
+                                                                    std::vector<PanTau::TauConstituent*>    neutral) = 0;
+            
+            virtual std::string convertNumberToString(double x) const = 0;
+            
+            virtual int getBinIndex(std::vector<double> binEdges, double value) const = 0;
+            
+//             virtual void vertexCorrection_eflowObjects(TVector3 vertexToCorrectTo, eflowObject* efo) = 0;
+            virtual void vertexCorrection_PFOs(const xAOD::TauJet* tauJet, xAOD::PFO* efo) = 0;
+            
+            virtual double stddev(double sumOfSquares, double sumOfValues, int numConsts) const = 0;
+            virtual double deltaRprime(const CLHEP::Hep3Vector& vec1, const CLHEP::Hep3Vector& vec2) const = 0;
+        
+            virtual int                 iPow(int man, int exp) = 0;
+            virtual double              ulAngle(double x, double y) = 0;
+            virtual double              sign(double a, double b) = 0;
+            virtual std::vector<double> calcThrust(std::vector<TauConstituent*>* tauConstituents, bool& calcIsValid) = 0;
+            virtual void                ludbrb(TMatrix* mom, double the, double phi, double bx, double by, double bz) = 0;
+            virtual std::vector<double> calcFWMoments(std::vector<TauConstituent*>* tauConstituents, bool& calcIsValid) = 0;
+            virtual std::vector<double> calcSphericity(std::vector<TauConstituent*>* tauConstituents, bool& calcIsValid) = 0;
+    };
+    
+
+    inline const InterfaceID& PanTau::ITool_HelperFunctions::interfaceID() {
+        return IID_ITool_HelperFunctions;
+    }
+
+}
+#endif //PANTAUINTERFACES_ITOOL_HELPERFUNCTIONS_H
+

Reconstruction/PanTau/PanTauInterfaces/PanTauInterfaces/ITool_InformationStore.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PANTAUINTERFACES_ITOOL_INFORMATIONSTORE_H
+#define PANTAUINTERFACES_ITOOL_INFORMATIONSTORE_H
+// Gaudi
+#include "GaudiKernel/IAlgTool.h"
+
+
+#include <string>
+
+class eflowObjectContainer;
+
+// namespace Analysis {
+//     class TauJetContainer;
+//     class TauDetailsContainer;
+// }
+
+//! xAOD EDM
+#include "xAODTau/TauJetContainer.h"
+
+namespace Rec {
+    class TrackParticleContainer;
+}
+
+
+namespace PanTau {
+
+
+
+    static const InterfaceID IID_ITool_InformationStore("PanTau::ITool_InformationStore", 1,0);
+
+    /** @class ITool_InformationStore
+        @brief Interface for Tool_InformationStore
+        @author Christian Limbach (limbach@physik.uni-bonn.de)
+    */
+
+
+    class ITool_InformationStore : virtual public IAlgTool {
+        public:
+            static const InterfaceID& interfaceID();
+            
+            virtual StatusCode updateInformation(std::string inputAlg) = 0;
+            virtual StatusCode getInfo_Int(std::string varName,     int& value) = 0;
+            virtual StatusCode getInfo_Double(std::string varName,  double& value) = 0;
+            virtual StatusCode getInfo_VecDouble(std::string varName,  std::vector<double>& value) = 0;
+            virtual StatusCode getInfo_String(std::string varName,  std::string& value) = 0;
+            virtual StatusCode getInfo_VecString(std::string varName,  std::vector<std::string>& value) = 0;
+            
+            virtual StatusCode dumpMaps() const = 0;
+            
+            virtual const eflowObjectContainer*             getContainer_eflowRec() const = 0;
+            virtual const xAOD::TauJetContainer*            getContainer_TauRec() const = 0;
+            virtual const Rec::TrackParticleContainer*      getContainer_TrackParticle() const = 0;
+    };
+    
+
+    inline const InterfaceID& PanTau::ITool_InformationStore::interfaceID() {
+        return IID_ITool_InformationStore;
+    }
+
+}
+#endif //PANTAUINTERFACES_ITOOL_INFORMATIONSTORE_H
+

Reconstruction/PanTau/PanTauInterfaces/PanTauInterfaces/ITool_InputConverter.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PANTAUINTERFACES_ITOOL_INPUTCONVERTER_H
+#define PANTAUINTERFACES_ITOOL_INPUTCONVERTER_H
+
+// Gaudi
+#include "GaudiKernel/IAlgTool.h"
+
+#include <string>
+
+
+//! xAOD EDM
+#include "xAODPFlow/PFO.h"
+#include "xAODTau/TauJet.h"
+
+namespace PanTau{
+    class TauConstituent;
+}
+
+class eflowObject;
+
+namespace Analysis {
+    class TauPi0Cluster;
+    class TauJet;
+}
+
+namespace Rec {
+    class TrackParticle;
+}
+
+
+
+
+namespace PanTau {
+
+
+
+    static const InterfaceID IID_ITool_InputConverter("PanTau::ITool_InputConverter", 1,0);
+
+    /** @class ITool_InputConverter
+        @brief Interface for Tool_InputConverter
+        @author Christian Limbach (limbach@physik.uni-bonn.de)
+    */
+
+
+    class ITool_InputConverter : virtual public IAlgTool {
+        public:
+            static const InterfaceID& interfaceID();
+            
+            
+            //PFO Converter (r19+)
+            virtual StatusCode ConvertToTauConstituent(xAOD::PFO* pfo,
+                                                       PanTau::TauConstituent* &tauConstituent,
+                                                       const xAOD::TauJet* tauJet,
+                                                       std::string algName) const = 0;
+            
+            virtual bool       passesPreselectionEnergy(double itsEnergy) const = 0;
+            
+            //cluster based converter
+//             virtual StatusCode ConvertToTauConstituent(eflowObject* efo, TauConstituent* &tauConstituent) const;
+            
+    };
+    
+
+    inline const InterfaceID& PanTau::ITool_InputConverter::interfaceID() {
+        return IID_ITool_InputConverter;
+    }
+
+}
+#endif //PANTAUINTERFACES_ITOOL_INPUTCONVERTER_H 

Reconstruction/PanTau/PanTauInterfaces/PanTauInterfaces/ITool_ModeDiscriminator.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PANTAUINTERFACES_ITOOL_MODEDISCRIMINATOR_H
+#define PANTAUINTERFACES_ITOOL_MODEDISCRIMINATOR_H
+
+#include "GaudiKernel/IAlgTool.h"
+
+
+//class Jet;
+namespace PanTau {
+    class PanTauSeed;
+}
+
+
+namespace PanTau {
+
+    static const InterfaceID IID_ITool_ModeDiscriminator("PanTau::ITool_ModeDiscriminator", 1, 0);
+
+    /** @class ITool_ModeDiscriminator
+        @brief Interface for PID from tau seeds.
+
+        @author Sebastian Fleischmann
+        @author Christian Limbach
+    */
+    class ITool_ModeDiscriminator : virtual public IAlgTool {
+        public:
+            static const InterfaceID& interfaceID( ) ;
+
+            virtual double getModeLikeliness(PanTau::PanTauSeed* inSeed, bool& wasSuccessful) = 0;
+            virtual double getResponse(PanTau::PanTauSeed* inSeed, bool& isOK) = 0;
+    };
+
+    
+    inline const InterfaceID& PanTau::ITool_ModeDiscriminator::interfaceID() {
+        return IID_ITool_ModeDiscriminator;
+    }
+
+
+}
+#endif // PANTAUINTERFACES_ITAUDISCRIMINANTTOOL_H

Reconstruction/PanTau/PanTauInterfaces/PanTauInterfaces/ITool_TauConstituentGetter.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PANTAUINTERFACES_ITOOL_TAUCONSTITUENTGETTER_H
+#define PANTAUINTERFACES_ITOOL_TAUCONSTITUENTGETTER_H
+
+// Gaudi
+#include "GaudiKernel/IAlgTool.h"
+
+#include <string>
+
+namespace PanTau{
+    class TauConstituent;
+}
+
+namespace Analysis {
+    class TauJet;
+}
+#include "xAODTau/TauJet.h"
+
+namespace PanTau {
+
+
+
+    static const InterfaceID IID_ITool_TauConstituentGetter("PanTau::ITool_TauConstituentGetter", 1,0);
+
+    /** @class ITool_TauConstituentGetter
+        @brief Interface for Tool_TauConstituentGetter
+        @author Christian Limbach (limbach@physik.uni-bonn.de)
+    */
+
+
+    class ITool_TauConstituentGetter : virtual public IAlgTool {
+        public:
+            static const InterfaceID& interfaceID();
+            
+            virtual StatusCode GetTauConstituents(//const Analysis::TauJet*,
+                                                  const xAOD::TauJet* tauJet,
+                                                  std::vector<TauConstituent*>& outputList,
+                                                  std::string algName) const = 0;
+            
+    };
+    
+
+    inline const InterfaceID& PanTau::ITool_TauConstituentGetter::interfaceID() {
+        return IID_ITool_TauConstituentGetter;
+    }
+
+}
+#endif //PANTAUINTERFACES_ITOOL_TAUCONSTITUENTGETTER_H 

Reconstruction/PanTau/PanTauInterfaces/PanTauInterfaces/ITool_TauConstituentSelector.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PANTAUINTERFACES_ITOOL_TAUCONSTITUENTSELECTOR_H
+#define PANTAUINTERFACES_ITOOL_TAUCONSTITUENTSELECTOR_H
+
+// Gaudi
+#include "GaudiKernel/IAlgTool.h"
+
+#include <vector>
+
+#include "PanTauEvent/TauConstituent.h"
+
+namespace PanTau {
+
+
+
+    static const InterfaceID IID_ITool_TauConstituentSelector("PanTau::ITool_TauConstituentSelector", 1,0);
+
+    /** @class ITool_TauConstituentSelector
+        @brief Interface for Tool_TauConstituentSelector
+        @author Christian Limbach (limbach@physik.uni-bonn.de)
+    */
+
+
+    class ITool_TauConstituentSelector : virtual public IAlgTool {
+        public:
+            static const InterfaceID& interfaceID();
+            
+            virtual StatusCode SelectTauConstituents(std::vector<TauConstituent*> inputList,
+                                                     std::vector<TauConstituent*>& outputList) const = 0;
+        protected:
+            virtual bool    passesSelection_NeutralConstituent(TauConstituent* tauConstituent) const = 0;
+            virtual bool    passesSelection_Pi0NeutConstituent(TauConstituent* tauConstituent) const = 0;
+            virtual bool    passesSelection_ChargedConstituent(TauConstituent* tauConstituent) const = 0;
+            virtual bool    passesSelection_OutNeutConstituent(TauConstituent* TauConstituent) const = 0;
+            virtual bool    passesSelection_OutChrgConstituent(TauConstituent* TauConstituent) const = 0;
+            virtual bool    passesSelection_NeutLowAConstituent(TauConstituent* TauConstituent) const = 0;
+            virtual bool    passesSelection_NeutLowBConstituent(TauConstituent* TauConstituent) const = 0;
+            
+            virtual double  getEtCut(double eta, PanTau::TauConstituent::Type constituentType) const = 0;
+    };
+    
+
+    inline const InterfaceID& PanTau::ITool_TauConstituentSelector::interfaceID() {
+        return IID_ITool_TauConstituentSelector;
+    }
+
+}
+#endif //PANTAUINTERFACES_ITOOL_TAUCONSTITUENTSELECTOR_H 

Reconstruction/PanTau/PanTauInterfaces/cmt/requirements

+package PanTauInterfaces
+
+author Sebastian Fleischmann <Sebastian.Fleischmann@cern.ch>
+
+use AtlasPolicy         AtlasPolicy-*
+use PanTauEvent         PanTauEvent-*           Reconstruction/PanTau
+use GaudiInterface      GaudiInterface-*      	    External