laura is hosted by Hepforge, IPPP Durham
Laura++  v3r5
A maximum likelihood fitting package for performing Dalitz-plot analysis.
Lau2DHistPdf.cc
Go to the documentation of this file.
1 
2 /*
3 Copyright 2008 University of Warwick
4 
5 Licensed under the Apache License, Version 2.0 (the "License");
6 you may not use this file except in compliance with the License.
7 You may obtain a copy of the License at
8 
9  http://www.apache.org/licenses/LICENSE-2.0
10 
11 Unless required by applicable law or agreed to in writing, software
12 distributed under the License is distributed on an "AS IS" BASIS,
13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 See the License for the specific language governing permissions and
15 limitations under the License.
16 */
17 
18 /*
19 Laura++ package authors:
20 John Back
21 Paul Harrison
22 Thomas Latham
23 */
24 
29 #include <cstdlib>
30 #include <iostream>
31 #include <vector>
32 
33 #include "TAxis.h"
34 #include "TH2.h"
35 #include "TRandom.h"
36 #include "TSystem.h"
37 
38 #include "Lau1DHistPdf.hh"
39 #include "Lau2DHistPdf.hh"
40 #include "LauRandom.hh"
41 
42 class LauParameter;
43 
45 
46 
47 Lau2DHistPdf::Lau2DHistPdf(const std::vector<TString>& theVarNames, const TH2* hist,
48  const LauFitData& minVals, const LauFitData& maxVals,
49  Bool_t useInterpolation, Bool_t fluctuateBins) :
50  LauAbsPdf(theVarNames, std::vector<LauAbsRValue*>(), minVals, maxVals),
51  hist_(hist ? dynamic_cast<TH2*>(hist->Clone()) : 0),
52  xProj_(0),
53  yProj_(0),
54  xVarPdf_(0),
55  yVarPdf_(0),
56  xName_(""),
57  yName_(""),
58  nBinsX_(0),
59  nBinsY_(0),
60  minX_(0.0),
61  maxX_(0.0),
62  minY_(0.0),
63  maxY_(0.0),
64  rangeX_(0.0),
65  rangeY_(0.0),
66  binXWidth_(0.0),
67  binYWidth_(0.0),
68  invBinXWidth_(0.0),
69  invBinYWidth_(0.0),
70  useInterpolation_(useInterpolation),
71  fluctuateBins_(fluctuateBins)
72 {
73  // Constructor
74 
75  // Check that we have two variables
76  if ( this->nInputVars() != 2 ) {
77  std::cerr << "ERROR in Lau2DHistPdf::Lau2DHistPdf : Have not been provided with exactly two variables." << std::endl;
78  gSystem->Exit(EXIT_FAILURE);
79  }
80 
81  // Set the variable names from the abstract class
82  xName_ = this->varNames()[0];
83  yName_ = this->varNames()[1];
84 
85  // Set the variable limits from the abstract class
86  minX_ = this->getMinAbscissa(xName_);
87  maxX_ = this->getMaxAbscissa(xName_);
88  minY_ = this->getMinAbscissa(yName_);
89  maxY_ = this->getMaxAbscissa(yName_);
90  rangeX_ = maxX_ - minX_;
91  rangeY_ = maxY_ - minY_;
92 
93  // Have we got a valid histogram
94  if ( hist_ == 0 ) {
95  std::cerr << "ERROR in Lau2DHistPdf::Lau2DHistPdf : Histogram pointer is null." << std::endl;
96  gSystem->Exit(EXIT_FAILURE);
97  }
98 
99  // Set the directory for the histogram
100  hist_->SetDirectory(0);
101 
102  // Save various attributes of the histogram
103  nBinsX_ = hist_->GetNbinsX();
104  nBinsY_ = hist_->GetNbinsY();
105 
106  TAxis* xAxis = hist_->GetXaxis();
107  Double_t xAxisMin = xAxis->GetXmin();
108  Double_t xAxisMax = xAxis->GetXmax();
109 
110  TAxis* yAxis = hist_->GetYaxis();
111  Double_t yAxisMin = yAxis->GetXmin();
112  Double_t yAxisMax = yAxis->GetXmax();
113 
114  // Check that axis ranges corresponds to ranges of abscissas
115  if (TMath::Abs(minX_ - xAxisMin)>1e-6) {
116  std::cerr << "ERROR in Lau2DHistPdf::Lau2DHistPdf : Histogram x-axis minimum: " << xAxisMin <<
117  " does not correspond to " << xName_ << " minimum: " << minX_ << "." << std::endl;
118  gSystem->Exit(EXIT_FAILURE);
119  }
120  if (TMath::Abs(maxX_ - xAxisMax)>1e-6) {
121  std::cerr << "ERROR in Lau2DHistPdf::Lau2DHistPdf : Histogram x-axis maximum: " << xAxisMax <<
122  " does not correspond to " << xName_ << " maximum: " << maxX_ << "." << std::endl;
123  gSystem->Exit(EXIT_FAILURE);
124  }
125  if (TMath::Abs(minY_ - yAxisMin)>1e-6) {
126  std::cerr << "ERROR in Lau2DHistPdf::Lau2DHistPdf : Histogram y-axis minimum: " << yAxisMin <<
127  " does not correspond to " << yName_ << " minimum: " << minY_ << "." << std::endl;
128  gSystem->Exit(EXIT_FAILURE);
129  }
130  if (TMath::Abs(maxY_ - yAxisMax)>1e-6) {
131  std::cerr << "ERROR in Lau2DHistPdf::Lau2DHistPdf : Histogram y-axis maximum: " << yAxisMax <<
132  " does not correspond to " << yName_ << " maximum: " << maxY_ << "." << std::endl;
133  gSystem->Exit(EXIT_FAILURE);
134  }
135 
136  // Calculate the bin widths and inverse bin widths
137  binXWidth_ = static_cast<Double_t>(TMath::Abs(rangeX_)/(nBinsX_*1.0));
138  binYWidth_ = static_cast<Double_t>(TMath::Abs(rangeY_)/(nBinsY_*1.0));
139  if (binXWidth_ > 1e-10) {invBinXWidth_ = 1.0/binXWidth_;}
140  if (binYWidth_ > 1e-10) {invBinYWidth_ = 1.0/binYWidth_;}
141 
142  // If the bins are to be fluctuated then do so now before
143  // calculating anything that depends on the bin content.
144  if (fluctuateBins) {
145  this->doBinFluctuation();
146  }
147 
148  // Create the projections and 1D PDFs from those
149  xProj_ = hist_->ProjectionX();
150  yProj_ = hist_->ProjectionY();
151  if ( !xProj_ || !yProj_ ) {
152  std::cerr << "ERROR in Lau2DHistPdf::Lau2DHistPdf : Can't get X or Y projection from 2D histogram." << std::endl;
153  gSystem->Exit(EXIT_FAILURE);
154  }
155  xVarPdf_ = new Lau1DHistPdf(xName_, xProj_, minX_, maxX_, useInterpolation_, fluctuateBins_);
156  yVarPdf_ = new Lau1DHistPdf(yName_, yProj_, minY_, maxY_, useInterpolation_, fluctuateBins_);
157 
158  // Calculate the PDF normalisation.
159  this->calcNorm();
160 
161  // And check it is OK.
162  this->checkNormalisation();
163 }
164 
166 {
167  // Destructor
168  delete hist_; hist_ = 0;
169  delete xProj_; xProj_ = 0;
170  delete yProj_; yProj_ = 0;
171  delete xVarPdf_; xVarPdf_ = 0;
172  delete yVarPdf_; yVarPdf_ = 0;
173 }
174 
175 void Lau2DHistPdf::calcPDFHeight( const LauKinematics* /*kinematics*/ )
176 {
177  if (this->heightUpToDate()) {
178  return;
179  }
180 
181  // Get the maximum height of the histogram
182  Int_t maxBin = hist_->GetMaximumBin();
183  Double_t height = hist_->GetBinContent(maxBin);
184  this->setMaxHeight(height);
185 }
186 
188 {
189  // Calculate the histogram normalisation.
190 
191  // Loop over the total x and y range to get the total area under x
192  // and y. Just sum the contributions up using 1e-3 increments of
193  // the range in x and y. Multiply the end result by dx and dy.
194 
195  Double_t dx(1e-3*rangeX_), dy(1e-3*rangeY_);
196  Double_t area(0.0);
197 
198  Double_t x(minX_ + dx/2.0);
199  while (x > minX_ && x < maxX_) {
200  Double_t y(minY_ + dy/2.0);
201  while (y > minY_ && y < maxY_) {
202  area += this->interpolateXY(x,y);
203  y += dy;
204  } // y while loop
205  x += dx;
206  } // x while loop
207 
208  Double_t norm = area*dx*dy;
209  this->setNorm(norm);
210 }
211 
213 {
214  Double_t dx(1e-3*rangeX_), dy(1e-3*rangeY_);
215  Double_t area(0.0);
216  Double_t areaNoNorm(0.0);
217 
218  // Preserve the value of a variable we change temporarily
219  Bool_t interpolate = useInterpolation_;
220 
221  Double_t x(minX_ + dx/2.0);
222  while (x > minX_ && x < maxX_) {
223  Double_t y(minY_ + dy/2.0);
224  while (y > minY_ && y < maxY_) {
225  area += this->interpolateXYNorm(x,y);
226  useInterpolation_ = kFALSE;
227  areaNoNorm += this->interpolateXY(x,y);
228  useInterpolation_ = kTRUE;
229  y += dy;
230  } // y while loop
231  x += dx;
232  } // x while loop
233  Double_t norm = area*dx*dy;
234 
235  useInterpolation_ = interpolate; //Restore old value
236 
237  std::cout << "INFO in Lau2DHistPdf::checkNormalisation : Area = " << area << ", dx = " << dx << ", dy = " << dy << ", dx*dy = " << dx*dy << std::endl;
238  std::cout << " : Area with no norm = " << areaNoNorm << "*dx*dy = " << areaNoNorm*dx*dy << std::endl;
239  std::cout << " : The total area of the normalised histogram PDF is " << norm << std::endl;
240 }
241 
242 Double_t Lau2DHistPdf::getBinHistValue(Int_t i, Int_t j) const
243 {
244  // Check that x co-ord is in range [1 , nBinsX_]
245  if ((i < 1) || (i > nBinsX_)) {
246  return 0.0;
247  }
248  // Check that y co-ord is in range [1 , nBinsY_]
249  if ((j < 1) || (j > nBinsY_)) {
250  return 0.0;
251  }
252  Double_t value = hist_->GetBinContent(i,j);
253  // protect against negative values
254  if ( value < 0.0 ) {
255  std::cerr << "WARNING in Lau2DHistPdf::getBinHistValue : Negative bin content set to zero!" << std::endl;
256  value = 0.0;
257  }
258  return value;
259 }
260 
261 Double_t Lau2DHistPdf::interpolateXYNorm(Double_t x, Double_t y) const
262 {
263  // Get the normalised interpolated value.
264  Double_t value = this->interpolateXY(x,y);
265  Double_t norm = this->getNorm();
266  return value/norm;
267 }
268 
269 Double_t Lau2DHistPdf::interpolateXY(Double_t x, Double_t y) const
270 {
271  // This function returns the interpolated value of the histogram
272  // function for the given values of x and y by finding the adjacent
273  // bins and extrapolating using weights based on the inverse
274  // distance of the point from the adajcent bin centres.
275 
276  // Find the 2D histogram bin for x and y
277  Int_t i = static_cast<Int_t>((x - minX_)*invBinXWidth_)+1;
278  Int_t j = static_cast<Int_t>((y - minY_)*invBinYWidth_)+1;
279 
280  if (i > nBinsX_) {i = nBinsX_;}
281  if (j > nBinsY_) {j = nBinsY_;}
282 
283  // Ask whether we want to do the interpolation, since this method is
284  // not reliable for low statistics histograms.
285  if (useInterpolation_ == kFALSE) {
286  return this->getBinHistValue(i,j);
287  }
288 
289  // Find the bin centres (actual co-ordinate positions, not histogram indices)
290  Double_t cbinx = static_cast<Double_t>(i-0.5)*binXWidth_ + minX_;
291  Double_t cbiny = static_cast<Double_t>(j-0.5)*binYWidth_ + minY_;
292 
293  // Find the adjacent bins
294  Double_t deltax = x - cbinx;
295  Double_t deltay = y - cbiny;
296 
297  Int_t i_adj(0), j_adj(0);
298  if (deltax > 0.0) {
299  i_adj = i + 1;
300  } else {
301  i_adj = i - 1;
302  }
303  if (deltay > 0.0) {
304  j_adj = j + 1;
305  } else {
306  j_adj = j - 1;
307  }
308 
309  Bool_t isXBoundary(kFALSE), isYBoundary(kFALSE);
310 
311  Double_t value(0.0);
312 
313  if (i_adj > nBinsX_ || i_adj < 1) {isYBoundary = kTRUE;}
314  if (j_adj > nBinsY_ || j_adj < 1) {isXBoundary = kTRUE;}
315 
316  // In the corners, do no interpolation. Use entry in bin (i,j)
317  if (isXBoundary == kTRUE && isYBoundary == kTRUE) {
318 
319  value = this->getBinHistValue(i,j);
320 
321  } else if (isXBoundary == kTRUE && isYBoundary == kFALSE) {
322 
323  // Find the adjacent x bin centre
324  Double_t cbinx_adj = static_cast<Double_t>(i_adj-0.5)*binXWidth_ + minX_;
325 
326  Double_t dx0 = TMath::Abs(x - cbinx);
327  Double_t dx1 = TMath::Abs(cbinx_adj - x);
328  Double_t inter_denom = dx0 + dx1;
329 
330  Double_t value1 = this->getBinHistValue(i,j);
331  Double_t value2 = this->getBinHistValue(i_adj,j);
332 
333  value = (value1*dx1 + value2*dx0)/inter_denom;
334 
335  } else if (isYBoundary == kTRUE && isXBoundary == kFALSE) {
336 
337  // Find the adjacent y bin centre
338  Double_t cbiny_adj = static_cast<Double_t>(j_adj-0.5)*binYWidth_ + minY_;
339 
340  Double_t dy0 = TMath::Abs(y - cbiny);
341  Double_t dy1 = TMath::Abs(cbiny_adj - y);
342  Double_t inter_denom = dy0 + dy1;
343 
344  Double_t value1 = this->getBinHistValue(i,j);
345  Double_t value2 = this->getBinHistValue(i,j_adj);
346 
347  value = (value1*dy1 + value2*dy0)/inter_denom;
348 
349  } else {
350 
351  // 2D linear interpolation using inverse distance as weights.
352  // Find the adjacent x and y bin centres
353  Double_t cbinx_adj = static_cast<Double_t>(i_adj-0.5)*binXWidth_ + minX_;
354  Double_t cbiny_adj = static_cast<Double_t>(j_adj-0.5)*binYWidth_ + minY_;
355 
356  Double_t dx0 = TMath::Abs(x - cbinx);
357  Double_t dx1 = TMath::Abs(cbinx_adj - x);
358  Double_t dy0 = TMath::Abs(y - cbiny);
359  Double_t dy1 = TMath::Abs(cbiny_adj - y);
360 
361  Double_t inter_denom = (dx0 + dx1)*(dy0 + dy1);
362 
363  Double_t value1 = this->getBinHistValue(i,j);
364  Double_t value2 = this->getBinHistValue(i_adj,j);
365  Double_t value3 = this->getBinHistValue(i,j_adj);
366  Double_t value4 = this->getBinHistValue(i_adj,j_adj);
367 
368  value = value1*dx1*dy1 + value2*dx0*dy1 + value3*dx1*dy0 + value4*dx0*dy0;
369  value /= inter_denom;
370  }
371 
372  return value;
373 }
374 
376 {
377  // Check that the given abscissa is within the allowed range
378  if (!this->checkRange(abscissas)) {
379  gSystem->Exit(EXIT_FAILURE);
380  }
381 
382  // Calculate the interpolated value
383  Double_t x = abscissas[0];
384  Double_t y = abscissas[1];
385  Double_t value = this->interpolateXY(x,y);
386  this->setUnNormPDFVal(value);
387 
388  // TODO - do we need this? I think probably not.
389  // Have the 1D PDFs calculate their likelihoods as well
390  //xVarPdf_->calcLikelihoodInfo(x);
391  //yVarPdf_->calcLikelihoodInfo(y);
392 }
393 
395 {
396  // Call the base class method
397  this->LauAbsPdf::calcLikelihoodInfo(iEvt);
398 
399  // Have the 1D PDFs retrieve their values as well
402 }
403 
404 Double_t Lau2DHistPdf::getLikelihood( const TString& theVarName ) const
405 {
406  if ( theVarName == xName_ ) {
407  return xVarPdf_->getLikelihood();
408  } else if ( theVarName == yName_ ) {
409  return yVarPdf_->getLikelihood();
410  } else {
411  std::cerr << "ERROR in Lau2DHistPdf::getLikelihood : Unrecognised variable name \"" << theVarName << "\", cannot determine likelihood." << std::endl;
412  return 0.0;
413  }
414 }
415 
417 {
418  // Call the base class method
419  this->LauAbsPdf::cacheInfo(inputData);
420 
421  // Have the 1D PDFs cache their info as well
422  xVarPdf_->cacheInfo(inputData);
423  yVarPdf_->cacheInfo(inputData);
424 }
425 
427 {
428  TRandom* random(LauRandom::randomFun());
429  for (Int_t i(0); i<nBinsX_; i++) {
430  for (Int_t j(0); j<nBinsY_; j++) {
431  Double_t currentContent = hist_->GetBinContent(i+1,j+1);
432  Double_t currentError = hist_->GetBinError(i+1,j+1);
433  Double_t newContent = random->Gaus(currentContent,currentError);
434  if (newContent<0.0) {
435  hist_->SetBinContent(i+1,j+1,0.0);
436  } else {
437  hist_->SetBinContent(i+1,j+1,newContent);
438  }
439  }
440  }
441 }
442 
444 {
445  this->withinGeneration(kTRUE);
446 
447  // Check that the PDF height is up to date
448  this->calcPDFHeight( kinematics );
449 
450  // Generate the value of the abscissa.
451  Bool_t gotAbscissa(kFALSE);
452  if (this->getRandomFun() == 0) {
453  std::cerr << "ERROR in Lau2DHistPdf::generate : Please set the random number generator for this PDF by using the setRandomFun(TRandom*) function." << std::endl;
454  this->withinGeneration(kFALSE);
455  gSystem->Exit(EXIT_FAILURE);
456  }
457 
458  Double_t genPDFVal(0.0);
459  LauAbscissas genAbscissas(2);
460 
461  Double_t PDFheight = this->getMaxHeight()*(1.0+1e-11);
462  while (!gotAbscissa) {
463 
464  genAbscissas[0] = this->getRandomFun()->Rndm()*this->getRange(xName_) + this->getMinAbscissa(xName_);
465  genAbscissas[1] = this->getRandomFun()->Rndm()*this->getRange(yName_) + this->getMinAbscissa(yName_);
466 
467  this->calcLikelihoodInfo(genAbscissas);
468  genPDFVal = this->getUnNormLikelihood();
469 
470  if (this->getRandomFun()->Rndm() <= genPDFVal/PDFheight) {gotAbscissa = kTRUE;}
471 
472  if (genPDFVal > PDFheight) {
473  std::cerr << "WARNING in LauAbsPdf::generate : genPDFVal = " << genPDFVal << " is larger than the specified PDF height " << this->getMaxHeight() << " for (x,y) = (" << genAbscissas[0] << "," << genAbscissas[1] << ")." << std::endl;
474  std::cerr << " : Need to reset height to be larger than " << genPDFVal << " by using the setMaxHeight(Double_t) function and re-run the Monte Carlo generation!" << std::endl;
475  }
476  }
477 
478  LauFitData genData;
479  genData[ xName_ ] = genAbscissas[0];
480  genData[ yName_ ] = genAbscissas[1];
481 
482  this->withinGeneration(kFALSE);
483 
484  return genData;
485 }
486 
virtual void calcLikelihoodInfo(const LauAbscissas &abscissas)
Calculate the likelihood (and intermediate info) for a given abscissa.
TRandom * randomFun()
Access the singleton random number generator with a particular seed.
Definition: LauRandom.cc:34
virtual void setUnNormPDFVal(Double_t unNormPDFVal)
Set the unnormalised likelihood.
Definition: LauAbsPdf.hh:383
virtual Double_t getMinAbscissa() const
Retrieve the minimum value of the (primary) abscissa.
Definition: LauAbsPdf.hh:131
virtual Bool_t heightUpToDate() const
Check if the maximum height of the PDF is up to date.
Definition: LauAbsPdf.hh:278
Lau1DHistPdf * xVarPdf_
1D PDF for x variable
Double_t interpolateXY(Double_t x, Double_t y) const
Perform the interpolation (unnormalised)
ClassImp(LauAbsCoeffSet)
Bool_t useInterpolation_
Control boolean for using the linear interpolation.
Double_t interpolateXYNorm(Double_t x, Double_t y) const
Perform the interpolation and divide by the normalisation.
void checkNormalisation()
Check the normalisation calculation.
virtual void cacheInfo(const LauFitDataTree &inputData)
Cache information from data.
virtual Double_t getUnNormLikelihood() const
Retrieve the unnormalised likelihood value.
Definition: LauAbsPdf.hh:210
File containing declaration of Lau2DHistPdf class.
TH2 * hist_
The underlying histogram.
Double_t invBinXWidth_
The histogram x-axis inverse bin width.
Class for defining a 1D histogram PDF.
Definition: Lau1DHistPdf.hh:45
virtual void setNorm(Double_t norm)
Set the normalisation factor.
Definition: LauAbsPdf.hh:339
Class for defining a 2D histogram PDF.
Definition: Lau2DHistPdf.hh:47
virtual Bool_t checkRange(const LauAbscissas &abscissas) const
Check that all abscissas are within their allowed ranges.
Definition: LauAbsPdf.cc:227
Double_t minY_
The histogram y-axis minimum.
std::map< TString, Double_t > LauFitData
Type for holding event data.
virtual LauFitData generate(const LauKinematics *kinematics)
Generate an event from the PDF.
virtual TRandom * getRandomFun() const
Retrieve the random function used for MC generation.
Definition: LauAbsPdf.hh:401
void doBinFluctuation()
Fluctuate the histogram bin contents in accordance with their errors.
TString xName_
x variable name
virtual Double_t getMaxHeight() const
Retrieve the maximum height.
Definition: LauAbsPdf.hh:235
virtual ~Lau2DHistPdf()
Destructor.
virtual void calcLikelihoodInfo(const LauAbscissas &abscissas)
Calculate the likelihood (and intermediate info) for a given value of the abscissas.
TH1 * yProj_
Projection of histogram y-axis.
Double_t binYWidth_
The histogram y-axis bin width.
Double_t getBinHistValue(Int_t i, Int_t j) const
Get the bin content from the histogram.
TH1 * xProj_
Projection of histogram x-axis.
virtual void setMaxHeight(Double_t maxHeight)
Set the maximum height.
Definition: LauAbsPdf.hh:345
Lau1DHistPdf * yVarPdf_
1D PDF for y variable
Class for defining the fit parameter objects.
Definition: LauParameter.hh:49
virtual void calcPDFHeight(const LauKinematics *kinematics)
Calculate the PDF height.
Double_t binXWidth_
The histogram x-axis bin width.
virtual Bool_t withinGeneration() const
Check whether the generate method is running.
Definition: LauAbsPdf.hh:449
File containing LauRandom namespace.
virtual void calcNorm()
Calculate the normalisation.
Double_t maxX_
The histogram x-axis maximum.
virtual Double_t getLikelihood() const
Retrieve the normalised likelihood value.
Definition: LauAbsPdf.cc:368
virtual void calcLikelihoodInfo(const LauAbscissas &abscissas)=0
Calculate the likelihood (and all associated information) given value(s) of the abscissa(s) ...
Double_t invBinYWidth_
The histogram y-axis inverse bin width.
Double_t minX_
The histogram x-axis minimum.
Class for defining the abstract interface for PDF classes.
Definition: LauAbsPdf.hh:55
Class for calculating 3-body kinematic quantities.
TString yName_
y variable name
Double_t maxY_
The histogram y-axis maximum.
virtual void cacheInfo(const LauFitDataTree &inputData)
Cache information from data.
Definition: LauAbsPdf.cc:255
Double_t value() const
The value of the parameter.
virtual Double_t getRange() const
Retrieve the range of the (primary) abscissa.
Definition: LauAbsPdf.hh:143
Pure abstract base class for defining a parameter containing an R value.
Definition: LauAbsRValue.hh:43
virtual Double_t getNorm() const
Retrieve the normalisation factor.
Definition: LauAbsPdf.hh:216
Double_t rangeX_
The histogram x-axis range.
Class to store the input fit variables.
std::vector< Double_t > LauAbscissas
The type used for containing multiple abscissa values.
Definition: LauAbsPdf.hh:59
Int_t nBinsX_
The number of bins on the x-axis of the histogram.
Int_t nBinsY_
The number of bins on the y-axis of the histogram.
Double_t rangeY_
The histogram y-axis range.
File containing declaration of Lau1DHistPdf class.