BTagging_v1.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: BTagging_v1.h 797330 2017-02-15 14:25:13Z guirriec $
#ifndef XAODBTAGGING_VERSIONS_BTAGGING_V1_H
#define XAODBTAGGING_VERSIONS_BTAGGING_V1_H
 
// Core include(s):
#include "AthContainers/AuxElement.h"
#include "AthLinks/ElementLink.h"
 
// xAOD include(s):
#include "xAODBTagging/BTaggingEnums.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODTracking/VertexContainer.h"
#include "xAODJet/JetContainer.h"
#include "xAODBTagging/BTagVertexContainer.h"
 
// STL include(s):
#include <map>
#include <vector>
#include <string>
#include <iostream>
#include "CxxUtils/checker_macros.h"
 
namespace xAOD {

  class BTagging_v1 : public SG::AuxElement {
 
  public:

    typedef std::vector< ElementLink< xAOD::TrackParticleContainer > >
    TPELVec_t;
    typedef std::vector<ElementLink<xAOD::VertexContainer> > VxELVec_t;
    typedef std::vector<ElementLink<xAOD::BTagVertexContainer> > BTagVxELVec_t;


    BTagging_v1();



    float SV0_significance3D() const;
    void setSV0_significance3D(float value);
    const TPELVec_t& SV0_TrackParticleLinks() const;
    void setSV0_TrackParticleLinks( const TPELVec_t& value );
    const xAOD::TrackParticle* SV0_TrackParticle( size_t i ) const;
    size_t nSV0_TrackParticles() const;
    void addSV0_TrackParticle(const ElementLink< xAOD::TrackParticleContainer >& link);
    void clearSV0_TrackParticleLinks();



    float SV1_pb() const;
    void setSV1_pb(float value);
    float SV1_pc() const;
    void setSV1_pc(float value);
    float SV1_pu() const;
    void setSV1_pu(float value);
    double SV1_loglikelihoodratio() const { return this->calcLLR(SV1_pb(),SV1_pu()); }
    const TPELVec_t& SV1_TrackParticleLinks() const;
    void setSV1_TrackParticleLinks( const TPELVec_t& value );
    const xAOD::TrackParticle* SV1_TrackParticle( size_t i ) const;
    size_t nSV1_TrackParticles() const;
    void addSV1_TrackParticle(const ElementLink< xAOD::TrackParticleContainer > & link);
    void clearSV1_TrackParticleLinks();



    float IP2D_pb() const;
    void setIP2D_pb(float value);
    float IP2D_pc() const;
    void setIP2D_pc(float value);
    float IP2D_pu() const;
    void setIP2D_pu(float value);
    float IP2D_loglikelihoodratio() const { return this->calcLLR(IP2D_pb(),IP2D_pu()); }
    const TPELVec_t& IP2D_TrackParticleLinks() const;
    void setIP2D_TrackParticleLinks( const TPELVec_t& value );
    const xAOD::TrackParticle* IP2D_TrackParticle( size_t i ) const;
    size_t nIP2D_TrackParticles() const;
    void addIP2D_TrackParticle(const ElementLink< xAOD::TrackParticleContainer > & link);
    void clearIP2D_TrackParticleLinks();

    

    float IP3D_pb() const;
    void setIP3D_pb(float value);
    float IP3D_pc() const;
    void setIP3D_pc(float value);
    float IP3D_pu() const;
    void setIP3D_pu(float value);
    float IP3D_loglikelihoodratio() const { return ( (IP3D_pb()==1.&&IP3D_pu()==1.e9) ? 0. : 
                                                      this->calcLLR(IP3D_pb(),IP3D_pu()) ); }

    const TPELVec_t& IP3D_TrackParticleLinks() const;
    void setIP3D_TrackParticleLinks( const TPELVec_t& value );
    const xAOD::TrackParticle* IP3D_TrackParticle( size_t i ) const;
    size_t nIP3D_TrackParticles() const;
    void addIP3D_TrackParticle(const ElementLink< xAOD::TrackParticleContainer > & link);
    void clearIP3D_TrackParticleLinks();


 
    float SV1plusIP3D_discriminant() const {
      return SV1_loglikelihoodratio() + IP3D_loglikelihoodratio();
    }



    float JetFitter_pb() const;
    void setJetFitter_pb(float value);
    float JetFitter_pc() const;
    void setJetFitter_pc(float value);
    float JetFitter_pu() const;
    void setJetFitter_pu(float value);
    float JetFitter_loglikelihoodratio() const { return this->calcLLR(JetFitter_pb(),JetFitter_pu()); }
 



    float MV1_discriminant() const;
    void setMV1_discriminant(float value);

 

    bool loglikelihoodratio(const std::string& taggername, double &value, 
                            const std::string& signal="pb", const std::string& bckgd="pu") const;
    bool MVx_discriminant(const std::string& taggername, double &value) const;
    bool pu(const std::string& taggername, double &value) const;
    bool pb(const std::string& taggername, double &value) const;
    bool pc(const std::string& taggername, double &value) const;
    bool ptau( const std::string& taggername, double &value) const;
    float calcLLR(double num, double den) const;
 

 
 

    bool taggerInfo(int& value, BTagInfo info) const;
    bool taggerInfo(float& value, BTagInfo info) const;
    bool taggerInfo(bool& value, BTagInfo info) const;
    bool taggerInfo(std::string& value, BTagInfo info) const;
    bool taggerInfo(std::vector<int>& value, BTagInfo info) const;
    bool taggerInfo(std::vector<float>& value, BTagInfo info) const;
    bool taggerInfo(std::vector<bool>& value, BTagInfo info) const;

    void setTaggerInfo(int value, BTagInfo info);
    void setTaggerInfo(float value, BTagInfo info);
    void setTaggerInfo(bool value, BTagInfo info);
    void setTaggerInfo(const std::string& value, BTagInfo info);
    void setTaggerInfo(const std::vector<int>& value, BTagInfo info);
    void setTaggerInfo(const std::vector<float>& value, BTagInfo info);
    void setTaggerInfo(const std::vector<bool>& value, BTagInfo info);



    template< class T >
    bool variable(const std::string &taggername,
                  const std::string &variablename, T &value) const;

    template< class T >
    void setVariable(const std::string &taggername,
                     const std::string &variablename, const T &value);


    void toPersistent();
 
    void setDynTPELName (const std::string &taggername,
                         const std::string &variablename);
    void setDynVxELName (const std::string &taggername,
                         const std::string &variablename);
    void setDynBTagVxELName (const std::string &taggername,
                             const std::string &variablename);
 
 
  }; // class BTagging
 
  template< class T >
  inline
  bool BTagging_v1::variable( const std::string &taggername,
                              const std::string &variablename,
                              T& value ) const {
 
    const std::string varname = taggername+ "_" + variablename;
    Accessor< T > acc( varname );
    if( ! acc.isAvailable( *this ) ) return false;
    value = acc( *this );
    return true;
  }
 
  template< class T >
  inline
  void BTagging_v1::setVariable( const std::string &taggername,
                                 const std::string &variablename,
                                 const T &value ) {
 
    const std::string varname = taggername+ "_" + variablename;
    Accessor< T > acc( varname );
    acc( *this ) = value;
    return;
  }
 
} // namespace xAOD
 
#endif // XAODBTAGGING_VERSIONS_BTAGGING_V1_H