InDetTrackTruthOriginDefs.h

Go to the documentation of this file.

// -*- c++ -*-
/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETTRACKSYSTEMATICSTOOLS_INDETTRACKTRUTHORIGINDEFS_H
#define INDETTRACKSYSTEMATICSTOOLS_INDETTRACKTRUTHORIGINDEFS_H

 
namespace InDet {
  namespace ExclusiveOrigin {
    enum ExclusiveOrigin : int {
      Pileup         = 0,
      Fake           = 1,
      Primary        = 2,
      FromB          = 3,
      FromBC         = 4,
      FromC          = 5,
      FromTau        = 6,
      OtherSecondary = 7
    };
  } // namespace ExclusiveOrigin
  
  namespace TrkOrigin {
 
    enum OriginType {
      // fake
      Fake=0,
      // pileup
      Pileup,
      // secondaries
      KshortDecay,
      StrangeMesonDecay,
      LambdaDecay,
      StrangeBaryonDecay,
      TauDecay,
      GammaConversion,
      OtherDecay,
      HadronicInteraction,
      OtherSecondary,
      // B/D decays
      BHadronDecay,
      DHadronDecay,
      // fragmentation
      Fragmentation,
      // unknown?
      OtherOrigin
    };


    inline bool isFake(int origin) {
      if (origin & (0x1 << Fake)) return true;
      return false;
    }

    inline bool isPileup(int origin) {
      if (origin & (0x1 << Pileup)) return true;
      return false;
    }

    inline bool isV0Decay(int origin) {
      if (origin & (0x1 << KshortDecay)) return true;
      if (origin & (0x1 << LambdaDecay)) return true;
      return false;
    }

    inline bool isKshortDecay(int origin) {
      if (origin & (0x1 << KshortDecay)) return true;
      return false;
    }

    inline bool isLambdaDecay(int origin) {
      if (origin & (0x1 << LambdaDecay)) return true;
      return false;
    }

    inline bool isStrangeMesonDecay(int origin) {
      if (origin & (0x1 << StrangeMesonDecay)) return true;
      return false;
    }

    inline bool isStrangeBaryonDecay(int origin) {
      if (origin & (0x1 << StrangeBaryonDecay)) return true;
      return false;
    }

    inline bool isGammaConversion(int origin) {
      if (origin & (0x1 << GammaConversion)) return true;
      return false;
    }

    inline bool isHadronicInteraction(int origin) {
      if (origin & (0x1 << HadronicInteraction)) return true;
      return false;
    }

    inline bool isFromTau(int origin) {
      if (origin & (0x1 << TauDecay)) return true;
      return false;
    }

    inline bool isSecondary(int origin) {
      static constexpr auto bit=[](int bitpos){return 0x1<<bitpos;};
      static constexpr int isSecondaryMask=bit(StrangeMesonDecay)|bit(StrangeBaryonDecay)|bit(GammaConversion)|bit(HadronicInteraction)|bit(OtherDecay)|bit(OtherSecondary);
      return (origin & isSecondaryMask);
    }

    inline bool isFromB(int origin) {
      if (origin & (0x1 << BHadronDecay)) return true;
      return false;
    }

    inline bool isFromD(int origin) {
      if (origin & (0x1 << DHadronDecay)) return true;
      return false;
    }

    inline bool isFromBNotFromD(int origin) {
      if (isFromD(origin)) return false;
      if (origin & (0x1 << BHadronDecay)) return true;
      return false;
    }

    inline bool isFromDNotFromB(int origin) {
      if (isFromB(origin)) return false;
      if (origin & (0x1 << DHadronDecay)) return true;
      return false;
    }

    inline bool isFromDfromB(int origin) {
      if (isFromB(origin) && isFromD(origin)) return true;
      return false;
    }

    inline bool isFragmentation(int origin) {
      if (origin & (0x1 << Fragmentation)) return true;
      return false;
    }

    inline bool isPrimary(int origin) {
      if (isFake(origin)) return false;
      if (isPileup(origin)) return false;
      if (isSecondary(origin)) return false;
      if (origin & (0x1 << OtherOrigin)) return false;
      return true;
    }
 
    inline int getTrkOrigin(int exclusiveOrigin) {
      /*
        input is exclusive origin enum value
        Here we convert from exclusive origin (used by ftag) to trk origin (bitmask used by track truth tools) 
      */
      switch (exclusiveOrigin) {
        case ExclusiveOrigin::Pileup:
          return (0x1 << Pileup);
        case ExclusiveOrigin::Fake:
          return (0x1 << Fake);
        case ExclusiveOrigin::FromB:
          return (0x1 << BHadronDecay);
        case ExclusiveOrigin::FromBC:
          return (0x1 << BHadronDecay) | (0x1 << DHadronDecay);
        case ExclusiveOrigin::FromC:
          return (0x1 << DHadronDecay);
        case ExclusiveOrigin::FromTau:
          return (0x1 << TauDecay);
        case ExclusiveOrigin::OtherSecondary:
          return (0x1 << StrangeMesonDecay) | (0x1 << StrangeBaryonDecay) | (0x1 << GammaConversion) | (0x1 << HadronicInteraction) | (0x1 << OtherDecay) | (0x1 << OtherSecondary);
        case ExclusiveOrigin::Primary:
          return 0; // primary tracks have no bits set
        default:
          return (0x1 << OtherOrigin);
      }
    }
  } // namespace TrkOrigin
 
  namespace ExclusiveOrigin {
    inline int getExclusiveOrigin(int origin) {
      /*
        The input origin is a bitwise flag.
        Here we use the inclusive origin to build an exclusive origin label as an integer.
      */
 
      if ( InDet::TrkOrigin::isPileup(origin) ) {
        return InDet::ExclusiveOrigin::Pileup;
      }
      else if ( InDet::TrkOrigin::isFake(origin) ) {
        return InDet::ExclusiveOrigin::Fake;
      }
      else if ( InDet::TrkOrigin::isFromBNotFromD(origin) ) {
        return InDet::ExclusiveOrigin::FromB;
      }
      else if ( InDet::TrkOrigin::isFromDfromB(origin) ) {
        return InDet::ExclusiveOrigin::FromBC;
      }
      else if ( InDet::TrkOrigin::isFromDNotFromB(origin) ) {
        return InDet::ExclusiveOrigin::FromC;
      }
      else if ( InDet::TrkOrigin::isFromTau(origin) ) {
        return InDet::ExclusiveOrigin::FromTau;
      }
      else if ( InDet::TrkOrigin::isSecondary(origin) ) {
        return InDet::ExclusiveOrigin::OtherSecondary;
      }
      else if ( InDet::TrkOrigin::isPrimary(origin) ) {
        return InDet::ExclusiveOrigin::Primary;
      }
 
      // in _extremely_ rare cases, handle tracks with unknown origin (OtherOrigin) 
      return InDet::ExclusiveOrigin::OtherSecondary;
    }
  }
 
} // namespace InDet
 
#endif