Commit 3e922d06 authored by Graeme Stewart's avatar Graeme Stewart
Browse files

Reconstruction/PanTau/PanTauEvent deleted from master

parent 2887b98b
################################################################################
# Package: PanTauEvent
################################################################################
# Declare the package name:
atlas_subdir( PanTauEvent )
# Declare the package's dependencies:
atlas_depends_on_subdirs( PUBLIC
Control/AthContainers
Control/CLIDSvc
Control/SGTools
Event/FourMom
Event/xAOD/xAODPFlow
Event/xAOD/xAODTau
Reconstruction/tauEvent
PRIVATE
GaudiKernel
Reconstruction/Jet/JetEvent
Reconstruction/Particle )
# External dependencies:
find_package( CLHEP )
find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
# Component(s) in the package:
atlas_add_library( PanTauEvent
src/*.cxx
PUBLIC_HEADERS PanTauEvent
INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
PRIVATE_INCLUDE_DIRS ${CLHEP_INCLUDE_DIRS}
PRIVATE_DEFINITIONS ${CLHEP_DEFINITIONS}
LINK_LIBRARIES ${ROOT_LIBRARIES} AthContainers SGTools FourMom xAODPFlow xAODTau tauEvent
PRIVATE_LINK_LIBRARIES ${CLHEP_LIBRARIES} GaudiKernel JetEvent Particle )
atlas_add_dictionary( PanTauEventDict
PanTauEvent/PanTauEventDict.h
PanTauEvent/selection.xml
INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
LINK_LIBRARIES ${ROOT_LIBRARIES} ${CLHEP_LIBRARIES} AthContainers SGTools FourMom xAODPFlow xAODTau tauEvent GaudiKernel JetEvent Particle PanTauEvent )
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
///////////////////////////////////////////////////////////////////
// CorrectedEflowMomentum.h, (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
#ifndef PANTAUEVENT_CORRECTEDEFLOWMOMENTUM_H
#define PANTAUEVENT_CORRECTEDEFLOWMOMENTUM_H
#include <bitset>
//#include "CLHEP/Vector/LorentzVector.h"
class eflowObject;
namespace CLHEP {
class HepLorentzVector;
}
namespace PanTau {
/** @class CorrectedEflowMomentum
Helper class to store massive and fitted 4-momenta of eflowObjects
@author Sebastian.Fleischmann@cern.ch
*/
class CorrectedEflowMomentum {
public:
/**
* This enum describes the type of the eflowObject.
*/
enum CorrectedEflowMomentumType {
/**
* charged
*/
Charged=0,
/**
* charged with qualified track
*/
QualifiedTrack=1,
/**
* EM neutral
*/
EmNeutral=2,
/**
* Pi0 Tagged
*/
Pi0=3,
/**
* HAD neutral
*/
HadNeutral=4,
/**
* Neutral (not further classified)
*/
Neutral=5,
/**
* New Types for optimization tests
*
* Neutrals above 1 GeV without further requirements
*/
Neutral1GeV=6,
/**
* Neutrals above 2 GeV without further requirements
*/
Neutral2GeV=7,
/**
* Neutrals above 1 GeV from core region (deltaR < 0.2)
*/
NeutralCore1GeV=8,
/**
* Neutrals above 2 GeV from core region (deltaR < 0.2)
*/
NeutralCore2GeV=9,
/**
* Qualified Charged over 2 GeV
*/
QualifiedTrack2GeV=10,
/**
* Qualified Neutral (this will be the final neutral ones to be used)
*/
QualifiedNeutral=11,
NumberOfCorrectedEflowMomentumTypes=12
};
/** Default Constructor for POOL. Do not use! */
CorrectedEflowMomentum();
/** Copy Constructor */
CorrectedEflowMomentum(const CorrectedEflowMomentum& rhs);
/** Assignment operator */
CorrectedEflowMomentum& operator=(const CorrectedEflowMomentum& rhs);
/**
* Full constructor.
*
* The eflowObject passed in does NOT belong to the this object!
*
* (in short delete it yourself)
*
* @param[in] eflow pointer to eflowObject
* @param[in] typePattern The pattern of 'types' which correspond to this
* seed. You create the bitset as follows:
* std::bitset<CorrectedEflowMomentum::NumberOfCorrectedEflowMomentumTypes> typePattern(0);
* typePattern.set(CorrectedEflowMomentum::Charged);
* @param[in] correctedMomentum corrected 4-momentum (HepLorentzVector) of the eflowObject (CorrectedEflowMomentum takes ownership)
* @param[in] fittedMomentum 4-momentum (HepLorentzVector) of the eflowObject from kinematic fit (CorrectedEflowMomentum takes ownership)
*/
CorrectedEflowMomentum(
const eflowObject *eflow,
const std::bitset<CorrectedEflowMomentum::NumberOfCorrectedEflowMomentumTypes> typePattern,
const CLHEP::HepLorentzVector *correctedMomentum = 0,
const CLHEP::HepLorentzVector *fittedMomentum = 0
);
/** Destructor */
virtual ~CorrectedEflowMomentum();
/**
* Use this method to find out if the CorrectedEflowMomentum is of a certain type:
* i.e. if ( seed->type(CorrectedEflowMomentum::Charged) { //etc }
*
* @return true if the CorrectedEflowMomentum is of this type
*/
bool type( const CorrectedEflowMomentumType& type ) const;
/** returns the eflowObject*/
const eflowObject* originalEflowObject() const;
/** returns typeFlags*/
long typeFlags() const;
/** return string based on type flag for feature storage */
static std::string typeName(CorrectedEflowMomentumType theType);
/** returns the corrected 4-momentum (HepLorentzVector) of the eflowObject*/
const CLHEP::HepLorentzVector* correctedMomentum() const;
/** returns the 4-momentum (HepLorentzVector) of the eflowObject from kinematic fit*/
const CLHEP::HepLorentzVector* fittedMomentum() const;
/** add the 4-momentum (HepLorentzVector) of the eflowObject from kinematic fit*/
void addFittedMomentum(const CLHEP::HepLorentzVector* hlv);
protected:
/** The jet */
const eflowObject* m_eflowObject;
/** flags for the types */
long m_typeFlags;
const CLHEP::HepLorentzVector* m_correctedMomentum;
const CLHEP::HepLorentzVector* m_fittedMomentum;
};
inline bool PanTau::CorrectedEflowMomentum::type( const CorrectedEflowMomentumType& type ) const
{
if ( ( 1<<static_cast<const int>(type) ) &m_typeFlags ) return true;
return false;
}
inline const eflowObject* PanTau::CorrectedEflowMomentum::originalEflowObject() const
{
return m_eflowObject;
}
inline long PanTau::CorrectedEflowMomentum::typeFlags() const
{
return m_typeFlags;
}
inline const CLHEP::HepLorentzVector* PanTau::CorrectedEflowMomentum::correctedMomentum() const
{
return m_correctedMomentum;
}
inline const CLHEP::HepLorentzVector* PanTau::CorrectedEflowMomentum::fittedMomentum() const
{
return m_fittedMomentum;
}
inline void PanTau::CorrectedEflowMomentum::addFittedMomentum(const CLHEP::HepLorentzVector* hlv)
{
m_fittedMomentum = hlv;
}
}
#endif // PANTAUEVENT_CORRECTEDEFLOWMOMENTUM_H
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
#///////////////////////////////////////////////////////////////////
// KinematicFitResult.h, (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
#ifndef PANTAUEVENT_KINEMATICFITRESULT_H
#define PANTAUEVENT_KINEMATICFITRESULT_H
#include "AthContainers/DataVector.h"
//#include "PanTauEvent/CorrectedEflowMomentum.h"
namespace PanTau {
class CorrectedEflowMomentum;
/** @class KinematicFitResult
Helper class to store result of kinematic fit
@author peter.wienemann@cern.ch
*/
class KinematicFitResult {
public:
/** Default Constructor */
KinematicFitResult();
/** Full constructor
* @param[in] chi square of fit
* @param[in] number of degrees of freedom of fit
*/
KinematicFitResult(
double chi2,
int ndof
);
/** Copy Constructor */
KinematicFitResult(const KinematicFitResult& rhs);
/** Assignment operator */
KinematicFitResult& operator=(const KinematicFitResult& rhs);
/** Destructor */
virtual ~KinematicFitResult();
/** returns chi2 of fit */
double chi2() const;
/** returns number of degrees of freedom */
int ndof() const;
protected:
double m_chi2;
int m_ndof;
};
inline double PanTau::KinematicFitResult::chi2() const
{
return m_chi2;
}
inline int PanTau::KinematicFitResult::ndof() const
{
return m_ndof;
}
}
#endif // PANTAUEVENT_KINEMATICFITRESULT_H
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
///////////////////////////////////////////////////////////////////
// PanTauDetails.h, (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
#ifndef PANTAUEVENT_PANTAUDETAILS_H
#define PANTAUEVENT_PANTAUDETAILS_H
#include <iostream>
#include <bitset>
#include "tauEvent/TauDetails.h"
#include "PanTauEvent/PanTauSeed.h"
#include "PanTauEvent/TauSeed.h"
class MsgStream;
namespace PanTau {
class TauFeature;
/** @class PanTauDetails
PanTau specific implementation of Analysis::TauDetails
@author limbach@physik.uni-bonn.de
@author Sebastian.Fleischmann@cern.ch
*/
class PanTauDetails: public Analysis::TauDetails {
public:
enum DetailsEnumeration {
t_isPanTauCandidate, //!< tells you whether this tauRec seed is considered as candidate for PanTau
t_RecoMode_SubAlg,
t_RecoMode_PanTau,
t_BDTValue_1p0n_vs_1p1n,
t_BDTValue_1p1n_vs_1pXn,
t_BDTValue_3p0n_vs_3pXn,
t_pantau_proto_pt,
t_pantau_proto_eta,
t_pantau_proto_phi,
t_pantau_proto_m,
t_pantau_final_pt,
t_pantau_final_eta,
t_pantau_final_phi,
t_pantau_final_m,
t_ChargedEFOs_pt,
t_ChargedEFOs_eta,
t_ChargedEFOs_phi,
t_ChargedEFOs_m,
t_NeutralEFOs_pt,
t_NeutralEFOs_eta,
t_NeutralEFOs_phi,
t_NeutralEFOs_m,
t_Pi0NeutEFOs_pt,
t_Pi0NeutEFOs_eta,
t_Pi0NeutEFOs_phi,
t_Pi0NeutEFOs_m
};
/** Default Constructor for POOL. Do not use! */
PanTauDetails();
/** Copy Constructor */
PanTauDetails(const PanTauDetails& rhs);
/** Assignment operator */
PanTauDetails& operator=(const PanTauDetails& rhs);
/**
* THE constructor for generalized pantau:
* the details ONLY know about a seed and correspond to its features!
*
* PanTauDetails does not take ownership of the seed)
*/
PanTauDetails(PanTau::PanTauSeed* inputSeed);
/**
* Full constructor. NOTE: delete it
*
* The TauSeed object passed in does NOT belong to the this object!
*
* @param[in] seed pointer to TauSeed (PanTauDetails does not take ownership)
* @param[in] features pointer to TauFeature (PanTauDetails takes ownership, do not delete yourself!)
*/
/*
PanTauDetails(
const PanTau::TauSeed *seed,
const PanTau::TauFeature *features = 0
);
*/
/** Destructor */
virtual ~PanTauDetails();
//NOTE: new way of retrieving the features:
PanTau::TauFeature* getFeatures() const;
//NOTE: new way of retreiving the seed
PanTau::PanTauSeed* getPanTauSeed() const;
//TODO: delete these two functions
/** returns PanTau::TauFeature (own features if we have features, otherwise return features of the seed) */
const PanTau::TauFeature* features() const;
/** returns PanTau::TauSeed the TauJet was created from*/
const PanTau::TauSeed* seed() const;
virtual const std::string& className() const;
/** the details to be accessable in the container */
virtual bool setScalarDetailByEnum(double newValue, int detEnum_index);
virtual bool setVectorDetailByEnum(std::vector<double> newVec, int detEnum_index);
//! =============================================================
//! Basic PanTau Variables (validity, reco mode & momenta)
//! =============================================================
int isPanTauCandidate() const;
std::string inputAlgName() const;
int RecoModeSubAlg() const;
int RecoModePanTau() const;
double BDTValue_1p0n_vs_1p1n() const;
double BDTValue_1p1n_vs_1pXn() const;
double BDTValue_3p0n_vs_3pXn() const;
double pantau_proto_pt() const;
double pantau_proto_eta() const;
double pantau_proto_phi() const;
double pantau_proto_m() const;
double pantau_final_pt() const;
double pantau_final_eta() const;
double pantau_final_phi() const;
double pantau_final_m() const;
std::vector<double> ChargedEFOs_pt() const;
std::vector<double> ChargedEFOs_eta() const;
std::vector<double> ChargedEFOs_phi() const;
std::vector<double> ChargedEFOs_m() const;
std::vector<double> NeutralEFOs_pt() const;
std::vector<double> NeutralEFOs_eta() const;
std::vector<double> NeutralEFOs_phi() const;
std::vector<double> NeutralEFOs_m() const;
std::vector<double> Pi0NeutEFOs_pt() const;
std::vector<double> Pi0NeutEFOs_eta() const;
std::vector<double> Pi0NeutEFOs_phi() const;
std::vector<double> Pi0NeutEFOs_m() const;
void set_isPanTauCandidate(int isPTC );
void set_InputAlgName(std::string inAlg);
void set_RecoModeSubAlg( int newValue);
void set_RecoModePanTau( int newValue);
void set_BDTValue_1p0n_vs_1p1n( double newValue);
void set_BDTValue_1p1n_vs_1pXn( double newValue);
void set_BDTValue_3p0n_vs_3pXn( double newValue);
void set_pantau_proto_pt( double newValue);
void set_pantau_proto_eta( double newValue);
void set_pantau_proto_phi( double newValue);
void set_pantau_proto_m( double newValue);
void set_pantau_final_pt( double newValue);
void set_pantau_final_eta( double newValue);
void set_pantau_final_phi( double newValue);
void set_pantau_final_m( double newValue);
void set_ChargedEFOs_pt( std::vector<double> newValue);
void set_ChargedEFOs_eta( std::vector<double> newValue);
void set_ChargedEFOs_phi( std::vector<double> newValue);
void set_ChargedEFOs_m( std::vector<double> newValue);
void set_NeutralEFOs_pt( std::vector<double> newValue);
void set_NeutralEFOs_eta( std::vector<double> newValue);
void set_NeutralEFOs_phi( std::vector<double> newValue);
void set_NeutralEFOs_m( std::vector<double> newValue);
void set_Pi0NeutEFOs_pt( std::vector<double> newValue);
void set_Pi0NeutEFOs_eta( std::vector<double> newValue);
void set_Pi0NeutEFOs_phi( std::vector<double> newValue);
void set_Pi0NeutEFOs_m( std::vector<double> newValue);
//! =======================================================================
//! ID Variables
//! =======================================================================
//! eflowRec
int eflowRec_Basic_NPi0NeutConsts() const;
int eflowRec_Basic_NNeutralConsts() const;
double eflowRec_Charged_HLV_SumPt() const;
double eflowRec_Charged_Ratio_EtOverEtAllConsts() const;
double eflowRec_Neutral_HLV_SumM() const;
double eflowRec_Neutral_PID_BDTValues_EtSort_1() const;
double eflowRec_Neutral_PID_BDTValues_BDTSort_2() const;
double eflowRec_Neutral_Ratio_EtOverEtAllConsts() const;
double eflowRec_Neutral_Mean_DRToLeading_WrtEtAllConsts() const;
double eflowRec_Combined_DeltaR1stNeutralTo1stCharged() const;
void set_eflowRec_Basic_NPi0NeutConsts(double newValue) ;
void set_eflowRec_Basic_NNeutralConsts(double newValue) ;
void set_eflowRec_Charged_HLV_SumPt(double newValue) ;
void set_eflowRec_Charged_Ratio_EtOverEtAllConsts(double newValue) ;
void set_eflowRec_Neutral_HLV_SumM(double newValue) ;
void set_eflowRec_Neutral_PID_BDTValues_EtSort_1(double newValue) ;
void set_eflowRec_Neutral_PID_BDTValues_BDTSort_2(double newValue) ;
void set_eflowRec_Neutral_Ratio_EtOverEtAllConsts(double newValue) ;
void set_eflowRec_Neutral_Mean_DRToLeading_WrtEtAllConsts(double newValue) ;
void set_eflowRec_Combined_DeltaR1stNeutralTo1stCharged(double newValue) ;
//! CellBased
int CellBased_Basic_NNeutralConsts() const;
double CellBased_Charged_JetMoment_EtDRxTotalEt() const;
double CellBased_Charged_StdDev_Et_WrtEtAllConsts() const;
double CellBased_Neutral_HLV_SumM() const;
double CellBased_Neutral_PID_BDTValues_BDTSort_1() const;
double CellBased_Neutral_PID_BDTValues_BDTSort_2() const;
double CellBased_Neutral_Ratio_1stBDTEtOverEtAllConsts() const;
double CellBased_Neutral_Ratio_EtOverEtAllConsts() const;
double CellBased_Neutral_Shots_NPhotonsInSeed() const;
double CellBased_Combined_DeltaR1stNeutralTo1stCharged() const;
void set_CellBased_Basic_NNeutralConsts(double newValue);
void set_CellBased_Charged_JetMoment_EtDRxTotalEt(double newValue);
void set_CellBased_Charged_StdDev_Et_WrtEtAllConsts(double newValue);
void set_CellBased_Neutral_HLV_SumM(double newValue);
void set_CellBased_Neutral_PID_BDTValues_BDTSort_1(double newValue);
void set_CellBased_Neutral_PID_BDTValues_BDTSort_2(double newValue);
void set_CellBased_Neutral_Ratio_1stBDTEtOverEtAllConsts(double newValue);
void set_CellBased_Neutral_Ratio_EtOverEtAllConsts(double newValue);
void set_CellBased_Neutral_Shots_NPhotonsInSeed(double newValue);
void set_CellBased_Combined_DeltaR1stNeutralTo1stCharged(double newValue);
protected:
/** Only for transient object:*/
PanTau::PanTauSeed* m_PanTauSeed;
/** the features of the details */
const TauFeature* m_features;
/** the features of the seed */
const TauSeed* m_seed;
static std::string s_className;
/** These members will be persistified:*/
/** the details to be accessable in the container */
//! ======================================================================
//! Basic PanTau Variables (validity, reco mode & momenta)
//! ======================================================================
int m_isPanTauCandidate; //!< tells you whether this tauRec seed is considered as candidate for PanTau
std::string m_Name_InputAlg;
int m_RecoMode_SubAlg;
int m_RecoMode_PanTau;
double m_BDTValue_1p0n_vs_1p1n;
double m_BDTValue_1p1n_vs_1pXn;
double m_BDTValue_3p0n_vs_3pXn;
double m_pantau_proto_pt;
double m_pantau_proto_eta;
double m_pantau_proto_phi;
double m_pantau_proto_m;
double m_pantau_final_pt;
double m_pantau_final_eta;
double m_pantau_final_phi;
double m_pantau_final_m;
std::vector<double> m_ChargedEFOs_pt;
std::vector<double> m_ChargedEFOs_eta;
std::vector<double> m_ChargedEFOs_phi;
std::vector<double> m_ChargedEFOs_m;