Analysis::IPTag Class Reference

#include <IPTag.h>

Inheritance diagram for Analysis::IPTag:

Collaboration diagram for Analysis::IPTag:

Public Member Functions
	IPTag (const std::string &, const std::string &, const IInterface *)
virtual	~IPTag ()
	Implementations of the methods defined in the abstract base class. More...
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	tagJet (const xAOD::Vertex &priVtx, const xAOD::Jet &jetToTag, xAOD::BTagging &BTag, const std::string &jetName) const override
void	trackWeight (const std::string &jetAuthor, const TrackGrade &grade, double sa0, double sz0, double &twb, double &twu, double &twc) const
	calculate individual track contribution to the three likelihoods: More...
virtual void	finalizeHistos () override

Private Attributes
std::string	m_runModus
	This switch is needed to indicate what to do. More...
std::string	m_xAODBaseName
	base name string for persistification in xaod More...
HistoHelperRoot *	m_histoHelper
	Histogram Helper Class. More...
bool	m_flipIP
	VD: bool switches. More...
bool	m_flipZIP
bool	m_usePosIP
bool	m_useNegIP
bool	m_useZIPSignForPosNeg
bool	m_use2DSignForIP3D
bool	m_useD0SignForZ0
bool	m_sortPt
bool	m_sortD0sig
bool	m_sortZ0D0sig
bool	m_RejectBadTracks
bool	m_SignWithSvx
bool	m_checkOverflows
bool	m_doForcedCalib
bool	m_useCHypo
bool	m_unbiasIPEstimation
bool	m_storeTrackParticles
bool	m_storeIpValues
bool	m_storeTrackParameters
std::string	m_trackAssociationName
	Name of the track-to-jet association in the BTagging object. More...
std::string	m_impactParameterView
	specify the tag type (1D or 2D) More...
std::string	m_forcedCalibName
	forcing the calibration folder of a given collection More...
std::string	m_referenceType
	for reference mode: More...
double	m_purificationDeltaR
double	m_jetPtMinRef
std::string	m_secVxFinderName
	names of fools for getting the secondary vertex information More...
int	m_NtrkMin
	additional switch for smart track selection More...
int	m_NtrkMax
float	m_trkFract
std::string	m_sortOption
std::vector< std::string >	m_hypotheses
std::vector< std::string >	m_trackGradePartitionsDefinition
	track classification. More...
std::vector< TrackGradePartition * >	m_trackGradePartitions
std::vector< std::string >	m_jetCollectionList
ToolHandle< TrackSelector >	m_trackSelectorTool
	Track selection cuts for IPTagging. More...
ToolHandle< NewLikelihoodTool >	m_likelihoodTool
	Pointer to the likelihood tool. More...
ToolHandle< SVForIPTool >	m_SVForIPTool
	Pointer to the SV tool. More...
ToolHandle< ITrackGradeFactory >	m_trackGradeFactory
	ToolHandle for the ITrackGradeFactory tool. More...
ToolHandle< Trk::ITrackToVertexIPEstimator >	m_trackToVertexIPEstimator
	GP: Tool for the estimation of the IPs to the Vertex. More...
std::atomic< int >	m_nbjet
std::atomic< int >	m_ncjet
std::atomic< int >	m_nljet

Detailed Description

b-jet tagger based on 2D or 3D impact parameter

Author

CPPM Marseille

Definition at line 34 of file IPTag.h.

Constructor & Destructor Documentation

IPTag()

Analysis::IPTag::IPTag	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 62 of file IPTag.cxx.

    : base_class(t,n,p),
      m_runModus("analysis"),
      m_histoHelper(0),
      m_sortPt(false),
      m_sortD0sig(false),
      m_sortZ0D0sig(false),
      m_unbiasIPEstimation(true),
      m_secVxFinderName("InDetVKalVxInJetTool"),
      m_trackSelectorTool("Analysis::TrackSelector", this),
      m_likelihoodTool("Analysis::NewLikelihoodTool", this),
      m_SVForIPTool("Analysis::SVForIPTool", this),
      m_trackGradeFactory("Analysis::BasicTrackGradeFactory", this),
      m_trackToVertexIPEstimator(this)
  {
    // global configuration:
    declareProperty("Runmodus"      , m_runModus);
    declareProperty("xAODBaseName"  , m_xAODBaseName);
    
    declareProperty("flipIPSign"          , m_flipIP              = false);
    declareProperty("flipZIPSign"         , m_flipZIP             = false);
    declareProperty("usePosIP"            , m_usePosIP            = true);
    declareProperty("useNegIP"            , m_useNegIP            = true);
    declareProperty("useZIPSignForPosNeg" , m_useZIPSignForPosNeg = false);
    declareProperty("use2DSignForIP3D"    , m_use2DSignForIP3D    = false);
    declareProperty("useD0SignForZ0"      , m_useD0SignForZ0      = false);
    declareProperty("RejectBadTracks"     , m_RejectBadTracks     = true);
    declareProperty("SignWithSvx"         , m_SignWithSvx         = false);
    declareProperty("checkOverflows"      , m_checkOverflows      = false);
    declareProperty("useForcedCalibration", m_doForcedCalib       = false);
    declareProperty("UseCHypo"            , m_useCHypo            = true);
    declareProperty("unbiasIPEstimation"  , m_unbiasIPEstimation);
 
    declareProperty("trackAssociationName"    , m_trackAssociationName = "BTagTrackToJetAssociator");
    declareProperty("jetCollectionList"       , m_jetCollectionList);
    declareProperty("impactParameterView"     , m_impactParameterView = "2D");
    declareProperty("ForcedCalibrationName"   , m_forcedCalibName = "Cone4H1Tower");
    
    declareProperty("trackGradePartitions"    , m_trackGradePartitionsDefinition);
    m_trackGradePartitionsDefinition.push_back("Good");
 
    declareProperty("referenceType"           , m_referenceType = "ALL"); // B, UDSG, ALL
    declareProperty("purificationDeltaR"      , m_purificationDeltaR = 0.8);
    declareProperty("jetPtMinRef"             , m_jetPtMinRef = 15.*Gaudi::Units::GeV);
 
    declareProperty("SecVxFinderName"         ,m_secVxFinderName);
 
    declareProperty("NtrkMin"                 , m_NtrkMin =6 );
    declareProperty("NtrkMax"                 , m_NtrkMax =6 );
    declareProperty("NtrkFract"               , m_trkFract=1.0 );
    declareProperty("SortingMode"             , m_sortOption="None"); //"None");
#define PROP(name, def) declareProperty( #name, m_ ## name = def)
    PROP(storeTrackParticles, true);
    PROP(storeIpValues, false);
    PROP(storeTrackParameters, true);
#undef PROP
 
    // tools:
    declareProperty("trackSelectorTool"         , m_trackSelectorTool              );
    declareProperty("LikelihoodTool"            , m_likelihoodTool                 );
    declareProperty("SVForIPTool"               , m_SVForIPTool                    );  
    declareProperty("trackGradeFactory"         , m_trackGradeFactory              );
    declareProperty("TrackToVertexIPEstimator"  , m_trackToVertexIPEstimator       );
  }

~IPTag()

Analysis::IPTag::~IPTag ( )

virtual

Implementations of the methods defined in the abstract base class.

Definition at line 129 of file IPTag.cxx.

                {
    delete m_histoHelper;
    for (size_t i = 0; i < m_trackGradePartitions.size(); i++)
      delete m_trackGradePartitions[i];
  }

Member Function Documentation

finalize()

StatusCode Analysis::IPTag::finalize ( )

overridevirtual

Definition at line 323 of file IPTag.cxx.

                             {
    if( m_runModus == "reference" ) {
      ATH_MSG_INFO("#BTAG# Number of jets used for calibration for reference "
           << m_referenceType << " : #b= " << m_nbjet << " #light= " << m_nljet  << " #charm= " << m_ncjet );
    }
    return StatusCode::SUCCESS;
  }

finalizeHistos()

virtual void Analysis::IPTag::finalizeHistos ( )

inlineoverridevirtual

Definition at line 56 of file IPTag.h.

{};

initialize()

StatusCode Analysis::IPTag::initialize ( )

overridevirtual

creation of TrackSelector: (private instance)

retrieving histoHelper:

retrieving the track grade factory

prepare the track partitions:

configure likelihood:

book calibration histograms if needed

Definition at line 138 of file IPTag.cxx.

                               {
    
    // VD: deciding the track sorting mode
    if ( m_sortOption=="None" ) {
      ATH_MSG_DEBUG("#BTAG# No sorting applied ");
      m_sortPt     =false;
      m_sortD0sig  =false;
      m_sortZ0D0sig=false;
    } else if ( m_sortOption=="SortPt" ) {
      ATH_MSG_DEBUG("#BTAG# Tracks will be sorted by Pt ");
      m_sortPt     =true;
      m_sortD0sig  =false;
      m_sortZ0D0sig=false;
    } else if ( m_sortOption=="SortD0" ) {
      ATH_MSG_DEBUG("#BTAG# Tracks will be sorted by |d0Sig| ");
      m_sortPt     =false;
      m_sortD0sig  =true;
      m_sortZ0D0sig=false;
    } else if ( m_sortOption=="SortZ0D0" ) {
      ATH_MSG_DEBUG("#BTAG# Tracks will be sorted by sqrt( |d0Sig|^2 + |z0Sig|^2 ) ");
      m_sortPt     =false;
      m_sortD0sig  =false;
      m_sortZ0D0sig=true;
    } else {
      ATH_MSG_ERROR("#BTAG# sorting option NOT recognised (please use: <None>, <SortPt>, <SortD0> ");
      return StatusCode::FAILURE;
    }
 
    if ( m_sortOption=="None" ) {
      m_NtrkMax =1000;
      m_NtrkMin =m_NtrkMax;
      m_trkFract=1.0;
    } else {
      if (m_trkFract!=1.0) {
    ATH_MSG_DEBUG("#BTAG# Considering only first "<< m_trkFract << " % of the tracks in the jet but keeping at least " << m_NtrkMin);     
      } else {
    ATH_MSG_DEBUG("#BTAG# Considering only maximum "<< m_NtrkMax << " per jet");     
      }
    }
 
 
    m_hypotheses.push_back("B");
    m_hypotheses.push_back("U");
    if(m_useCHypo){
      m_hypotheses.push_back("C");
    }
 
    // FF: comment out V0 finding
    if (m_SVForIPTool.retrieve().isFailure() )  {
       ATH_MSG_FATAL("#BTAG# Failed to retrieve tool " << m_SVForIPTool);
       return StatusCode::FAILURE;
    } else {
       ATH_MSG_DEBUG("#BTAG# Retrieved tool " << m_SVForIPTool);
    }
    if (m_trackToVertexIPEstimator.retrieve().isFailure() ) {
      ATH_MSG_FATAL("#BTAG# Failed to retrieve tool " << m_trackToVertexIPEstimator);
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG("#BTAG# Retrieved tool " << m_trackToVertexIPEstimator);
    }
    
 
    if ( m_trackSelectorTool.retrieve().isFailure() ) {
      ATH_MSG_FATAL("#BTAG# Failed to retrieve tool " << m_trackSelectorTool);
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG("#BTAG# Retrieved tool " << m_trackSelectorTool);
    }
 
    ITHistSvc* myHistoSvc;
    if( service( "THistSvc", myHistoSvc ).isSuccess() ) {
      ATH_MSG_DEBUG("#BTAG# HistoSvc loaded successfully.");
      m_histoHelper = new HistoHelperRoot(myHistoSvc);
      m_histoHelper->setCheckOverflows(m_checkOverflows);
    } else {
      ATH_MSG_ERROR("#BTAG# HistoSvc could NOT bo loaded.");
    }
 
    if ( m_trackGradeFactory.retrieve().isFailure() ) {
      ATH_MSG_FATAL("#BTAG# Failed to retrieve tool " << m_trackGradeFactory);
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG("#BTAG# Retrieved tool " << m_trackGradeFactory);
    }
    
 
    int nbPart = m_trackGradePartitionsDefinition.size();
    ATH_MSG_DEBUG("#BTAG# Defining " << nbPart <<" track partitions: ");
    for(int i=0;i<nbPart;i++) {
      TrackGradePartition* part(0);
      try {
        part = new TrackGradePartition(m_trackGradePartitionsDefinition[i],
                                       *m_trackGradeFactory);
      }
      catch (std::string error) {
        ATH_MSG_ERROR("#BTAG# Reported error " << error);
        ATH_MSG_ERROR("#BTAG# List of categories provided to IPTag by jO : ");
        for (int l=0;l<nbPart;l++) {
          ATH_MSG_ERROR("#BTAG#  string " << m_trackGradePartitionsDefinition[l]);
        }
        ATH_MSG_ERROR("#BTAG# List of categories provided by the TrackGradeFactory " << m_trackGradeFactory);
 
        const TrackGradesDefinition & trackFactoryGradesDefinition = m_trackGradeFactory->getTrackGradesDefinition();
        const std::vector<TrackGrade> & gradeList = trackFactoryGradesDefinition.getList();
        std::vector<TrackGrade>::const_iterator listIter=gradeList.begin();
        std::vector<TrackGrade>::const_iterator listEnd=gradeList.end();
        if (msgLvl(MSG::ERROR)) {
          for ( ; listIter !=listEnd ; ++listIter ) {
            ATH_MSG_ERROR("#BTAG# n. " << (*listIter).gradeNumber() << " string " << (*listIter).gradeString());
          }
        }
        ATH_MSG_ERROR("#BTAG# Terminating now... ");
        return StatusCode::FAILURE;
      }
      ATH_MSG_DEBUG((*part));
      m_trackGradePartitions.push_back(part);
    }
 
    if( m_runModus == "analysis" ) {
      if ( m_likelihoodTool.retrieve().isFailure() ) {
        ATH_MSG_FATAL("#BTAG# Failed to retrieve tool " << m_likelihoodTool);
        return StatusCode::FAILURE;
      } else {
        ATH_MSG_DEBUG("#BTAG# Retrieved tool " << m_likelihoodTool);
      }
      m_likelihoodTool->defineHypotheses(m_hypotheses);
      m_likelihoodTool->printStatus();
    }
 
    const TrackGradesDefinition & trackFactoryGradesDefinition = m_trackGradeFactory->getTrackGradesDefinition();
    const std::vector<TrackGrade> & gradeList = trackFactoryGradesDefinition.getList();
    std::vector<TrackGrade>::const_iterator listBegin=gradeList.begin();
    std::vector<TrackGrade>::const_iterator listEnd=gradeList.end();
 
    if( m_runModus == "reference" ) {
      ATH_MSG_DEBUG("#BTAG# running IPTag in reference mode");
      for(uint j=0;j<m_jetCollectionList.size();j++) {
 
        for (std::vector<TrackGrade>::const_iterator listIter=listBegin ; listIter !=listEnd ; ++listIter ) {
          const TrackGrade & grd = (*listIter);
      if(m_impactParameterView=="1D") {
        for(uint ih=0;ih<m_hypotheses.size();ih++) {
          std::string hName = "/RefFile/IP1D/" + m_jetCollectionList[j] + "/"
        + m_hypotheses[ih] + "/" + grd.gradeString() + "/SipZ0";
          ATH_MSG_VERBOSE("#BTAG# booking for IP1D: " << hName);
          m_histoHelper->bookHisto(hName,"Signed Impact Parameter (z)",400,-40.,60.);
        }
      }
      if(m_impactParameterView=="2D") {
        for(uint ih=0;ih<m_hypotheses.size();ih++) {
          std::string hName = "/RefFile/IP2D/" + m_jetCollectionList[j] + "/"
        + m_hypotheses[ih] + "/" + grd.gradeString() + "/SipA0";
          ATH_MSG_VERBOSE("#BTAG# booking for IP2D: " << hName);
          m_histoHelper->bookHisto(hName,"Signed Impact Parameter (rphi)",400,-40.,60.);
        }
      }
      if(m_impactParameterView=="3D") {
        const int nbx  = 36;
        const int nby  = 21;
        double xbi[nbx] = {-40.0,-20.0,-15.0,-10.0,-8.0,-6.0,-5.5,-5.0,-4.5,-4.0,-3.5,-3.0,-2.5,-2.0,-1.5,-1.0,-0.5,
                   0.0,0.5,1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0,5.5,6.0,8.0,10.0,15.0,20.0,40.0,60.0};
        double ybi[nby] = {-40.,-20.,-12.,-8.,-4.,-3.,-2.,-1.,-0.5,0.,0.5,1.,2.,3.,4.,6.,8.,12.,20.,40.,60.};
        for(uint ih=0;ih<m_hypotheses.size();ih++) {
          std::string hName = "/RefFile/IP3D/" + m_jetCollectionList[j] + "/"
                + m_hypotheses[ih] + "/" + grd.gradeString() + "/Sip3D";
          ATH_MSG_VERBOSE("#BTAG# booking for IP3D: " << hName);
          m_histoHelper->bookHisto(hName,"Signed IP Z0 vs (rphi)",nbx-1,xbi,nby-1,ybi);
        }
      }
    } // endloop on partitions
 
    }
      // ms m_histoHelper->print();
    }
 
    return StatusCode::SUCCESS;
  }

tagJet()

StatusCode Analysis::IPTag::tagJet ( const xAOD::Vertex &  priVtx, const xAOD::Jet &  jetToTag, xAOD::BTagging &  BTag, const std::string &  jetName  ) const

overridevirtual

author to know which jet algorithm:

for the reference mode we need the true label:

extract the TrackParticles from the jet and apply track selection:

jet direction:

prepare vectors with all track information: TP links, i.p. significances, track grade, etc

track parameters defined at the primary vertex:

use new Tool for "unbiased" IP estimation

sign of the impact parameter

option to flip signs for negative tag method

select according to sign: skip tracks if not ok

significances

fill reference histograms:

• ms

fill information to xaod:

define and compute likelihood:

fill likelihood information in xaod:

fill trackParticle links and other track informations in xaod:

Definition at line 332 of file IPTag.cxx.

  {
    ATH_MSG_VERBOSE("#BTAG# m_impactParameterView = " << m_impactParameterView );
    std::string author = jetName;
    if (m_doForcedCalib) author = m_forcedCalibName;
    ATH_MSG_VERBOSE("#BTAG# Using jet type " << author << " for calibrations.");
 
    int label = -1;
    //std::string label = "N/A";
    std::string pref  = "";
    // FF: Disable reference mode running for now
    if( m_runModus == "reference" ) {
      // here we require a jet selection:
      if( jetToTag.pt()>m_jetPtMinRef && fabs(jetToTag.eta())<2.5 ) {
    label = xAOD::jetFlavourLabel(&jetToTag);
    double deltaRtoClosestB = 999., deltaRtoClosestC = 999., deltaRtoClosestT = 999.;
        double deltaRmin(0.);
        if (jetToTag.getAttribute("TruthLabelDeltaR_B",deltaRtoClosestB)) {
          // for purification: require no b or c quark closer than dR=m_purificationDeltaR
      jetToTag.getAttribute("TruthLabelDeltaR_C",deltaRtoClosestC);
      jetToTag.getAttribute("TruthLabelDeltaR_T",deltaRtoClosestT);
          deltaRmin = deltaRtoClosestB < deltaRtoClosestC ? deltaRtoClosestB : deltaRtoClosestC;
          deltaRmin = deltaRtoClosestT < deltaRmin ? deltaRtoClosestT : deltaRmin;
        } else {
          ATH_MSG_ERROR("#BTAG# No TruthInfo ! Cannot run in reference mode !");
          return StatusCode::FAILURE;
        }
        if ( (    "B"==m_referenceType &&   5==label ) ||  // b-jets    
             ( "UDSG"==m_referenceType &&   0==label ) ||  // light jets
             (  "ALL"==m_referenceType && // all jets: b + purified light jets
            ( 5==label || 4==label || ( 0==label && deltaRmin > m_purificationDeltaR ) ) )
             ) {
          if (5==label) {
            pref = m_hypotheses[0];
            m_nbjet++;
          } else if (0==label) {
            pref = m_hypotheses[1];
            m_nljet++;
          } else if (4==label && m_useCHypo) {
            pref = m_hypotheses[2];
            m_ncjet++;
          }
        }
      }
    }
    
    std::vector<GradedTrack> tracksInJet;
    int nbPart = m_trackGradePartitionsDefinition.size();
 
    std::vector<const xAOD::TrackParticle*> TrkFromV0;
    Amg::Vector3D SvxDirection;
    bool canUseSvxDirection=false;
    
    if (m_SignWithSvx) {
      m_SVForIPTool->getDirectionFromSecondaryVertexInfo(SvxDirection,canUseSvxDirection,//output
                                                         &BTag,m_secVxFinderName,priVtx);//input
    }
    
    // bad tracks from V0s, conversions, interactions:
    m_SVForIPTool->getTrkFromV0FromSecondaryVertexInfo(TrkFromV0,//output
                                                       &BTag,m_secVxFinderName);//input
    if (TrkFromV0.size()!=0)  ATH_MSG_DEBUG("#BTAG# TrkFromV0 : number of reconstructed bad tracks: " << TrkFromV0.size());
 
    int nbTrak = 0;
    SG::AuxElement::ConstAccessor<std::vector<ElementLink<xAOD::TrackParticleContainer> > >
      trackAssocAcc (m_trackAssociationName);
    std::vector< ElementLink< xAOD::TrackParticleContainer > > associationLinks = 
      trackAssocAcc (BTag);
    double sumTrkpT = 0;
    if( associationLinks.size() == 0 ) {
        ATH_MSG_VERBOSE("#BTAG#  Could not find tracks associated with BTagging object as " << m_trackAssociationName);
    } else {
      
      std::vector< ElementLink< xAOD::TrackParticleContainer> >::const_iterator trkIter;
      // We loop over the tracks twice: the first time is to compute the summed pt of all tracks satisfying
      // the "normal" criteria; the second time a possibly tighter pt cut may be applied
      for( trkIter = associationLinks.begin(); trkIter != associationLinks.end() ; ++trkIter ) {
    const xAOD::TrackParticle* aTemp = **trkIter;
    
 
    if (m_trackSelectorTool->selectTrack(priVtx.position(),
                                             aTemp))
        {
          sumTrkpT += aTemp->pt();
        }
      }
      
      for( trkIter = associationLinks.begin(); trkIter != associationLinks.end() ; ++trkIter ) {
        const xAOD::TrackParticle* aTemp = **trkIter;
        nbTrak++;
        if( m_trackSelectorTool->selectTrack(priVtx.position(), aTemp, sumTrkpT) ) {
          TrackGrade* theGrade = m_trackGradeFactory->getGrade(*aTemp, jetToTag.p4() );
          ATH_MSG_VERBOSE("#BTAG#  result of selectTrack is OK, grade= " << theGrade->gradeString() );
      bool tobeUsed = false;
          for(int i=0;i<nbPart;i++) {
            if( std::find( (m_trackGradePartitions[i]->grades()).begin(), 
               (m_trackGradePartitions[i]->grades()).end(), 
               *theGrade ) 
        != (m_trackGradePartitions[i]->grades()).end() ) tobeUsed = true;
          }
      // is it a bad track ?
          if( std::find(TrkFromV0.begin(),TrkFromV0.end(),aTemp) != TrkFromV0.end() ) {
            ATH_MSG_VERBOSE("#BTAG# Bad track in jet, pt = " << aTemp->pt() << " eta = " 
                << aTemp->eta() << " phi = " << aTemp->phi() ); 
            if (m_RejectBadTracks) tobeUsed = false;
          }
          // check required IP sign:
          if (tobeUsed) tracksInJet.push_back(GradedTrack(*trkIter, *theGrade));
          delete theGrade;
          theGrade=0;
        }
      }
    }
 
    ATH_MSG_VERBOSE("#BTAG# #tracks = " << nbTrak);
    ATH_MSG_VERBOSE("#BTAG# the z of the primary = " << priVtx.position().z());
 
    Amg::Vector3D jetDirection(jetToTag.px(),jetToTag.py(),jetToTag.pz());
    Amg::Vector3D unit = jetDirection.unit();
    if (m_SignWithSvx && canUseSvxDirection) {
      unit = SvxDirection.unit();
      ATH_MSG_DEBUG("#BTAG# Using direction from sec vertex finder: " << 
            " phi: " << unit.phi() << " theta: " << unit.theta() << 
            " instead of jet direction phi: " << jetDirection.phi() << 
            " theta: " << jetDirection.theta() );
    }
 
    std::vector<ElementLink<xAOD::TrackParticleContainer> > IPTracks;
    std::vector<double> vectD0;
    std::vector<double> vectD0Signi;
    std::vector<double> vectZ0;
    std::vector<double> vectZ0Signi;
    std::vector<TrackGrade> vectGrades;
    std::vector<bool> vectFromV0;
    std::vector<float> vectWeightB;
    std::vector<float> vectWeightU;
    std::vector<float> vectWeightC;
    std::vector<myIPxDinfo> vectObj;
 
    // reserve approximate space (optimization):
    const int nbTrackMean = 5;
    vectD0.reserve(nbTrackMean);
    vectD0Signi.reserve(nbTrackMean);
    vectZ0.reserve(nbTrackMean);
    vectZ0Signi.reserve(nbTrackMean);
    vectGrades.reserve(nbTrackMean);
    vectFromV0.reserve(nbTrackMean);
    vectWeightB.reserve(nbTrackMean);
    vectWeightU.reserve(nbTrackMean);
    vectWeightC.reserve(nbTrackMean);
    vectObj.reserve(nbTrackMean);
 
    for (std::vector<GradedTrack>::iterator trkItr = tracksInJet.begin(); 
         trkItr != tracksInJet.end(); ++trkItr) {
 
      const xAOD::TrackParticle* trk = *(trkItr->track);
      bool isFromV0 = (std::find(TrkFromV0.begin(),TrkFromV0.end(),trk) != TrkFromV0.end());
 
      double d0wrtPriVtx(0.);
      double z0wrtPriVtx(0.);
      double d0ErrwrtPriVtx(1.);
      double z0ErrwrtPriVtx(1.);
 
      std::unique_ptr<Trk::ImpactParametersAndSigma> myIPandSigma = nullptr;
      if (m_trackToVertexIPEstimator) { 
        myIPandSigma = m_trackToVertexIPEstimator->estimate(trk, &priVtx, m_unbiasIPEstimation);
      }
      if(0==myIPandSigma) {
        ATH_MSG_WARNING("#BTAG# IPTAG: trackToVertexIPEstimator failed !");
      } else {
        d0wrtPriVtx=myIPandSigma->IPd0;
        d0ErrwrtPriVtx=myIPandSigma->sigmad0;
        z0wrtPriVtx=myIPandSigma->IPz0SinTheta;
        z0ErrwrtPriVtx=myIPandSigma->sigmaz0SinTheta;
      }
 
      double signOfIP(1.);
      if (m_impactParameterView=="2D" || m_impactParameterView=="1D" ||
         ( m_impactParameterView=="3D" && m_use2DSignForIP3D)  ) {
        signOfIP=m_trackToVertexIPEstimator->get2DLifetimeSignOfTrack(trk->perigeeParameters(),
                                                                      unit, priVtx);
      }
      if (m_impactParameterView=="3D" && !m_use2DSignForIP3D) {
        signOfIP=m_trackToVertexIPEstimator->get3DLifetimeSignOfTrack(trk->perigeeParameters(),
                                                                      unit, priVtx);
      }
      double signOfZIP = m_trackToVertexIPEstimator->getZLifetimeSignOfTrack(trk->perigeeParameters(),
                                                                             unit, priVtx);
 
      if (m_useD0SignForZ0) signOfZIP = signOfIP;
 
      if(m_flipIP  && m_runModus!="reference")  signOfIP = -signOfIP;
      if(m_flipZIP && m_runModus!="reference") signOfZIP = -signOfZIP;
 
      if( m_runModus != "reference" ) {
        if(signOfIP>0 && !m_usePosIP) continue;
        if(signOfIP<0 && !m_useNegIP) continue;
        if( m_useZIPSignForPosNeg ) {
          if(m_impactParameterView=="3D" && signOfZIP>0 && !m_usePosIP) continue;
          if(m_impactParameterView=="3D" && signOfZIP<0 && !m_useNegIP) continue;
        }
      }
 
      double sIP         = signOfIP*fabs(d0wrtPriVtx);
      double significance= signOfIP*fabs(d0wrtPriVtx/d0ErrwrtPriVtx);
      double szIP        = signOfZIP*fabs(z0wrtPriVtx);
      double z0Sig       = signOfZIP*fabs(z0wrtPriVtx/z0ErrwrtPriVtx);
 
      ATH_MSG_VERBOSE("#BTAG# IPTAG: Trk: grade= " << trkItr->grade.gradeString()
            << " Eta= " << trk->eta() << " Phi= " << trk->phi() << " pT= " << trk->pt()
            << " d0= " << sIP
            << "+-" << d0ErrwrtPriVtx
            << " sigd0= " << significance
            << " z0= " << szIP
            << "+-" << z0ErrwrtPriVtx
            << " sigz0= " << z0Sig);
      
      // VD: I know that this is ugly but I want to minimise the changes as much as I can
      myIPxDinfo tmpObj;
      tmpObj.trk=trkItr->track;
      tmpObj.d0   =sIP;
      tmpObj.d0sig=significance;
      tmpObj.z0   =szIP;
      tmpObj.z0sig=z0Sig;
      tmpObj.grade=trkItr->grade;
      tmpObj.trkP =trk;
      tmpObj.fromV0=isFromV0;
      // compute individual track contribution to likelihood:
      double tpb = 0., tpu = 0., tpc = 0.;
      this->trackWeight(author,trkItr->grade,significance,z0Sig,tpb,tpu,tpc);
      tmpObj.wB   =tpb;
      tmpObj.wU   =tpu;
      tmpObj.wC   =tpc;
      vectObj.push_back(tmpObj);
    }
 
    if (m_sortPt)      std::sort( vectObj.begin() , vectObj.end() , StructPTsorting );
    if (m_sortD0sig)   std::sort( vectObj.begin() , vectObj.end() , StructD0Sigsorting );
    if (m_sortZ0D0sig) std::sort( vectObj.begin() , vectObj.end() , StructZ0D0Sigsorting );
    
    int resizeVal=vectObj.size();
    if (m_NtrkMax!=1000) {
      if ( m_trkFract==1.0 ) {
    if ( m_NtrkMax<resizeVal ) resizeVal=m_NtrkMax;
      } else {
    int resizeVal2=(int)( (float)resizeVal*m_trkFract);
    if (resizeVal<m_NtrkMin) resizeVal=m_NtrkMin;
    if ( resizeVal2<resizeVal ) resizeVal=resizeVal2;
      }
    }
    //std::cout << "before resizing: " << vectObj.size() << std::endl;
    vectObj.resize(resizeVal);
    //std::cout << "after resizing: " << vectObj.size() << std::endl;
    
    for (unsigned int i=0; i<vectObj.size(); i++) {
      //if( m_impactParameterView=="3D" ) std::cout << i << " track pt: " << ((vectObj[i]).trkP)->pt() << "   d0sig: " << (vectObj[i]).d0sig << std::endl;
      if( m_runModus == "reference" ) {
    if( !pref.empty() ) { // current jet passes selection for Sig or Bkg
      ATH_MSG_DEBUG("#BTAG# filling ref histo for " << pref);
          const TrackGradesDefinition & trackFactoryGradesDefinition = m_trackGradeFactory->getTrackGradesDefinition();
          const std::vector<TrackGrade> & gradeList = trackFactoryGradesDefinition.getList();
          std::vector<TrackGrade>::const_iterator listIter=gradeList.begin();
          std::vector<TrackGrade>::const_iterator listEnd=gradeList.end();
          for ( ; listIter !=listEnd ; ++listIter ) {
            const TrackGrade & grd = (*listIter);
        ATH_MSG_DEBUG("#BTAG#   filling ref histo for grade " << grd.gradeString() );
        if( grd==(vectObj[i]).grade ) { // check the grade of current track
          ATH_MSG_DEBUG("#BTAG#   track is of required grade ");
              const std::string suffix = "_" + grd.gradeString();
              if( m_impactParameterView=="1D" ) {
            std::string hName = "/RefFile/IP1D/" + author + "/"
          + pref + "/" + grd.gradeString() + "/SipZ0";
            ATH_MSG_DEBUG("#BTAG#   histo 1D: " << hName);
        m_histoHelper->fillHisto(hName, (vectObj[i]).z0sig );
          }
              if( m_impactParameterView=="2D" ) {
            std::string hName = "/RefFile/IP2D/" + author + "/"
          + pref + "/" + grd.gradeString() + "/SipA0";
            ATH_MSG_DEBUG("#BTAG#   histo 2D: " << hName);
        m_histoHelper->fillHisto(hName, (vectObj[i]).d0sig );
          }
              if( m_impactParameterView=="3D" ) {
            std::string hName = "/RefFile/IP3D/" + author + "/"
          + pref + "/" + grd.gradeString() + "/Sip3D";
            ATH_MSG_DEBUG("#BTAG#   histo 3D: " << hName);
        m_histoHelper->fillHisto(hName,(vectObj[i]).d0sig, (vectObj[i]).z0sig);
          }
        }
      }
    }
      }//*/ ////// END of reference mode ....
 
      IPTracks.push_back( (vectObj[i]).trk );
      vectD0.push_back( (vectObj[i]).d0 );
      vectD0Signi.push_back( (vectObj[i]).d0sig );
      vectZ0.push_back( (vectObj[i]).z0 );
      vectZ0Signi.push_back( (vectObj[i]).z0sig );
      vectGrades.push_back( (vectObj[i]).grade );
      vectFromV0.push_back( (vectObj[i]).fromV0 );
      vectWeightB.push_back( (vectObj[i]).wB );
      vectWeightU.push_back( (vectObj[i]).wU );
      vectWeightC.push_back( (vectObj[i]).wC );
 
    } // endloop on tracks
 
    if(m_runModus=="analysis") {
 
      std::vector<Slice> slices;
      for(unsigned int i=0; i<vectD0Signi.size(); i++) {
        if(m_impactParameterView=="3D") {
          AtomicProperty atom1(vectD0Signi[i],"Significance of IP (rphi)");
          AtomicProperty atom2(vectZ0Signi[i],"Significance of Z0");
          std::string compoName(author+"#");
          compoName += vectGrades[i].gradeString();
          compoName += "/Sip3D";
          Composite compo1(compoName);
          compo1.atoms.push_back(atom1);
          compo1.atoms.push_back(atom2);
          Slice slice1("IP3D");
          slice1.composites.push_back(compo1);
          slices.push_back(slice1);
        }
        if(m_impactParameterView=="2D") {
          AtomicProperty atom1(vectD0Signi[i],"Significance of IP (rphi)");
          std::string compoName(author+"#");
          compoName += vectGrades[i].gradeString();
          compoName += "/SipA0";
          Composite compo1(compoName);
          compo1.atoms.push_back(atom1);
          Slice slice1("IP2D");
          slice1.composites.push_back(compo1);
          slices.push_back(slice1);
        }
        if(m_impactParameterView=="1D") {
          AtomicProperty atom1(vectZ0Signi[i],"Significance of IP (z)");
          std::string compoName(author+"#");
          compoName += vectGrades[i].gradeString();
          compoName += "/SipZ0";
          Composite compo1(compoName);
          compo1.atoms.push_back(atom1);
          Slice slice1("IP1D");
          slice1.composites.push_back(compo1);
          slices.push_back(slice1);
        }
      }
      std::vector<double> lkl;
      lkl.reserve(3);
      if(vectD0Signi.size()>0) {
        lkl = m_likelihoodTool->calculateLikelihood(slices);
        if (lkl.size() != 3) {
          ATH_MSG_WARNING("#BTAG# likelihood size is " << lkl.size() << " expected size is 3");
          lkl.resize(3,0.0);
        }
      } else {
        lkl.push_back(1.);
        lkl.push_back(1.e9);
        lkl.push_back(1.e9);
      }
 
        ATH_MSG_DEBUG("#BTAG# likelihood : number of values = " << lkl.size() );
        ATH_MSG_DEBUG("#BTAG# likelihood : " 
        << "pb= " << lkl[0] << " pu= " << lkl[1] << " pc= " << lkl[2] );
 
      BTag.setVariable<float>(m_xAODBaseName, "pb", lkl[0]);
      BTag.setVariable<float>(m_xAODBaseName, "pu", lkl[1]);
      if (m_useCHypo) BTag.setVariable<float>(m_xAODBaseName, "pc", lkl[2]);
 
      if (IPTracks.size() == 0) {
        ATH_MSG_VERBOSE("#BTAG# IPTracks is empty.");
      }
      else
      {
    ATH_MSG_VERBOSE("#BTAG# IPTracks is not empty: "<<IPTracks.size());
      }
      // NB: all vector<double> are converted as vector<float> for persistency.
      std::vector<float> f_vectD0( vectD0.begin(), vectD0.end() );
      std::vector<float> f_vectD0Signi( vectD0Signi.begin(), vectD0Signi.end() );
      std::vector<float> f_vectZ0( vectZ0.begin(), vectZ0.end() );
      std::vector<float> f_vectZ0Signi( vectZ0Signi.begin(), vectZ0Signi.end() );
      std::vector<int> i_vectGrades( vectGrades.begin(), vectGrades.end() );
      // specific fast accessors for mainstream instances of IPTag: IP3D, IP2D
      if( "IP3D"==m_xAODBaseName ) {
        if (m_storeTrackParticles) BTag.setIP3D_TrackParticleLinks(IPTracks);
        if (m_storeIpValues) {
          BTag.setTaggerInfo(f_vectD0,      xAOD::BTagInfo::IP3D_valD0wrtPVofTracks);
          BTag.setTaggerInfo(f_vectZ0,      xAOD::BTagInfo::IP3D_valZ0wrtPVofTracks);
        }
        if (m_storeTrackParameters) {
          BTag.setTaggerInfo(f_vectD0Signi, xAOD::BTagInfo::IP3D_sigD0wrtPVofTracks);
          BTag.setTaggerInfo(f_vectZ0Signi, xAOD::BTagInfo::IP3D_sigZ0wrtPVofTracks);
          BTag.setTaggerInfo(vectWeightB,   xAOD::BTagInfo::IP3D_weightBofTracks);
          BTag.setTaggerInfo(vectWeightU,   xAOD::BTagInfo::IP3D_weightUofTracks);
          BTag.setTaggerInfo(vectWeightC,   xAOD::BTagInfo::IP3D_weightCofTracks);
          BTag.setTaggerInfo(vectFromV0,    xAOD::BTagInfo::IP3D_flagFromV0ofTracks);
          BTag.setTaggerInfo(i_vectGrades,  xAOD::BTagInfo::IP3D_gradeOfTracks);
        }
      } else {
        if( "IP2D"==m_xAODBaseName ) {
          if (m_storeTrackParticles) BTag.setIP2D_TrackParticleLinks(IPTracks);
          if (m_storeIpValues) BTag.setTaggerInfo(f_vectD0,      xAOD::BTagInfo::IP2D_valD0wrtPVofTracks);
          if (m_storeTrackParameters) {
            BTag.setTaggerInfo(f_vectD0Signi, xAOD::BTagInfo::IP2D_sigD0wrtPVofTracks);
            BTag.setTaggerInfo(vectWeightB,   xAOD::BTagInfo::IP2D_weightBofTracks);
            BTag.setTaggerInfo(vectWeightU,   xAOD::BTagInfo::IP2D_weightUofTracks);
            BTag.setTaggerInfo(vectWeightC,   xAOD::BTagInfo::IP2D_weightCofTracks);
            BTag.setTaggerInfo(vectFromV0,    xAOD::BTagInfo::IP2D_flagFromV0ofTracks);
            BTag.setTaggerInfo(i_vectGrades,  xAOD::BTagInfo::IP2D_gradeOfTracks);
          }
        } else { // generic accessors
          if (m_storeTrackParticles) {
            BTag.setVariable<std::vector<ElementLink<xAOD::TrackParticleContainer> > > (
              m_xAODBaseName, "TrackParticleLinks", IPTracks );
            BTag.setDynTPELName( m_xAODBaseName, "TrackParticleLinks");
          }
          if (m_storeIpValues) {
            BTag.setVariable< std::vector<float> > (m_xAODBaseName, "valD0wrtPVofTracks", f_vectD0);
            if (m_impactParameterView=="3D") {
              BTag.setVariable< std::vector<float> > (m_xAODBaseName, "valZ0wrtPVofTracks", f_vectZ0);
            }
          }
          if (m_storeTrackParameters) {
            BTag.setVariable< std::vector<float> > (m_xAODBaseName, "sigD0wrtPVofTracks", f_vectD0Signi);
            if(m_impactParameterView=="3D") {
              BTag.setVariable< std::vector<float> > (m_xAODBaseName, "sigZ0wrtPVofTracks", f_vectZ0Signi);
            }
            BTag.setVariable< std::vector<float> > (m_xAODBaseName, "weightBofTracks",    vectWeightB);
            BTag.setVariable< std::vector<float> > (m_xAODBaseName, "weightUofTracks",    vectWeightU);
            BTag.setVariable< std::vector<float> > (m_xAODBaseName, "weightCofTracks",    vectWeightC);
            BTag.setVariable< std::vector<bool> >  (m_xAODBaseName, "flagFromV0ofTracks", vectFromV0);
            BTag.setVariable< std::vector<int> >   (m_xAODBaseName, "gradeOfTracks",      i_vectGrades);
          }
        }
      }
    }
 
    return StatusCode::SUCCESS;
  }

trackWeight()

void Analysis::IPTag::trackWeight	(	const std::string &	jetAuthor,
		const TrackGrade &	grade,
		double	sa0,
		double	sz0,
		double &	twb,
		double &	twu,
		double &	twc
	)		const

calculate individual track contribution to the three likelihoods:

compute individual track contribution to the likelihoods:

define and compute likelihood:

Definition at line 796 of file IPTag.cxx.

                                                     { // output parameters
    std::vector<Slice> slices;
    if(m_impactParameterView=="3D") {
      AtomicProperty atom1(sa0,"Significance of IP (rphi)");
      AtomicProperty atom2(sz0,"Significance of Z0");
      std::string compoName(author+"#");
      compoName += grade.gradeString();
      compoName += "/Sip3D";
      Composite compo1(compoName);
      compo1.atoms.push_back(atom1);
      compo1.atoms.push_back(atom2);
      Slice slice1("IP3D");
      slice1.composites.push_back(compo1);
      slices.push_back(slice1);
    }
    if(m_impactParameterView=="2D") {
      AtomicProperty atom1(sa0,"Significance of IP (rphi)");
      std::string compoName(author+"#");
      compoName += grade.gradeString();
      compoName += "/SipA0";
      Composite compo1(compoName);
      compo1.atoms.push_back(atom1);
      Slice slice1("IP2D");
      slice1.composites.push_back(compo1);
      slices.push_back(slice1);
    }
    if(m_impactParameterView=="1D") {
      AtomicProperty atom1(sz0,"Significance of IP (z)");
      std::string compoName(author+"#");
      compoName += grade.gradeString();
      compoName += "/SipZ0";
      Composite compo1(compoName);
      compo1.atoms.push_back(atom1);
      Slice slice1("IP1D");
      slice1.composites.push_back(compo1);
      slices.push_back(slice1);
    }
    std::vector<double> tmp = m_likelihoodTool->calculateLikelihood(slices);
    twb = tmp[0];
    twu = tmp[1];
    twc = 0.;
    if(m_useCHypo) twc = tmp[2];
  }

Member Data Documentation

m_checkOverflows

bool Analysis::IPTag::m_checkOverflows

private

Definition at line 84 of file IPTag.h.

m_doForcedCalib

bool Analysis::IPTag::m_doForcedCalib

private

Definition at line 85 of file IPTag.h.

m_flipIP

bool Analysis::IPTag::m_flipIP

private

VD: bool switches.

Definition at line 72 of file IPTag.h.

m_flipZIP

bool Analysis::IPTag::m_flipZIP

private

Definition at line 73 of file IPTag.h.

m_forcedCalibName

std::string Analysis::IPTag::m_forcedCalibName

private

forcing the calibration folder of a given collection

Definition at line 102 of file IPTag.h.

m_histoHelper

HistoHelperRoot* Analysis::IPTag::m_histoHelper

private

Histogram Helper Class.

Definition at line 69 of file IPTag.h.

m_hypotheses

std::vector<std::string> Analysis::IPTag::m_hypotheses

private

Definition at line 120 of file IPTag.h.

m_impactParameterView

std::string Analysis::IPTag::m_impactParameterView

private

specify the tag type (1D or 2D)

Definition at line 99 of file IPTag.h.

m_jetCollectionList

std::vector<std::string> Analysis::IPTag::m_jetCollectionList

private

Definition at line 124 of file IPTag.h.

m_jetPtMinRef

double Analysis::IPTag::m_jetPtMinRef

private

Definition at line 107 of file IPTag.h.

m_likelihoodTool

ToolHandle< NewLikelihoodTool > Analysis::IPTag::m_likelihoodTool

private

Pointer to the likelihood tool.

Definition at line 132 of file IPTag.h.

m_nbjet

std::atomic<int> Analysis::IPTag::m_nbjet

mutableprivate

Definition at line 144 of file IPTag.h.

m_ncjet

std::atomic<int> Analysis::IPTag::m_ncjet

mutableprivate

Definition at line 145 of file IPTag.h.

m_nljet

std::atomic<int> Analysis::IPTag::m_nljet

mutableprivate

Definition at line 146 of file IPTag.h.

m_NtrkMax

int Analysis::IPTag::m_NtrkMax

private

Definition at line 114 of file IPTag.h.

m_NtrkMin

int Analysis::IPTag::m_NtrkMin

private

additional switch for smart track selection

Definition at line 113 of file IPTag.h.

m_purificationDeltaR

double Analysis::IPTag::m_purificationDeltaR

private

Definition at line 106 of file IPTag.h.

m_referenceType

std::string Analysis::IPTag::m_referenceType

private

for reference mode:

Definition at line 105 of file IPTag.h.

m_RejectBadTracks

bool Analysis::IPTag::m_RejectBadTracks

private

Definition at line 82 of file IPTag.h.

m_runModus

std::string Analysis::IPTag::m_runModus

private

This switch is needed to indicate what to do.

The algorithm can be run to produce reference histograms from the given MC files (m_runModus=0) or to work in analysis mode (m_runModus=1) where already made reference histograms are read. 0=Do not read histos, 1=Read referece histos (analysis mode)

Definition at line 63 of file IPTag.h.

m_secVxFinderName

std::string Analysis::IPTag::m_secVxFinderName

private

names of fools for getting the secondary vertex information

Definition at line 110 of file IPTag.h.

m_SignWithSvx

bool Analysis::IPTag::m_SignWithSvx

private

Definition at line 83 of file IPTag.h.

m_sortD0sig

bool Analysis::IPTag::m_sortD0sig

private

Definition at line 80 of file IPTag.h.

m_sortOption

std::string Analysis::IPTag::m_sortOption

private

Definition at line 116 of file IPTag.h.

m_sortPt

bool Analysis::IPTag::m_sortPt

private

Definition at line 79 of file IPTag.h.

m_sortZ0D0sig

bool Analysis::IPTag::m_sortZ0D0sig

private

Definition at line 81 of file IPTag.h.

m_storeIpValues

bool Analysis::IPTag::m_storeIpValues

private

Definition at line 91 of file IPTag.h.

m_storeTrackParameters

bool Analysis::IPTag::m_storeTrackParameters

private

Definition at line 92 of file IPTag.h.

m_storeTrackParticles

bool Analysis::IPTag::m_storeTrackParticles

private

Definition at line 90 of file IPTag.h.

m_SVForIPTool

ToolHandle< SVForIPTool > Analysis::IPTag::m_SVForIPTool

private

Pointer to the SV tool.

Definition at line 135 of file IPTag.h.

m_trackAssociationName

std::string Analysis::IPTag::m_trackAssociationName

private

Name of the track-to-jet association in the BTagging object.

Definition at line 96 of file IPTag.h.

m_trackGradeFactory

ToolHandle< ITrackGradeFactory > Analysis::IPTag::m_trackGradeFactory

private

ToolHandle for the ITrackGradeFactory tool.

Definition at line 138 of file IPTag.h.

m_trackGradePartitions

std::vector<TrackGradePartition*> Analysis::IPTag::m_trackGradePartitions

private

Definition at line 123 of file IPTag.h.

m_trackGradePartitionsDefinition

std::vector<std::string> Analysis::IPTag::m_trackGradePartitionsDefinition

private

track classification.

Definition at line 122 of file IPTag.h.

m_trackSelectorTool

ToolHandle< TrackSelector > Analysis::IPTag::m_trackSelectorTool

private

Track selection cuts for IPTagging.

Definition at line 129 of file IPTag.h.

m_trackToVertexIPEstimator

ToolHandle< Trk::ITrackToVertexIPEstimator > Analysis::IPTag::m_trackToVertexIPEstimator

private

GP: Tool for the estimation of the IPs to the Vertex.

Definition at line 141 of file IPTag.h.

m_trkFract

float Analysis::IPTag::m_trkFract

private

Definition at line 115 of file IPTag.h.

m_unbiasIPEstimation

bool Analysis::IPTag::m_unbiasIPEstimation

private

Definition at line 87 of file IPTag.h.

m_use2DSignForIP3D

bool Analysis::IPTag::m_use2DSignForIP3D

private

Definition at line 77 of file IPTag.h.

m_useCHypo

bool Analysis::IPTag::m_useCHypo

private

Definition at line 86 of file IPTag.h.

m_useD0SignForZ0

bool Analysis::IPTag::m_useD0SignForZ0

private

Definition at line 78 of file IPTag.h.

m_useNegIP

bool Analysis::IPTag::m_useNegIP

private

Definition at line 75 of file IPTag.h.

m_usePosIP

bool Analysis::IPTag::m_usePosIP

private

Definition at line 74 of file IPTag.h.

m_useZIPSignForPosNeg

bool Analysis::IPTag::m_useZIPSignForPosNeg

private

Definition at line 76 of file IPTag.h.

m_xAODBaseName

std::string Analysis::IPTag::m_xAODBaseName

private

base name string for persistification in xaod

Definition at line 66 of file IPTag.h.

---

The documentation for this class was generated from the following files:

• IPTag.h
• IPTag.cxx