Variation.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <memory>
 
#include <TString.h>
 
#include "Math/Vector4D.h"
 
#include "Core/Objects/interface/Weight.h"
 
namespace DAS {
 
typedef ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<float>> FourVector;
 
namespace Uncertainties {
 
struct Variation {
 
    const TString group; 
    const TString name; 
 
    const std::size_t index; 
    const int bit; 
 
    ~Variation () = default;
 
    Variation (const TString& group, const TString& name, size_t index = 0, int bit = 0) :
        group(group), name(name), index(index), bit(bit)
    { }
 
    Variation (const Variation& v) :
        group(v.group), name(v.name), index(v.index), bit(v.bit)
    { }
 
    Variation (Variation&& v) :
        group(std::move(v.group)), name(std::move(v.name)),
        index(std::move(v.index)), bit(std::move(v.bit))
    { }
 
    template<class T>
    const T& getCorrection (const std::string_view& group,
                            const std::vector<T>& corrections) const;
 
    template<class PhysicsObject>
    const Weight& getWeight (const PhysicsObject& object) const;
 
    template<class PhysicsObject>
    FourVector getCorrP4 (const PhysicsObject& object) const;
};
 
template<class T 
> inline const T& Variation::getCorrection (const std::string_view& group,
                                          const std::vector<T>& corrections) const
{
    if (index >= corrections.size() || group != this->group)
        return corrections.front();
    return corrections.at(index);
}
 
template<class PhysicsObject> 
[[ deprecated ]]
inline const DAS::Weight& Variation::getWeight (const PhysicsObject& object) const
{
    return getCorrection(PhysicsObject::WeightVar, object.weights);
}
 
template<class PhysicsObject> 
[[ deprecated ]]
inline FourVector Variation::getCorrP4 (const PhysicsObject& object) const
{
    return group == PhysicsObject::ScaleVar ? object.CorrP4(index) : object.CorrP4(0);
}
 
const Variation nominal {"", "nominal"};
 
inline std::ostream& operator<< (std::ostream& s, const DAS::Uncertainties::Variation& v)
{
    return s << v.group << ' ' << v.name << ' ' << v.index << ' ' << v.bit;
}
 
} // end of namespace Uncertainties
 
} // end of namespace DAS