ATLAS Offline Software
ZDCFitWrapper.h
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #ifndef ZDCANALYSIS_ZDCFITWRAPPER_H
6 #define ZDCANALYSIS_ZDCFITWRAPPER_H
7 
8 #include "CxxUtils/checker_macros.h"
9 
10 // Base class that defines the interface
11 //
12 #include <TF1.h>
13 #include <memory>
14 
15 double ZDCFermiExpFit(const double* xvec, const double* pvec);
16 double ZDCFermiExpFitRefl(const double* xvec, const double* pvec);
17 
18 class ATLAS_NOT_THREAD_SAFE ZDCFitWrapper
19 {
20 private:
21  std::shared_ptr<TF1> m_wrapperTF1{};
22 
23  float m_tmin{0};
24  float m_tmax{0};
25 
26  float m_ampMin{0};
27  float m_ampMax{0};
28 
29  float m_t0Min{0};
30  float m_t0Max{0};
31 
32  bool m_adjTLimitsEvent{false};
33  float m_tminAdjust{0};
34  float m_tempTmin{0};
35  float m_tempTmax{0};
36 
37 protected:
38  // Actually sets the t0 parameter limits in the fit function
39  //
40  virtual void SetT0FitLimits(float tMin, float tMax) = 0;
41 
42 public:
43  ZDCFitWrapper(const std::shared_ptr<TF1>& wrapperTF1) : m_wrapperTF1(wrapperTF1),
44  m_ampMin(0),
45  m_adjTLimitsEvent(true) // true here forces a setting of T0 par limits on first event
46  {
47  m_tmin = m_wrapperTF1->GetXmin();
48  m_tmax = m_wrapperTF1->GetXmax();
49 
50  m_t0Min = m_tmin;
51  m_t0Max = m_tmax;
52  }
53 
54  virtual ~ZDCFitWrapper() {}
55 
56  void Initialize(float initialAmp, float initialT0, float ampMin, float ampMax);
57  void Initialize(float initialAmp, float initialT0, float ampMin, float ampMax, float fitTmin, float fitTmax, float fitTRef);
58 
59  // Performs the class-specific event initialization
60  //
61  virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax) = 0;
62 
63  void SetAmpMinMax(float minAmp, float maxAmp)
64  {
65  m_ampMin = minAmp;
66  m_ampMax = maxAmp;
67  }
68 
69  void SetT0Range(float t0Min, float t0Max)
70  {
71  m_t0Min = t0Min;
72  m_t0Max = t0Max;
73 
74  SetT0FitLimits(t0Min, t0Max);
75  }
76 
77  virtual void ConstrainFit() = 0;
78  virtual void UnconstrainFit() = 0;
79 
80  virtual float GetAmplitude() const = 0;
81  virtual float GetAmpError() const = 0;
82  virtual float GetTime() const = 0;
83  virtual float GetTau1() const = 0;
84  virtual float GetTau2() const = 0;
85 
86  float GetMinAmp() const {return m_ampMin;}
87  float GetMaxAmp() const {return m_ampMax;}
88 
89  float GetTMin() const {return m_tmin;}
90  float GetTMax() const {return m_tmax;}
91 
92  float GetT0Min() const {
93  if (m_adjTLimitsEvent) return m_tempTmin;
94  else return m_t0Min;
95  }
96 
97  float GetT0Max() const {
98  if (m_adjTLimitsEvent) return m_tempTmax;
99  else return m_t0Max;
100  }
101 
102  float GetTMinAdjust() const {return m_tminAdjust;}
103 
104  virtual float GetBkgdMaxFraction() const = 0;
105 
106  virtual float GetShapeParameter(size_t index) const = 0;
107 
108  virtual double operator()(const double *x, const double *p) = 0;
109 
110  virtual std::shared_ptr<TF1> GetWrapperTF1() {return m_wrapperTF1;}
111  virtual const TF1* GetWrapperTF1() const {return m_wrapperTF1.get();}
112  virtual TF1* GetWrapperTF1RawPtr() const {return m_wrapperTF1.get();}
113 };
114 
115 class ATLAS_NOT_THREAD_SAFE ZDCPrePulseFitWrapper : public ZDCFitWrapper
116 {
117 protected:
118  float m_preT0Min;
119  float m_preT0Max;
120 public:
121  ZDCPrePulseFitWrapper(std::shared_ptr<TF1> wrapperTF1) : ZDCFitWrapper(wrapperTF1)
122  {
123  m_preT0Min = GetTMin();
124  m_preT0Max = GetTMax();
125  }
126 
127  virtual void SetInitialPrePulse(float amp, float t0, float expamp, bool fixPrePulseToZero) = 0;
128 
129  virtual void SetPrePulseT0Range(float tmin, float tmax) = 0;
130  virtual void SetPostPulseT0Range(float tmin, float tmax, float initialPostT0) = 0;
131 
132  virtual unsigned int GetPreT0ParIndex() const = 0;
133 
134  virtual float GetPreT0() const = 0;
135  virtual float GetPreAmp() const = 0;
136 
137  virtual float GetPostT0() const = 0;
138  virtual float GetPostAmp() const = 0;
139 
140  virtual float GetExpAmp() const = 0;
141 };
142 
143 class ATLAS_NOT_THREAD_SAFE ZDCPreExpFitWrapper : public ZDCFitWrapper
144 {
145 protected:
146  float m_defaultTau;
147  bool m_fixTau;
148 
149 public:
150  ZDCPreExpFitWrapper(std::shared_ptr<TF1> wrapperTF1, float defaultExpTau, bool fixTau) :
151  ZDCFitWrapper(wrapperTF1), m_defaultTau(defaultExpTau), m_fixTau(fixTau)
152  {}
153 
154  virtual void SetInitialExpPulse(float expamp) = 0;
155 
156  bool fixExpTau() const {return m_fixTau;}
157  float getDefaultExpTau() const {return m_defaultTau;}
158 
159  virtual float GetExpAmp() const = 0;
160  virtual float GetExpTau() const = 0;
161 };
162 
163 class ATLAS_NOT_THREAD_SAFE ZDCFitExpFermiVariableTaus : public ZDCFitWrapper
164 {
165 protected:
166  bool m_fixTau1{false};
167  bool m_fixTau2{false};
168 
169  float m_tau1{0};
170  float m_tau2{0};
171 
172 public:
173 
174  ZDCFitExpFermiVariableTaus(const std::string& tag, float tmin, float tmax, bool fixTau1, bool fixTau2, float tau1, float tau2);
175 
176  virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax) override;
177  virtual void SetT0FitLimits(float tMin, float tMax) override;
178 
179  virtual float GetAmplitude() const override {return GetWrapperTF1()->GetParameter(0); }
180  virtual float GetAmpError() const override {return GetWrapperTF1()->GetParError(0); }
181 
182  virtual float GetTau1() const override {return GetWrapperTF1()->GetParameter(2);}
183  virtual float GetTau2() const override {return GetWrapperTF1()->GetParameter(3);}
184 
185  virtual float GetTime() const override {
186  const TF1* theTF1 = GetWrapperTF1();
187 
188  float fitT0 = theTF1->GetParameter(1);
189 
190  float tau1 = theTF1->GetParameter(2);
191  float tau2 = theTF1->GetParameter(3);
192 
193  // Correct the time to the maximum
194  //
195  if (tau2 > tau1) fitT0 += tau1 * std::log(tau2 / tau1 - 1.0);
196  return fitT0;
197  }
198 
199  virtual float GetShapeParameter(size_t index) const override
200  {
201  if (index == 0) return GetWrapperTF1()->GetParameter(2);
202  else if (index == 1) return GetWrapperTF1()->GetParameter(3);
203  else throw std::runtime_error("Fit parameter does not exist.");
204  }
205 
206  virtual float GetBkgdMaxFraction() const override
207  {
208  const TF1* theTF1 = ZDCFitWrapper::GetWrapperTF1();
209  double amp = theTF1->GetParameter(0);
210  double constant = theTF1->GetParameter(4);
211 
212  if (amp > 0) return constant / amp;
213  else return -1;
214  }
215 
216  virtual double operator()(const double *x, const double *p) override{
217  return ZDCFermiExpFit(x, p);
218  }
219 
220  virtual void ConstrainFit() override;
221  virtual void UnconstrainFit() override;
222 };
223 
224 //
225 // A special version of the fermi*negative exponential function that includes a term to describe
226 // the "reflection" effects we see in the ZDC+LHCf joint run due to the splitting of the ZDC
227 // signals to send a copy to LHCf DAQ. It's not really a reflection but an artifact introduced
228 // by the bandwidth limit of the linear fan-in/fan-out module that we used.
229 //
230 class ATLAS_NOT_THREAD_SAFE ZDCFitExpFermiVariableTausLHCf : public ZDCFitWrapper
231 {
232 protected:
233  bool m_fixTau1{false};
234  bool m_fixTau2{false};
235 
236  float m_tau1{0};
237  float m_tau2{0};
238 
239 public:
240 
241  ZDCFitExpFermiVariableTausLHCf(const std::string& tag, float tmin, float tmax, bool fixTau1, bool fixTau2, float tau1, float tau2);
242 
243  virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax) override;
244  virtual void SetT0FitLimits(float tMin, float tMax) override;
245 
246  virtual float GetAmplitude() const override {return GetWrapperTF1()->GetParameter(0); }
247  virtual float GetAmpError() const override {return GetWrapperTF1()->GetParError(0); }
248 
249  virtual float GetTau1() const override {return GetWrapperTF1()->GetParameter(2);}
250  virtual float GetTau2() const override {return GetWrapperTF1()->GetParameter(3);}
251 
252  virtual float GetTime() const override {
253  const TF1* theTF1 = GetWrapperTF1();
254 
255  float fitT0 = theTF1->GetParameter(1);
256 
257  float tau1 = theTF1->GetParameter(2);
258  float tau2 = theTF1->GetParameter(3);
259 
260  // Correct the time to the maximum
261  //
262  if (tau2 > tau1) fitT0 += tau1 * std::log(tau2 / tau1 - 1.0);
263  return fitT0;
264  }
265 
266  virtual float GetShapeParameter(size_t index) const override
267  {
268  if (index == 0) return GetWrapperTF1()->GetParameter(2);
269  else if (index == 1) return GetWrapperTF1()->GetParameter(3);
270  else throw std::runtime_error("Fit parameter does not exist.");
271  }
272 
273  virtual float GetBkgdMaxFraction() const override
274  {
275  const TF1* theTF1 = ZDCFitWrapper::GetWrapperTF1();
276  double amp = theTF1->GetParameter(0);
277  double constant = theTF1->GetParameter(4);
278 
279  if (amp > 0) return constant / amp;
280  else return -1;
281  }
282 
283  virtual double operator()(const double *x, const double *p) override{
284  return ZDCFermiExpFitRefl(x, p);
285  }
286 
287  virtual void ConstrainFit() override;
288  virtual void UnconstrainFit() override;
289 };
290 
291 class ATLAS_NOT_THREAD_SAFE ZDCFitExpFermiVariableTausRun3 : public ZDCFitExpFermiVariableTaus
292 {
293 public:
294  ZDCFitExpFermiVariableTausRun3(const std::string& tag, float tmin, float tmax, bool fixTau1, bool fixTau2, float tau1, float tau2);
295 };
296 
297 class ATLAS_NOT_THREAD_SAFE ZDCFitExpFermiFixedTaus : public ZDCFitWrapper
298 {
299 private:
300  float m_tau1{0};
301  float m_tau2{0};
302 
303  float m_norm{0};
304  float m_timeCorr{0};
305 
306  std::shared_ptr<TF1> m_expFermiFunc{};
307 
308 public:
309 
310  ZDCFitExpFermiFixedTaus(const std::string& tag, float tmin, float tmax, float tau1, float tau2);
311 
312  ~ZDCFitExpFermiFixedTaus() {}
313 
314  virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax) override;
315  virtual void SetT0FitLimits(float tMin, float tMax) override;
316 
317  virtual void ConstrainFit() override;
318  virtual void UnconstrainFit() override;
319 
320  virtual float GetAmplitude() const override {return GetWrapperTF1()->GetParameter(0); }
321  virtual float GetAmpError() const override {return GetWrapperTF1()->GetParError(0); }
322 
323  virtual float GetTau1() const override {return m_tau1;}
324  virtual float GetTau2() const override {return m_tau2;}
325 
326  virtual float GetTime() const override {
327  return GetWrapperTF1()->GetParameter(1) + m_timeCorr; // Correct the time to the maximum
328  }
329 
330  virtual float GetShapeParameter(size_t index) const override
331  {
332  if (index == 0) return m_tau1;
333  else if (index == 1) return m_tau2;
334  else throw std::runtime_error("Fit parameter does not exist.");
335  }
336 
337  virtual float GetBkgdMaxFraction() const override
338  {
339  const TF1* theTF1 = ZDCFitWrapper::GetWrapperTF1();
340  double amp = theTF1->GetParameter(0);
341  double C = theTF1->GetParameter(2);
342 
343  return C / amp;
344  }
345 
346  virtual double operator() (const double *x, const double *p) override
347  {
348  double amp = p[0];
349  double t0 = p[1];
350  double C = p[2];
351 
352  double deltaT = x[0] - t0;
353 
354  double expFermi = amp * m_norm * m_expFermiFunc->operator()(deltaT);
355 
356  return expFermi + C; // + bckgd;
357  }
358 };
359 
360 class ATLAS_NOT_THREAD_SAFE ZDCFitExpFermiPrePulse : public ZDCPrePulseFitWrapper
361 {
362 private:
363  float m_tau1{0};
364  float m_tau2{0};
365  float m_norm{0};
366  float m_timeCorr{0};
367  std::shared_ptr<TF1> m_expFermiFunc = 0;
368 
369 public:
370  ZDCFitExpFermiPrePulse(const std::string& tag, float tmin, float tmax, float tau1, float tau2);
371  ~ZDCFitExpFermiPrePulse() {}
372 
373  virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax) override;
374  virtual void SetT0FitLimits(float tMin, float tMax) override;
375 
376 
377  virtual void SetInitialPrePulse(float amp, float t0, float /*expamp = 0*/, bool /*fixPrePulseToZero = false*/) override {
378  GetWrapperTF1()->SetParameter(2, std::max(amp, (float) 1.5)); //1.5 here ensures that we're above lower limit
379  GetWrapperTF1()->SetParameter(3, t0);
380  }
381 
382  virtual void SetPrePulseT0Range(float tmin, float tmax) override;
383  virtual void SetPostPulseT0Range(float /*tmin*/, float /*tmax*/, float /*initialPostT0*/) override {return;}
384 
385  virtual void ConstrainFit() override;
386  virtual void UnconstrainFit() override;
387 
388  virtual unsigned int GetPreT0ParIndex() const override {return 3;}
389 
390  virtual float GetAmplitude() const override {return GetWrapperTF1()->GetParameter(0); }
391  virtual float GetAmpError() const override {return GetWrapperTF1()->GetParError(0); }
392 
393  virtual float GetTau1() const override {return m_tau1;}
394  virtual float GetTau2() const override {return m_tau2;}
395 
396  virtual float GetPreT0() const override {return 0;}
397  virtual float GetPreAmp() const override {return 0;}
398 
399  virtual float GetPostT0() const override {return 0;}
400  virtual float GetPostAmp() const override {return 0;}
401 
402  virtual float GetExpAmp() const override {return 0;}
403 
404  virtual float GetTime() const override {
405  return GetWrapperTF1()->GetParameter(1) + m_timeCorr; // Correct the time to the maximum
406  }
407 
408  virtual float GetShapeParameter(size_t index) const override
409  {
410  if (index == 0) return m_tau1;
411  else if (index == 1) return m_tau2;
412  else if (index < 5) return GetWrapperTF1()->GetParameter(index);
413  else throw std::runtime_error("Fit parameter does not exist.");
414  }
415 
416  virtual float GetBkgdMaxFraction() const override
417  {
418  const TF1* theTF1 = ZDCFitWrapper::GetWrapperTF1();
419 
420  double maxTime = GetTime();
421 
422  double amp = theTF1->GetParameter(0);
423  if (amp <= 0) return -1;
424 
425  double preAmp = theTF1->GetParameter(2);
426  double preT0 = theTF1->GetParameter(3);
427 
428  double deltaTPre = maxTime - preT0;
429  double background = preAmp * m_norm * m_expFermiFunc->operator()(deltaTPre);
430 
431  return background / (amp + background);
432  }
433 
434  virtual double operator() (const double *x, const double *p) override
435  {
436  double t = x[0];
437 
438  double amp = p[0];
439  double t0 = p[1];
440  double preAmp = p[2];
441  double preT0 = p[3];
442  double C = p[4];
443 
444  double deltaT = t - t0;
445  double deltaTPre = t - preT0;
446 
447  // We subtract off the value of the pre-pulse at the minimum time (nominally 0,
448  // but can change if we exclude early samples) to account for the subtraction of the pre-sample
449  //
450  double deltaPresamp = GetTMinAdjust() - preT0;
451 
452  // double bckgd = linSlope*t;
453 
454  double pulse1 = amp * m_norm * m_expFermiFunc->operator()(deltaT);
455  double pulse2 = preAmp * m_norm * (m_expFermiFunc->operator()(deltaTPre) -
456  m_expFermiFunc->operator()(deltaPresamp));
457 
458  return C + pulse1 + pulse2;// + bckgd;
459  }
460 };
461 
462 class ATLAS_NOT_THREAD_SAFE ZDCFitExpFermiLHCfPrePulse : public ZDCPrePulseFitWrapper
463 {
464 private:
465  float m_tau1{0};
466  float m_tau2{0};
467  float m_norm{0};
468  float m_timeCorr{0};
469  std::shared_ptr<TF1> m_expFermiLHCfFunc = 0;
470 
471 public:
472  ZDCFitExpFermiLHCfPrePulse(const std::string& tag, float tmin, float tmax, float tau1, float tau2);
473  ~ZDCFitExpFermiLHCfPrePulse() {}
474 
475  virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax) override;
476  virtual void SetT0FitLimits(float tMin, float tMax) override;
477 
478 
479  virtual void SetInitialPrePulse(float amp, float t0, float /*expamp = 0*/, bool /*fixPrePulseToZero = false*/) override {
480  GetWrapperTF1()->SetParameter(2, std::max(amp, (float) 1.5)); //1.5 here ensures that we're above lower limit
481  GetWrapperTF1()->SetParameter(3, t0);
482  }
483 
484  virtual void SetPrePulseT0Range(float tmin, float tmax) override;
485  virtual void SetPostPulseT0Range(float /*tmin*/, float /*tmax*/, float /*initialPostT0*/) override {return;}
486 
487  virtual void ConstrainFit() override;
488  virtual void UnconstrainFit() override;
489 
490  virtual unsigned int GetPreT0ParIndex() const override {return 3;}
491 
492  virtual float GetAmplitude() const override {return GetWrapperTF1()->GetParameter(0); }
493  virtual float GetAmpError() const override {return GetWrapperTF1()->GetParError(0); }
494 
495  virtual float GetTau1() const override {return m_tau1;}
496  virtual float GetTau2() const override {return m_tau2;}
497 
498  virtual float GetPreT0() const override {return GetWrapperTF1()->GetParameter(3);}
499  virtual float GetPreAmp() const override {return GetWrapperTF1()->GetParameter(3);}
500 
501  virtual float GetPostT0() const override {return 0;}
502  virtual float GetPostAmp() const override {return 0;}
503 
504  virtual float GetExpAmp() const override {return 0;}
505 
506  virtual float GetTime() const override {
507  return GetWrapperTF1()->GetParameter(1) + m_timeCorr; // Correct the time to the maximum
508  }
509 
510  virtual float GetShapeParameter(size_t index) const override
511  {
512  if (index == 0) return m_tau1;
513  else if (index == 1) return m_tau2;
514  else if (index < 5) return GetWrapperTF1()->GetParameter(index);
515  else throw std::runtime_error("Fit parameter does not exist.");
516  }
517 
518  virtual float GetBkgdMaxFraction() const override
519  {
520  const TF1* theTF1 = ZDCFitWrapper::GetWrapperTF1();
521 
522  double maxTime = GetTime();
523 
524  double amp = theTF1->GetParameter(0);
525  if (amp <= 0) return 1;
526 
527  double preAmp = theTF1->GetParameter(2);
528  double preT0 = theTF1->GetParameter(3);
529 
530  double deltaTPre = maxTime - preT0;
531  double background = preAmp * m_norm * m_expFermiLHCfFunc->operator()(deltaTPre);
532 
533  return background / (amp + background);
534  }
535 
536  virtual double operator() (const double *x, const double *p) override
537  {
538  double t = x[0];
539 
540  double amp = p[0];
541  double t0 = p[1];
542  double preAmp = p[2];
543  double preT0 = p[3];
544  double C = p[4];
545 
546  double deltaT = t - t0;
547  double deltaTPre = t - preT0;
548 
549  // We subtract off the value of the pre-pulse at the minimum time (nominally 0,
550  // but can change if we exclude early samples) to account for the subtraction of the pre-sample
551  //
552  double deltaPresamp = GetTMinAdjust() - preT0;
553 
554  double pulse1 = amp * m_norm * m_expFermiLHCfFunc->operator()(deltaT);
555  double pulse2 = preAmp * m_norm * (m_expFermiLHCfFunc->operator()(deltaTPre) -
556  m_expFermiLHCfFunc->operator()(deltaPresamp));
557 
558  return C + pulse1 + pulse2;// + bckgd;
559  }
560 };
561 
562 class ATLAS_NOT_THREAD_SAFE ZDCFitExpFermiPreExp : public ZDCPreExpFitWrapper
563 {
564 private:
565  float m_tau1{0};
566  float m_tau2{0};
567  float m_norm{0};
568  float m_timeCorr{0};
569 
570  std::shared_ptr<TF1> m_expFermiFunc{0};
571 
572 public:
573  ZDCFitExpFermiPreExp(const std::string& tag, float tmin, float tmax, float tau1, float tau2,
574  float defExpTau, float fixExpTau);
575  ~ZDCFitExpFermiPreExp() {}
576 
577  virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax) override;
578  virtual void SetT0FitLimits(float tMin, float tMax) override;
579 
580  virtual void SetInitialExpPulse(float amp) override
581  {
582  GetWrapperTF1()->SetParameter(2, std::max(amp, (float) 0.5)); //0.5 here ensures that we're above lower limit (0)
583  }
584 
585  virtual void ConstrainFit() override;
586  virtual void UnconstrainFit() override;
587 
588  virtual float GetAmplitude() const override {return GetWrapperTF1()->GetParameter(0); }
589  virtual float GetAmpError() const override {return GetWrapperTF1()->GetParError(0); }
590 
591  virtual float GetTau1() const override {return m_tau1;}
592  virtual float GetTau2() const override {return m_tau2;}
593 
594  virtual float GetTime() const override {
595  return GetWrapperTF1()->GetParameter(1) + m_timeCorr; // Correct the time to the maximum
596  }
597 
598  virtual float GetExpAmp() const override {return GetWrapperTF1()->GetParameter(2);}
599  virtual float GetExpTau() const override {return GetWrapperTF1()->GetParameter(3);}
600 
601  virtual float GetShapeParameter(size_t index) const override
602  {
603  if (index == 0) return m_tau1;
604  else if (index == 1) return m_tau2;
605  else if (index < 5) return GetWrapperTF1()->GetParameter(index);
606  else throw std::runtime_error("Fit parameter does not exist.");
607  }
608 
609  virtual float GetBkgdMaxFraction() const override
610  {
611  const TF1* theTF1 = ZDCFitWrapper::GetWrapperTF1();
612  double maxTime = GetTime();
613 
614  double amp = theTF1->GetParameter(0);
615  if (amp <= 0) return -1;
616 
617  double preAmp = theTF1->GetParameter(2);
618  double preT0 = theTF1->GetParameter(3);
619 
620  double deltaTPre = maxTime - preT0;
621  double background = preAmp * m_norm * m_expFermiFunc->operator()(deltaTPre);
622 
623  return background / (amp + background);
624  }
625 
626  virtual double operator() (const double *x, const double *p) override
627  {
628  double t = x[0];
629 
630  double amp = p[0];
631  double t0 = p[1];
632  double expAmp = p[2];
633  double expTau = p[3];
634  double expSqrtTau = p[4];
635  double C = p[5];
636 
637  double deltaT = t - t0;
638  double pulse = amp * m_norm * m_expFermiFunc->operator()(deltaT);
639 
640  // We subtract off the value of the exponential pulse at the minimum time (nominally 0),
641  // because it would have been included in the baseline subtraction
642  //
643  double tRef = GetTMinAdjust();
644  double expPre = 0;
645  if (t > 0 && std::abs(expSqrtTau)>1e-6) expPre = expAmp * (std::exp(-t/expTau-expSqrtTau*std::sqrt(t)) - std::exp(-tRef/expTau));
646  else expPre = expAmp * (std::exp(-t/expTau) - std::exp(-tRef/expTau));
647 
648  return C + pulse + expPre;
649  }
650 };
651 
652 class ATLAS_NOT_THREAD_SAFE ZDCFitExpFermiLHCfPreExp : public ZDCPreExpFitWrapper
653 {
654 private:
655  float m_tau1{0};
656  float m_tau2{0};
657  float m_norm{0};
658  float m_timeCorr{0};
659 
660  std::shared_ptr<TF1> m_expFermiLHCfFunc{};
661 
662 public:
663  ZDCFitExpFermiLHCfPreExp(const std::string& tag, float tmin, float tmax, float tau1, float tau2,
664  float defExpTau, float fixExpTau);
665  ~ZDCFitExpFermiLHCfPreExp() {}
666 
667  virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax) override;
668  virtual void SetT0FitLimits(float tMin, float tMax) override;
669 
670  virtual void SetInitialExpPulse(float amp) override
671  {
672  GetWrapperTF1()->SetParameter(4, std::max(amp, (float) 0.5)); //0.5 here ensures that we're above lower limit (0)
673  }
674 
675  virtual void ConstrainFit() override;
676  virtual void UnconstrainFit() override;
677 
678  virtual float GetAmplitude() const override {return GetWrapperTF1()->GetParameter(0); }
679  virtual float GetAmpError() const override {return GetWrapperTF1()->GetParError(0); }
680 
681  virtual float GetTau1() const override {return m_tau1;}
682  virtual float GetTau2() const override {return m_tau2;}
683 
684  virtual float GetTime() const override {
685  return GetWrapperTF1()->GetParameter(1) + m_timeCorr; // Correct the time to the maximum
686  }
687 
688  virtual float GetExpAmp() const override {return GetWrapperTF1()->GetParameter(4);}
689  virtual float GetExpTau() const override {return GetWrapperTF1()->GetParameter(5);}
690 
691  virtual float GetShapeParameter(size_t index) const override
692  {
693  if (index == 0) return m_tau1;
694  else if (index == 1) return m_tau2;
695  else if (index < 5) return GetWrapperTF1()->GetParameter(index);
696  else throw std::runtime_error("Fit parameter does not exist.");
697  }
698 
699  virtual float GetBkgdMaxFraction() const override
700  {
701  const TF1* theTF1 = ZDCFitWrapper::GetWrapperTF1();
702  double amp = theTF1->GetParameter(0);
703  if (amp <= 0) return 1;
704 
705  double maxTime = GetTime();
706 
707  double expAmp = theTF1->GetParameter(4);
708  double expTau = theTF1->GetParameter(5);
709  double bexpSqrt = theTF1->GetParameter(6);
710 
711  double tRef = GetTMinAdjust();
712  double expPre = expAmp * (std::exp(-maxTime/expTau - bexpSqrt*maxTime*maxTime) - std::exp(-tRef/expTau - bexpSqrt*tRef*tRef));
713 
714  return expPre / (amp + expPre);
715  }
716 
717  virtual double operator() (const double *x, const double *p) override
718  {
719  double t = x[0];
720 
721  double amp = p[0];
722  double t0 = p[1];
723 
724  double tau1 = p[2];
725  double tau2 = p[3];
726 
727  double expAmp = p[4];
728  double expTau = p[5];
729  double bexpSqrt = p[6];
730  double reflFrac = p[7];
731 
732  m_expFermiLHCfFunc->SetParameter(0, amp);
733  m_expFermiLHCfFunc->SetParameter(2, tau1);
734  m_expFermiLHCfFunc->SetParameter(3, tau2);
735  m_expFermiLHCfFunc->SetParameter(6, reflFrac);
736 
737  m_timeCorr = m_tau1 * std::log(m_tau2 / m_tau1 - 1.0);
738 
739  double deltaT = t - t0;
740  double pulse = m_expFermiLHCfFunc->operator()(deltaT);
741 
742  // We subtract off the value of the exponential pulse at the minimum time (nominally 0),
743  // because it would have been included in the baseline subtraction
744  //
745  double tRef = GetTMinAdjust();
746  double expPre = 0;
747 
748  expPre = expAmp * (std::exp(-t/expTau - bexpSqrt*t*t) - std::exp(-tRef/expTau - bexpSqrt*tRef*tRef));
749 
750  return pulse + expPre;
751  }
752 };
753 
754 // ----------------------------------------------------------------------
755 class ATLAS_NOT_THREAD_SAFE ZDCFitExpFermiLinearFixedTaus : public ZDCFitWrapper
756 {
757 private:
758  float m_tau1;
759  float m_tau2;
760 
761  float m_norm;
762  float m_timeCorr;
763 
764  std::shared_ptr<TF1> m_expFermiFunc;
765 
766 public:
767 
768  ZDCFitExpFermiLinearFixedTaus(const std::string& tag, float tmin, float tmax, float tau1, float tau2);
769 
770  ~ZDCFitExpFermiLinearFixedTaus() {}
771 
772  virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax) override;
773  virtual void SetT0FitLimits(float tMin, float tMax) override;
774 
775  virtual void ConstrainFit() override;
776  virtual void UnconstrainFit() override;
777 
778  virtual float GetAmplitude() const override {return GetWrapperTF1()->GetParameter(0); }
779  virtual float GetAmpError() const override {return GetWrapperTF1()->GetParError(0); }
780 
781  virtual float GetTau1() const override {return m_tau1;}
782  virtual float GetTau2() const override {return m_tau2;}
783 
784  virtual float GetTime() const override {
785  return GetWrapperTF1()->GetParameter(1) + m_timeCorr; // Correct the time to the maximum
786  }
787 
788  virtual float GetShapeParameter(size_t index) const override
789  {
790  if (index == 0) return m_tau1;
791  else if (index == 1) return m_tau2;
792  else throw std::runtime_error("Fit parameter does not exist.");
793  }
794 
795  virtual float GetBkgdMaxFraction() const override
796  {
797  const TF1* theTF1 = ZDCFitWrapper::GetWrapperTF1();
798  double amp = theTF1->GetParameter(0);
799  double slope = theTF1->GetParameter(2);
800 
801  double background = slope * GetTime();
802  return background / amp;
803  }
804 
805  virtual double operator() (const double *x, const double *p) override
806  {
807  double amp = p[0];
808  double t0 = p[1];
809  double deltaT = x[0] - t0;
810 
811  double bckgd = p[2] * x[0] + p[3];
812 
813  double expFermi = amp * m_norm * m_expFermiFunc->operator()(deltaT);
814 
815  return expFermi + bckgd;
816  }
817 };
818 
819 // ----------------------------------------------------------------------
820 class ATLAS_NOT_THREAD_SAFE ZDCFitExpFermiLinearPrePulse : public ZDCPrePulseFitWrapper
821 {
822 private:
823  float m_tau1;
824  float m_tau2;
825  float m_norm;
826  float m_timeCorr;
827  std::shared_ptr<TF1> m_expFermiFunc;
828 
829 public:
830  ZDCFitExpFermiLinearPrePulse(const std::string& tag, float tmin, float tmax, float tau1, float tau2);
831  ~ZDCFitExpFermiLinearPrePulse() {}
832 
833  virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax) override;
834  virtual void SetT0FitLimits(float tMin, float tMax) override;
835 
836  virtual void ConstrainFit() override;
837  virtual void UnconstrainFit() override;
838 
839  virtual void SetInitialPrePulse(float amp, float t0, float /*expamp = 0*/, bool /*fixPrePulseToZero = false*/) override {
840  GetWrapperTF1()->SetParameter(2, std::max(amp, (float) 1.5)); //1.5 here ensures that we're above lower limit
841  GetWrapperTF1()->SetParameter(3, t0);
842  }
843 
844  virtual void SetPrePulseT0Range(float tmin, float tmax) override;
845  virtual void SetPostPulseT0Range(float /*tmin*/, float /*tmax*/, float /*initialPostT0*/) override {return;}
846 
847  unsigned int GetPreT0ParIndex() const override {return 3;}
848 
849  virtual float GetAmplitude() const override {return GetWrapperTF1()->GetParameter(0); }
850  virtual float GetAmpError() const override {return GetWrapperTF1()->GetParError(0); }
851 
852  virtual float GetTau1() const override {return m_tau1;}
853  virtual float GetTau2() const override {return m_tau2;}
854 
855  virtual float GetPreT0() const override {
856  float fitPreT0 = GetWrapperTF1()->GetParameter(3);
857 
858  // Correct the time to the maximum
859  //
860  fitPreT0 += m_timeCorr;
861 
862  return fitPreT0;
863  }
864  virtual float GetPreAmp() const override {return GetWrapperTF1()->GetParameter(2);}
865 
866  virtual float GetPostT0() const override {return 0;}
867  virtual float GetPostAmp() const override {return 0;}
868 
869  virtual float GetExpAmp() const override {return 0;}
870 
871  virtual float GetTime() const override {
872  return GetWrapperTF1()->GetParameter(1) + m_timeCorr; // Correct the time to the maximum
873  }
874 
875  virtual float GetShapeParameter(size_t index) const override
876  {
877  if (index == 0) return m_tau1;
878  else if (index == 1) return m_tau2;
879  else if (index < 5) return GetWrapperTF1()->GetParameter(index);
880  else throw std::runtime_error("Fit parameter does not exist.");
881  }
882 
883  virtual float GetBkgdMaxFraction() const override
884  {
885  const TF1* theTF1 = ZDCFitWrapper::GetWrapperTF1();
886 
887  double maxTime = GetTime();
888 
889  double amp = theTF1->GetParameter(0);
890  double preAmp = theTF1->GetParameter(2);
891  double preT0 = theTF1->GetParameter(3);
892  double slope = theTF1->GetParameter(4);
893 
894  double deltaTPre = maxTime - preT0;
895 
896  double background = slope * maxTime + preAmp * m_norm * (m_expFermiFunc->operator()(deltaTPre) -
897  m_expFermiFunc->operator()(-preT0));
898 
899  return background / amp;
900  }
901 
902  virtual double operator() (const double *x, const double *p) override
903  {
904  double t = x[0];
905 
906  double amp = p[0];
907  double t0 = p[1];
908  double preAmp = p[2];
909  double preT0 = p[3];
910  double linSlope = p[4];
911 
912  double deltaT = t - t0;
913  double deltaTPre = t - preT0;
914 
915  // We subtract off the value of the pre-pulse at the minimum time (nominally 0,
916  // but can change if we exclude early samples) to account for the subtraction of the pre-sample
917  //
918  double deltaPresamp = GetTMinAdjust() - preT0;
919 
920  double pulse1 = amp * m_norm * m_expFermiFunc->operator()(deltaT);
921  double pulse2 = preAmp * m_norm * (m_expFermiFunc->operator()(deltaTPre) -
922  m_expFermiFunc->operator()(deltaPresamp));
923 
924  double bckgd = linSlope * (t - deltaPresamp) + p[5];
925 
926  return pulse1 + pulse2 + bckgd;
927  }
928 };
929 
930 
931 
932 // ----------------------------------------------------------------------
933 class ATLAS_NOT_THREAD_SAFE ZDCFitComplexPrePulse : public ZDCPrePulseFitWrapper
934 {
935 private:
936  float m_tau1;
937  float m_tau2;
938  float m_norm;
939  float m_timeCorr;
940  std::shared_ptr<TF1> m_expFermiFunc;
941 
942 public:
943  ZDCFitComplexPrePulse(const std::string& tag, float tmin, float tmax, float tau1, float tau2);
944  ~ZDCFitComplexPrePulse() {}
945 
946  virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax) override;
947  virtual void SetT0FitLimits(float tMin, float tMax) override;
948 
949  virtual void SetInitialPrePulse(float amp, float t0, float expamp, bool /*fixPrePulseToZero = false*/) override {
950  GetWrapperTF1()->SetParameter(2, std::max(amp, (float) 1.5)); //1.5 here ensures that we're above lower limit
951  GetWrapperTF1()->SetParameter(3, t0);
952  GetWrapperTF1()->SetParameter(6, std::max(std::abs(expamp), (float) 1.5));
953  }
954 
955  virtual void ConstrainFit() override;
956  virtual void UnconstrainFit() override;
957 
958  virtual void SetPrePulseT0Range(float tmin, float tmax) override;
959  virtual void SetPostPulseT0Range(float /*tmin*/, float /*tmax*/, float /*initialPostT0*/) override {return;}
960 
961  unsigned int GetPreT0ParIndex() const override {return 3;}
962 
963  virtual float GetAmplitude() const override {return GetWrapperTF1()->GetParameter(0); }
964  virtual float GetAmpError() const override {return GetWrapperTF1()->GetParError(0); }
965 
966  virtual float GetTau1() const override {return m_tau1;}
967  virtual float GetTau2() const override {return m_tau2;}
968 
969  virtual float GetPreT0() const override {
970  float fitPreT0 = GetWrapperTF1()->GetParameter(3);
971 
972  // Correct the time to the maximum
973  //
974  fitPreT0 += m_timeCorr;
975 
976  return fitPreT0;
977  }
978  virtual float GetPreAmp() const override {return GetWrapperTF1()->GetParameter(2);}
979 
980  virtual float GetPostT0() const override {return 0;}
981  virtual float GetPostAmp() const override {return 0;}
982 
983  virtual float GetExpAmp() const override {return GetWrapperTF1()->GetParameter(6);}
984 
985  virtual float GetTime() const override {
986  return GetWrapperTF1()->GetParameter(1) + m_timeCorr; // Correct the time to the maximum
987  }
988 
989  virtual float GetShapeParameter(size_t index) const override
990  {
991  if (index == 0) return m_tau1;
992  else if (index == 1) return m_tau2;
993  else if (index < 5) return GetWrapperTF1()->GetParameter(index);
994  else throw std::runtime_error("Fit parameter does not exist.");
995  }
996 
997  virtual float GetBkgdMaxFraction() const override
998  {
999  const TF1* theTF1 = ZDCFitWrapper::GetWrapperTF1();
1000 
1001  double maxTime = GetTime();
1002 
1003  double amp = theTF1->GetParameter(0);
1004  double preAmp = theTF1->GetParameter(2);
1005  double preT0 = theTF1->GetParameter(3);
1006  double slope = theTF1->GetParameter(4);
1007 
1008  double deltaTPre = maxTime - preT0;
1009 
1010  double background = slope * maxTime + preAmp * m_norm * (m_expFermiFunc->operator()(deltaTPre) -
1011  m_expFermiFunc->operator()(-preT0));
1012 
1013  return background / amp;
1014  }
1015 
1016  virtual double operator() (const double *x, const double *p) override
1017  {
1018  double t = x[0];
1019 
1020  double amp = p[0];
1021  double t0 = p[1];
1022  double preAmp = p[2];
1023  double preT0 = p[3];
1024  double linSlope = p[4];
1025  double linConst = p[5];
1026  double expamp = p[6];
1027 
1028  double deltaT = t - t0;
1029  double deltaTPre = t - preT0;
1030 
1031  // We subtract off the value of the pre-pulse at the minimum time (nominally 0,
1032  // but can change if we exclude early samples) to account for the subtraction of the pre-sample
1033  //
1034  double deltaPresamp = GetTMinAdjust() - preT0;
1035 
1036  double pulse1 = amp * m_norm * m_expFermiFunc->operator()(deltaT);
1037  double pulse2 = preAmp * m_norm * (m_expFermiFunc->operator()(deltaTPre) - m_expFermiFunc->operator()(deltaPresamp));
1038 
1039  double linBG = linSlope * (t - deltaPresamp) + linConst;
1040  double expBG = expamp * std::exp(-(t) / m_tau2) - expamp; // deltaPresamp
1041 
1042  return pulse1 + pulse2 + linBG + expBG;
1043  }
1044 };
1045 
1046 
1047 // ----------------------------------------------------------------------
1048 class ATLAS_NOT_THREAD_SAFE ZDCFitGeneralPulse : public ZDCPrePulseFitWrapper
1049 {
1050 private:
1051  float m_tau1;
1052  float m_tau2;
1053  float m_norm;
1054  float m_timeCorr;
1055  std::shared_ptr<TF1> m_expFermiFunc;
1056 
1057 public:
1058  ZDCFitGeneralPulse(const std::string& tag, float tmin, float tmax, float tau1, float tau2);
1059  ~ZDCFitGeneralPulse() {}
1060 
1061  virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax) override;
1062  virtual void SetT0FitLimits(float tMin, float tMax) override;
1063 
1064  virtual void SetInitialPrePulse(float amp, float t0, float expamp, bool fixPrePulseToZero) override {
1065  GetWrapperTF1()->ReleaseParameter(2);
1066  GetWrapperTF1()->ReleaseParameter(3);
1067  GetWrapperTF1()->SetParameter(2, std::max(amp, (float) 1.5)); //1.5 here ensures that we're above lower limit
1068  GetWrapperTF1()->SetParameter(3, std::max(t0, (float) 20.0));
1069  GetWrapperTF1()->SetParameter(6, std::max(std::abs(expamp), (float) 1.5));
1070 
1071  if (fixPrePulseToZero) {
1072  GetWrapperTF1()->FixParameter(2, 0. );
1073  GetWrapperTF1()->FixParameter(3, 20.);
1074  }
1075  }
1076 
1077  virtual void ConstrainFit() override;
1078  virtual void UnconstrainFit() override;
1079 
1080  virtual void SetPrePulseT0Range(float tmin, float tmax) override;
1081  virtual void SetPostPulseT0Range(float tmin, float tmax, float initialPostT0) override;
1082 
1083  unsigned int GetPreT0ParIndex() const override {return 3;}
1084 
1085  virtual float GetAmplitude() const override {return GetWrapperTF1()->GetParameter(0); }
1086  virtual float GetAmpError() const override {return GetWrapperTF1()->GetParError(0); }
1087 
1088  virtual float GetTau1() const override {return m_tau1;}
1089  virtual float GetTau2() const override {return m_tau2;}
1090 
1091  virtual float GetPreT0() const override {
1092  float fitPreT0 = GetWrapperTF1()->GetParameter(3);
1093 
1094  // Correct the time to the maximum
1095  //
1096  fitPreT0 += m_timeCorr;
1097 
1098  return fitPreT0;
1099  }
1100  virtual float GetPreAmp() const override {return GetWrapperTF1()->GetParameter(2);}
1101 
1102  virtual float GetPostT0() const override {
1103  float fitPostT0 = GetWrapperTF1()->GetParameter(8);
1104 
1105  // Correct the time to the maximum
1106  //
1107  fitPostT0 += m_timeCorr;
1108 
1109  return fitPostT0;
1110  }
1111  virtual float GetPostAmp() const override {return GetWrapperTF1()->GetParameter(7);}
1112 
1113  virtual float GetExpAmp() const override {return GetWrapperTF1()->GetParameter(6);}
1114 
1115  virtual float GetTime() const override {
1116  return GetWrapperTF1()->GetParameter(1) + m_timeCorr; // Correct the time to the maximum
1117  }
1118 
1119  virtual float GetShapeParameter(size_t index) const override
1120  {
1121  if (index == 0) return m_tau1;
1122  else if (index == 1) return m_tau2;
1123  else if (index < 5) return GetWrapperTF1()->GetParameter(index);
1124  else throw std::runtime_error("Fit parameter does not exist.");
1125  }
1126 
1127  virtual float GetBkgdMaxFraction() const override
1128  {
1129  const TF1* theTF1 = ZDCFitWrapper::GetWrapperTF1();
1130 
1131  double maxTime = GetTime();
1132 
1133  double amp = theTF1->GetParameter(0);
1134  double preAmp = theTF1->GetParameter(2);
1135  double preT0 = theTF1->GetParameter(3);
1136  double slope = theTF1->GetParameter(4);
1137 
1138  double deltaTPre = maxTime - preT0;
1139 
1140  double background = slope * maxTime + preAmp * m_norm * (m_expFermiFunc->operator()(deltaTPre) -
1141  m_expFermiFunc->operator()(-preT0));
1142 
1143  return background / amp;
1144  }
1145 
1146  virtual double operator() (const double *x, const double *p) override
1147  {
1148  double t = x[0];
1149 
1150  double amp = p[0];
1151  double t0 = p[1];
1152  double preAmp = p[2];
1153  double preT0 = p[3];
1154  double linSlope = p[4];
1155  double linConst = p[5];
1156  double expamp = p[6];
1157  double postAmp = p[7];
1158  double postT0 = p[8];
1159 
1160  double deltaT = t - t0;
1161  double deltaTPre = t - preT0;
1162  double deltaTPost = t - postT0;
1163 
1164  // We subtract off the value of the pre-pulse at the minimum time (nominally 0,
1165  // but can change if we exclude early samples) to account for the subtraction of the pre-sample
1166  //
1167  double deltaPresamp = GetTMinAdjust() - preT0;
1168 
1169  double pulse1 = amp * m_norm * m_expFermiFunc->operator()(deltaT);
1170  double pulse2 = preAmp * m_norm * (m_expFermiFunc->operator()(deltaTPre) - m_expFermiFunc->operator()(deltaPresamp));
1171  double pulse3 = postAmp * m_norm * m_expFermiFunc->operator()(deltaTPost);
1172 
1173  double linBG = linSlope * t + linConst;
1174  double expBG = expamp * std::exp(-(t) / m_tau2) - expamp * std::exp(-(GetTMinAdjust()) / m_tau2); // deltaPresamp
1175 
1176  return pulse1 + pulse2 + pulse3 + linBG + expBG;
1177  }
1178 };
1179 #endif
ZDCFitWrapper::ZDCFitWrapper
ZDCFitWrapper(const std::shared_ptr< TF1 > &wrapperTF1)
Definition: ZDCFitWrapper.h:43
ZDCFitWrapper::GetAmplitude
virtual float GetAmplitude() const =0
ZDCFitWrapper::GetTMinAdjust
float GetTMinAdjust() const
Definition: ZDCFitWrapper.h:102
ZDCFitExpFermiPreExp::GetAmpError
virtual float GetAmpError() const override
Definition: ZDCFitWrapper.h:589
ZDCFitExpFermiLinearPrePulse::m_tau2
float m_tau2
Definition: ZDCFitWrapper.h:824
ZDCFitExpFermiLinearPrePulse::GetTau1
virtual float GetTau1() const override
Definition: ZDCFitWrapper.h:852
ZDCFitWrapper::SetT0FitLimits
virtual void SetT0FitLimits(float tMin, float tMax)=0
ZDCFitExpFermiVariableTausLHCf
Definition: ZDCFitWrapper.h:231
ZDCFitGeneralPulse::GetTau1
virtual float GetTau1() const override
Definition: ZDCFitWrapper.h:1088
ZDCFitComplexPrePulse::GetPostT0
virtual float GetPostT0() const override
Definition: ZDCFitWrapper.h:980
ZDCFitExpFermiLinearPrePulse::SetPostPulseT0Range
virtual void SetPostPulseT0Range(float, float, float) override
Definition: ZDCFitWrapper.h:845
ZDCFitExpFermiPreExp::GetExpAmp
virtual float GetExpAmp() const override
Definition: ZDCFitWrapper.h:598
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
ZDCFitExpFermiLHCfPrePulse::GetShapeParameter
virtual float GetShapeParameter(size_t index) const override
Definition: ZDCFitWrapper.h:510
max
#define max(a, b)
Definition: cfImp.cxx:41
ZDCFitGeneralPulse::m_norm
float m_norm
Definition: ZDCFitWrapper.h:1053
ZDCFitWrapper::DoInitialize
virtual void DoInitialize(float initialAmp, float initialT0, float ampMin, float ampMax)=0
ZDCFitExpFermiVariableTaus::operator()
virtual double operator()(const double *x, const double *p) override
Definition: ZDCFitWrapper.h:216
ZDCFitExpFermiPrePulse::GetPreAmp
virtual float GetPreAmp() const override
Definition: ZDCFitWrapper.h:397
ZDCFitExpFermiPrePulse::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const override
Definition: ZDCFitWrapper.h:416
ZDCFitExpFermiPreExp::SetInitialExpPulse
virtual void SetInitialExpPulse(float amp) override
Definition: ZDCFitWrapper.h:580
ZDCPrePulseFitWrapper::GetPostAmp
virtual float GetPostAmp() const =0
ZDCPrePulseFitWrapper
Definition: ZDCFitWrapper.h:116
ZDCFitExpFermiPreExp::GetShapeParameter
virtual float GetShapeParameter(size_t index) const override
Definition: ZDCFitWrapper.h:601
ZDCFitExpFermiFixedTaus
Definition: ZDCFitWrapper.h:298
ZDCFitComplexPrePulse::m_timeCorr
float m_timeCorr
Definition: ZDCFitWrapper.h:939
ZDCFitExpFermiPrePulse::GetExpAmp
virtual float GetExpAmp() const override
Definition: ZDCFitWrapper.h:402
ZDCFitWrapper::GetShapeParameter
virtual float GetShapeParameter(size_t index) const =0
ZDCFitGeneralPulse::m_expFermiFunc
std::shared_ptr< TF1 > m_expFermiFunc
Definition: ZDCFitWrapper.h:1055
ZDCFitWrapper
Definition: ZDCFitWrapper.h:19
ZDCFitExpFermiPrePulse::SetInitialPrePulse
virtual void SetInitialPrePulse(float amp, float t0, float, bool) override
Definition: ZDCFitWrapper.h:377
ATLAS_NOT_THREAD_SAFE
#define ATLAS_NOT_THREAD_SAFE
getNoisyStrip() Find noisy strips from hitmaps and write out into xml/db formats
Definition: checker_macros.h:212
ZDCPreExpFitWrapper::getDefaultExpTau
float getDefaultExpTau() const
Definition: ZDCFitWrapper.h:157
ZDCFitExpFermiPrePulse::GetPostT0
virtual float GetPostT0() const override
Definition: ZDCFitWrapper.h:399
ZDCPrePulseFitWrapper::GetExpAmp
virtual float GetExpAmp() const =0
ZDCFitExpFermiLinearPrePulse::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const override
Definition: ZDCFitWrapper.h:883
ZDCPrePulseFitWrapper::SetInitialPrePulse
virtual void SetInitialPrePulse(float amp, float t0, float expamp, bool fixPrePulseToZero)=0
ZDCFitExpFermiPreExp::GetTime
virtual float GetTime() const override
Definition: ZDCFitWrapper.h:594
index
Definition: index.py:1
ZDCFitComplexPrePulse::GetPreAmp
virtual float GetPreAmp() const override
Definition: ZDCFitWrapper.h:978
ZDCFitExpFermiFixedTaus::GetAmpError
virtual float GetAmpError() const override
Definition: ZDCFitWrapper.h:321
ZDCFitExpFermiLinearFixedTaus::~ZDCFitExpFermiLinearFixedTaus
~ZDCFitExpFermiLinearFixedTaus()
Definition: ZDCFitWrapper.h:770
ZDCFitComplexPrePulse::GetPreT0ParIndex
unsigned int GetPreT0ParIndex() const override
Definition: ZDCFitWrapper.h:961
ZDCFitWrapper::ConstrainFit
virtual void ConstrainFit()=0
ZDCFitExpFermiVariableTaus::GetTime
virtual float GetTime() const override
Definition: ZDCFitWrapper.h:185
ZDCFitWrapper::GetTime
virtual float GetTime() const =0
ZDCFitExpFermiVariableTausLHCf::GetTau2
virtual float GetTau2() const override
Definition: ZDCFitWrapper.h:250
ZDCPrePulseFitWrapper::m_preT0Max
float m_preT0Max
Definition: ZDCFitWrapper.h:119
ZDCFitExpFermiLinearFixedTaus::m_timeCorr
float m_timeCorr
Definition: ZDCFitWrapper.h:762
ZDCFitExpFermiVariableTausLHCf::GetTime
virtual float GetTime() const override
Definition: ZDCFitWrapper.h:252
ZDCFitGeneralPulse::m_tau1
float m_tau1
Definition: ZDCFitWrapper.h:1051
ZDCFitExpFermiLinearPrePulse::GetPreT0ParIndex
unsigned int GetPreT0ParIndex() const override
Definition: ZDCFitWrapper.h:847
DMTest::C
C_v1 C
Definition: C.h:26
ZDCPreExpFitWrapper::fixExpTau
bool fixExpTau() const
Definition: ZDCFitWrapper.h:156
ALFA_EventTPCnv_Dict::t0
std::vector< ALFA_RawData_p1 > t0
Definition: ALFA_EventTPCnvDict.h:42
ZDCFitGeneralPulse::GetExpAmp
virtual float GetExpAmp() const override
Definition: ZDCFitWrapper.h:1113
ZDCFitExpFermiVariableTaus::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const override
Definition: ZDCFitWrapper.h:206
ZDCFitComplexPrePulse::GetShapeParameter
virtual float GetShapeParameter(size_t index) const override
Definition: ZDCFitWrapper.h:989
ZDCFitExpFermiLinearPrePulse
Definition: ZDCFitWrapper.h:821
ZDCFitExpFermiLinearPrePulse::m_norm
float m_norm
Definition: ZDCFitWrapper.h:825
ZDCFitGeneralPulse::SetInitialPrePulse
virtual void SetInitialPrePulse(float amp, float t0, float expamp, bool fixPrePulseToZero) override
Definition: ZDCFitWrapper.h:1064
ZDCFitExpFermiLHCfPreExp::GetShapeParameter
virtual float GetShapeParameter(size_t index) const override
Definition: ZDCFitWrapper.h:691
ZDCPreExpFitWrapper
Definition: ZDCFitWrapper.h:144
ZDCFitGeneralPulse::GetPostAmp
virtual float GetPostAmp() const override
Definition: ZDCFitWrapper.h:1111
ZDCFitExpFermiLHCfPrePulse::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const override
Definition: ZDCFitWrapper.h:518
ZDCFitExpFermiLHCfPreExp::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const override
Definition: ZDCFitWrapper.h:699
ZDCFitWrapper::~ZDCFitWrapper
virtual ~ZDCFitWrapper()
Definition: ZDCFitWrapper.h:54
ZDCFitGeneralPulse::GetAmplitude
virtual float GetAmplitude() const override
Definition: ZDCFitWrapper.h:1085
ZDCFitGeneralPulse::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const override
Definition: ZDCFitWrapper.h:1127
ZDCFitWrapper::GetWrapperTF1
virtual std::shared_ptr< TF1 > GetWrapperTF1()
Definition: ZDCFitWrapper.h:110
ZDCFitComplexPrePulse::~ZDCFitComplexPrePulse
~ZDCFitComplexPrePulse()
Definition: ZDCFitWrapper.h:944
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ZDCFitExpFermiLinearFixedTaus::m_tau2
float m_tau2
Definition: ZDCFitWrapper.h:759
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
ZDCFitExpFermiLinearPrePulse::GetShapeParameter
virtual float GetShapeParameter(size_t index) const override
Definition: ZDCFitWrapper.h:875
ZDCFitGeneralPulse::GetPreT0ParIndex
unsigned int GetPreT0ParIndex() const override
Definition: ZDCFitWrapper.h:1083
ZDCFitComplexPrePulse::GetPreT0
virtual float GetPreT0() const override
Definition: ZDCFitWrapper.h:969
x
#define x
ZDCFitExpFermiPrePulse::GetTime
virtual float GetTime() const override
Definition: ZDCFitWrapper.h:404
ZDCFitExpFermiLHCfPrePulse::GetPreAmp
virtual float GetPreAmp() const override
Definition: ZDCFitWrapper.h:499
ZDCFitExpFermiLHCfPreExp
Definition: ZDCFitWrapper.h:653
ZDCFitExpFermiLHCfPrePulse::GetTau1
virtual float GetTau1() const override
Definition: ZDCFitWrapper.h:495
ZDCFitExpFermiLHCfPreExp::GetTime
virtual float GetTime() const override
Definition: ZDCFitWrapper.h:684
ZDCFitWrapper::GetTau2
virtual float GetTau2() const =0
ZDCFitExpFermiVariableTausLHCf::GetAmplitude
virtual float GetAmplitude() const override
Definition: ZDCFitWrapper.h:246
ZDCPreExpFitWrapper::GetExpTau
virtual float GetExpTau() const =0
ZDCFitExpFermiLinearPrePulse::m_expFermiFunc
std::shared_ptr< TF1 > m_expFermiFunc
Definition: ZDCFitWrapper.h:827
ZDCFitExpFermiVariableTaus::GetShapeParameter
virtual float GetShapeParameter(size_t index) const override
Definition: ZDCFitWrapper.h:199
ZDCPrePulseFitWrapper::GetPreT0
virtual float GetPreT0() const =0
ZDCPreExpFitWrapper::ZDCPreExpFitWrapper
ZDCPreExpFitWrapper(std::shared_ptr< TF1 > wrapperTF1, float defaultExpTau, bool fixTau)
Definition: ZDCFitWrapper.h:150
ZDCFitExpFermiFixedTaus::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const override
Definition: ZDCFitWrapper.h:337
ZDCFitExpFermiLinearPrePulse::GetPreAmp
virtual float GetPreAmp() const override
Definition: ZDCFitWrapper.h:864
ZDCFitExpFermiPrePulse::GetAmplitude
virtual float GetAmplitude() const override
Definition: ZDCFitWrapper.h:390
ZDCFitGeneralPulse::GetPreAmp
virtual float GetPreAmp() const override
Definition: ZDCFitWrapper.h:1100
ZDCFitExpFermiLinearPrePulse::GetTau2
virtual float GetTau2() const override
Definition: ZDCFitWrapper.h:853
ZDCFitExpFermiLinearPrePulse::~ZDCFitExpFermiLinearPrePulse
~ZDCFitExpFermiLinearPrePulse()
Definition: ZDCFitWrapper.h:831
ZDCFitExpFermiPrePulse::GetTau2
virtual float GetTau2() const override
Definition: ZDCFitWrapper.h:394
ZDCFitExpFermiFixedTaus::GetTau1
virtual float GetTau1() const override
Definition: ZDCFitWrapper.h:323
ZDCFitExpFermiLHCfPreExp::GetExpAmp
virtual float GetExpAmp() const override
Definition: ZDCFitWrapper.h:688
ZDCFitExpFermiLinearPrePulse::SetInitialPrePulse
virtual void SetInitialPrePulse(float amp, float t0, float, bool) override
Definition: ZDCFitWrapper.h:839
ZDCFitExpFermiVariableTausLHCf::GetTau1
virtual float GetTau1() const override
Definition: ZDCFitWrapper.h:249
ZDCFitExpFermiVariableTaus::GetTau1
virtual float GetTau1() const override
Definition: ZDCFitWrapper.h:182
ZDCFitExpFermiLHCfPrePulse::~ZDCFitExpFermiLHCfPrePulse
~ZDCFitExpFermiLHCfPrePulse()
Definition: ZDCFitWrapper.h:473
ZDCFitExpFermiLHCfPrePulse::GetPreT0
virtual float GetPreT0() const override
Definition: ZDCFitWrapper.h:498
ZDCFitComplexPrePulse::GetTau2
virtual float GetTau2() const override
Definition: ZDCFitWrapper.h:967
ZDCFitGeneralPulse::GetShapeParameter
virtual float GetShapeParameter(size_t index) const override
Definition: ZDCFitWrapper.h:1119
ZDCFitGeneralPulse::GetTime
virtual float GetTime() const override
Definition: ZDCFitWrapper.h:1115
ZDCFitWrapper::UnconstrainFit
virtual void UnconstrainFit()=0
ZDCFitWrapper::GetAmpError
virtual float GetAmpError() const =0
ZDCFitExpFermiPrePulse::GetTau1
virtual float GetTau1() const override
Definition: ZDCFitWrapper.h:393
ZDCFitWrapper::SetT0Range
void SetT0Range(float t0Min, float t0Max)
Definition: ZDCFitWrapper.h:69
ZDCFitWrapper::GetMinAmp
float GetMinAmp() const
Definition: ZDCFitWrapper.h:86
ZDCFermiExpFitRefl
double ZDCFermiExpFitRefl(const double *xvec, const double *pvec)
Definition: ZDCFitWrapper.cxx:689
ZDCFitExpFermiVariableTausLHCf::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const override
Definition: ZDCFitWrapper.h:273
ZDCFitWrapper::GetWrapperTF1RawPtr
virtual TF1 * GetWrapperTF1RawPtr() const
Definition: ZDCFitWrapper.h:112
ZDCFitExpFermiLinearFixedTaus::GetTime
virtual float GetTime() const override
Definition: ZDCFitWrapper.h:784
ZDCFitExpFermiLHCfPreExp::GetTau1
virtual float GetTau1() const override
Definition: ZDCFitWrapper.h:681
ZDCFitGeneralPulse::m_timeCorr
float m_timeCorr
Definition: ZDCFitWrapper.h:1054
ZDCFitComplexPrePulse::m_tau1
float m_tau1
Definition: ZDCFitWrapper.h:936
ZDCFitGeneralPulse::GetPostT0
virtual float GetPostT0() const override
Definition: ZDCFitWrapper.h:1102
ZDCFitExpFermiLHCfPreExp::~ZDCFitExpFermiLHCfPreExp
~ZDCFitExpFermiLHCfPreExp()
Definition: ZDCFitWrapper.h:665
ZDCFitWrapper::GetT0Max
float GetT0Max() const
Definition: ZDCFitWrapper.h:97
ZDCPreExpFitWrapper::GetExpAmp
virtual float GetExpAmp() const =0
ZDCFitWrapper::GetMaxAmp
float GetMaxAmp() const
Definition: ZDCFitWrapper.h:87
ZDCFitWrapper::GetTMin
float GetTMin() const
Definition: ZDCFitWrapper.h:89
ZDCFitExpFermiVariableTaus::GetTau2
virtual float GetTau2() const override
Definition: ZDCFitWrapper.h:183
ZDCFitExpFermiPrePulse::GetShapeParameter
virtual float GetShapeParameter(size_t index) const override
Definition: ZDCFitWrapper.h:408
ZDCFitGeneralPulse::~ZDCFitGeneralPulse
~ZDCFitGeneralPulse()
Definition: ZDCFitWrapper.h:1059
ZDCFitExpFermiLHCfPreExp::GetAmpError
virtual float GetAmpError() const override
Definition: ZDCFitWrapper.h:679
ZDCFitExpFermiLinearPrePulse::GetTime
virtual float GetTime() const override
Definition: ZDCFitWrapper.h:871
ZDCPreExpFitWrapper::SetInitialExpPulse
virtual void SetInitialExpPulse(float expamp)=0
ZDCFitExpFermiPrePulse::GetPreT0
virtual float GetPreT0() const override
Definition: ZDCFitWrapper.h:396
ZDCFitExpFermiVariableTausLHCf::GetShapeParameter
virtual float GetShapeParameter(size_t index) const override
Definition: ZDCFitWrapper.h:266
ZDCFitExpFermiVariableTausLHCf::GetAmpError
virtual float GetAmpError() const override
Definition: ZDCFitWrapper.h:247
ZDCFitWrapper::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const =0
ZDCFitExpFermiLHCfPreExp::GetAmplitude
virtual float GetAmplitude() const override
Definition: ZDCFitWrapper.h:678
dumpNswErrorDb.constant
def constant
Definition: dumpNswErrorDb.py:22
ZDCFitExpFermiLinearFixedTaus::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const override
Definition: ZDCFitWrapper.h:795
ZDCFitExpFermiPrePulse
Definition: ZDCFitWrapper.h:361
ZDCFitExpFermiLHCfPrePulse::GetTau2
virtual float GetTau2() const override
Definition: ZDCFitWrapper.h:496
ZDCFitExpFermiVariableTaus
Definition: ZDCFitWrapper.h:164
ZDCFitExpFermiFixedTaus::GetTau2
virtual float GetTau2() const override
Definition: ZDCFitWrapper.h:324
ZDCFitExpFermiLHCfPreExp::GetExpTau
virtual float GetExpTau() const override
Definition: ZDCFitWrapper.h:689
ZDCFitComplexPrePulse::SetPostPulseT0Range
virtual void SetPostPulseT0Range(float, float, float) override
Definition: ZDCFitWrapper.h:959
ZDCFitComplexPrePulse::GetAmpError
virtual float GetAmpError() const override
Definition: ZDCFitWrapper.h:964
ZDCFitExpFermiLHCfPrePulse::GetPostAmp
virtual float GetPostAmp() const override
Definition: ZDCFitWrapper.h:502
ZDCFitExpFermiPreExp::~ZDCFitExpFermiPreExp
~ZDCFitExpFermiPreExp()
Definition: ZDCFitWrapper.h:575
ZDCFitComplexPrePulse::GetExpAmp
virtual float GetExpAmp() const override
Definition: ZDCFitWrapper.h:983
ZDCFitExpFermiLinearFixedTaus::m_norm
float m_norm
Definition: ZDCFitWrapper.h:761
ZDCFitExpFermiFixedTaus::GetShapeParameter
virtual float GetShapeParameter(size_t index) const override
Definition: ZDCFitWrapper.h:330
ZDCFitExpFermiPreExp::GetAmplitude
virtual float GetAmplitude() const override
Definition: ZDCFitWrapper.h:588
ZDCFitExpFermiLHCfPrePulse::GetAmplitude
virtual float GetAmplitude() const override
Definition: ZDCFitWrapper.h:492
ZDCFitExpFermiLHCfPrePulse::GetAmpError
virtual float GetAmpError() const override
Definition: ZDCFitWrapper.h:493
ZDCFitExpFermiLinearPrePulse::GetPostAmp
virtual float GetPostAmp() const override
Definition: ZDCFitWrapper.h:867
ZDCFitComplexPrePulse::GetPostAmp
virtual float GetPostAmp() const override
Definition: ZDCFitWrapper.h:981
ZDCFitExpFermiLinearPrePulse::GetPreT0
virtual float GetPreT0() const override
Definition: ZDCFitWrapper.h:855
ZDCFitWrapper::GetTau1
virtual float GetTau1() const =0
ZDCFitComplexPrePulse::GetTime
virtual float GetTime() const override
Definition: ZDCFitWrapper.h:985
ZDCFitExpFermiFixedTaus::GetAmplitude
virtual float GetAmplitude() const override
Definition: ZDCFitWrapper.h:320
ZDCFitExpFermiPreExp::GetExpTau
virtual float GetExpTau() const override
Definition: ZDCFitWrapper.h:599
ZDCPrePulseFitWrapper::GetPreT0ParIndex
virtual unsigned int GetPreT0ParIndex() const =0
ZDCFitComplexPrePulse::m_expFermiFunc
std::shared_ptr< TF1 > m_expFermiFunc
Definition: ZDCFitWrapper.h:940
jobOptions.Initialize
Initialize
Definition: jobOptions.pA.py:28
ZDCFitExpFermiLHCfPreExp::GetTau2
virtual float GetTau2() const override
Definition: ZDCFitWrapper.h:682
ZDCFitExpFermiLinearPrePulse::GetAmpError
virtual float GetAmpError() const override
Definition: ZDCFitWrapper.h:850
ZDCFitWrapper::GetT0Min
float GetT0Min() const
Definition: ZDCFitWrapper.h:92
ZDCFitComplexPrePulse
Definition: ZDCFitWrapper.h:934
ZDCFitExpFermiLinearPrePulse::m_timeCorr
float m_timeCorr
Definition: ZDCFitWrapper.h:826
ZDCFitComplexPrePulse::m_tau2
float m_tau2
Definition: ZDCFitWrapper.h:937
ZDCFitExpFermiLinearFixedTaus::GetShapeParameter
virtual float GetShapeParameter(size_t index) const override
Definition: ZDCFitWrapper.h:788
ZDCFitExpFermiLHCfPrePulse::SetInitialPrePulse
virtual void SetInitialPrePulse(float amp, float t0, float, bool) override
Definition: ZDCFitWrapper.h:479
ZDCFitExpFermiLHCfPrePulse::GetExpAmp
virtual float GetExpAmp() const override
Definition: ZDCFitWrapper.h:504
ZDCFitGeneralPulse::GetAmpError
virtual float GetAmpError() const override
Definition: ZDCFitWrapper.h:1086
ZDCFitExpFermiPreExp::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const override
Definition: ZDCFitWrapper.h:609
ZDCFitExpFermiLinearFixedTaus::GetAmpError
virtual float GetAmpError() const override
Definition: ZDCFitWrapper.h:779
ZDCFitExpFermiVariableTaus::GetAmplitude
virtual float GetAmplitude() const override
Definition: ZDCFitWrapper.h:179
ZDCFitExpFermiLinearPrePulse::GetExpAmp
virtual float GetExpAmp() const override
Definition: ZDCFitWrapper.h:869
ZDCFitWrapper::SetAmpMinMax
void SetAmpMinMax(float minAmp, float maxAmp)
Definition: ZDCFitWrapper.h:63
ZDCFitExpFermiLinearFixedTaus::GetTau1
virtual float GetTau1() const override
Definition: ZDCFitWrapper.h:781
ZDCFitExpFermiVariableTausRun3
Definition: ZDCFitWrapper.h:292
ZDCFitExpFermiPreExp::GetTau2
virtual float GetTau2() const override
Definition: ZDCFitWrapper.h:592
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
ZDCFitComplexPrePulse::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const override
Definition: ZDCFitWrapper.h:997
ZDCFitExpFermiLinearFixedTaus::m_tau1
float m_tau1
Definition: ZDCFitWrapper.h:758
ZDCFitGeneralPulse::m_tau2
float m_tau2
Definition: ZDCFitWrapper.h:1052
ZDCFitComplexPrePulse::m_norm
float m_norm
Definition: ZDCFitWrapper.h:938
ZDCFitExpFermiLinearPrePulse::m_tau1
float m_tau1
Definition: ZDCFitWrapper.h:823
ZDCFitExpFermiLinearPrePulse::GetAmplitude
virtual float GetAmplitude() const override
Definition: ZDCFitWrapper.h:849
ZDCFitExpFermiFixedTaus::GetTime
virtual float GetTime() const override
Definition: ZDCFitWrapper.h:326
ZDCPrePulseFitWrapper::GetPostT0
virtual float GetPostT0() const =0
ZDCPreExpFitWrapper::m_fixTau
bool m_fixTau
Definition: ZDCFitWrapper.h:147
ZDCPrePulseFitWrapper::SetPrePulseT0Range
virtual void SetPrePulseT0Range(float tmin, float tmax)=0
ZDCFitComplexPrePulse::GetAmplitude
virtual float GetAmplitude() const override
Definition: ZDCFitWrapper.h:963
ZDCPrePulseFitWrapper::ZDCPrePulseFitWrapper
ZDCPrePulseFitWrapper(std::shared_ptr< TF1 > wrapperTF1)
Definition: ZDCFitWrapper.h:121
ZDCFitWrapper::GetTMax
float GetTMax() const
Definition: ZDCFitWrapper.h:90
ZDCPrePulseFitWrapper::SetPostPulseT0Range
virtual void SetPostPulseT0Range(float tmin, float tmax, float initialPostT0)=0
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
ZDCFitExpFermiVariableTaus::GetAmpError
virtual float GetAmpError() const override
Definition: ZDCFitWrapper.h:180
ZDCFitExpFermiPrePulse::GetAmpError
virtual float GetAmpError() const override
Definition: ZDCFitWrapper.h:391
ZDCFitExpFermiPreExp::GetTau1
virtual float GetTau1() const override
Definition: ZDCFitWrapper.h:591
ZDCFitExpFermiLinearFixedTaus::m_expFermiFunc
std::shared_ptr< TF1 > m_expFermiFunc
Definition: ZDCFitWrapper.h:764
ZDCFitExpFermiPrePulse::GetPreT0ParIndex
virtual unsigned int GetPreT0ParIndex() const override
Definition: ZDCFitWrapper.h:388
ZDCFitGeneralPulse::GetPreT0
virtual float GetPreT0() const override
Definition: ZDCFitWrapper.h:1091
ZDCFitWrapper::GetWrapperTF1
virtual const TF1 * GetWrapperTF1() const
Definition: ZDCFitWrapper.h:111
pvec
std::array< fp_t, 2 > pvec
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:9
ZDCFitWrapper::operator()
virtual double operator()(const double *x, const double *p)=0
ZDCFitComplexPrePulse::SetInitialPrePulse
virtual void SetInitialPrePulse(float amp, float t0, float expamp, bool) override
Definition: ZDCFitWrapper.h:949
ZDCPrePulseFitWrapper::m_preT0Min
float m_preT0Min
Definition: ZDCFitWrapper.h:118
ZDCFitComplexPrePulse::GetTau1
virtual float GetTau1() const override
Definition: ZDCFitWrapper.h:966
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:24
ZDCFitExpFermiLinearFixedTaus::GetAmplitude
virtual float GetAmplitude() const override
Definition: ZDCFitWrapper.h:778
ZDCFitGeneralPulse::GetTau2
virtual float GetTau2() const override
Definition: ZDCFitWrapper.h:1089
ZDCFitExpFermiVariableTausLHCf::operator()
virtual double operator()(const double *x, const double *p) override
Definition: ZDCFitWrapper.h:283
checker_macros.h
Define macros for attributes used to control the static checker.
ZDCFitExpFermiPrePulse::~ZDCFitExpFermiPrePulse
~ZDCFitExpFermiPrePulse()
Definition: ZDCFitWrapper.h:371
ZDCPrePulseFitWrapper::GetPreAmp
virtual float GetPreAmp() const =0
ZDCPreExpFitWrapper::m_defaultTau
float m_defaultTau
Definition: ZDCFitWrapper.h:146
ZDCFitExpFermiPrePulse::GetPostAmp
virtual float GetPostAmp() const override
Definition: ZDCFitWrapper.h:400
ZDCFitExpFermiLHCfPrePulse::GetTime
virtual float GetTime() const override
Definition: ZDCFitWrapper.h:506
ZDCFitExpFermiPrePulse::SetPostPulseT0Range
virtual void SetPostPulseT0Range(float, float, float) override
Definition: ZDCFitWrapper.h:383
ZDCFitExpFermiLHCfPrePulse
Definition: ZDCFitWrapper.h:463
ZDCFitExpFermiLinearFixedTaus::GetTau2
virtual float GetTau2() const override
Definition: ZDCFitWrapper.h:782
ZDCFitExpFermiFixedTaus::~ZDCFitExpFermiFixedTaus
~ZDCFitExpFermiFixedTaus()
Definition: ZDCFitWrapper.h:312
ZDCFitExpFermiPreExp
Definition: ZDCFitWrapper.h:563
ZDCFitExpFermiLinearPrePulse::GetPostT0
virtual float GetPostT0() const override
Definition: ZDCFitWrapper.h:866
ZDCFitExpFermiLHCfPrePulse::SetPostPulseT0Range
virtual void SetPostPulseT0Range(float, float, float) override
Definition: ZDCFitWrapper.h:485
ZDCFitExpFermiLinearFixedTaus
Definition: ZDCFitWrapper.h:756
ZDCFitExpFermiLHCfPreExp::SetInitialExpPulse
virtual void SetInitialExpPulse(float amp) override
Definition: ZDCFitWrapper.h:670
ZDCFitGeneralPulse
Definition: ZDCFitWrapper.h:1049
ZDCFermiExpFit
double ZDCFermiExpFit(const double *xvec, const double *pvec)
Definition: ZDCFitWrapper.cxx:662
ZDCFitExpFermiLHCfPrePulse::GetPreT0ParIndex
virtual unsigned int GetPreT0ParIndex() const override
Definition: ZDCFitWrapper.h:490
ZDCFitExpFermiLHCfPrePulse::GetPostT0
virtual float GetPostT0() const override
Definition: ZDCFitWrapper.h:501
Generated on Tue Jul 2 2024 21:33:12 for ATLAS Offline Software by   doxygen 1.8.18