CMS 3D CMS Logo
List of all members | Public Member Functions | Private Member Functions | Private Attributes
ErrorsPropagationAnalyzer Class Reference

#include <MuonAnalysis/MomentumScaleCalibration/plugins/ErrorsPropagationAnalyzer.cc>

Inheritance diagram for ErrorsPropagationAnalyzer:
edm::EDAnalyzer edm::EDConsumerBase

Public Member Functions

 ErrorsPropagationAnalyzer (const edm::ParameterSet &)
 
 ~ErrorsPropagationAnalyzer () override
 
- Public Member Functions inherited from edm::EDAnalyzer
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 EDAnalyzer ()
 
SerialTaskQueue * globalLuminosityBlocksQueue ()
 
SerialTaskQueue * globalRunsQueue ()
 
ModuleDescription const & moduleDescription () const
 
std::string workerType () const
 
 ~EDAnalyzer () override
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
 EDConsumerBase (EDConsumerBase &&)=default
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase const & operator= (EDConsumerBase const &)=delete
 
EDConsumerBase & operator= (EDConsumerBase &&)=default
 
bool registeredToConsume (ProductResolverIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
ProductResolverIndexAndSkipBit uncheckedIndexFrom (EDGetToken) const
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
virtual ~EDConsumerBase () noexcept(false)
 

Private Member Functions

void analyze (const edm::Event &, const edm::EventSetup &) override
 
void drawHistograms (const TProfile *histo, const TProfile *histoPlusErr, const TProfile *histoMinusErr, const TString &type, const TString &yLabel)
 
void endJob () override
 
void fillHistograms ()
 
void fillValueError ()
 
double massResolution (const lorentzVector &mu1, const lorentzVector &mu2, const std::vector< double > &parval, const double &sigmaPt1, const double &sigmaPt2)
 Modified method to take into account the error. More...
 
double massResolution (const lorentzVector &mu1, const lorentzVector &mu2, double *parval, const double &sigmaPt1, const double &sigmaPt2)
 

Private Attributes

bool debug_
 
std::vector< int > errorFactors_
 
std::vector< double > errors_
 
int etaBins_
 
double etaMax_
 
double etaMaxCut_
 
double etaMin_
 
double etaMinCut_
 
uint32_t maxEvents_
 
TString outputFileName_
 
std::vector< double > parameters_
 
int ptBins_
 
double ptMax_
 
double ptMaxCut_
 
double ptMin_
 
double ptMinCut_
 
int resolFitType_
 
TProfile * sigmaMassOverMassVsEta_
 
TProfile * sigmaMassOverMassVsEtaMinusErr_
 
TProfile * sigmaMassOverMassVsEtaPlusErr_
 
TProfile * sigmaMassOverMassVsPt_
 
TProfile * sigmaMassOverMassVsPtMinusErr_
 
TProfile * sigmaMassOverMassVsPtPlusErr_
 
TProfile * sigmaMassVsEta_
 
TProfile * sigmaMassVsEtaMinusErr_
 
TProfile * sigmaMassVsEtaPlusErr_
 
TProfile * sigmaMassVsPt_
 
TProfile * sigmaMassVsPtMinusErr_
 
TProfile * sigmaMassVsPtPlusErr_
 
TProfile * sigmaPtVsEta_
 
TProfile * sigmaPtVsEtaDiff_
 
TProfile * sigmaPtVsEtaMinusErr_
 
TProfile * sigmaPtVsEtaPlusErr_
 
TProfile * sigmaPtVsPt_
 
TProfile * sigmaPtVsPtDiff_
 
TProfile * sigmaPtVsPtMinusErr_
 
TProfile * sigmaPtVsPtPlusErr_
 
TString treeFileName_
 
std::vector< double > valueMinusError_
 
std::vector< double > valuePlusError_
 

Additional Inherited Members

- Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer ModuleType
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &)
 
static bool wantsGlobalLuminosityBlocks ()
 
static bool wantsGlobalRuns ()
 
static bool wantsStreamLuminosityBlocks ()
 
static bool wantsStreamRuns ()
 
- Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes ()
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes (ESInputTag const &tag)
 
template<typename ESProduct , Transition Tr = Transition::Event>
auto esConsumes (eventsetup::EventSetupRecordKey const &, ESInputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 

Detailed Description

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 49 of file ErrorsPropagationAnalyzer.h.

Constructor & Destructor Documentation

ErrorsPropagationAnalyzer::ErrorsPropagationAnalyzer ( const edm::ParameterSet &  iConfig)
explicit

Definition at line 6 of file ErrorsPropagationAnalyzer.cc.

References gather_cfg::cout, errorFactors_, errors_, etaBins_, etaMax_, etaMin_, cmsRelvalreport::exit, fillValueError(), edm::ParameterSet::getParameter(), parameters_, ptBins_, ptMax_, ptMin_, sigmaMassOverMassVsEta_, sigmaMassOverMassVsEtaMinusErr_, sigmaMassOverMassVsEtaPlusErr_, sigmaMassOverMassVsPt_, sigmaMassOverMassVsPtMinusErr_, sigmaMassOverMassVsPtPlusErr_, sigmaMassVsEta_, sigmaMassVsEtaMinusErr_, sigmaMassVsEtaPlusErr_, sigmaMassVsPt_, sigmaMassVsPtMinusErr_, sigmaMassVsPtPlusErr_, sigmaPtVsEta_, sigmaPtVsEtaDiff_, sigmaPtVsEtaMinusErr_, sigmaPtVsEtaPlusErr_, sigmaPtVsPt_, sigmaPtVsPtDiff_, sigmaPtVsPtMinusErr_, and sigmaPtVsPtPlusErr_.

6  :
7  treeFileName_( iConfig.getParameter<std::string>("InputFileName") ),
8  resolFitType_( iConfig.getParameter<int>("ResolFitType") ),
9  maxEvents_( iConfig.getParameter<int>("MaxEvents") ),
10  outputFileName_( iConfig.getParameter<std::string>("OutputFileName") ),
11  ptBins_( iConfig.getParameter<int>("PtBins") ),
12  ptMin_( iConfig.getParameter<double>("PtMin") ),
13  ptMax_( iConfig.getParameter<double>("PtMax") ),
14  etaBins_( iConfig.getParameter<int>("EtaBins") ),
15  etaMin_( iConfig.getParameter<double>("EtaMin") ),
16  etaMax_( iConfig.getParameter<double>("EtaMax") ),
17  debug_( iConfig.getParameter<bool>("Debug") ),
18  ptMinCut_( iConfig.getUntrackedParameter<double>("PtMinCut", 0.) ),
19  ptMaxCut_( iConfig.getUntrackedParameter<double>("PtMaxCut", 999999.) ),
20  etaMinCut_( iConfig.getUntrackedParameter<double>("EtaMinCut", 0.) ),
21  etaMaxCut_( iConfig.getUntrackedParameter<double>("EtaMaxCut", 100.) )
22 {
23  parameters_ = iConfig.getParameter<std::vector<double> >("Parameters");
24  errors_ = iConfig.getParameter<std::vector<double> >("Errors");
25  errorFactors_ = iConfig.getParameter<std::vector<int> >("ErrorFactors");
26 
27  if( (parameters_.size() != errors_.size()) || (parameters_.size() != errorFactors_.size()) ) {
28  std::cout << "Error: parameters and errors have different number of values" << std::endl;
29  exit(1);
30  }
31 
32  fillValueError();
33 
34  sigmaPtVsPt_ = new TProfile("sigmaPtVsPtProfile", "sigmaPtVsPt", ptBins_, ptMin_, ptMax_);
35  sigmaPtVsPtPlusErr_ = new TProfile("sigmaPtVsPtPlusErrProfile", "sigmaPtVsPtPlusErr", ptBins_, ptMin_, ptMax_);
36  sigmaPtVsPtMinusErr_ = new TProfile("sigmaPtVsPtMinusErrProfile", "sigmaPtVsPtMinusErr", ptBins_, ptMin_, ptMax_);
37 
38  sigmaPtVsEta_ = new TProfile("sigmaPtVsEtaProfile", "sigmaPtVsEta", etaBins_, etaMin_, etaMax_);
39  sigmaPtVsEtaPlusErr_ = new TProfile("sigmaPtVsEtaPlusErrProfile", "sigmaPtVsEtaPlusErr", etaBins_, etaMin_, etaMax_);
40  sigmaPtVsEtaMinusErr_ = new TProfile("sigmaPtVsEtaMinusErrProfile", "sigmaPtVsEtaMinusErr", etaBins_, etaMin_, etaMax_);
41 
42  sigmaMassVsPt_ = new TProfile("sigmaMassVsPtProfile", "sigmaMassVsPt", ptBins_, ptMin_, ptMax_);
43  sigmaMassVsPtPlusErr_ = new TProfile("sigmaMassVsPtPlusErrProfile", "sigmaMassVsPtPlusErr", ptBins_, ptMin_, ptMax_);
44  sigmaMassVsPtMinusErr_ = new TProfile("sigmaMassVsPtMinusErrProfile", "sigmaMassVsPtMinusErr", ptBins_, ptMin_, ptMax_);
45 
46  sigmaMassVsEta_ = new TProfile("sigmaMassVsEtaProfile", "sigmaMassVsEta", etaBins_, etaMin_, etaMax_);
47  sigmaMassVsEtaPlusErr_ = new TProfile("sigmaMassVsEtaPlusErrProfile", "sigmaMassVsEtaPlusErr", etaBins_, etaMin_, etaMax_);
48  sigmaMassVsEtaMinusErr_ = new TProfile("sigmaMassVsEtaMinusErrProfile", "sigmaMassVsEtaMinusErr", etaBins_, etaMin_, etaMax_);
49 
50  sigmaMassOverMassVsPt_ = new TProfile("sigmaMassOverMassVsPtProfile", "sigmaMassOverMassVsPt", ptBins_, ptMin_, ptMax_);
51  sigmaMassOverMassVsPtPlusErr_ = new TProfile("sigmaMassOverMassVsPtPlusErrProfile", "sigmaMassOverMassVsPtPlusErr", ptBins_, ptMin_, ptMax_);
52  sigmaMassOverMassVsPtMinusErr_ = new TProfile("sigmaMassOverMassVsPtMinusErrProfile", "sigmaMassOverMassVsPtMinusErr", ptBins_, ptMin_, ptMax_);
53 
54  sigmaMassOverMassVsEta_ = new TProfile("sigmaMassOverMassVsEtaProfile", "sigmaMassOverMassVsEta", etaBins_, etaMin_, etaMax_);
55  sigmaMassOverMassVsEtaPlusErr_ = new TProfile("sigmaMassOverMassVsEtaPlusErrProfile", "sigmaMassOverMassVsEtaPlusErr", etaBins_, etaMin_, etaMax_);
56  sigmaMassOverMassVsEtaMinusErr_ = new TProfile("sigmaMassOverMassVsEtaMinusErrProfile", "sigmaMassOverMassVsEtaMinusErr", etaBins_, etaMin_, etaMax_);
57 
58  sigmaPtVsPtDiff_ = new TProfile("sigmaPtVsPtDiffProfile", "sigmaPtVsPtDiff", ptBins_, ptMin_, ptMax_);
59  sigmaPtVsEtaDiff_ = new TProfile("sigmaPtVsEtaDiffProfile", "sigmaPtVsEtaDiff", etaBins_, etaMin_, etaMax_);
60 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
gather_cfg.cout
cout
Definition: gather_cfg.py:144
ErrorsPropagationAnalyzer::~ErrorsPropagationAnalyzer ( )
override

Definition at line 77 of file ErrorsPropagationAnalyzer.cc.

References drawHistograms(), fillHistograms(), download_sqlite_cfg::outputFile, outputFileName_, sigmaMassOverMassVsEta_, sigmaMassOverMassVsEtaMinusErr_, sigmaMassOverMassVsEtaPlusErr_, sigmaMassOverMassVsPt_, sigmaMassOverMassVsPtMinusErr_, sigmaMassOverMassVsPtPlusErr_, sigmaMassVsEta_, sigmaMassVsEtaMinusErr_, sigmaMassVsEtaPlusErr_, sigmaMassVsPt_, sigmaMassVsPtMinusErr_, sigmaMassVsPtPlusErr_, sigmaPtVsEta_, sigmaPtVsEtaDiff_, sigmaPtVsEtaMinusErr_, sigmaPtVsEtaPlusErr_, sigmaPtVsPt_, sigmaPtVsPtDiff_, sigmaPtVsPtMinusErr_, and sigmaPtVsPtPlusErr_.

78 {
79  gROOT->SetStyle("Plain");
80 
81  fillHistograms();
82 
83  TFile * outputFile = new TFile(outputFileName_, "RECREATE");
84 
85  drawHistograms(sigmaPtVsEta_, sigmaPtVsEtaPlusErr_, sigmaPtVsEtaMinusErr_, "sigmaPtVsEta", "#sigma(Pt)/Pt");
86  drawHistograms(sigmaPtVsPt_, sigmaPtVsPtPlusErr_, sigmaPtVsPtMinusErr_, "sigmaPtVsPt", "#sigma(Pt)/Pt");
87 
88  drawHistograms(sigmaMassVsEta_, sigmaMassVsEtaPlusErr_, sigmaMassVsEtaMinusErr_, "sigmaMassVsEta", "#sigma(M)");
89  drawHistograms(sigmaMassVsPt_, sigmaMassVsPtPlusErr_, sigmaMassVsPtMinusErr_, "sigmaMassVsPt", "#sigma(M)");
90 
91  drawHistograms(sigmaMassOverMassVsEta_, sigmaMassOverMassVsEtaPlusErr_, sigmaMassOverMassVsEtaMinusErr_, "sigmaMassOverMassVsEta", "#sigma(M)/M");
92  drawHistograms(sigmaMassOverMassVsPt_, sigmaMassOverMassVsPtPlusErr_, sigmaMassOverMassVsPtMinusErr_, "sigmaMassOverMassVsPt", "#sigma(M)/M");
93 
94  sigmaPtVsPtDiff_->Write();
95  sigmaPtVsEtaDiff_->Write();
96 
97  outputFile->Write();
98  outputFile->Close();
99 }
download_sqlite_cfg.outputFile
outputFile
Definition: download_sqlite_cfg.py:5
ErrorsPropagationAnalyzer::drawHistograms
void drawHistograms(const TProfile *histo, const TProfile *histoPlusErr, const TProfile *histoMinusErr, const TString &type, const TString &yLabel)
Definition: ErrorsPropagationAnalyzer.cc:101

Member Function Documentation

void ErrorsPropagationAnalyzer::analyze ( const edm::Event &  iEvent,
const edm::EventSetup &  iSetup 
)
overrideprivate

Definition at line 214 of file ErrorsPropagationAnalyzer.cc.

215 {
216 }
void ErrorsPropagationAnalyzer::drawHistograms ( const TProfile *  histo,
const TProfile *  histoPlusErr,
const TProfile *  histoMinusErr,
const TString &  type,
const TString &  yLabel 
)
private

Definition at line 101 of file ErrorsPropagationAnalyzer.cc.

References svgfig::canvas(), mps_fire::i, sigmaMassOverMassVsEta_, sigmaMassOverMassVsEtaMinusErr_, sigmaMassOverMassVsEtaPlusErr_, sigmaMassVsEta_, sigmaMassVsEtaMinusErr_, sigmaMassVsEtaPlusErr_, sigmaPtVsEta_, sigmaPtVsEtaMinusErr_, sigmaPtVsEtaPlusErr_, fftjetcommon_cfi::title, and MuonErrorMatrixValues_cff::values.

Referenced by ~ErrorsPropagationAnalyzer().

104 {
105  TH1D * sigmaPtVsEtaTH1D = new TH1D(type, type, histo->GetNbinsX(),
106  histo->GetXaxis()->GetXmin(), histo->GetXaxis()->GetXmax());
107  TH1D * sigmaPtVsEtaPlusErrTH1D = new TH1D(type+"PlusErr", type+"PlusErr", histo->GetNbinsX(),
108  histo->GetXaxis()->GetXmin(), histo->GetXaxis()->GetXmax());
109  TH1D * sigmaPtVsEtaMinusErrTH1D = new TH1D(type+"MinusErr", type+"MinusErr", histo->GetNbinsX(),
110  histo->GetXaxis()->GetXmin(), histo->GetXaxis()->GetXmax());
111 
112  TH1D * sigmaMassVsEtaTH1D = new TH1D(type, type, histo->GetNbinsX(),
113  histo->GetXaxis()->GetXmin(), histo->GetXaxis()->GetXmax());
114  TH1D * sigmaMassVsEtaPlusErrTH1D = new TH1D(type+"PlusErr", type+"PlusErr", histo->GetNbinsX(),
115  histo->GetXaxis()->GetXmin(), histo->GetXaxis()->GetXmax());
116  TH1D * sigmaMassVsEtaMinusErrTH1D = new TH1D(type+"MinusErr", type+"MinusErr", histo->GetNbinsX(),
117  histo->GetXaxis()->GetXmin(), histo->GetXaxis()->GetXmax());
118 
119  TH1D * sigmaMassOverMassVsEtaTH1D = new TH1D(type, type, histo->GetNbinsX(),
120  histo->GetXaxis()->GetXmin(), histo->GetXaxis()->GetXmax());
121  TH1D * sigmaMassOverMassVsEtaPlusErrTH1D = new TH1D(type+"PlusErr", type+"PlusErr", histo->GetNbinsX(),
122  histo->GetXaxis()->GetXmin(), histo->GetXaxis()->GetXmax());
123  TH1D * sigmaMassOverMassVsEtaMinusErrTH1D = new TH1D(type+"MinusErr", type+"MinusErr", histo->GetNbinsX(),
124  histo->GetXaxis()->GetXmin(), histo->GetXaxis()->GetXmax());
125 
126  TCanvas * canvas = new TCanvas("canvas"+type, "canvas"+type, 1000, 800);
127  for( int iBin = 1; iBin <= histo->GetNbinsX(); ++iBin ) {
128  sigmaPtVsEtaTH1D->SetBinContent(iBin, histo->GetBinContent(iBin));
129  sigmaPtVsEtaPlusErrTH1D->SetBinContent(iBin, histoPlusErr->GetBinContent(iBin));
130  sigmaPtVsEtaMinusErrTH1D->SetBinContent(iBin, histoMinusErr->GetBinContent(iBin));
131  }
132  int numBins = sigmaPtVsEtaTH1D->GetNbinsX();
133  // Draw TGraph with asymmetric errors
134  Double_t * values = sigmaPtVsEtaTH1D->GetArray();
135  Double_t * valuesPlus = sigmaPtVsEtaPlusErrTH1D->GetArray();
136  Double_t * valuesMinus = sigmaPtVsEtaMinusErrTH1D->GetArray();
137  double * posErrors = new double[numBins];
138  double * negErrors = new double[numBins];
139 
140  TGraphAsymmErrors * graphAsymmErrors = new TGraphAsymmErrors(sigmaPtVsEtaTH1D);
141  TGraph * graph = new TGraph(sigmaPtVsEtaTH1D);
142 
143  for( int i=1; i<=numBins; ++i ) {
144  // std::cout << "filling " << i << std::endl;
145  posErrors[i-1] = valuesPlus[i] - values[i];
146  if( valuesMinus[i] < 0 ) negErrors[i-1] = values[i];
147  else negErrors[i-1] = values[i] - valuesMinus[i];
148 
149  graphAsymmErrors->SetPointEYlow(i-1, negErrors[i-1]);
150  graphAsymmErrors->SetPointEYhigh(i-1, posErrors[i-1]);
151  }
152 
153  canvas->Draw();
154 
155  delete [] posErrors;
156  delete [] negErrors;
157 
158  graphAsymmErrors->SetTitle("");
159  graphAsymmErrors->SetFillColor(kGray);
160  graphAsymmErrors->Draw("A2");
161  TString title(type);
162  if( type == "Eta" ) title = "#eta";
163  graphAsymmErrors->GetXaxis()->SetTitle(title);
164  graphAsymmErrors->GetYaxis()->SetTitle("yLabel");
165  graph->Draw();
166 
167  // graph->SetLineColor(kGray);
168  // graph->SetMarkerColor(kBlack);
169  // graph->Draw("AP");
170 
171 // if( debug_ ) {
172 // sigmaPtVsEtaPlusErrTH1D->SetLineColor(kRed);
173 // sigmaPtVsEtaMinusErrTH1D->SetLineColor(kBlue);
174 // }
175 // else {
176 // sigmaPtVsEtaPlusErrTH1D->SetFillColor(kGray);
177 // sigmaPtVsEtaPlusErrTH1D->SetLineColor(kWhite);
178 // sigmaPtVsEtaMinusErrTH1D->SetFillColor(kWhite);
179 // sigmaPtVsEtaMinusErrTH1D->SetLineColor(kWhite);
180 // }
181 // sigmaPtVsEtaPlusErrTH1D->Draw();
182 // sigmaPtVsEtaTH1D->Draw("SAME");
183 // sigmaPtVsEtaMinusErrTH1D->Draw("SAME");
184 
185  sigmaPtVsEtaPlusErrTH1D->Write();
186  sigmaPtVsEtaTH1D->Write();
187  sigmaPtVsEtaMinusErrTH1D->Write();
188 
189  sigmaPtVsEtaPlusErr_->Write();
190  sigmaPtVsEta_->Write();
191  sigmaPtVsEtaMinusErr_->Write();
192 
193  // Mass
194  sigmaMassVsEtaPlusErrTH1D->Write();
195  sigmaMassVsEtaTH1D->Write();
196  sigmaMassVsEtaMinusErrTH1D->Write();
197 
198  sigmaMassOverMassVsEtaPlusErrTH1D->Write();
199  sigmaMassOverMassVsEtaTH1D->Write();
200  sigmaMassOverMassVsEtaMinusErrTH1D->Write();
201 
202  sigmaMassVsEtaPlusErr_->Write();
203  sigmaMassVsEta_->Write();
204  sigmaMassVsEtaMinusErr_->Write();
205 
206  sigmaMassOverMassVsEtaPlusErr_->Write();
207  sigmaMassOverMassVsEta_->Write();
208  sigmaMassOverMassVsEtaMinusErr_->Write();
209 
210  canvas->Write();
211 }
type
type
Definition: HCALResponse.h:21
mps_fire.i
i
Definition: mps_fire.py:329
fftjetcommon_cfi.title
title
Definition: fftjetcommon_cfi.py:32
MuonErrorMatrixValues_cff.values
values
Definition: MuonErrorMatrixValues_cff.py:6
svgfig.canvas
def canvas(sub, attr)
Definition: svgfig.py:481
void ErrorsPropagationAnalyzer::endJob ( void  )
inlineoverrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 61 of file ErrorsPropagationAnalyzer.h.

References massResolution().

61 {};
void ErrorsPropagationAnalyzer::fillHistograms ( )
private

Definition at line 289 of file ErrorsPropagationAnalyzer.cc.

References gather_cfg::cout, MuScleFitUtils::debug, debug_, MuScleFitUtils::debugMassResol_, DEFINE_FWK_MODULE, errors_, etaMaxCut_, etaMinCut_, mps_fire::i, ResonanceBuilder::mass, massResolution(), maxEvents_, parameters_, hiDetachedQuadStep_cff::pt1, hiDetachedQuadStep_cff::pt2, ptMaxCut_, ptMinCut_, RootTreeHandler::readTree(), MuScleFitUtils::resfind, resolFitType_, MuScleFitUtils::resolutionFunction, resolutionFunctionService(), resolutionFunctionVecService(), sigmaMassOverMassVsEta_, sigmaMassOverMassVsEtaMinusErr_, sigmaMassOverMassVsEtaPlusErr_, sigmaMassOverMassVsPt_, sigmaMassOverMassVsPtMinusErr_, sigmaMassOverMassVsPtPlusErr_, sigmaMassVsEta_, sigmaMassVsEtaMinusErr_, sigmaMassVsEtaPlusErr_, sigmaMassVsPt_, sigmaMassVsPtMinusErr_, sigmaMassVsPtPlusErr_, resolutionFunctionBase< T >::sigmaPt(), resolutionFunctionBase< T >::sigmaPtError(), sigmaPtVsEta_, sigmaPtVsEtaDiff_, sigmaPtVsEtaMinusErr_, sigmaPtVsEtaPlusErr_, sigmaPtVsPt_, sigmaPtVsPtDiff_, sigmaPtVsPtMinusErr_, sigmaPtVsPtPlusErr_, SigmaPtDiff::squaredDiff(), and treeFileName_.

Referenced by ~ErrorsPropagationAnalyzer().

290 {
291  std::cout << "Reading muon pairs from Root Tree in " << treeFileName_ << std::endl;
292  RootTreeHandler rootTreeHandler;
293 
294  typedef std::vector<std::pair<lorentzVector,lorentzVector> > MuonPairVector;
295  MuonPairVector savedPair;
296  std::vector<std::pair<unsigned int, unsigned long long> > evtRun;
297  rootTreeHandler.readTree(maxEvents_, treeFileName_, &savedPair, 0, &evtRun);
298  // rootTreeHandler.readTree(maxEvents, inputRootTreeFileName_, &savedPair, &(MuScleFitUtils::genPair));
299 
300  resolutionFunctionBase<std::vector<double> > * resolutionFunctionForVec = resolutionFunctionVecService( resolFitType_ );
301  MuScleFitUtils::resolutionFunction = resolutionFunctionService( resolFitType_ );
302  MuScleFitUtils::debugMassResol_ = false;
303  MuScleFitUtils::debug = 0;
304  MuScleFitUtils::resfind = std::vector<int>(6, 0);
305 
306  SigmaPt sigmaPt( parameters_, errors_ );
307  SigmaPtDiff sigmaPtDiff;
308 
309  // Loop on all the pairs
310  unsigned int i = 0;
311  MuonPairVector::iterator it = savedPair.begin();
312  std::cout << "Starting loop on " << savedPair.size() << " muons" << std::endl;
313  for( ; it != savedPair.end(); ++it, ++i ) {
314  double pt1 = it->first.pt();
315  double eta1 = it->first.eta();
316  double pt2 = it->second.pt();
317  double eta2 = it->second.eta();
318 
319  if( debug_ ) {
320  std::cout << "pt1 = " << pt1 << ", eta1 = " << eta1 << ", pt2 = " << pt2 << ", eta2 = " << eta2 << std::endl;
321  }
322  // double fabsEta1 = fabs(eta1);
323  // double fabsEta2 = fabs(eta2);
324 
325  if( pt1 == 0 && pt2 == 0 && eta1 == 0 && eta2 == 0 ) continue;
326 
327 
328  // double sigmaPt1 = sigmaPt( eta1 );
329  // double sigmaPt2 = sigmaPt( eta2 );
330 
331  // double sigmaPtPlusErr1 = sigmaPt1 + sigmaPt.sigma(eta1);
332  // double sigmaPtPlusErr2 = sigmaPt2 + sigmaPt.sigma(eta2);
333  // double sigmaPtMinusErr1 = sigmaPt1 - sigmaPt.sigma(eta1);
334  // double sigmaPtMinusErr2 = sigmaPt2 - sigmaPt.sigma(eta2);
335 
336  double sigmaPt1 = resolutionFunctionForVec->sigmaPt( pt1,eta1,parameters_ );
337  double sigmaPt2 = resolutionFunctionForVec->sigmaPt( pt2,eta2,parameters_ );
338  double sigmaPtPlusErr1 = sigmaPt1 + resolutionFunctionForVec->sigmaPtError( pt1,eta1,parameters_,errors_);
339  double sigmaPtPlusErr2 = sigmaPt2 + resolutionFunctionForVec->sigmaPtError( pt2,eta2,parameters_,errors_ );
340  double sigmaPtMinusErr1 = sigmaPt1 - resolutionFunctionForVec->sigmaPtError( pt1,eta1,parameters_,errors_ );
341  double sigmaPtMinusErr2 = sigmaPt2 - resolutionFunctionForVec->sigmaPtError( pt2,eta2,parameters_,errors_ );
342 
343  // double sigmaMass = MuScleFitUtils::massResolution( it->first, it->second, parameters_ );
344  // double sigmaMassPlusErr = MuScleFitUtils::massResolution( it->first, it->second, valuePlusError_ );
345  // double sigmaMassMinusErr = MuScleFitUtils::massResolution( it->first, it->second, valueMinusError_ );
346  double sigmaMass = massResolution( it->first, it->second, parameters_, sigmaPt1, sigmaPt2 );
347  double sigmaMassPlusErr = massResolution( it->first, it->second, parameters_, sigmaPtPlusErr1, sigmaPtPlusErr2 );
348  double sigmaMassMinusErr = massResolution( it->first, it->second, parameters_, sigmaPtMinusErr1, sigmaPtMinusErr2 );
349 
350  double mass = (it->first + it->second).mass();
351 
352  if( debug_ ) {
353  std::cout << "sigmaPt1 = " << sigmaPt1 << " + " << sigmaPtPlusErr1 << " - " << sigmaPtMinusErr1 << std::endl;
354  std::cout << "sigmaPt2 = " << sigmaPt2 << " + " << sigmaPtPlusErr2 << " - " << sigmaPtMinusErr2 << std::endl;
355  std::cout << "sigmaMass = " << sigmaMass << " + " << sigmaMassPlusErr << " - " << sigmaMassMinusErr << std::endl;
356  }
357 
358  // Protections from nans
359  if( pt1 != pt1 ) continue;
360  if( pt2 != pt2 ) continue;
361  if( eta1 != eta1 ) continue;
362  if( eta2 != eta2 ) continue;
363  if( sigmaPt1 != sigmaPt1 ) continue;
364  if( sigmaPt2 != sigmaPt2 ) continue;
365  if( sigmaPtPlusErr1 != sigmaPtPlusErr1 ) continue;
366  if( sigmaPtPlusErr2 != sigmaPtPlusErr2 ) continue;
367  if( sigmaPtMinusErr1 != sigmaPtMinusErr1 ) continue;
368  if( sigmaPtMinusErr2 != sigmaPtMinusErr2 ) continue;
369  if( sigmaMass != sigmaMass ) continue;
370  if( sigmaMassPlusErr != sigmaMassPlusErr ) continue;
371  if( sigmaMassMinusErr != sigmaMassMinusErr ) continue;
372  if( mass == 0 ) continue;
373 
374  std::cout << "Muon pair number " << i << std::endl;
375 
376  // std::cout << "sigmaPt1 = " << sigmaPt1 << ", sigmaPt2 = " << sigmaPt2 << std::endl;
377  // std::cout << "sigmaPtPlusErr1 = " << sigmaPtPlusErr1 << ", sigmaPtMinusErr2 = " << sigmaPtMinusErr2 << std::endl;
378  // std::cout << "sigmaPtMinusErr1 = " << sigmaPtPlusErr1 << ", sigmaPtMinusErr2 = " << sigmaPtMinusErr2 << std::endl;
379 
380 
381  if( (pt1 >= ptMinCut_ && pt1 <= ptMaxCut_) && (fabs(eta1) >= etaMinCut_ && fabs(eta1) <= etaMaxCut_) ) {
382  sigmaPtVsPt_->Fill(pt1, sigmaPt1);
383  sigmaPtVsPtPlusErr_->Fill(pt1, sigmaPtPlusErr1);
384  sigmaPtVsPtMinusErr_->Fill(pt1, sigmaPtMinusErr1);
385  sigmaPtVsPtDiff_->Fill(pt1, sigmaPtDiff.squaredDiff(eta1));
386  sigmaMassVsPt_->Fill(pt1, sigmaMass*mass);
387  sigmaMassVsPtPlusErr_->Fill(pt1, sigmaMassPlusErr*mass);
388  sigmaMassVsPtMinusErr_->Fill(pt1, sigmaMassMinusErr*mass);
389  sigmaMassOverMassVsPt_->Fill(pt1, sigmaMass);
390  sigmaMassOverMassVsPtPlusErr_->Fill(pt1, sigmaMassPlusErr);
391  sigmaMassOverMassVsPtMinusErr_->Fill(pt1, sigmaMassMinusErr);
392 
393  sigmaPtVsEta_->Fill(eta1, sigmaPt1);
394  sigmaPtVsEtaPlusErr_->Fill(eta1, sigmaPtPlusErr1);
395  sigmaPtVsEtaMinusErr_->Fill(eta1, sigmaPtMinusErr1);
396  sigmaPtVsEtaDiff_->Fill(eta1, sigmaPtDiff.squaredDiff(eta1));
397  sigmaMassVsEta_->Fill(eta1, sigmaMass*mass);
398  sigmaMassVsEtaPlusErr_->Fill(eta1, sigmaMassPlusErr*mass);
399  sigmaMassVsEtaMinusErr_->Fill(eta1, sigmaMassMinusErr*mass);
400  sigmaMassOverMassVsEta_->Fill(eta1, sigmaMass);
401  sigmaMassOverMassVsEtaPlusErr_->Fill(eta1, sigmaMassPlusErr);
402  sigmaMassOverMassVsEtaMinusErr_->Fill(eta1, sigmaMassMinusErr);
403  }
404  if( (pt2 >= ptMinCut_ && pt2 <= ptMaxCut_) && (fabs(eta2) >= etaMinCut_ && fabs(eta2) <= etaMaxCut_) ) {
405  sigmaPtVsPt_->Fill(pt2, sigmaPt2);
406  sigmaPtVsPtPlusErr_->Fill(pt2, sigmaPtPlusErr2);
407  sigmaPtVsPtMinusErr_->Fill(pt2, sigmaPtMinusErr2);
408  sigmaPtVsPtDiff_->Fill(pt2, sigmaPtDiff.squaredDiff(eta2));
409  sigmaMassVsPt_->Fill(pt2, sigmaMass*mass);
410  sigmaMassVsPtPlusErr_->Fill(pt2, sigmaMassPlusErr*mass);
411  sigmaMassVsPtMinusErr_->Fill(pt2, sigmaMassMinusErr*mass);
412  sigmaMassOverMassVsPt_->Fill(pt2, sigmaMass);
413  sigmaMassOverMassVsPtPlusErr_->Fill(pt2, sigmaMassPlusErr);
414  sigmaMassOverMassVsPtMinusErr_->Fill(pt2, sigmaMassMinusErr);
415 
416  sigmaPtVsEta_->Fill(eta2, sigmaPt2);
417  sigmaPtVsEtaPlusErr_->Fill(eta2, sigmaPtPlusErr2);
418  sigmaPtVsEtaMinusErr_->Fill(eta2, sigmaPtMinusErr2);
419  sigmaPtVsEtaDiff_->Fill(eta2, sigmaPtDiff.squaredDiff(eta2));
420  sigmaMassVsEta_->Fill(eta2, sigmaMass*mass);
421  sigmaMassVsEtaPlusErr_->Fill(eta2, sigmaMassPlusErr*mass);
422  sigmaMassVsEtaMinusErr_->Fill(eta2, sigmaMassMinusErr*mass);
423  sigmaMassOverMassVsEta_->Fill(eta2, sigmaMass);
424  sigmaMassOverMassVsEtaPlusErr_->Fill(eta2, sigmaMassPlusErr);
425  sigmaMassOverMassVsEtaMinusErr_->Fill(eta2, sigmaMassMinusErr);
426  }
427  }
428 }
mps_fire.i
i
Definition: mps_fire.py:329
SigmaPtDiff
Returns ( sigmaPt/Pt(data)^2 - sigmaPt/Pt(MC)^2 )
Definition: SigmaPtDiff.h:71
MuScleFitUtils::debugMassResol_
static bool debugMassResol_
Definition: MuScleFitUtils.h:251
MuScleFitUtils::debug
static int debug
Definition: MuScleFitUtils.h:113
RootTreeHandler::readTree
void readTree(const int maxEvents, const TString &fileName, MuonPairVector *savedPair, const int muonType, std::vector< std::pair< unsigned int, unsigned long long > > *evtRun, MuonPairVector *genPair=nullptr)
Definition: RootTreeHandler.h:88
resolutionFunctionBase::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)=0
resolutionFunctionVecService
resolutionFunctionBase< std::vector< double > > * resolutionFunctionVecService(const int identifier)
Service to build the resolution functor corresponding to the passed identifier when receiving a std::...
Definition: Functions.cc:50
hiDetachedQuadStep_cff.pt2
pt2
Definition: hiDetachedQuadStep_cff.py:69
MuonPairVector
std::vector< std::pair< lorentzVector, lorentzVector > > MuonPairVector
Definition: RootTreeHandler.h:13
hiDetachedQuadStep_cff.pt1
pt1
Definition: hiDetachedQuadStep_cff.py:69
SigmaPtDiff::squaredDiff
double squaredDiff(const double &eta)
Definition: SigmaPtDiff.h:139
ErrorsPropagationAnalyzer::massResolution
double massResolution(const lorentzVector &mu1, const lorentzVector &mu2, const std::vector< double > &parval, const double &sigmaPt1, const double &sigmaPt2)
Modified method to take into account the error.
Definition: ErrorsPropagationAnalyzer.cc:218
resolutionFunctionService
resolutionFunctionBase< double * > * resolutionFunctionService(const int identifier)
Service to build the resolution functor corresponding to the passed identifier.
Definition: Functions.cc:38
gather_cfg.cout
cout
Definition: gather_cfg.py:144
MuScleFitUtils::resfind
static std::vector< int > resfind
Definition: MuScleFitUtils.h:193
resolutionFunctionBase::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:679
MuScleFitUtils::resolutionFunction
static resolutionFunctionBase< double * > * resolutionFunction
Definition: MuScleFitUtils.h:136
void ErrorsPropagationAnalyzer::fillValueError ( )
private

Definition at line 62 of file ErrorsPropagationAnalyzer.cc.

References errorFactors_, errors_, mps_fire::i, parameters_, valueMinusError_, and valuePlusError_.

Referenced by ErrorsPropagationAnalyzer().

63 {
64  valuePlusError_.resize(parameters_.size());
65  valueMinusError_.resize(parameters_.size());
66 
67  std::vector<double>::const_iterator parIt = parameters_.begin();
68  std::vector<double>::const_iterator errIt = errors_.begin();
69  std::vector<int>::const_iterator errFactorIt = errorFactors_.begin();
70  int i=0;
71  for( ; parIt != parameters_.end(); ++parIt, ++errIt, ++errFactorIt, ++i ) {
72  valuePlusError_[i] = *parIt + (*errIt)*(*errFactorIt);
73  valueMinusError_[i] = *parIt - (*errIt)*(*errFactorIt);
74  }
75 }
mps_fire.i
i
Definition: mps_fire.py:329
ErrorsPropagationAnalyzer::valueMinusError_
std::vector< double > valueMinusError_
Definition: ErrorsPropagationAnalyzer.h:93
ErrorsPropagationAnalyzer::valuePlusError_
std::vector< double > valuePlusError_
Definition: ErrorsPropagationAnalyzer.h:92
double ErrorsPropagationAnalyzer::massResolution ( const lorentzVector &  mu1,
const lorentzVector &  mu2,
const std::vector< double > &  parval,
const double &  sigmaPt1,
const double &  sigmaPt2 
)
private

Modified method to take into account the error.

Definition at line 218 of file ErrorsPropagationAnalyzer.cc.

References triggerObjects_cff::id, createfilelist::int, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by endJob(), and fillHistograms().

223 {
224  double * p = new double[(int)(parval.size())];
225  std::vector<double>::const_iterator it = parval.begin();
226  int id = 0;
227  for ( ; it!=parval.end(); ++it, ++id) {
228  p[id] = *it;
229  }
230  double massRes = massResolution (mu1, mu2, p, sigmaPt1, sigmaPt2);
231  delete[] p;
232  return massRes;
233 }
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:28
ErrorsPropagationAnalyzer::massResolution
double massResolution(const lorentzVector &mu1, const lorentzVector &mu2, const std::vector< double > &parval, const double &sigmaPt1, const double &sigmaPt2)
Modified method to take into account the error.
Definition: ErrorsPropagationAnalyzer.cc:218
double ErrorsPropagationAnalyzer::massResolution ( const lorentzVector &  mu1,
const lorentzVector &  mu2,
double *  parval,
const double &  sigmaPt1,
const double &  sigmaPt2 
)
private

Definition at line 235 of file ErrorsPropagationAnalyzer.cc.

References funct::cos(), resolutionFunctionBase< T >::covPt1Pt2(), JetChargeProducer_cfi::exp, ResonanceBuilder::mass, MuScleFitUtils::mMu2, funct::pow(), hiDetachedQuadStep_cff::pt1, hiDetachedQuadStep_cff::pt2, MuScleFitUtils::resolutionFunction, resolutionFunctionBase< T >::sigmaCotgTh(), resolutionFunctionBase< T >::sigmaPhi(), funct::sin(), and mathSSE::sqrt().

240 {
241  double mass = (mu1+mu2).mass();
242  double pt1 = mu1.Pt();
243  double phi1 = mu1.Phi();
244  double eta1 = mu1.Eta();
245  double theta1 = 2*atan(exp(-eta1));
246  double pt2 = mu2.Pt();
247  double phi2 = mu2.Phi();
248  double eta2 = mu2.Eta();
249  double theta2 = 2*atan(exp(-eta2));
250 
251  // ATTENTION: need to compute 1/tan(theta) as cos(theta)/sin(theta) because the latter diverges for theta=pi/2
252  // -----------------------------------------------------------------------------------------------------------
253  double dmdpt1 = (pt1/std::pow(sin(theta1),2)*sqrt((std::pow(pt2/sin(theta2),2)+MuScleFitUtils::mMu2)/(std::pow(pt1/sin(theta1),2)+MuScleFitUtils::mMu2))-
254  pt2*(cos(phi1-phi2)+cos(theta1)*cos(theta2)/(sin(theta1)*sin(theta2))))/mass;
255  double dmdpt2 = (pt2/std::pow(sin(theta2),2)*sqrt((std::pow(pt1/sin(theta1),2)+MuScleFitUtils::mMu2)/(std::pow(pt2/sin(theta2),2)+MuScleFitUtils::mMu2))-
256  pt1*(cos(phi2-phi1)+cos(theta2)*cos(theta1)/(sin(theta2)*sin(theta1))))/mass;
257  double dmdphi1 = pt1*pt2/mass*sin(phi1-phi2);
258  double dmdphi2 = pt2*pt1/mass*sin(phi2-phi1);
259  double dmdcotgth1 = (pt1*pt1*cos(theta1)/sin(theta1)*
260  sqrt((std::pow(pt2/sin(theta2),2)+MuScleFitUtils::mMu2)/(std::pow(pt1/sin(theta1),2)+MuScleFitUtils::mMu2)) -
261  pt1*pt2*cos(theta2)/sin(theta2))/mass;
262  double dmdcotgth2 = (pt2*pt2*cos(theta2)/sin(theta2)*
263  sqrt((std::pow(pt1/sin(theta1),2)+MuScleFitUtils::mMu2)/(std::pow(pt2/sin(theta2),2)+MuScleFitUtils::mMu2)) -
264  pt2*pt1*cos(theta1)/sin(theta1))/mass;
265 
266  // Resolution parameters:
267  // ----------------------
268  // double sigma_pt1 = MuScleFitUtils::resolutionFunction->sigmaPt( pt1,eta1,parval );
269  // double sigma_pt2 = MuScleFitUtils::resolutionFunction->sigmaPt( pt2,eta2,parval );
270  double sigma_pt1 = sigmaPt1;
271  double sigma_pt2 = sigmaPt2;
272  double sigma_phi1 = MuScleFitUtils::resolutionFunction->sigmaPhi( pt1,eta1,parval );
273  double sigma_phi2 = MuScleFitUtils::resolutionFunction->sigmaPhi( pt2,eta2,parval );
274  double sigma_cotgth1 = MuScleFitUtils::resolutionFunction->sigmaCotgTh( pt1,eta1,parval );
275  double sigma_cotgth2 = MuScleFitUtils::resolutionFunction->sigmaCotgTh( pt2,eta2,parval );
276  double cov_pt1pt2 = MuScleFitUtils::resolutionFunction->covPt1Pt2( pt1, eta1, pt2, eta2, parval );
277 
278  // Sigma_Pt is defined as a relative sigmaPt/Pt for this reason we need to
279  // multiply it by pt.
280  double mass_res = sqrt(std::pow(dmdpt1*sigma_pt1*pt1,2)+std::pow(dmdpt2*sigma_pt2*pt2,2)+
281  std::pow(dmdphi1*sigma_phi1,2)+std::pow(dmdphi2*sigma_phi2,2)+
282  std::pow(dmdcotgth1*sigma_cotgth1,2)+std::pow(dmdcotgth2*sigma_cotgth2,2)+
283  2*dmdpt1*dmdpt2*cov_pt1pt2);
284 
285  return mass_res;
286 }
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
hiDetachedQuadStep_cff.pt2
pt2
Definition: hiDetachedQuadStep_cff.py:69
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:18
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
resolutionFunctionBase::covPt1Pt2
virtual double covPt1Pt2(const double &pt1, const double &eta1, const double &pt2, const double &eta2, const T &parval)
Definition: Functions.h:685
hiDetachedQuadStep_cff.pt1
pt1
Definition: hiDetachedQuadStep_cff.py:69
resolutionFunctionBase::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)=0
MuScleFitUtils::mMu2
static const double mMu2
Definition: MuScleFitUtils.h:122
resolutionFunctionBase::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)=0
JetChargeProducer_cfi.exp
exp
Definition: JetChargeProducer_cfi.py:6
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:40
MuScleFitUtils::resolutionFunction
static resolutionFunctionBase< double * > * resolutionFunction
Definition: MuScleFitUtils.h:136

Member Data Documentation

bool ErrorsPropagationAnalyzer::debug_
private

Definition at line 84 of file ErrorsPropagationAnalyzer.h.

Referenced by fillHistograms().

std::vector<int> ErrorsPropagationAnalyzer::errorFactors_
private

Definition at line 90 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), and fillValueError().

std::vector<double> ErrorsPropagationAnalyzer::errors_
private

Definition at line 89 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), fillHistograms(), and fillValueError().

int ErrorsPropagationAnalyzer::etaBins_
private

Definition at line 81 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer().

double ErrorsPropagationAnalyzer::etaMax_
private

Definition at line 83 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer().

double ErrorsPropagationAnalyzer::etaMaxCut_
private

Definition at line 86 of file ErrorsPropagationAnalyzer.h.

Referenced by fillHistograms().

double ErrorsPropagationAnalyzer::etaMin_
private

Definition at line 82 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer().

double ErrorsPropagationAnalyzer::etaMinCut_
private

Definition at line 86 of file ErrorsPropagationAnalyzer.h.

Referenced by fillHistograms().

uint32_t ErrorsPropagationAnalyzer::maxEvents_
private

Definition at line 76 of file ErrorsPropagationAnalyzer.h.

Referenced by fillHistograms().

TString ErrorsPropagationAnalyzer::outputFileName_
private

Definition at line 77 of file ErrorsPropagationAnalyzer.h.

Referenced by ~ErrorsPropagationAnalyzer().

std::vector<double> ErrorsPropagationAnalyzer::parameters_
private

Definition at line 88 of file ErrorsPropagationAnalyzer.h.

Referenced by Mixins._TypedParameterizable::clone(), Types.PSet::clone(), Mixins._TypedParameterizable::copy(), ErrorsPropagationAnalyzer(), fillHistograms(), and fillValueError().

int ErrorsPropagationAnalyzer::ptBins_
private

Definition at line 78 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer().

double ErrorsPropagationAnalyzer::ptMax_
private

Definition at line 80 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer().

double ErrorsPropagationAnalyzer::ptMaxCut_
private

Definition at line 86 of file ErrorsPropagationAnalyzer.h.

Referenced by fillHistograms().

double ErrorsPropagationAnalyzer::ptMin_
private

Definition at line 79 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer().

double ErrorsPropagationAnalyzer::ptMinCut_
private

Definition at line 86 of file ErrorsPropagationAnalyzer.h.

Referenced by fillHistograms().

int ErrorsPropagationAnalyzer::resolFitType_
private

Definition at line 75 of file ErrorsPropagationAnalyzer.h.

Referenced by fillHistograms().

TProfile* ErrorsPropagationAnalyzer::sigmaMassOverMassVsEta_
private

Definition at line 115 of file ErrorsPropagationAnalyzer.h.

Referenced by drawHistograms(), ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaMassOverMassVsEtaMinusErr_
private

Definition at line 117 of file ErrorsPropagationAnalyzer.h.

Referenced by drawHistograms(), ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaMassOverMassVsEtaPlusErr_
private

Definition at line 116 of file ErrorsPropagationAnalyzer.h.

Referenced by drawHistograms(), ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaMassOverMassVsPt_
private

Definition at line 119 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaMassOverMassVsPtMinusErr_
private

Definition at line 121 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaMassOverMassVsPtPlusErr_
private

Definition at line 120 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaMassVsEta_
private

Definition at line 107 of file ErrorsPropagationAnalyzer.h.

Referenced by drawHistograms(), ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaMassVsEtaMinusErr_
private

Definition at line 109 of file ErrorsPropagationAnalyzer.h.

Referenced by drawHistograms(), ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaMassVsEtaPlusErr_
private

Definition at line 108 of file ErrorsPropagationAnalyzer.h.

Referenced by drawHistograms(), ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaMassVsPt_
private

Definition at line 111 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaMassVsPtMinusErr_
private

Definition at line 113 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaMassVsPtPlusErr_
private

Definition at line 112 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaPtVsEta_
private

Definition at line 95 of file ErrorsPropagationAnalyzer.h.

Referenced by drawHistograms(), ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaPtVsEtaDiff_
private

Definition at line 103 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaPtVsEtaMinusErr_
private

Definition at line 97 of file ErrorsPropagationAnalyzer.h.

Referenced by drawHistograms(), ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaPtVsEtaPlusErr_
private

Definition at line 96 of file ErrorsPropagationAnalyzer.h.

Referenced by drawHistograms(), ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaPtVsPt_
private

Definition at line 99 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaPtVsPtDiff_
private

Definition at line 104 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaPtVsPtMinusErr_
private

Definition at line 101 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TProfile* ErrorsPropagationAnalyzer::sigmaPtVsPtPlusErr_
private

Definition at line 100 of file ErrorsPropagationAnalyzer.h.

Referenced by ErrorsPropagationAnalyzer(), fillHistograms(), and ~ErrorsPropagationAnalyzer().

TString ErrorsPropagationAnalyzer::treeFileName_
private

Definition at line 74 of file ErrorsPropagationAnalyzer.h.

Referenced by fillHistograms().

std::vector<double> ErrorsPropagationAnalyzer::valueMinusError_
private

Definition at line 93 of file ErrorsPropagationAnalyzer.h.

Referenced by fillValueError().

std::vector<double> ErrorsPropagationAnalyzer::valuePlusError_
private

Definition at line 92 of file ErrorsPropagationAnalyzer.h.

Referenced by fillValueError().

Generated for CMSSW Reference Manual by doxygen 1.8.11