ResolutionFit

Description

Performs a fit of the resolution with the NSC function, including ad-hoc modification $d$ for possibly non-linearities in the jet resolution:

\[ \frac{\sigma}{p_\mathrm{T}} = \sqrt{ \frac{N^2}{p_\mathrm{T}^2} + \frac{S^2}{p_\mathrm{T}^d} + C^2 } \]

where N stands for noise, S for stochastic, and C for constant.

Inheritance diagram for ResolutionFit:

Collaboration diagram for ResolutionFit:

Public Types
enum	{   N = 0, S, C, d,   NPARS }
enum	Status { failed = 0b0000, base = 0b0001, modified = 0b0010 }

Public Member Functions
	ResolutionFit (const unique_ptr< TH1 > &h, ostream &cout)
void	NSC ()
void	NSCd ()
	~ResolutionFit ()
Public Member Functions inherited from AbstractFit
virtual bool	good () const

Private Member Functions
void	Write (const char *) override

Additional Inherited Members
Public Attributes inherited from AbstractFit
const std::unique_ptr< TH1 > &	h
std::uint32_t	status
std::ostream &	cout
double *	p
double *	e
std::unique_ptr< TF1 >	f
std::optional< double >	chi2ndf
std::optional< double >	chi2ndfErr
std::pair< float, float >	interval
Protected Member Functions inherited from AbstractFit
	AbstractFit (const unique_ptr< TH1 > &h, ostream &cout, int npars)
virtual	~AbstractFit ()
void	fit (std::pair< float, float >, const char *)

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
N
S
C
d
NPARS

         {
        N = 0,
        S,
        C,
        d,
        NPARS
    }; 

Status

enum Status

Enumerator
failed
base
modified

                {
        failed     = 0b0000,
        base       = 0b0001,
        modified   = 0b0010,
    };

Constructor & Destructor Documentation

ResolutionFit()

ResolutionFit ( const unique_ptr< TH1 > &  h, ostream &  cout  )

inline

Preparing for fit, setting ranges.

Todo:

take average of last three points?

                                                            :
        AbstractFit(h, cout, NPARS)
    {
        interval.first = 32;
        for (int N = h->GetNbinsX()+1; h->GetBinContent(N) == 0 && N > 0; --N)
            interval.second = h->GetBinLowEdge(N-3);
 
        f = make_unique<TF1>("f", ::mNSC, interval.first, interval.second, NPARS);
        p[N] = 2.;      e[N] = 1;
        p[S] = 1.;      e[S] = 0.5;
        p[C] = 0.05;    e[C] = 0.03; 
        p[d] = 1;       e[d] = 0.1;
        f->SetParameters(p);
        f->SetParErrors (e);
 
        f->SetParName(N, "N");
        f->SetParName(S, "S");
        f->SetParName(C, "C");
        f->SetParName(d, "d");
 
        f->SetNpx(2000); // Increase points used to draw TF1 object when saving
    }

~ResolutionFit()

~ResolutionFit ( )

inline

    {
        for (int i = 0; i < NPARS; ++i)
            if (!isfinite(p[i]))
                BOOST_THROW_EXCEPTION( runtime_error(Form("Fit parameter %d is not finite", i)) );
    }

Member Function Documentation

NSC()

void NSC

(

)

{
    f->SetParLimits(N, 0, 10);
    f->SetParLimits(S, 0, 3);
    f->SetParLimits(C, 0, 0.1);
    f->FixParameter(d, 1);
 
    fit(interval, __func__);
 
    if (!chi2ndf) return;
    status |= Status::base;
    Write(__func__);
}

NSCd()

void NSCd

(

)

{
    f->SetParLimits(N, -10, 10);
    f->SetParLimits(S, p[S]/2, p[S]*2);
    f->SetParLimits(C, p[C]/2, p[C]*2);
    f->SetParLimits(d, 0.5, 1.5);
 
    auto lastChi2ndf = chi2ndf;
    float L = interval.first;
    const int N = h->GetNbinsX();
    for (int im = h->FindBin(L); im > 0; --im) {
        if (h->GetBinContent(im) == 0) continue;
        L = h->GetBinLowEdge(im);
        float R = interval.second;
        for (int iM = h->FindBin(R); iM <= N; ++iM) {
            if (h->GetBinContent(iM) == 0) continue;
            R = h->GetBinLowEdge(iM+1);
            fit({L,R}, __func__);
        }
    }
 
    if (!chi2ndf || *chi2ndf >= *lastChi2ndf) return;
    status |= Status::modified;
    Write(__func__);
}

Write()

void Write ( const char *  name )

overrideprivatevirtual

Write best current estimate in current directory.

Three color codes are used to categorize fits on their final state (after all 3 fits are performed):

• Red for a failed fit
• Orange a successful NSC fit
• Green a successful modified NSC fit

Reimplemented from AbstractFit.

{
    bool goodNSC  = (status & Status::base) == Status::base;
    bool goodNSCd = (status & Status::modified) == Status::modified;
    if      (goodNSCd) f->SetLineColor(kGreen+1);
    else if (goodNSC ) f->SetLineColor(kOrange+1);
    else               f->SetLineColor(kRed+1);
 
    AbstractFit::Write(name);
}

---

The documentation for this struct was generated from the following file:

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JEC/bin/fitJetResolution.cc