laura is hosted by Hepforge, IPPP Durham
Laura++  v3r3
A maximum likelihood fitting package for performing Dalitz-plot analysis.
LauParameter.cc
Go to the documentation of this file.
1 
2 // Copyright University of Warwick 2006 - 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 <map>
17 using std::cout;
18 using std::cerr;
19 using std::endl;
20 using std::map;
21 
22 #include "TRandom.h"
23 
24 #include "LauParameter.hh"
25 #include "LauRandom.hh"
26 
28 
29 
31  name_(""),
32  value_(0.0),
33  error_(0.0),
34  negError_(0.0),
35  posError_(0.0),
36  genValue_(0.0),
37  initValue_(0.0),
38  minValue_(0.0),
39  maxValue_(0.0),
40  fixed_(kTRUE),
41  secondStage_(kFALSE),
42  gaussConstraint_(kFALSE),
43  constraintMean_(0.0),
44  constraintWidth_(0.0),
45  gcc_(0.0),
46  bias_(0.0),
47  pull_(0.0),
48  clone_(kFALSE),
49  parent_(0),
50  blinder_(0)
51 {
52 }
53 
54 LauParameter::LauParameter(const TString& parName) :
55  name_(parName),
56  value_(0.0),
57  error_(0.0),
58  negError_(0.0),
59  posError_(0.0),
60  genValue_(0.0),
61  initValue_(0.0),
62  minValue_(0.0),
63  maxValue_(0.0),
64  fixed_(kTRUE),
65  secondStage_(kFALSE),
66  gaussConstraint_(kFALSE),
67  constraintMean_(0.0),
68  constraintWidth_(0.0),
69  gcc_(0.0),
70  bias_(0.0),
71  pull_(0.0),
72  clone_(kFALSE),
73  parent_(0),
74  blinder_(0)
75 {
76 }
77 
78 LauParameter::LauParameter(Double_t parValue) :
79  name_(""),
80  value_(parValue),
81  error_(0.0),
82  negError_(0.0),
83  posError_(0.0),
84  genValue_(parValue),
85  initValue_(parValue),
86  minValue_(parValue-1e-6),
87  maxValue_(parValue+1e-6),
88  fixed_(kTRUE),
89  secondStage_(kFALSE),
90  gaussConstraint_(kFALSE),
91  constraintMean_(0.0),
92  constraintWidth_(0.0),
93  gcc_(0.0),
94  bias_(0.0),
95  pull_(0.0),
96  clone_(kFALSE),
97  parent_(0),
98  blinder_(0)
99 {
100 }
101 
102 LauParameter::LauParameter(const TString& parName, Double_t parValue) :
103  name_(parName),
104  value_(parValue),
105  error_(0.0),
106  negError_(0.0),
107  posError_(0.0),
108  genValue_(parValue),
109  initValue_(parValue),
110  minValue_(parValue-1e-6),
111  maxValue_(parValue+1e-6),
112  fixed_(kTRUE),
113  secondStage_(kFALSE),
114  gaussConstraint_(kFALSE),
115  constraintMean_(0.0),
116  constraintWidth_(0.0),
117  gcc_(0.0),
118  bias_(0.0),
119  pull_(0.0),
120  clone_(kFALSE),
121  parent_(0),
122  blinder_(0)
123 {
124 }
125 
126 LauParameter::LauParameter(Double_t parValue, Double_t min, Double_t max) :
127  name_(""),
128  value_(parValue),
129  error_(0.0),
130  negError_(0.0),
131  posError_(0.0),
132  genValue_(parValue),
133  initValue_(parValue),
134  minValue_(min),
135  maxValue_(max),
136  fixed_(kTRUE),
137  secondStage_(kFALSE),
138  gaussConstraint_(kFALSE),
139  constraintMean_(0.0),
140  constraintWidth_(0.0),
141  gcc_(0.0),
142  bias_(0.0),
143  pull_(0.0),
144  clone_(kFALSE),
145  parent_(0),
146  blinder_(0)
147 {
148  this->checkRange();
149 }
150 
151 LauParameter::LauParameter(Double_t parValue, Double_t parError, Double_t min, Double_t max) :
152  name_(""),
153  value_(parValue),
154  error_(parError),
155  negError_(0.0),
156  posError_(0.0),
157  genValue_(parValue),
158  initValue_(parValue),
159  minValue_(min),
160  maxValue_(max),
161  fixed_(kTRUE),
162  secondStage_(kFALSE),
163  gaussConstraint_(kFALSE),
164  constraintMean_(0.0),
165  constraintWidth_(0.0),
166  gcc_(0.0),
167  bias_(0.0),
168  pull_(0.0),
169  clone_(kFALSE),
170  parent_(0),
171  blinder_(0)
172 {
173  this->checkRange();
174 }
175 
176 LauParameter::LauParameter(Double_t parValue, Double_t min, Double_t max, Bool_t parFixed) :
177  name_(""),
178  value_(parValue),
179  error_(0.0),
180  negError_(0.0),
181  posError_(0.0),
182  genValue_(parValue),
183  initValue_(parValue),
184  minValue_(min),
185  maxValue_(max),
186  fixed_(parFixed),
187  secondStage_(kFALSE),
188  gaussConstraint_(kFALSE),
189  constraintMean_(0.0),
190  constraintWidth_(0.0),
191  gcc_(0.0),
192  bias_(0.0),
193  pull_(0.0),
194  clone_(kFALSE),
195  parent_(0),
196  blinder_(0)
197 {
198  this->checkRange();
199 }
200 
201 LauParameter::LauParameter(const TString& parName, Double_t parValue, Double_t min, Double_t max) :
202  name_(parName),
203  value_(parValue),
204  error_(0.0),
205  negError_(0.0),
206  posError_(0.0),
207  genValue_(parValue),
208  initValue_(parValue),
209  minValue_(min),
210  maxValue_(max),
211  fixed_(kTRUE),
212  secondStage_(kFALSE),
213  gaussConstraint_(kFALSE),
214  constraintMean_(0.0),
215  constraintWidth_(0.0),
216  gcc_(0.0),
217  bias_(0.0),
218  pull_(0.0),
219  clone_(kFALSE),
220  parent_(0),
221  blinder_(0)
222 {
223  this->checkRange();
224 }
225 
226 LauParameter::LauParameter(const TString& parName, Double_t parValue, Double_t min, Double_t max, Bool_t parFixed) :
227  name_(parName),
228  value_(parValue),
229  error_(0.0),
230  negError_(0.0),
231  posError_(0.0),
232  genValue_(parValue),
233  initValue_(parValue),
234  minValue_(min),
235  maxValue_(max),
236  fixed_(parFixed),
237  secondStage_(kFALSE),
238  gaussConstraint_(kFALSE),
239  constraintMean_(0.0),
240  constraintWidth_(0.0),
241  gcc_(0.0),
242  bias_(0.0),
243  pull_(0.0),
244  clone_(kFALSE),
245  parent_(0),
246  blinder_(0)
247 {
248  this->checkRange();
249 }
250 
251 LauParameter::LauParameter(const TString& parName, Double_t parValue, Double_t parError, Double_t min, Double_t max) :
252  name_(parName),
253  value_(parValue),
254  error_(parError),
255  negError_(0.0),
256  posError_(0.0),
257  genValue_(parValue),
258  initValue_(parValue),
259  minValue_(min),
260  maxValue_(max),
261  fixed_(kTRUE),
262  secondStage_(kFALSE),
263  gaussConstraint_(kFALSE),
264  constraintMean_(0.0),
265  constraintWidth_(0.0),
266  gcc_(0.0),
267  bias_(0.0),
268  pull_(0.0),
269  clone_(kFALSE),
270  parent_(0),
271  blinder_(0)
272 {
273  this->checkRange();
274 }
275 
276 LauParameter::LauParameter(const LauParameter& rhs) : TObject(rhs), LauAbsRValue(rhs),
277  name_(rhs.name_),
278  value_(rhs.value_),
279  error_(rhs.error_),
280  negError_(rhs.negError_),
281  posError_(rhs.posError_),
282  genValue_(rhs.genValue_),
283  initValue_(rhs.initValue_),
284  minValue_(rhs.minValue_),
285  maxValue_(rhs.maxValue_),
286  fixed_(rhs.fixed_),
291  gcc_(rhs.gcc_),
292  bias_(rhs.bias_),
293  pull_(rhs.pull_),
294  clone_(rhs.clone_),
295  parent_(rhs.parent_),
296  clones_(rhs.clones_),
297  blinder_((rhs.blinder_==0) ? 0 : new LauBlind(*(rhs.blinder_)))
298 {
299 }
300 
302 {
303  if (&rhs != this) {
304  TObject::operator=(rhs);
306  name_ = rhs.name_;
307  value_ = rhs.value_;
308  error_ = rhs.error_;
309  negError_ = rhs.negError_;
310  posError_ = rhs.posError_;
311  genValue_ = rhs.genValue_;
312  initValue_ = rhs.initValue_;
313  minValue_ = rhs.minValue_;
314  maxValue_ = rhs.maxValue_;
315  fixed_ = rhs.fixed_;
320  gcc_ = rhs.gcc_;
321  bias_ = rhs.bias_;
322  pull_ = rhs.pull_;
323  clone_ = rhs.clone_;
324  parent_ = rhs.parent_;
325  clones_ = rhs.clones_;
326  delete blinder_;
327  blinder_ = (rhs.blinder_==0) ? 0 : new LauBlind(*(rhs.blinder_));
328  }
329  return *this;
330 }
331 
333 {
334  delete blinder_;
335 }
336 
337 std::vector<LauParameter*> LauParameter::getPars()
338 {
339  std::vector<LauParameter*> list;
340  list.push_back(this);
341  return list;
342 }
343 
344 void LauParameter::value(Double_t newValue)
345 {
346  if (this->clone()) {
347  parent_->value(newValue);
348  } else {
349  this->checkRange(newValue,this->minValue(),this->maxValue());
350  this->updateClones(kTRUE);
351  }
352 }
353 
354 void LauParameter::error(Double_t newError)
355 {
356  if (this->clone()) {
357  parent_->error(newError);
358  } else {
359  error_ = TMath::Abs(newError);
360  this->updateClones(kFALSE);
361  }
362 }
363 
364 void LauParameter::negError(Double_t newNegError)
365 {
366  if (this->clone()) {
367  parent_->negError(newNegError);
368  } else {
369  negError_ = TMath::Abs(newNegError);
370  this->updateClones(kFALSE);
371  }
372 }
373 
374 void LauParameter::posError(Double_t newPosError)
375 {
376  if (this->clone()) {
377  parent_->posError(newPosError);
378  } else {
379  posError_ = TMath::Abs(newPosError);
380  this->updateClones(kFALSE);
381  }
382 }
383 
384 void LauParameter::errors(Double_t newError, Double_t newNegError, Double_t newPosError)
385 {
386  if (this->clone()) {
387  parent_->errors(newError,newNegError,newPosError);
388  } else {
389  error_ = TMath::Abs(newError);
390  negError_ = TMath::Abs(newNegError);
391  posError_ = TMath::Abs(newPosError);
392  this->updateClones(kFALSE);
393  }
394 }
395 
396 void LauParameter::valueAndErrors(Double_t newValue, Double_t newError, Double_t newNegError, Double_t newPosError)
397 {
398  if (this->clone()) {
399  parent_->valueAndErrors(newValue,newError,newNegError,newPosError);
400  } else {
401  this->checkRange(newValue,this->minValue(),this->maxValue());
402  error_ = TMath::Abs(newError);
403  negError_ = TMath::Abs(newNegError);
404  posError_ = TMath::Abs(newPosError);
405  this->updateClones(kFALSE);
406  }
407 }
408 
409 void LauParameter::globalCorrelationCoeff(Double_t newGCCValue)
410 {
411  if (this->clone()) {
412  parent_->globalCorrelationCoeff(newGCCValue);
413  } else {
414  gcc_ = newGCCValue;
415  this->updateClones(kFALSE);
416  }
417 }
418 
419 void LauParameter::genValue(Double_t newGenValue)
420 {
421  if (this->clone()) {
422  parent_->genValue(newGenValue);
423  } else {
424  genValue_ = newGenValue;
425  this->updateClones(kFALSE);
426  }
427 }
428 
429 void LauParameter::initValue(Double_t newInitValue)
430 {
431  if (this->clone()) {
432  parent_->initValue(newInitValue);
433  } else {
434  initValue_ = newInitValue;
435  this->updateClones(kFALSE);
436  }
437 }
438 
439 void LauParameter::minValue(Double_t newMinValue)
440 {
441  if (this->clone()) {
442  parent_->minValue(newMinValue);
443  } else {
444  this->checkRange(this->value(),newMinValue,this->maxValue());
445  this->updateClones(kFALSE);
446  }
447 }
448 
449 void LauParameter::maxValue(Double_t newMaxValue)
450 {
451  if (this->clone()) {
452  parent_->maxValue(newMaxValue);
453  } else {
454  this->checkRange(this->value(),this->minValue(),newMaxValue);
455  this->updateClones(kFALSE);
456  }
457 }
458 
459 void LauParameter::range(Double_t newMinValue, Double_t newMaxValue)
460 {
461  if (this->clone()) {
462  parent_->range(newMinValue,newMaxValue);
463  } else {
464  this->checkRange(this->value(),newMinValue,newMaxValue);
465  this->updateClones(kFALSE);
466  }
467 }
468 
469 void LauParameter::valueAndRange(Double_t newValue, Double_t newMinValue, Double_t newMaxValue)
470 {
471  if (this->clone()) {
472  parent_->valueAndRange(newValue,newMinValue,newMaxValue);
473  } else {
474  this->checkRange(newValue,newMinValue,newMaxValue);
475  this->updateClones(kFALSE);
476  }
477 }
478 
479 void LauParameter::name(const TString& newName)
480 {
481  // no need to update clones here
482  // clones are allowed to have different names
483  name_ = newName;
484 }
485 
486 void LauParameter::fixed(Bool_t parFixed)
487 {
488  if (this->clone()) {
489  parent_->fixed(parFixed);
490  } else {
491  fixed_ = parFixed;
492  this->updateClones(kFALSE);
493  }
494 }
495 
496 void LauParameter::secondStage(Bool_t secondStagePar)
497 {
498  if (this->clone()) {
499  parent_->secondStage(secondStagePar);
500  } else {
501  secondStage_ = secondStagePar;
502  this->updateClones(kFALSE);
503  }
504 }
505 
506 void LauParameter::addGaussianConstraint(Double_t newGaussMean, Double_t newGaussWidth)
507 {
508  if (this->clone()) {
509  parent_->addGaussianConstraint(newGaussMean,newGaussWidth);
510  } else {
511  gaussConstraint_ = kTRUE;
512  constraintMean_ = newGaussMean;
513  constraintWidth_ = newGaussWidth;
514  this->updateClones(kFALSE);
515  }
516 }
517 
519 {
520  if (this->clone()) {
522  } else {
523  gaussConstraint_ = kFALSE;
524  this->updateClones(kFALSE);
525  }
526 }
527 
528 void LauParameter::blindParameter(const TString& blindingString, const Double_t width)
529 {
530  if (this->clone()) {
531  parent_->blindParameter(blindingString,width);
532  return;
533  }
534 
535  if ( blinder_ != 0 ) {
536  std::cerr << "WARNING in LauParameter::blindParameter : blinding has already been set up for this parameter" << std::endl;
537  return;
538  }
539 
540  blinder_ = new LauBlind(blindingString,width);
541 
542  for (map<LauParameter*,Double_t>::iterator iter = clones_.begin(); iter != clones_.end(); ++iter) {
543  LauParameter* clonePar = iter->first;
544  if ( clonePar->blinder_ != 0 ) {
545  std::cerr << "WARNING in LauParameter::blindParameter : blinding has already been set up for a clone of this parameter - it will be replaced!" << std::endl;
546  delete clonePar->blinder_;
547  clonePar->blinder_ = 0;
548  }
549  clonePar->blinder_ = new LauBlind(*blinder_);
550  }
551 }
552 
554 {
555  if (this->clone()) {
556  parent_->updatePull();
557  return;
558  }
559 
560  // calculate the bias
561  bias_ = value_ - genValue_;
562 
563  // if we have errors calculated then calculate
564  // the pull using the best error available
565  if ((bias_ > 0.0) && (negError_ > 1e-10)) {
566  pull_ = bias_ / negError_;
567  } else if ((bias_ < 0.0) && (posError_ > 1e-10)) {
568  pull_ = bias_ / posError_;
569  } else if (error_ > 1e-10) {
570  pull_ = bias_ / error_;
571  } else {
572  pull_ = 0.0;
573  }
574 
575  this->updateClones(kFALSE);
576 }
577 
578 void LauParameter::checkRange(Double_t val, Double_t minVal, Double_t maxVal)
579 {
580  // first check that min is less than max (or they are the same - this is allowed)
581  if (minVal > maxVal) {
582  cerr<<"ERROR in LauParameter::checkRange : minValue: "<<minVal<<" greater than maxValue: "<<maxVal<<endl;
583  if (minValue_ > maxValue_) {
585  cerr<<" : Setting both to "<<maxValue_<<"."<<endl;
586  } else {
587  cerr<<" : Not changing anything."<<endl;
588  }
589  return;
590  }
591 
592  minValue_ = minVal;
593  maxValue_ = maxVal;
594 
595  // now check that the value is still within the range
596  if ((val < minVal) || (val > maxVal)) {
597  if (name_ != "") {
598  cerr<<"ERROR in LauParameter::checkRange : value: "<<val<<" not in allowed range ["<<minVal<<" , "<<maxVal<<"] for parameter \""<<name_<<"\"."<<endl;
599  } else {
600  cerr<<"ERROR in LauParameter::checkRange : value: "<<val<<" not in allowed range ["<<minVal<<" , "<<maxVal<<"]."<<endl;
601  }
602  if (val < minVal) {
603  cerr<<" : Setting value to minValue: "<<minVal<<endl;
604  val = minVal;
605  } else {
606  cerr<<" : Setting value to maxValue: "<<maxVal<<endl;
607  val = maxVal;
608  }
609  }
610  value_ = val;
611 }
612 
614 {
615  // if we're a clone we mustn't be cloned ourselves
616  // but instead return another clone of our parent
617  // (this is so that the parent knows of all its clones)
618  if (this->clone()) {
619  LauParameter* clonePar = parent_->createClone(constFactor);
620  clonePar->name(this->name());
621  return clonePar;
622  }
623 
624  // clone ourselves using the copy-constructor
625  LauParameter* clonePar = new LauParameter(*this);
626  Double_t newValue = clonePar->value() * constFactor;
627  clonePar->value( newValue );
628  clonePar->wipeClones();
629  clonePar->clone(this);
630  clones_.insert( std::make_pair( clonePar, constFactor ) );
631  return clonePar;
632 }
633 
634 LauParameter* LauParameter::createClone(const TString& newName, Double_t constFactor)
635 {
636  // self message to create the clone
637  LauParameter* clonePar = this->createClone(constFactor);
638  // set the new name
639  clonePar->name(newName);
640  // and return
641  return clonePar;
642 }
643 
644 void LauParameter::updateClones(Bool_t justValue)
645 {
646  // if we don't have any clones then there's nothing to do
647  if ( clones_.empty() ) {
648  return;
649  }
650 
651  // we have to set the values directly rather than using member functions because otherwise we'd get into an infinite loop
652  if (justValue) {
653  for (map<LauParameter*,Double_t>::iterator iter = clones_.begin(); iter != clones_.end(); ++iter) {
654  LauParameter* clonePar = iter->first;
655  Double_t constFactor = iter->second;
656  clonePar->value_ = constFactor*this->value();
657  }
658  } else {
659  for (map<LauParameter*,Double_t>::iterator iter = clones_.begin(); iter != clones_.end(); ++iter) {
660  LauParameter* clonePar = iter->first;
661  Double_t constFactor = iter->second;
662  clonePar->value_ = constFactor*this->value();
663  clonePar->error_ = constFactor*this->error();
664  clonePar->negError_ = constFactor*this->negError();
665  clonePar->posError_ = constFactor*this->posError();
666  clonePar->genValue_ = constFactor*this->genValue();
667  clonePar->initValue_ = constFactor*this->initValue();
668  clonePar->minValue_ = constFactor*this->minValue();
669  clonePar->maxValue_ = constFactor*this->maxValue();
670  clonePar->fixed_ = this->fixed();
671  clonePar->secondStage_ = this->secondStage();
672  clonePar->gaussConstraint_ = this->gaussConstraint();
673  clonePar->constraintMean_ = this->constraintMean();
674  clonePar->constraintWidth_ = this->constraintWidth();
675  clonePar->gcc_ = this->globalCorrelationCoeff();
676  clonePar->bias_ = this->bias();
677  clonePar->pull_ = this->pull();
678  }
679  }
680 }
681 
683 {
684  this->randomiseValue(this->minValue(), this->maxValue());
685 }
686 
687 void LauParameter::randomiseValue(Double_t minVal, Double_t maxVal)
688 {
689  // if we're fixed then do nothing
690  if (this->fixed()) {
691  return;
692  }
693 
694  // check supplied values are sensible
695  if (maxVal < minVal) {
696  cerr<<"ERROR in LauParameter::randomiseValue : Supplied maximum value smaller than minimum value."<<endl;
697  return;
698  }
699  if (maxVal > this->maxValue()) {
700  maxVal = this->maxValue();
701  }
702  if (minVal < this->minValue()) {
703  minVal = this->minValue();
704  }
705 
706  // use the zero-seed random number generator to get values that are
707  // uniformly distributed over the given range
708  Double_t randNo = LauRandom::zeroSeedRandom()->Rndm();
709  Double_t val = randNo*(maxVal - minVal) + minVal;
710  this->initValue(val);
711 }
712 
713 // ostream operator
714 std::ostream& operator << (std::ostream& stream, const LauParameter& par)
715 {
716  stream << par.value();
717  return stream;
718 }
719 
Double_t range() const
The range allowed for the parameter.
Double_t genValue_
Toy generation value.
LauAbsRValue & operator=(const LauAbsRValue &)
Copy assignment operator.
Definition: LauAbsRValue.hh:42
Bool_t fixed() const
Check whether the parameter is fixed or floated.
std::map< LauParameter *, Double_t > clones_
The clones of this parameter.
Double_t constraintMean_
Mean value of the Gaussian constraint.
TRandom * zeroSeedRandom()
Access the singleton random number generator with seed set from machine clock time (within +-1 sec)...
Definition: LauRandom.cc:30
Double_t maxValue() const
The maximum value allowed for the parameter.
ClassImp(LauAbsCoeffSet)
LauParameter()
Default constructor.
Definition: LauParameter.cc:30
const TString & name() const
The parameter name.
Double_t constraintWidth() const
The width of the Gaussian constraint.
Double_t bias() const
The bias in the parameter.
LauParameter * parent_
The parent parameter.
virtual ~LauParameter()
Bool_t gaussConstraint_
Choice to use Gaussian constraint.
Double_t negError() const
The lower error on the parameter.
Double_t minValue() const
The minimum value allowed for the parameter.
Double_t maxValue_
Maximum value for the parameter.
void valueAndRange(Double_t newValue, Double_t newMinValue, Double_t newMaxValue)
Set the value and range for the parameter.
void updateClones(Bool_t justValue)
Method to update clone values.
Double_t bias_
Parameter bias.
Double_t posError() const
The upper error on the parameter.
Double_t error_
The error on the parameter.
Bool_t clone() const
Check whether is a clone or not.
void checkRange()
Method to check whether value provided is whithin the range and that the minimum and maximum limits m...
Double_t pull() const
The pull value for the parameter.
std::ostream & operator<<(std::ostream &os, const LauComplex &z)
Definition: LauComplex.cc:43
Double_t minValue_
Minimum value for the parameter.
File containing declaration of LauParameter class.
Double_t pull_
Parameter pull.
Double_t constraintMean() const
The mean of the Gaussian constraint.
Double_t negError_
The lower error on the parameter.
Bool_t gaussConstraint() const
Check whether a Gaussian constraints is applied.
Double_t gcc_
Global correlation coefficient.
Bool_t secondStage() const
Check whether the parameter should be floated only in the second stage of a two stage fit...
std::vector< LauParameter * > getPars()
Get the LauParameter itself.
Double_t error() const
The error on the parameter.
Class for defining the fit parameter objects.
Definition: LauParameter.hh:35
void randomiseValue()
Randomise the value of the parameter (if it is floating).
void valueAndErrors(Double_t newValue, Double_t newError, Double_t newNegError=0.0, Double_t newPosError=0.0)
Set the value and errors on the parameter.
Double_t posError_
The upper error on the parameter.
File containing LauRandom namespace.
TString name_
The parameter name.
Double_t initValue() const
The initial value of the parameter.
void blindParameter(const TString &blindingString, const Double_t width)
Blind the parameter.
Bool_t secondStage_
Flag whether it is floated only in the second stage of the fit.
Double_t value_
The parameter value.
Bool_t clone_
Flag whether the parameter is a clone.
void updatePull()
Call to update the bias and pull values.
LauParameter * createClone(Double_t constFactor=1.0)
Method to create a clone from the parent parameter using the copy constructor.
void addGaussianConstraint(Double_t newGaussMean, Double_t newGaussWidth)
Add a Gaussian constraint (or modify an existing one)
Bool_t fixed_
Fix/float option for parameter.
Double_t value() const
The value of the parameter.
void wipeClones()
Method to clear the clone parameters.
LauBlind * blinder_
The blinding engine.
Class for blinding and unblinding a number based on a blinding string.
Definition: LauBlind.hh:28
Double_t globalCorrelationCoeff() const
The parameter global correlation coefficient.
Double_t constraintWidth_
Width of the Gaussian constraint.
Pure abstract base class for defining a parameter containing an R value.
Definition: LauAbsRValue.hh:29
Double_t genValue() const
The value generated for the parameter.
void removeGaussianConstraint()
Remove the Gaussian constraint.
void errors(Double_t newError, Double_t newNegError, Double_t newPosError)
Set the error values on the parameter.
Double_t initValue_
Initial fit value.
LauParameter & operator=(const LauParameter &rhs)
Copy assignment operator.