CMS 3D CMS Logo
List of all members | Classes | Public Member Functions | Protected Member Functions | Protected Attributes
MuScleFitBase Class Reference

#include <MuScleFitBase.h>

Inheritance diagram for MuScleFitBase:
MuScleFit TestCorrection TestCorrection

Classes

class  ProbForIntegral
 Functor used to compute the normalization integral of probability functions. More...
 

Public Member Functions

 MuScleFitBase (const edm::ParameterSet &iConfig)
 
virtual ~MuScleFitBase () noexcept(false)
 

Protected Member Functions

void clearHistoMap ()
 Clean the histograms map. More...
 
void fillHistoMap (TFile *outputFile, unsigned int iLoop)
 Create the histograms map. More...
 
void readProbabilityDistributionsFromFile ()
 Read probability distributions from a local root file. More...
 
void writeHistoMap (const unsigned int iLoop)
 Save the histograms map to file. More...
 

Protected Attributes

int debug_
 
std::vector< GenMuonPair > genMuonPairs_
 Stores the genMuon pairs and the motherId prior to the creation of the internal tree. More...
 
std::map< std::string, Histograms * > mapHisto_
 The map of histograms. More...
 
std::vector< MuonPair > muonPairs_
 Used to store the muon pairs plus run and event number prior to the creation of the internal tree. More...
 
std::string probabilitiesFile_
 
std::string probabilitiesFileInPath_
 
int theCompressionSettings_
 
std::vector< TFile * > theFiles_
 The files were the histograms are saved. More...
 
std::string theGenInfoRootFileName_
 
edm::InputTag theMuonLabel_
 
int theMuonType_
 
std::string theRootFileName_
 

Detailed Description

This class is used as a base for MuSlceFit. The reason for putting some of the methods inside this base class is that they are used also by the TestCorrection analyzer.

Definition at line 18 of file MuScleFitBase.h.

Constructor & Destructor Documentation

◆ MuScleFitBase()

MuScleFitBase::MuScleFitBase ( const edm::ParameterSet &  iConfig)
inline

Definition at line 20 of file MuScleFitBase.h.

21  : probabilitiesFileInPath_(iConfig.getUntrackedParameter<std::string>(
22  "ProbabilitiesFileInPath", "MuonAnalysis/MomentumScaleCalibration/test/Probs_new_Horace_CTEQ_1000.root")),
23  probabilitiesFile_(iConfig.getUntrackedParameter<std::string>("ProbabilitiesFile", "")),
24  theMuonType_(iConfig.getParameter<int>("MuonType")),
25  theMuonLabel_(iConfig.getParameter<edm::InputTag>("MuonLabel")),
26  theCompressionSettings_(iConfig.getUntrackedParameter<int>("compressionSettings", -1)),
27  theRootFileName_(iConfig.getUntrackedParameter<std::string>("OutputFileName")),
28  theGenInfoRootFileName_(
29  iConfig.getUntrackedParameter<std::string>("OutputGenInfoFileName", "genSimRecoPlots.root")),
30  debug_(iConfig.getUntrackedParameter<int>("debug", 0)) {}

◆ ~MuScleFitBase()

virtual MuScleFitBase::~MuScleFitBase ( )
inlinevirtualnoexcept

Definition at line 31 of file MuScleFitBase.h.

31 {}

Member Function Documentation

◆ clearHistoMap()

void MuScleFitBase::clearHistoMap ( )
protected

Clean the histograms map.

Definition at line 143 of file MuScleFitBase.cc.

143  {
144  for (std::map<std::string, Histograms*>::const_iterator histo = mapHisto_.begin(); histo != mapHisto_.end();
145  histo++) {
146  delete (*histo).second;
147  }
148 }

References timingPdfMaker::histo, and mapHisto_.

Referenced by MuScleFit::endOfFastLoop().

◆ fillHistoMap()

void MuScleFitBase::fillHistoMap ( TFile *  outputFile,
unsigned int  iLoop 
)
protected

Create the histograms map.

Definition at line 9 of file MuScleFitBase.cc.

9  {
10  //Reconstructed muon kinematics
11  //-----------------------------
12  outputFile->cd();
13  // If no Z is required, use a smaller mass range.
14  double minMass = 0.;
15  double maxMass = 200.;
16  double maxPt = 100.;
17  double yMaxEta = 4.;
18  double yMaxPt = 2.;
19  if (MuScleFitUtils::resfind[0] != 1) {
20  maxMass = 20.;
21  maxPt = 20.;
22  yMaxEta = 0.2;
23  yMaxPt = 0.2;
24  // If running on standalone muons we need to expand the window range
25  if (theMuonType_ == 2) {
26  yMaxEta = 20.;
27  }
28  }
29 
30  LogDebug("MuScleFitBase") << "Creating new histograms" << std::endl;
31 
32  mapHisto_["hRecBestMu"] = new HParticle("hRecBestMu", minMass, maxMass, maxPt);
33  mapHisto_["hRecBestMuVSEta"] = new HPartVSEta("hRecBestMuVSEta", minMass, maxMass, maxPt);
34  //mapHisto_["hRecBestMuVSPhi"] = new HPartVSPhi ("hRecBestMuVSPhi");
35  //mapHisto_["hRecBestMu_Acc"] = new HParticle ("hRecBestMu_Acc", minMass, maxMass);
36  mapHisto_["hDeltaRecBestMu"] = new HDelta("hDeltaRecBestMu");
37 
38  mapHisto_["hRecBestRes"] = new HParticle("hRecBestRes", minMass, maxMass, maxPt);
39  mapHisto_["hRecBestResAllEvents"] = new HParticle("hRecBestResAllEvents", minMass, maxMass, maxPt);
40  //mapHisto_["hRecBestRes_Acc"] = new HParticle ("hRecBestRes_Acc", minMass, maxMass);
41  // If not finding Z, use a smaller mass window
42  mapHisto_["hRecBestResVSMu"] = new HMassVSPart("hRecBestResVSMu", minMass, maxMass, maxPt);
43  mapHisto_["hRecBestResVSRes"] = new HMassVSPart("hRecBestResVSRes", minMass, maxMass, maxPt);
44  //Generated Mass versus pt
45  mapHisto_["hGenResVSMu"] = new HMassVSPart("hGenResVSMu", minMass, maxMass, maxPt);
46  // Likelihood values VS muon variables
47  // -------------------------------------
48  mapHisto_["hLikeVSMu"] = new HLikelihoodVSPart("hLikeVSMu");
49  mapHisto_["hLikeVSMuMinus"] = new HLikelihoodVSPart("hLikeVSMuMinus");
50  mapHisto_["hLikeVSMuPlus"] = new HLikelihoodVSPart("hLikeVSMuPlus");
51 
52  //Resolution VS muon kinematic
53  //----------------------------
54  mapHisto_["hResolMassVSMu"] =
55  new HResolutionVSPart(outputFile, "hResolMassVSMu", maxPt, 0., yMaxEta, 0., yMaxPt, true);
56  mapHisto_["hFunctionResolMassVSMu"] =
57  new HResolutionVSPart(outputFile, "hFunctionResolMassVSMu", maxPt, 0, 0.1, 0, 0.1, true);
58  mapHisto_["hResolPtGenVSMu"] = new HResolutionVSPart(outputFile, "hResolPtGenVSMu", maxPt, -0.1, 0.1, -0.1, 0.1);
59  mapHisto_["hResolPtSimVSMu"] = new HResolutionVSPart(outputFile, "hResolPtSimVSMu", maxPt, -0.1, 0.1, -0.1, 0.1);
60  mapHisto_["hResolEtaGenVSMu"] =
61  new HResolutionVSPart(outputFile, "hResolEtaGenVSMu", maxPt, -0.02, 0.02, -0.02, 0.02);
62  mapHisto_["hResolEtaSimVSMu"] =
63  new HResolutionVSPart(outputFile, "hResolEtaSimVSMu", maxPt, -0.02, 0.02, -0.02, 0.02);
64  mapHisto_["hResolThetaGenVSMu"] =
65  new HResolutionVSPart(outputFile, "hResolThetaGenVSMu", maxPt, -0.02, 0.02, -0.02, 0.02);
66  mapHisto_["hResolThetaSimVSMu"] =
67  new HResolutionVSPart(outputFile, "hResolThetaSimVSMu", maxPt, -0.02, 0.02, -0.02, 0.02);
68  mapHisto_["hResolCotgThetaGenVSMu"] =
69  new HResolutionVSPart(outputFile, "hResolCotgThetaGenVSMu", maxPt, -0.02, 0.02, -0.02, 0.02);
70  mapHisto_["hResolCotgThetaSimVSMu"] =
71  new HResolutionVSPart(outputFile, "hResolCotgThetaSimVSMu", maxPt, -0.02, 0.02, -0.02, 0.02);
72  mapHisto_["hResolPhiGenVSMu"] =
73  new HResolutionVSPart(outputFile, "hResolPhiGenVSMu", maxPt, -0.02, 0.02, -0.02, 0.02);
74  mapHisto_["hResolPhiSimVSMu"] =
75  new HResolutionVSPart(outputFile, "hResolPhiSimVSMu", maxPt, -0.02, 0.02, -0.02, 0.02);
76 
77  if (MuScleFitUtils::debugMassResol_) {
78  mapHisto_["hdMdPt1"] = new HResolutionVSPart(outputFile, "hdMdPt1", maxPt, 0, 100, -3.2, 3.2, true);
79  mapHisto_["hdMdPt2"] = new HResolutionVSPart(outputFile, "hdMdPt2", maxPt, 0, 100, -3.2, 3.2, true);
80  mapHisto_["hdMdPhi1"] = new HResolutionVSPart(outputFile, "hdMdPhi1", maxPt, 0, 100, -3.2, 3.2, true);
81  mapHisto_["hdMdPhi2"] = new HResolutionVSPart(outputFile, "hdMdPhi2", maxPt, 0, 100, -3.2, 3.2, true);
82  mapHisto_["hdMdCotgTh1"] = new HResolutionVSPart(outputFile, "hdMdCotgTh1", maxPt, 0, 100, -3.2, 3.2, true);
83  mapHisto_["hdMdCotgTh2"] = new HResolutionVSPart(outputFile, "hdMdCotgTh2", maxPt, 0, 100, -3.2, 3.2, true);
84  }
85 
86  HTH2D* recoGenHisto =
87  new HTH2D(outputFile, "hPtRecoVsPtGen", "Pt reco vs Pt gen", "hPtRecoVsPtGen", 120, 0., 120., 120, 0, 120.);
88  (*recoGenHisto)->SetXTitle("Pt gen (GeV)");
89  (*recoGenHisto)->SetYTitle("Pt reco (GeV)");
90  mapHisto_["hPtRecoVsPtGen"] = recoGenHisto;
91  HTH2D* recoSimHisto =
92  new HTH2D(outputFile, "hPtRecoVsPtSim", "Pt reco vs Pt sim", "hPtRecoVsPtSim", 120, 0., 120., 120, 0, 120.);
93  (*recoSimHisto)->SetXTitle("Pt sim (GeV)");
94  (*recoSimHisto)->SetYTitle("Pt reco (GeV)");
95  mapHisto_["hPtRecoVsPtSim"] = recoSimHisto;
96  // Resolutions from resolution functions
97  // -------------------------------------
98  mapHisto_["hFunctionResolPt"] = new HFunctionResolution(outputFile, "hFunctionResolPt", maxPt);
99  mapHisto_["hFunctionResolCotgTheta"] = new HFunctionResolution(outputFile, "hFunctionResolCotgTheta", maxPt);
100  mapHisto_["hFunctionResolPhi"] = new HFunctionResolution(outputFile, "hFunctionResolPhi", maxPt);
101 
102  // Mass probability histograms
103  // ---------------------------
104  // The word "profile" is added to the title automatically
105  mapHisto_["hMass_P"] = new HTProfile(outputFile, "Mass_P", "Mass probability", 4000, 0., 200., 0., 50.);
106  mapHisto_["hMass_fine_P"] = new HTProfile(outputFile, "Mass_fine_P", "Mass probability", 4000, 0., 20., 0., 50.);
107  mapHisto_["hMass_Probability"] = new HTH1D(outputFile, "Mass_Probability", "Mass probability", 4000, 0., 200.);
108  mapHisto_["hMass_fine_Probability"] =
109  new HTH1D(outputFile, "Mass_fine_Probability", "Mass probability", 4000, 0., 20.);
110  mapHisto_["hMassProbVsMu"] = new HMassVSPartProfile("hMassProbVsMu", minMass, maxMass, maxPt);
111  mapHisto_["hMassProbVsRes"] = new HMassVSPartProfile("hMassProbVsRes", minMass, maxMass, maxPt);
112  mapHisto_["hMassProbVsMu_fine"] = new HMassVSPartProfile("hMassProbVsMu_fine", minMass, maxMass, maxPt);
113  mapHisto_["hMassProbVsRes_fine"] = new HMassVSPartProfile("hMassProbVsRes_fine", minMass, maxMass, maxPt);
114 
115  // (M_reco-M_gen)/M_gen vs (pt, eta) of the muons from MC
116  mapHisto_["hDeltaMassOverGenMassVsPt"] = new HTH2D(outputFile,
117  "DeltaMassOverGenMassVsPt",
118  "DeltaMassOverGenMassVsPt",
119  "DeltaMassOverGenMass",
120  200,
121  0,
122  maxPt,
123  200,
124  -0.2,
125  0.2);
126  mapHisto_["hDeltaMassOverGenMassVsEta"] = new HTH2D(outputFile,
127  "DeltaMassOverGenMassVsEta",
128  "DeltaMassOverGenMassVsEta",
129  "DeltaMassOverGenMass",
130  200,
131  -3.,
132  3.,
133  200,
134  -0.2,
135  0.2);
136 
137  // Square of mass resolution vs (pt, eta) of the muons from MC
138  // EM 2012.12.19 mapHisto_["hMassResolutionVsPtEta"] = new HCovarianceVSxy( "Mass", "Mass", 100, 0., maxPt, 60, -3, 3, outputFile->mkdir("MassCovariance") );
139  // Mass resolution vs (pt, eta) from resolution function
140  mapHisto_["hFunctionResolMass"] = new HFunctionResolution(outputFile, "hFunctionResolMass", maxPt);
141 }

References MuScleFitUtils::debugMassResol_, LogDebug, mapHisto_, B2GTnPMonitor_cfi::maxMass, L1TrackerEtMissProducer_cfi::maxPt, B2GTnPMonitor_cfi::minMass, download_sqlite_cfg::outputFile, MuScleFitUtils::resfind, and theMuonType_.

Referenced by MuScleFit::startingNewLoop(), and TestCorrection::TestCorrection().

◆ readProbabilityDistributionsFromFile()

void MuScleFitBase::readProbabilityDistributionsFromFile ( )
protected

Read probability distributions from a local root file.

Definition at line 159 of file MuScleFitBase.cc.

159  {
160  std::array<TH2D*, 6> GLZ = {{nullptr}};
161  std::array<TH2D*, 6> GL = {{nullptr}};
162  std::unique_ptr<TFile> ProbsFile;
163  if (!probabilitiesFile_.empty()) {
164  ProbsFile = std::make_unique<TFile>(probabilitiesFile_.c_str());
165  std::cout << "[MuScleFit-Constructor]: Reading TH2D probabilities from " << probabilitiesFile_ << std::endl;
166  } else {
167  // edm::FileInPath file("MuonAnalysis/MomentumScaleCalibration/test/Probs_new_1000_CTEQ.root");
168  // edm::FileInPath file("MuonAnalysis/MomentumScaleCalibration/test/Probs_new_Horace_CTEQ_1000.root");
169  // edm::FileInPath file("MuonAnalysis/MomentumScaleCalibration/test/Probs_merge.root");
170  edm::FileInPath file(probabilitiesFileInPath_.c_str());
171  ProbsFile = std::make_unique<TFile>(file.fullPath().c_str());
172  std::cout << "[MuScleFit-Constructor]: Reading TH2D probabilities from " << probabilitiesFileInPath_ << std::endl;
173  }
174 
175  ProbsFile->cd();
176  bool resfindEmpty = true;
177  if (MuScleFitUtils::rapidityBinsForZ_ && MuScleFitUtils::resfind[0] && theMuonType_ != 2) {
178  resfindEmpty = false;
179  for (unsigned char i = 0; i < GLZ.size(); i++) {
180  char nameh[6];
181  snprintf(nameh, 6, "GLZ%hhu", i);
182  GLZ[i] = dynamic_cast<TH2D*>(ProbsFile->Get(nameh));
183  }
184  } else if (MuScleFitUtils::resfind[0] && theMuonType_ == 2) {
185  GL[0] = dynamic_cast<TH2D*>(ProbsFile->Get("GL0"));
186  resfindEmpty = false;
187  }
188  for (unsigned char i = 1; i < GL.size(); ++i) {
189  if (MuScleFitUtils::resfind[i]) {
190  char nameh[6];
191  snprintf(nameh, 6, "GL%hhu", i);
192  GL[i] = dynamic_cast<TH2D*>(ProbsFile->Get(nameh));
193  resfindEmpty = false;
194  }
195  }
196  if (resfindEmpty) {
197  std::cout << "[MuScleFit-Constructor]: No resonance selected, please fill the resfind array" << std::endl;
198  exit(1);
199  }
200 
201  // Read the limits for M and Sigma axis for each pdf
202  // Note: we assume all the Z histograms to have the same limits
203  // x is mass, y is sigma
204  if (MuScleFitUtils::rapidityBinsForZ_ && MuScleFitUtils::resfind[0] && theMuonType_ != 2) {
205  MuScleFitUtils::ResHalfWidth[0] = (GLZ[0]->GetXaxis()->GetXmax() - GLZ[0]->GetXaxis()->GetXmin()) / 2.;
206  MuScleFitUtils::ResMaxSigma[0] = (GLZ[0]->GetYaxis()->GetXmax() - GLZ[0]->GetYaxis()->GetXmin());
207  MuScleFitUtils::ResMinMass[0] = (GLZ[0]->GetXaxis()->GetXmin());
208  }
209  if (MuScleFitUtils::resfind[0] && theMuonType_ == 2) {
210  MuScleFitUtils::ResHalfWidth[0] = (GL[0]->GetXaxis()->GetXmax() - GL[0]->GetXaxis()->GetXmin()) / 2.;
211  MuScleFitUtils::ResMaxSigma[0] = (GL[0]->GetYaxis()->GetXmax() - GL[0]->GetYaxis()->GetXmin());
212  MuScleFitUtils::ResMinMass[0] = (GL[0]->GetXaxis()->GetXmin());
213  }
214  for (unsigned int i = 1; i < GL.size(); ++i) {
215  if (MuScleFitUtils::resfind[i]) {
216  MuScleFitUtils::ResHalfWidth[i] = (GL[i]->GetXaxis()->GetXmax() - GL[i]->GetXaxis()->GetXmin()) / 2.;
217  MuScleFitUtils::ResMaxSigma[i] = (GL[i]->GetYaxis()->GetXmax() - GL[i]->GetYaxis()->GetXmin());
218  MuScleFitUtils::ResMinMass[i] = (GL[i]->GetXaxis()->GetXmin());
219  // if( debug_>2 ) {
220  std::cout << "MuScleFitUtils::ResHalfWidth[" << i << "] = " << MuScleFitUtils::ResHalfWidth[i] << std::endl;
221  std::cout << "MuScleFitUtils::ResMaxSigma[" << i << "] = " << MuScleFitUtils::ResMaxSigma[i] << std::endl;
222  // }
223  }
224  }
225 
226  // Extract normalization for mass slice in Y bins of Z
227  // ---------------------------------------------------
228  if (MuScleFitUtils::rapidityBinsForZ_ && MuScleFitUtils::resfind[0] && theMuonType_ != 2) {
229  for (unsigned int iY = 0; iY < GLZ.size(); iY++) {
230  int nBinsX = GLZ[iY]->GetNbinsX();
231  int nBinsY = GLZ[iY]->GetNbinsY();
232  if (nBinsX != MuScleFitUtils::nbins + 1 || nBinsY != MuScleFitUtils::nbins + 1) {
233  std::cout << "Error: for histogram \"" << GLZ[iY]->GetName() << "\" bins are not " << MuScleFitUtils::nbins
234  << std::endl;
235  std::cout << "nBinsX = " << nBinsX << ", nBinsY = " << nBinsY << std::endl;
236  exit(1);
237  }
238  for (int iy = 0; iy <= MuScleFitUtils::nbins; iy++) {
239  MuScleFitUtils::GLZNorm[iY][iy] = 0.;
240  for (int ix = 0; ix <= MuScleFitUtils::nbins; ix++) {
241  MuScleFitUtils::GLZValue[iY][ix][iy] = GLZ[iY]->GetBinContent(ix + 1, iy + 1);
242  MuScleFitUtils::GLZNorm[iY][iy] +=
243  MuScleFitUtils::GLZValue[iY][ix][iy] * (2 * MuScleFitUtils::ResHalfWidth[0]) / MuScleFitUtils::nbins;
244  }
245  }
246  }
247  }
248 
249  if (MuScleFitUtils::resfind[0] && theMuonType_ == 2) {
250  int nBinsX = GL[0]->GetNbinsX();
251  int nBinsY = GL[0]->GetNbinsY();
252  if (nBinsX != MuScleFitUtils::nbins + 1 || nBinsY != MuScleFitUtils::nbins + 1) {
253  std::cout << "Error: for histogram \"" << GL[0]->GetName() << "\" bins are not " << MuScleFitUtils::nbins
254  << std::endl;
255  std::cout << "nBinsX = " << nBinsX << ", nBinsY = " << nBinsY << std::endl;
256  exit(1);
257  }
258 
259  for (int iy = 0; iy <= MuScleFitUtils::nbins; iy++) {
260  MuScleFitUtils::GLNorm[0][iy] = 0.;
261  for (int ix = 0; ix <= MuScleFitUtils::nbins; ix++) {
262  MuScleFitUtils::GLValue[0][ix][iy] = GL[0]->GetBinContent(ix + 1, iy + 1);
263  // N.B. approximation: we should compute the integral of the function used to compute the probability (linear
264  // interpolation of the mass points). This computation could be troublesome because the points have a steep
265  // variation near the mass peak and the normal integral is not precise in these conditions.
266  // Furthermore it is slow.
267  MuScleFitUtils::GLNorm[0][iy] +=
268  MuScleFitUtils::GLValue[0][ix][iy] * (2 * MuScleFitUtils::ResHalfWidth[0]) / MuScleFitUtils::nbins;
269  }
270  }
271  }
272  // Extract normalization for each mass slice
273  // -----------------------------------------
274  for (unsigned int ires = 1; ires < GL.size(); ires++) {
275  if (MuScleFitUtils::resfind[ires]) {
276  int nBinsX = GL[ires]->GetNbinsX();
277  int nBinsY = GL[ires]->GetNbinsY();
278  if (nBinsX != MuScleFitUtils::nbins + 1 || nBinsY != MuScleFitUtils::nbins + 1) {
279  std::cout << "Error: for histogram \"" << GL[ires]->GetName() << "\" bins are not " << MuScleFitUtils::nbins
280  << std::endl;
281  std::cout << "nBinsX = " << nBinsX << ", nBinsY = " << nBinsY << std::endl;
282  exit(1);
283  }
284 
285  for (int iy = 0; iy <= MuScleFitUtils::nbins; iy++) {
286  MuScleFitUtils::GLNorm[ires][iy] = 0.;
287  for (int ix = 0; ix <= MuScleFitUtils::nbins; ix++) {
288  MuScleFitUtils::GLValue[ires][ix][iy] = GL[ires]->GetBinContent(ix + 1, iy + 1);
289  // N.B. approximation: we should compute the integral of the function used to compute the probability (linear
290  // interpolation of the mass points). This computation could be troublesome because the points have a steep
291  // variation near the mass peak and the normal integral is not precise in these conditions.
292  // Furthermore it is slow.
293  MuScleFitUtils::GLNorm[ires][iy] +=
294  MuScleFitUtils::GLValue[ires][ix][iy] * (2 * MuScleFitUtils::ResHalfWidth[ires]) / MuScleFitUtils::nbins;
295  }
296  }
297  }
298  }
299  // Free all the memory for the probability histograms.
300  if (MuScleFitUtils::rapidityBinsForZ_ && MuScleFitUtils::resfind[0] && theMuonType_ != 2) {
301  for (unsigned int i = 0; i < GLZ.size(); i++) {
302  delete GLZ[i];
303  }
304  }
305  if (MuScleFitUtils::resfind[0] && theMuonType_ == 2)
306  delete GL[0];
307  for (unsigned int ires = 1; ires < GL.size(); ires++) {
308  if (MuScleFitUtils::resfind[ires])
309  delete GL[ires];
310  }
311 }

References gather_cfg::cout, beamvalidation::exit(), geometryDiff::file, GL, MuScleFitUtils::GLNorm, MuScleFitUtils::GLValue, MuScleFitUtils::GLZNorm, MuScleFitUtils::GLZValue, mps_fire::i, ires, MuScleFitUtils::nbins, probabilitiesFile_, probabilitiesFileInPath_, MuScleFitUtils::rapidityBinsForZ_, MuScleFitUtils::resfind, MuScleFitUtils::ResHalfWidth, MuScleFitUtils::ResMaxSigma, MuScleFitUtils::ResMinMass, and theMuonType_.

Referenced by MuScleFit::beginOfJobInConstructor(), and TestCorrection::initialize().

◆ writeHistoMap()

void MuScleFitBase::writeHistoMap ( const unsigned int  iLoop)
protected

Save the histograms map to file.

Definition at line 150 of file MuScleFitBase.cc.

150  {
151  for (std::map<std::string, Histograms*>::const_iterator histo = mapHisto_.begin(); histo != mapHisto_.end();
152  histo++) {
153  // This is to avoid writing into subdirs. Need a workaround.
154  theFiles_[iLoop]->cd();
155  (*histo).second->Write();
156  }
157 }

References timingPdfMaker::histo, mapHisto_, and theFiles_.

Referenced by MuScleFit::endOfFastLoop(), and TestCorrection::~TestCorrection().

Member Data Documentation

◆ debug_

int MuScleFitBase::debug_
protected

Definition at line 53 of file MuScleFitBase.h.

Referenced by MuScleFit::applyBias(), MuScleFit::applySmearing(), MuScleFit::beginOfJobInConstructor(), MuScleFit::checkDeltaR(), MuScleFit::duringFastLoop(), MuScleFit::duringLoop(), MuScleFit::endOfJob(), TestCorrection::fillMuonCollection(), MuScleFit::fillMuonCollection(), MuScleFit::MuScleFit(), MuScleFit::selectMuons(), MuScleFit::startingNewLoop(), and MuScleFit::~MuScleFit().

◆ genMuonPairs_

std::vector<GenMuonPair> MuScleFitBase::genMuonPairs_
protected

Stores the genMuon pairs and the motherId prior to the creation of the internal tree.

Definition at line 84 of file MuScleFitBase.h.

Referenced by MuScleFit::selectMuons(), and MuScleFit::~MuScleFit().

◆ mapHisto_

std::map<std::string, Histograms*> MuScleFitBase::mapHisto_
protected

The map of histograms.

Definition at line 79 of file MuScleFitBase.h.

Referenced by TestCorrection::analyze(), clearHistoMap(), MuScleFit::duringFastLoop(), MuScleFit::fillComparisonHistograms(), fillHistoMap(), and writeHistoMap().

◆ muonPairs_

std::vector<MuonPair> MuScleFitBase::muonPairs_
protected

Used to store the muon pairs plus run and event number prior to the creation of the internal tree.

Definition at line 82 of file MuScleFitBase.h.

Referenced by MuScleFit::selectMuons(), and MuScleFit::~MuScleFit().

◆ probabilitiesFile_

std::string MuScleFitBase::probabilitiesFile_
protected

Definition at line 45 of file MuScleFitBase.h.

Referenced by readProbabilityDistributionsFromFile().

◆ probabilitiesFileInPath_

std::string MuScleFitBase::probabilitiesFileInPath_
protected

Definition at line 44 of file MuScleFitBase.h.

Referenced by readProbabilityDistributionsFromFile().

◆ theCompressionSettings_

int MuScleFitBase::theCompressionSettings_
protected

Definition at line 49 of file MuScleFitBase.h.

Referenced by MuScleFit::beginOfJobInConstructor().

◆ theFiles_

std::vector<TFile*> MuScleFitBase::theFiles_
protected

The files were the histograms are saved.

Definition at line 76 of file MuScleFitBase.h.

Referenced by MuScleFit::beginOfJobInConstructor(), MuScleFit::endOfFastLoop(), MuScleFit::startingNewLoop(), TestCorrection::TestCorrection(), writeHistoMap(), and TestCorrection::~TestCorrection().

◆ theGenInfoRootFileName_

std::string MuScleFitBase::theGenInfoRootFileName_
protected

Definition at line 51 of file MuScleFitBase.h.

Referenced by MuScleFit::beginOfJobInConstructor().

◆ theMuonLabel_

edm::InputTag MuScleFitBase::theMuonLabel_
protected

Definition at line 48 of file MuScleFitBase.h.

Referenced by MuScleFit::MuScleFit().

◆ theMuonType_

int MuScleFitBase::theMuonType_
protected

Definition at line 47 of file MuScleFitBase.h.

Referenced by TestCorrection::analyze(), fillHistoMap(), MuScleFit::MuScleFit(), readProbabilityDistributionsFromFile(), MuScleFit::selectMuons(), MuScleFit::takeSelectedMuonType(), and MuScleFit::~MuScleFit().

◆ theRootFileName_

std::string MuScleFitBase::theRootFileName_
protected

Definition at line 50 of file MuScleFitBase.h.

Referenced by MuScleFit::beginOfJobInConstructor(), and TestCorrection::TestCorrection().

mps_fire.i
i
Definition: mps_fire.py:428
HDelta
Definition: Histograms.h:425
gather_cfg.cout
cout
Definition: gather_cfg.py:144
MuScleFitUtils::nbins
static int nbins
Definition: MuScleFitUtils.h:222
HFunctionResolution
Definition: Histograms.h:1550
MuScleFitUtils::ResHalfWidth
static double ResHalfWidth[6]
Definition: MuScleFitUtils.h:221
HLikelihoodVSPart
Definition: Histograms.h:1462
MuScleFitUtils::ResMinMass
static double ResMinMass[6]
Definition: MuScleFitUtils.h:137
timingPdfMaker.histo
histo
Definition: timingPdfMaker.py:278
L1TrackerEtMissProducer_cfi.maxPt
maxPt
Definition: L1TrackerEtMissProducer_cfi.py:14
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
MuScleFitUtils::resfind
static std::vector< int > resfind
Definition: MuScleFitUtils.h:210
GL
TF1 * GL
Definition: MuScleFitUtils.cc:83
HTH2D
A wrapper for the TH2D histogram to allow it to be put inside the same map as all the other classes i...
Definition: Histograms.h:137
MuScleFitUtils::rapidityBinsForZ_
static bool rapidityBinsForZ_
Definition: MuScleFitUtils.h:251
HMassVSPart
Definition: Histograms.h:778
edm::FileInPath
Definition: FileInPath.h:61
ires
int ires[2]
Definition: CascadeWrapper.h:19
MuScleFitBase::theFiles_
std::vector< TFile * > theFiles_
The files were the histograms are saved.
Definition: MuScleFitBase.h:76
download_sqlite_cfg.outputFile
outputFile
Definition: download_sqlite_cfg.py:5
MuScleFitUtils::debugMassResol_
static bool debugMassResol_
Definition: MuScleFitUtils.h:268
MuScleFitBase::probabilitiesFileInPath_
std::string probabilitiesFileInPath_
Definition: MuScleFitBase.h:44
HResolutionVSPart
A set of histograms for resolution.
Definition: Histograms.h:1201
MuScleFitBase::theMuonLabel_
edm::InputTag theMuonLabel_
Definition: MuScleFitBase.h:48
MuScleFitBase::theRootFileName_
std::string theRootFileName_
Definition: MuScleFitBase.h:50
HTProfile
A wrapper for the TProfile histogram to allow it to be put inside the same map as all the other class...
Definition: Histograms.h:213
geometryDiff.file
file
Definition: geometryDiff.py:13
MuScleFitBase::theMuonType_
int theMuonType_
Definition: MuScleFitBase.h:47
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233
B2GTnPMonitor_cfi.maxMass
maxMass
Definition: B2GTnPMonitor_cfi.py:55
MuScleFitBase::probabilitiesFile_
std::string probabilitiesFile_
Definition: MuScleFitBase.h:45
MuScleFitBase::debug_
int debug_
Definition: MuScleFitBase.h:53
MuScleFitUtils::GLNorm
static double GLNorm[6][1001]
Definition: MuScleFitUtils.h:219
MuScleFitBase::theGenInfoRootFileName_
std::string theGenInfoRootFileName_
Definition: MuScleFitBase.h:51
MuScleFitUtils::GLZNorm
static double GLZNorm[40][1001]
Definition: MuScleFitUtils.h:217
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
MuScleFitBase::theCompressionSettings_
int theCompressionSettings_
Definition: MuScleFitBase.h:49
MuScleFitUtils::ResMaxSigma
static double ResMaxSigma[6]
Definition: MuScleFitUtils.h:220
HTH1D
A wrapper for the TH1D histogram to allow it to be put inside the same map as all the other classes i...
Definition: Histograms.h:187
HMassVSPartProfile
Definition: Histograms.h:1109
MuScleFitUtils::GLZValue
static double GLZValue[40][1001][1001]
Definition: MuScleFitUtils.h:216
MuScleFitUtils::GLValue
static double GLValue[6][1001][1001]
Definition: MuScleFitUtils.h:218
HPartVSEta
Definition: Histograms.h:524
B2GTnPMonitor_cfi.minMass
minMass
Definition: B2GTnPMonitor_cfi.py:54
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
MuScleFitBase::mapHisto_
std::map< std::string, Histograms * > mapHisto_
The map of histograms.
Definition: MuScleFitBase.h:79
beamvalidation.exit
def exit(msg="")
Definition: beamvalidation.py:52
HParticle
Definition: Histograms.h:244
edm::InputTag
Definition: InputTag.h:15
Generated for CMSSW Reference Manual by doxygen 1.8.16