laura is hosted by Hepforge, IPPP Durham
Laura++  v1r0
A maximum likelihood fitting package for performing Dalitz-plot analysis.
LauDabbaRes.cc
Go to the documentation of this file.
1 
2 // Copyright University of Warwick 2010 - 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 //****************************************************************************
16 // Class for defining the Dabba resonance model
17 //****************************************************************************
18 
19 // --CLASS DESCRIPTION [MODEL] --
20 // Class for defining the Dabba resonance model
21 // Formulae and data values from arXiv:0901.2217 - author D.V.Bugg
22 
23 #include <iostream>
24 
25 #include "LauConstants.hh"
26 #include "LauDabbaRes.hh"
27 
28 ClassImp(LauDabbaRes)
29 
30 
31 LauDabbaRes::LauDabbaRes(TString resName, Double_t resMass, Double_t resWidth, Int_t resSpin,
32  Int_t resCharge, Int_t resPairAmpInt, const LauDaughters* daughters) :
33  LauAbsResonance(resName, resMass, resWidth, resSpin, resCharge, resPairAmpInt, daughters),
34  mSumSq_(0.0),
35  sAdler_(0.0),
36  b_(24.49),
37  alpha_(0.1),
38  beta_(0.1)
39 {
40 }
41 
43 {
44 }
45 
47 {
48  // check that we have a D and a pi
49  this->checkDaughterTypes();
50 
51  // Initialise various constants
52  Double_t massDaug1 = this->getMassDaug1();
53  Double_t massDaug2 = this->getMassDaug2();
54 
55  Double_t mSum = massDaug1 + massDaug2;
56  mSumSq_ = mSum*mSum;
57 
58  Double_t massDaug1Sq = massDaug1*massDaug1;
59  Double_t massDaug2Sq = massDaug2*massDaug2;
60  sAdler_ = TMath::Max(massDaug1Sq,massDaug2Sq) - 0.5*TMath::Min(massDaug1Sq,massDaug2Sq); // Adler zero at (mD)^2 - 0.5*(mpi)^2
61 
62  Int_t resSpin = this->getSpin();
63  if (resSpin != 0) {
64  std::cerr << "WARNING in LauDabbaRes::initialise : Spin = " << resSpin << " is not zero! It will be ignored anyway!" << std::endl;
65  }
66 }
67 
68 void LauDabbaRes::setConstants(Double_t b, Double_t alpha, Double_t beta) {
69  b_ = b;
70  alpha_ = alpha;
71  beta_ = beta;
72 }
73 
75 {
76  // Check that the daughter tracks are D and pi. Otherwise issue a warning.
77  Int_t resPairAmpInt = this->getPairInt();
78  if (resPairAmpInt < 1 || resPairAmpInt > 3) {
79  std::cerr << "WARNING in LauDabbaRes::checkDaughterTypes : resPairAmpInt = " << resPairAmpInt << " is out of the range [1,2,3]." << std::endl;
80  return;
81  }
82 
83  // Check that daughter types agree
84  const TString& nameDaug1 = this->getNameDaug1();
85  const TString& nameDaug2 = this->getNameDaug2();
86  if ( !( nameDaug1.Contains("pi", TString::kIgnoreCase) && nameDaug2.Contains("d", TString::kIgnoreCase) ) ) {
87  if ( !( nameDaug2.Contains("pi", TString::kIgnoreCase) && nameDaug1.Contains("d", TString::kIgnoreCase) ) ) {
88  std::cerr << "ERROR in LauDabbaRes::checkDaughterTypes : Dabba model is using daughters \"" << nameDaug1 << "\" and \"" << nameDaug2 << "\" that are not a D meson and a pion." << std::endl;
89  }
90  }
91 }
92 
93 LauComplex LauDabbaRes::resAmp(Double_t mass, Double_t spinTerm)
94 {
95  // This function returns the complex dynamical amplitude for a Dabba distribution
96  // given the invariant mass and cos(helicity) values.
97 
98  // Invariant mass squared combination for the system
99  Double_t s = mass*mass;
100 
101  // Dabba is spin zero - so there are no helicity factors.
102  // Just set it to 1.0 in case anyone decides to use it at a later date.
103  spinTerm = 1.0;
104 
105  // Phase-space factor
106  Double_t rho(0.0);
107  Double_t sDiff = s - mSumSq_;
108  if ( sDiff > 0.0 ) {
109  rho = TMath::Sqrt(1.0 - mSumSq_/s);
110  }
111 
112  Double_t realPart = 1.0 - beta_ * sDiff;
113 
114  Double_t imagPart = b_ * TMath::Exp( - alpha_ * sDiff ) * ( s - sAdler_ ) * rho;
115 
116  LauComplex resAmplitude( realPart, imagPart );
117 
118  Double_t denomFactor = realPart*realPart + imagPart*imagPart;
119 
120  Double_t invDenomFactor = 0.0;
121  if (denomFactor > 1e-10) {invDenomFactor = 1.0/denomFactor;}
122 
123  resAmplitude.rescale(spinTerm*invDenomFactor);
124 
125  return resAmplitude;
126 }
127 
Double_t alpha_
Constant factor.
Definition: LauDabbaRes.hh:87
Class that defines the particular 3-body decay under study.
Definition: LauDaughters.hh:33
Double_t beta_
Constant factor.
Definition: LauDabbaRes.hh:89
TString getNameDaug2() const
Get the name of the second daughter of the resonance.
virtual LauComplex resAmp(Double_t mass, Double_t spinTerm)
Complex resonant amplitude.
Definition: LauDabbaRes.cc:93
Double_t mSumSq_
Defined as mD + mPi all squared.
Definition: LauDabbaRes.hh:81
Double_t getMassDaug1() const
Get the mass of daughter 1.
Int_t getPairInt() const
Get the integer to identify which DP axis the resonance belongs to.
Double_t getMassDaug2() const
Get the mass of daughter 2.
virtual void initialise()
Initialise the model.
Definition: LauDabbaRes.cc:46
File containing declaration of LauDabbaRes class.
const Double_t beta
Angle beta of the unitarity triangle.
Definition: LauConstants.hh:84
virtual ~LauDabbaRes()
Destructor.
Definition: LauDabbaRes.cc:42
Abstract class for defining type for resonance amplitude models (Breit-Wigner, Flatte etc...
Class for defining the Dabba resonance model.
Definition: LauDabbaRes.hh:31
void checkDaughterTypes() const
Check that the daughter particles are D and pi.
Definition: LauDabbaRes.cc:74
File containing LauConstants namespace.
Double_t sAdler_
Defined as mD*mD - 0.5*mPi*mPi.
Definition: LauDabbaRes.hh:83
Class for defining a complex number.
Definition: LauComplex.hh:47
TString getNameDaug1() const
Get the name of the first daughter of the resonance.
Double_t b_
Constant factor.
Definition: LauDabbaRes.hh:85
Int_t getSpin() const
Get the spin of the resonance.
void setConstants(Double_t b, Double_t alpha, Double_t beta)
Set the parameter values.
Definition: LauDabbaRes.cc:68