jet::CompParametrization Namespace Reference

Enumerations
enum	TypeEnum {   UNKNOWN =0, Pt, PtEta, PtAbsEta,   PtAbsMass, PtMass, PtMassEta, PtMassAbsEta,   PtAbsMassEta, PtAbsMassAbsEta, eLOGmOe, eLOGmOeEta,   eLOGmOeAbsEta, PtLOGPtMassForTagSF }

Functions
TString	enumToString (const TypeEnum type)
TypeEnum	stringToEnum (const TString &type)
bool	isAbsEta (const TypeEnum type)
bool	includesMass (const TypeEnum type)

Enumeration Type Documentation

TypeEnum

enum jet::CompParametrization::TypeEnum

Enumerator
UNKNOWN
Pt
PtEta
PtAbsEta
PtAbsMass
PtMass
PtMassEta
PtMassAbsEta
PtAbsMassEta
PtAbsMassAbsEta
eLOGmOe
eLOGmOeEta
eLOGmOeAbsEta
PtLOGPtMassForTagSF

Definition at line 44 of file UncertaintyEnum.h.

    {
        UNKNOWN=0,      // Failure/unset/etc
        Pt,             // 1D, (pT) dependence
        PtEta,          // 2D, (pT,eta) dependence
        PtAbsEta,       // 2D, (pT,|eta|) dependence
        PtAbsMass,      // 2D, (pT,mass) dependence
        PtMass,         // 2D, (pt,m/pT) dependence
        PtMassEta,      // 3D, (pT,m/pT,eta) dependence
        PtMassAbsEta,   // 3D, (pT,m/pT,|eta|) dependence
        PtAbsMassEta,   // 3D, (pT,mass,eta) dependence
        PtAbsMassAbsEta,// 3D, (pT,mass,|eta|) dependence
        eLOGmOe,        // 2D, (E,log(m/E)) dependence
        eLOGmOeEta,     // 3D, (E,log(m/E),eta) dependence
        eLOGmOeAbsEta,  // 3D, (E,log(m/E),|eta|) dependence
        PtLOGPtMassForTagSF,// 2D, (pt,log(m/pT)) dependence, only for tagging SF
    };

Function Documentation

enumToString()

TString jet::CompParametrization::enumToString

(

const TypeEnum

type

)

Definition at line 91 of file UncertaintyEnum.cxx.

    {
        switch(type)
        {
            case Pt:            return "Pt";
            case PtEta:         return "PtEta";
            case PtAbsEta:      return "PtAbsEta";
            case PtAbsMass:     return "PtAbsMass";
            case PtMass:        return "PtMass";
            case PtMassEta:     return "PtMassEta";
            case PtMassAbsEta:  return "PtMassAbsEta";
            case PtAbsMassEta:  return "PtAbsMassEta";
            case PtAbsMassAbsEta: return "PtAbsMassAbsEta";
            case eLOGmOe:       return "eLOGmOe";
            case eLOGmOeEta:    return "eLOGmOeEta";
            case eLOGmOeAbsEta: return "eLOGmOeAbsEta";
        case PtLOGPtMassForTagSF: return "PtLOGPtMassForTagSF";
            default:            return "UNKNOWN";
        }
    }

includesMass()

bool jet::CompParametrization::includesMass

(

const TypeEnum

type

)

Definition at line 156 of file UncertaintyEnum.cxx.

    {
        switch(type)
        {
            case PtAbsMass:
            case PtMass:
        case PtLOGPtMassForTagSF:
            case PtMassEta:
            case PtMassAbsEta:
            case PtAbsMassEta:
            case PtAbsMassAbsEta:
            case eLOGmOe:
            case eLOGmOeEta:
            case eLOGmOeAbsEta:
                return true;
            
            default:
                return false;
        }
    }

isAbsEta()

bool jet::CompParametrization::isAbsEta

(

const TypeEnum

type

)

Definition at line 143 of file UncertaintyEnum.cxx.

    {
        switch(type)
        {
            case PtAbsEta:
            case PtMassAbsEta:  
            case PtAbsMassAbsEta:
            case eLOGmOeAbsEta: return true;
            
            default:            return false;
        }
    }

stringToEnum()

TypeEnum jet::CompParametrization::stringToEnum

(

const TString &

type

)

Definition at line 112 of file UncertaintyEnum.cxx.

    {
        if (!type.CompareTo("Pt",TString::kIgnoreCase))
            return Pt;
        if (!type.CompareTo("PtEta",TString::kIgnoreCase))
            return PtEta;
        if (!type.CompareTo("PtAbsEta",TString::kIgnoreCase))
            return PtAbsEta;
        if (!type.CompareTo("PtAbsMass",TString::kIgnoreCase))
            return PtAbsMass;
        if (!type.CompareTo("PtMass",TString::kIgnoreCase))
            return PtMass;
        if (!type.CompareTo("PtMassEta",TString::kIgnoreCase))
            return PtMassEta;
        if (!type.CompareTo("PtMassAbsEta",TString::kIgnoreCase))
            return PtMassAbsEta;
        if (!type.CompareTo("PtAbsMassEta",TString::kIgnoreCase))
            return PtAbsMassEta;
        if (!type.CompareTo("PtAbsMassAbsEta",TString::kIgnoreCase))
            return PtAbsMassAbsEta;
        if (!type.CompareTo("eLOGmOe",TString::kIgnoreCase))
            return eLOGmOe;
        if (!type.CompareTo("eLOGmOeEta",TString::kIgnoreCase))
            return eLOGmOeEta;
        if (!type.CompareTo("eLOGmOeAbsEta",TString::kIgnoreCase))
            return eLOGmOeAbsEta;
        if (!type.CompareTo("PtLOGPtMassForTagSF",TString::kIgnoreCase))
            return PtLOGPtMassForTagSF;
        return UNKNOWN;
    }