Commit f95c4718 authored by Graeme Stewart's avatar Graeme Stewart
Browse files

Reconstruction/PanTau/PanTauInterfaces deleted from master

parent 470c0e04
################################################################################
# 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 )
/*
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
/*
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
/*
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
/*
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
/*
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
/*
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
/*
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
/*
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
/*
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
/*
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
<
package PanTauInterfaces
author Sebastian Fleischmann <Sebastian.Fleischmann@cern.ch>
use AtlasPolicy AtlasPolicy-*
use PanTauEvent PanTauEvent-* Reconstruction/PanTau