laura is hosted by Hepforge, IPPP Durham
Laura++  v1r0
A maximum likelihood fitting package for performing Dalitz-plot analysis.
LauDPDepSumPdf.cc
Go to the documentation of this file.
1 
2 // Copyright University of Warwick 2009 - 2013.
3 // Distributed under the Boost Software License, Version 1.0.
4 // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5 
6 // Authors:
7 // Thomas Latham
8 // John Back
9 // Paul Harrison
10 
15 #include <iostream>
16 #include <vector>
17 using std::cout;
18 using std::cerr;
19 using std::endl;
20 using std::vector;
21 
22 #include "TMath.h"
23 #include "TSystem.h"
24 
25 #include "LauConstants.hh"
26 #include "LauDaughters.hh"
27 #include "LauEffModel.hh"
28 #include "LauParameter.hh"
29 #include "LauDPDepSumPdf.hh"
30 
31 ClassImp(LauDPDepSumPdf)
32 
33 
35  const LauDaughters* daughters,
36  const TH2* dpHisto, Bool_t upperHalf) :
37  LauAbsPdf(pdf1 ? pdf1->varNames() : vector<TString>(), vector<LauParameter*>(), pdf1 ? pdf1->getMinAbscissas() : LauFitData(), pdf1 ? pdf1->getMaxAbscissas() : LauFitData()),
38  daughters_( new LauDaughters(*daughters) ),
39  pdf1_(pdf1),
40  pdf2_(pdf2),
41  frac_(0),
42  fracVal_(0.5),
43  dpDependence_( new LauEffModel(daughters, 0) ),
44  dpAxis_( CentreDist )
45 {
46  // Constructor for the sum PDF.
47  // We are defining the sum as:
48  // f x (PDF1/S(PDF1)) + (1-f) x (PDF2/S(PDF2))
49  // where f is the fraction, x is multiplication, PDFi is the i'th PDF,
50  // and S(PDFi) is the integral of the i'th PDF.
51  // The value of the fraction is read from the DP histogram.
52 
53  dpDependence_->setEffHisto( dpHisto, kTRUE, kFALSE, 0.0, 0.0, upperHalf, daughters->squareDP() );
54 
55  // So the first thing we have to do is check the pointers are all valid.
56  if (!pdf1 || !pdf2) {
57  cerr<<"ERROR in LauDPDepSumPdf constructor: one of the 2 PDF pointers is null."<<endl;
58  gSystem->Exit(EXIT_FAILURE);
59  }
60 
61  // Next check that the abscissa ranges are the same for each PDF
62  if (pdf1->getMinAbscissa() != pdf2->getMinAbscissa()) {
63  cerr<<"ERROR in LauDPDepSumPdf constructor: minimum abscissa values not the same for the two PDFs."<<endl;
64  gSystem->Exit(EXIT_FAILURE);
65  }
66  if (pdf1->getMaxAbscissa() != pdf2->getMaxAbscissa()) {
67  cerr<<"ERROR in LauDPDepSumPdf constructor: maximum abscissa values not the same for the two PDFs."<<endl;
68  gSystem->Exit(EXIT_FAILURE);
69  }
70 
71  // Also check that both PDFs are expecting the same number of input variables
72  if (pdf1->nInputVars() != pdf2->nInputVars()) {
73  cerr<<"ERROR in LauDPDepSumPdf constructor: number of input variables not the same for the two PDFs."<<endl;
74  gSystem->Exit(EXIT_FAILURE);
75  }
76 
77  // Also check that both PDFs are expecting the same variable name(s)
78  if (pdf1->varNames() != pdf2->varNames()) {
79  cerr<<"ERROR in LauDPDepSumPdf constructor: variable name(s) not the same for the two PDFs."<<endl;
80  gSystem->Exit(EXIT_FAILURE);
81  }
82 
83  // Then we need to grab all the parameters and pass them to the base class.
84  // This is so that when we are asked for them they can be put into the fit.
85  // The number of parameters is the number in PDF1 + the number in PDF2.
86  UInt_t nPar(pdf1->nParameters()+pdf2->nParameters());
87  vector<LauParameter*> params; params.reserve(nPar);
88  vector<LauParameter*>& pdf1pars = pdf1->getParameters();
89  vector<LauParameter*>& pdf2pars = pdf2->getParameters();
90  for (vector<LauParameter*>::iterator iter = pdf1pars.begin(); iter != pdf1pars.end(); ++iter) {
91  params.push_back(*iter);
92  }
93  for (vector<LauParameter*>::iterator iter = pdf2pars.begin(); iter != pdf2pars.end(); ++iter) {
94  params.push_back(*iter);
95  }
96  this->addParameters(params);
97 
98  // Cache the normalisation factor
99  this->calcNorm();
100 }
101 
103  LauParameter* frac,
104  const LauDaughters* daughters,
105  const std::vector<Double_t>& fracCoeffs,
106  DPAxis dpAxis) :
107  LauAbsPdf(pdf1 ? pdf1->varNames() : vector<TString>(), vector<LauParameter*>(), pdf1 ? pdf1->getMinAbscissas() : LauFitData(), pdf1 ? pdf1->getMaxAbscissas() : LauFitData()),
108  daughters_( new LauDaughters(*daughters) ),
109  pdf1_(pdf1),
110  pdf2_(pdf2),
111  frac_(frac),
112  fracVal_( frac ? frac->value() : 0.0 ),
113  dpDependence_( 0 ),
114  fracCoeffs_( fracCoeffs ),
115  dpAxis_( dpAxis )
116 {
117  // Constructor for the sum PDF.
118  // We are defining the sum as:
119  // f x (PDF1/S(PDF1)) + (1-f) x (PDF2/S(PDF2))
120  // where f is the fraction, x is multiplication, PDFi is the i'th PDF,
121  // and S(PDFi) is the integral of the i'th PDF.
122  // The value of the fraction has a polynomial dependence on one of
123  // the DP axes.
124 
125  // So the first thing we have to do is check the pointers are all valid.
126  if (!pdf1 || !pdf2) {
127  cerr<<"ERROR in LauDPDepSumPdf constructor: one of the 2 PDF pointers is null."<<endl;
128  gSystem->Exit(EXIT_FAILURE);
129  }
130  if ( !frac ) {
131  cerr<<"ERROR in LauDPDepSumPdf constructor: the fraction parameter pointer is null."<<endl;
132  gSystem->Exit(EXIT_FAILURE);
133  }
134 
135  // Next check that the abscissa ranges are the same for each PDF
136  if (pdf1->getMinAbscissa() != pdf2->getMinAbscissa()) {
137  cerr<<"ERROR in LauDPDepSumPdf constructor: minimum abscissa values not the same for the two PDFs."<<endl;
138  gSystem->Exit(EXIT_FAILURE);
139  }
140  if (pdf1->getMaxAbscissa() != pdf2->getMaxAbscissa()) {
141  cerr<<"ERROR in LauDPDepSumPdf constructor: maximum abscissa values not the same for the two PDFs."<<endl;
142  gSystem->Exit(EXIT_FAILURE);
143  }
144 
145  // Also check that both PDFs are expecting the same number of input variables
146  if (pdf1->nInputVars() != pdf2->nInputVars()) {
147  cerr<<"ERROR in LauDPDepSumPdf constructor: number of input variables not the same for the two PDFs."<<endl;
148  gSystem->Exit(EXIT_FAILURE);
149  }
150 
151  // Also check that both PDFs are expecting the same variable name(s)
152  if (pdf1->varNames() != pdf2->varNames()) {
153  cerr<<"ERROR in LauDPDepSumPdf constructor: variable name(s) not the same for the two PDFs."<<endl;
154  gSystem->Exit(EXIT_FAILURE);
155  }
156 
157  // Then we need to grab all the parameters and pass them to the base class.
158  // This is so that when we are asked for them they can be put into the fit.
159  // The number of parameters is the number in PDF1 + the number in PDF2.
160  UInt_t nPar( pdf1->nParameters() + pdf2->nParameters() + 1 );
161  vector<LauParameter*> params; params.reserve(nPar);
162  params.push_back(frac);
163  vector<LauParameter*>& pdf1pars = pdf1->getParameters();
164  vector<LauParameter*>& pdf2pars = pdf2->getParameters();
165  for (vector<LauParameter*>::iterator iter = pdf1pars.begin(); iter != pdf1pars.end(); ++iter) {
166  params.push_back(*iter);
167  }
168  for (vector<LauParameter*>::iterator iter = pdf2pars.begin(); iter != pdf2pars.end(); ++iter) {
169  params.push_back(*iter);
170  }
171  this->addParameters(params);
172 
173  // Now check that we can find the fraction parameter ok
174  frac_ = this->findParameter("frac");
175  if (frac_ == 0) {
176  cerr<<"ERROR in LauDPDepSumPdf constructor: parameter \"frac\" not found."<<endl;
177  gSystem->Exit(EXIT_FAILURE);
178  }
179 
180  // Cache the normalisation factor
181  this->calcNorm();
182 }
183 
185 {
186  // Destructor
187  delete daughters_; daughters_ = 0;
188  delete dpDependence_; dpDependence_ = 0;
189 }
190 
191 LauDPDepSumPdf::LauDPDepSumPdf(const LauDPDepSumPdf& other) : LauAbsPdf(other.varName(), other.getParameters(), other.getMinAbscissa(), other.getMaxAbscissa()),
192  daughters_( other.daughters_ ),
193  pdf1_( other.pdf1_ ),
194  pdf2_( other.pdf2_ ),
195  frac_( other.frac_ ),
196  fracVal_( other.fracVal_ ),
197  dpDependence_( (other.dpDependence_) ? new LauEffModel( *other.dpDependence_ ) : 0 ),
198  fracCoeffs_( other.fracCoeffs_ ),
199  dpAxis_( other.dpAxis_ ),
200  fractions_( other.fractions_ )
201 {
202  // Copy constructor
203  this->setRandomFun(other.getRandomFun());
204  this->calcNorm();
205 }
206 
208 {
209  // Check that the given abscissa is within the allowed range
210  if (!this->checkRange(abscissas)) {
211  gSystem->Exit(EXIT_FAILURE);
212  }
213 
214  LauAbscissas noDPVars(1);
215  noDPVars[0] = abscissas[0];
216 
217  // Evaluate the normalised PDF values
218  if ( pdf1_->isDPDependent() ) {
219  pdf1_->calcLikelihoodInfo(abscissas);
220  } else {
221  pdf1_->calcLikelihoodInfo(noDPVars);
222  }
223  if ( pdf2_->isDPDependent() ) {
224  pdf2_->calcLikelihoodInfo(abscissas);
225  } else {
226  pdf2_->calcLikelihoodInfo(noDPVars);
227  }
228  Double_t result1 = pdf1_->getLikelihood();
229  Double_t result2 = pdf2_->getLikelihood();
230 
231  // Determine the fraction
232  // The DP variables will be abscissas[nInputVars] and
233  // abscissas[nInputVars+1] (if present).
234  UInt_t nVars = this->nInputVars();
235  if ( abscissas.size() == nVars+2 ) {
236  Double_t m13Sq = abscissas[nVars];
237  Double_t m23Sq = abscissas[nVars+1];
238  LauKinematics* kinematics = daughters_->getKinematics();
239  if ( dpDependence_ ) {
240  kinematics->updateKinematics( m13Sq, m23Sq );
241  fracVal_ = dpDependence_->calcEfficiency( kinematics );
242  } else {
243  fracVal_ = frac_->value();
244  Double_t dpPos(0.0);
245  if ( dpAxis_ == M12 ) {
246  dpPos = kinematics->calcThirdMassSq(m13Sq,m23Sq);
247  } else if ( dpAxis_ == M13 ) {
248  dpPos = m13Sq;
249  } else if ( dpAxis_ == M23 ) {
250  dpPos = m23Sq;
251  } else if ( dpAxis_ == MMIN ) {
252  dpPos = TMath::Min( m13Sq, m23Sq );
253  } else if ( dpAxis_ == MMAX ) {
254  dpPos = TMath::Max( m13Sq, m23Sq );
255  } else {
256  dpPos = kinematics->distanceFromDPCentre(m13Sq,m23Sq);
257  }
258  this->scaleFrac( dpPos );
259  }
260  }
261 
262  // Add them together
263  Double_t result = fracVal_ * result1 + (1.0-fracVal_) * result2;
264  this->setUnNormPDFVal(result);
265 }
266 
267 void LauDPDepSumPdf::scaleFrac( Double_t dpPos )
268 {
269  Int_t power = 1;
270  for (std::vector<Double_t>::const_iterator iter = fracCoeffs_.begin(); iter != fracCoeffs_.end(); ++iter) {
271  Double_t coeff = (*iter);
272  fracVal_ += coeff * TMath::Power(dpPos,power);
273  ++power;
274  }
275 }
276 
278 {
279  // Nothing to do here, since it is already normalized
280  this->setNorm(1.0);
281 }
282 
284 {
285  // This method gives you the maximum possible height of the PDF.
286  // It combines the maximum heights of the two individual PDFs.
287  // So it would give the true maximum if the two individual maxima coincided.
288  // It is guaranteed to always be >= the true maximum.
289 
290  // Update the heights of the individual PDFs
291  pdf1_->calcPDFHeight( kinematics );
292  pdf2_->calcPDFHeight( kinematics );
293 
294  // Get the up to date parameter values
295  if ( dpDependence_ ) {
296  fracVal_ = dpDependence_->calcEfficiency( kinematics );
297  } else {
298  fracVal_ = frac_->value();
299  Double_t dpPos(0.0);
300  if ( dpAxis_ == M12 ) {
301  dpPos = kinematics->getm12Sq();
302  } else if ( dpAxis_ == M13 ) {
303  dpPos = kinematics->getm13Sq();
304  } else if ( dpAxis_ == M23 ) {
305  dpPos = kinematics->getm23Sq();
306  } else if ( dpAxis_ == MMIN ) {
307  Double_t m13Sq = kinematics->getm13Sq();
308  Double_t m23Sq = kinematics->getm23Sq();
309  dpPos = TMath::Min( m13Sq, m23Sq );
310  } else if ( dpAxis_ == MMAX ) {
311  Double_t m13Sq = kinematics->getm13Sq();
312  Double_t m23Sq = kinematics->getm23Sq();
313  dpPos = TMath::Max( m13Sq, m23Sq );
314  } else {
315  dpPos = kinematics->distanceFromDPCentre();
316  }
317  this->scaleFrac( dpPos );
318  }
319 
320  // Find the (un-normalised) individual PDF maxima
321  Double_t height1 = pdf1_->getMaxHeight();
322  Double_t height2 = pdf2_->getMaxHeight();
323 
324  // Get the individual PDF normalisation factors
325  Double_t norm1 = pdf1_->getNorm();
326  Double_t norm2 = pdf2_->getNorm();
327 
328  // Calculate the normalised individual PDF maxima
329  height1 /= norm1;
330  height2 /= norm2;
331 
332  // Combine these heights together
333  Double_t height = fracVal_ * height1 + (1-fracVal_) * height2;
334  this->setMaxHeight(height);
335 }
336 
338 {
341 }
342 
343 // Override the base class methods for cacheInfo and calcLikelihoodInfo(UInt_t iEvt).
344 // For both of these we delegate to the two constituent PDFs.
345 
347 {
348  // delegate to the two sub-PDFs to cache their information
349  pdf1_->cacheInfo(inputData);
350  pdf2_->cacheInfo(inputData);
351 
352  // now check that the DP variables are included in the data
353  Bool_t hasBranch = inputData.haveBranch( "m13Sq" );
354  hasBranch &= inputData.haveBranch( "m23Sq" );
355  if (!hasBranch) {
356  cerr<<"ERROR in LauDPDepSumPdf::cacheInfo : Input data does not contain Dalitz plot variables m13Sq and/or m23Sq."<<endl;
357  return;
358  }
359 
360  // determine whether we are caching our PDF value
361  Bool_t doCaching( this->nFixedParameters() == this->nParameters() );
362  this->cachePDF( doCaching );
363 
364  if ( !doCaching ) {
365  // in this case we seem to be doing a fit where the parameters are floating
366  // so need to mark that the PDF height is no longer up to date
367  this->heightUpToDate(kFALSE);
368  }
369 
370  // clear the vector and reserve enough space
371  UInt_t nEvents = inputData.nEvents();
372  fractions_.clear();
373  fractions_.reserve(nEvents);
374 
375  // loop through the events, determine the fraction and store
376  for (UInt_t iEvt = 0; iEvt < nEvents; iEvt++) {
377 
378  const LauFitData& dataValues = inputData.getData(iEvt);
379 
380  Double_t m13Sq = dataValues.find("m13Sq")->second;
381  Double_t m23Sq = dataValues.find("m23Sq")->second;
382 
383  LauKinematics* kinematics = daughters_->getKinematics();
384  if ( dpDependence_ ) {
385  // if we're using the histogram then just
386  // determine the fraction and store
387  kinematics->updateKinematics( m13Sq, m23Sq );
388  fracVal_ = dpDependence_->calcEfficiency( kinematics );
389  } else {
390  // if we're scaling the fraction parameter then we
391  // just store the scaling info since the parameter
392  // might be floating
393  fracVal_ = frac_->value();
394  Double_t dpPos(0.0);
395  if ( dpAxis_ == M12 ) {
396  dpPos = kinematics->calcThirdMassSq(m13Sq,m23Sq);
397  } else if ( dpAxis_ == M13 ) {
398  dpPos = m13Sq;
399  } else if ( dpAxis_ == M23 ) {
400  dpPos = m23Sq;
401  } else if ( dpAxis_ == MMIN ) {
402  dpPos = TMath::Min( m13Sq, m23Sq );
403  } else if ( dpAxis_ == MMAX ) {
404  dpPos = TMath::Max( m13Sq, m23Sq );
405  } else {
406  dpPos = kinematics->distanceFromDPCentre(m13Sq,m23Sq);
407  }
408  this->scaleFrac( dpPos );
409  fracVal_ -= frac_->value();
410  }
411 
412  fractions_.push_back( fracVal_ );
413  }
414 }
415 
417 {
418  // Get the fraction value for this event
419  fracVal_ = fractions_[iEvt];
420  if ( frac_ ) {
421  // if we're scaling the parameter then need to add the
422  // current value of the parameter
423  fracVal_ += frac_->value();
424  }
425 
426  // Evaluate the normalised PDF values
427  pdf1_->calcLikelihoodInfo(iEvt);
428  pdf2_->calcLikelihoodInfo(iEvt);
429  Double_t result1 = pdf1_->getLikelihood();
430  Double_t result2 = pdf2_->getLikelihood();
431 
432  // Add them together
433  Double_t result = fracVal_ * result1 + (1-fracVal_) * result2;
434  this->setUnNormPDFVal(result);
435 }
436 
virtual void cacheInfo(const LauFitDataTree &inputData)
Cache information from data.
virtual void calcLikelihoodInfo(const LauAbscissas &abscissas)
Calculate the likelihood (and intermediate info) for a given abscissa.
Double_t calcThirdMassSq(Double_t firstMassSq, Double_t secondMassSq) const
Calculate the third invariant mass square from the two provided (e.g. mjkSq from mijSq and mikSq) ...
virtual void setUnNormPDFVal(Double_t unNormPDFVal)
Set the unnormalised likelihood.
Definition: LauAbsPdf.hh:454
virtual Double_t getMinAbscissa() const
Retrieve the minimum value of the (primary) abscissa.
Definition: LauAbsPdf.hh:158
DPAxis
Define possibilties for the DP axes.
virtual void checkPositiveness()
Check that PDF is positive.
virtual Bool_t heightUpToDate() const
Check if the maximum height of the PDF is up to date.
Definition: LauAbsPdf.hh:349
virtual void addParameters(std::vector< LauParameter * > &params)
Add parameters to the PDF.
Definition: LauAbsPdf.cc:522
Class that defines the particular 3-body decay under study.
Definition: LauDaughters.hh:33
virtual UInt_t nParameters() const
Retrieve the number of PDF parameters.
Definition: LauAbsPdf.hh:91
virtual void calcNorm()
Calculate the normalisation.
LauAbsPdf * pdf2_
Second PDF.
File containing declaration of LauDaughters class.
void scaleFrac(Double_t dpPos)
Scale fraction according to DP position.
virtual void calcPDFHeight(const LauKinematics *kinematics)=0
Calculate the maximum height of the PDF.
virtual const std::vector< LauParameter * > & getParameters() const
Retrieve the parameters of the PDF, e.g. so that they can be loaded into a fit.
Definition: LauAbsPdf.hh:321
virtual void setNorm(Double_t norm)
Set the normalisation factor.
Definition: LauAbsPdf.hh:410
LauParameter * frac_
Fractional contribution of first PDF to the final PDF.
virtual Bool_t checkRange(const LauAbscissas &abscissas) const
Check that all abscissas are within their allowed ranges.
Definition: LauAbsPdf.cc:213
Class for defining a PDF that is the DP-dependent sum of two other PDFs.
std::map< TString, Double_t > LauFitData
Type for holding event data.
Double_t getm23Sq() const
Get the m23 invariant mass square.
Double_t distanceFromDPCentre() const
Calculate the distance from the currently set (m13Sq, m23Sq) point to the centre of the Dalitz plot (...
LauDPDepSumPdf(LauAbsPdf *pdf1, LauAbsPdf *pdf2, const LauDaughters *daughters, const TH2 *dpHisto, Bool_t upperHalf=kFALSE)
Constructor - fraction determined by 2D histogram.
virtual TRandom * getRandomFun() const
Retrieve the random function used for MC generation.
Definition: LauAbsPdf.hh:472
std::vector< Double_t > fractions_
Cached values of fractions.
virtual Double_t getMaxHeight() const
Retrieve the maximum height.
Definition: LauAbsPdf.hh:303
virtual ~LauDPDepSumPdf()
Destructor.
void updateKinematics(Double_t m13Sq, Double_t m23Sq)
Update all kinematic quantities based on the DP co-ordinates m13Sq and m23Sq.
File containing declaration of LauDPDepSumPdf class.
LauAbsPdf * pdf1_
First PDF.
Double_t calcEfficiency(const LauKinematics *kinematics) const
Determine the efficiency for a given point in the Dalitz plot.
Definition: LauEffModel.cc:95
File containing declaration of LauParameter class.
virtual void calcPDFHeight(const LauKinematics *kinematics)
Calculate the PDF height.
LauKinematics * getKinematics()
Retrieve the Dalitz plot kinematics.
virtual std::vector< TString > varNames() const
Retrieve the names of the abscissas.
Definition: LauAbsPdf.cc:103
const std::vector< Double_t > fracCoeffs_
Polynomial used to scale fraction.
virtual Double_t getMaxAbscissa() const
Retrieve the maximum value of the (primary) abscissa.
Definition: LauAbsPdf.hh:164
Double_t fracVal_
Fractional contribution of first PDF to the final PDF.
virtual Bool_t isDPDependent() const
Specifies whether or not the PDF is DP dependent.
Definition: LauAbsPdf.hh:110
virtual void setMaxHeight(Double_t maxHeight)
Set the maximum height.
Definition: LauAbsPdf.hh:416
DPAxis dpAxis_
The DP axis we depend on.
Class for defining the fit parameter objects.
Definition: LauParameter.hh:31
const LauFitData & getData(UInt_t iEvt) const
Retrieve the data for a given event.
File containing declaration of LauEffModel class.
Double_t getm12Sq() const
Get the m12 invariant mass square.
virtual Bool_t cachePDF() const
Check if the PDF is to be cached.
Definition: LauAbsPdf.hh:355
Class that implements the efficiency description across the signal Dalitz plot.
Definition: LauEffModel.hh:37
virtual Double_t getLikelihood() const
Retrieve the normalised likelihood value.
Definition: LauAbsPdf.cc:354
Double_t getm13Sq() const
Get the m13 invariant mass square.
virtual void calcLikelihoodInfo(const LauAbscissas &abscissas)=0
Calculate the likelihood (and all associated information) given value(s) of the abscissa(s) ...
File containing LauConstants namespace.
virtual void checkPositiveness()=0
Ensure the PDF is positive definite.
virtual LauParameter * findParameter(const TString &parName)
Retrieve the specified parameter.
Definition: LauAbsPdf.cc:381
Bool_t haveBranch(const TString &name) const
Check if the named branch is stored.
Class for defining the abstract interface for PDF classes.
Definition: LauAbsPdf.hh:40
Class for calculating 3-body kinematic quantities.
virtual UInt_t nFixedParameters() const
Retrieve the number of fixed PDF parameters.
Definition: LauAbsPdf.cc:113
virtual void cacheInfo(const LauFitDataTree &inputData)
Cache information from data.
Definition: LauAbsPdf.cc:241
Double_t value() const
The value of the parameter.
LauDaughters * daughters_
Daughter particles.
UInt_t nEvents() const
Retrieve the number of events.
LauEffModel * dpDependence_
DP dependence.
virtual UInt_t nInputVars() const
Retrieve the number of abscissas.
Definition: LauAbsPdf.hh:103
virtual void setRandomFun(TRandom *randomFun)
Set the random function used for toy MC generation.
Definition: LauAbsPdf.hh:315
virtual Double_t getNorm() const
Retrieve the normalisation factor.
Definition: LauAbsPdf.hh:284
Class to store the input fit variables.
std::vector< Double_t > LauAbscissas
The type used for containing multiple abscissa values.
Definition: LauAbsPdf.hh:44