laura is hosted by Hepforge, IPPP Durham
Laura++  3.6.0
A maximum likelihood fitting package for performing Dalitz-plot analysis.
LauDatabasePDG.cc
Go to the documentation of this file.
1 
2 /*
3 Copyright 2008 University of Warwick
4 
5 Licensed under the Apache License, Version 2.0 (the "License");
6 you may not use this file except in compliance with the License.
7 You may obtain a copy of the License at
8 
9  http://www.apache.org/licenses/LICENSE-2.0
10 
11 Unless required by applicable law or agreed to in writing, software
12 distributed under the License is distributed on an "AS IS" BASIS,
13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 See the License for the specific language governing permissions and
15 limitations under the License.
16 */
17 
18 /*
19 Laura++ package authors:
20 John Back
21 Paul Harrison
22 Thomas Latham
23 */
24 
29 #include <iostream>
30 using std::cerr;
31 using std::cout;
32 using std::endl;
33 
34 #include "LauDatabasePDG.hh"
35 #include "LauParticlePDG.hh"
36 
37 #include "TDatabasePDG.h"
38 
39 LauDatabasePDG* LauDatabasePDG::theInstance_ = 0;
40 
41 // Constructor
42 
43 LauDatabasePDG::LauDatabasePDG() :
44  theDatabase_( new TDatabasePDG() ),
45  particles_(),
46  debug_( kFALSE )
47 {
48 }
49 
50 // Destructor
51 
52 LauDatabasePDG::~LauDatabasePDG()
53 {
54  delete theDatabase_;
55  theDatabase_ = 0;
56  for ( LauPDGList::iterator iter = particles_.begin(); iter != particles_.end(); ++iter ) {
57  delete iter->second;
58  iter->second = 0;
59  }
60 }
61 
62 // Private static method to access the instance
63 // Will create it and add the missing particles if it doesn't already exist
64 
65 LauDatabasePDG& LauDatabasePDG::get()
66 {
67  if ( theInstance_ == 0 ) {
68  theInstance_ = new LauDatabasePDG();
69  theInstance_->addMissingParticles();
70  }
71  return *theInstance_;
72 }
73 
74 // All static methods grab the instance and call the private non-static
75 // methods - this ensures that the database exists and that the missing
76 // particles are added to it.
77 
78 const LauParticlePDG* LauDatabasePDG::particle( Int_t theCode )
79 {
80  return LauDatabasePDG::get().createParticle( theCode );
81 }
82 
83 const LauParticlePDG* LauDatabasePDG::particle( const TString& theString )
84 {
85  return LauDatabasePDG::get().createParticle( theString );
86 }
87 
88 Int_t LauDatabasePDG::code( const TString& theString )
89 {
90  return LauDatabasePDG::get().pdgCode( theString );
91 }
92 
93 TString LauDatabasePDG::string( Int_t theCode )
94 {
95  return LauDatabasePDG::get().pdgName( theCode );
96 }
97 
98 // The following method adds particles to the ROOT database that are
99 // missing from it's default setup. This should only be called once,
100 // immediately after the creation of the instance.
101 
102 void LauDatabasePDG::addMissingParticles()
103 {
104  TParticlePDG* part( 0 );
105  TParticlePDG* antipart( 0 );
106 
107  // format is:
108  // name, title, mass, stable?, width, 3*Q, category, PDG code
109 
110  part =
111  theDatabase_->AddParticle( "deuteron", "deuteron", 1.8756134, kTRUE, 0.0, 3, "Nucleus", 1011 );
112  antipart = theDatabase_->AddAntiParticle( "anti-deuteron", -1011 );
113  part->SetAntiParticle( antipart );
114  antipart->SetAntiParticle( part );
115 
116  part = theDatabase_->AddParticle( "tritium", "tritium", 2.80925, kTRUE, 0.0, 3, "Nucleus", 1021 );
117  antipart = theDatabase_->AddAntiParticle( "anti-tritium", -1021 );
118  part->SetAntiParticle( antipart );
119  antipart->SetAntiParticle( part );
120 
121  part = theDatabase_->AddParticle( "He3", "He3", 2.80923, kTRUE, 0.0, 6, "Nucleus", 1012 );
122  antipart = theDatabase_->AddAntiParticle( "anti-He3", -1012 );
123  part->SetAntiParticle( antipart );
124  antipart->SetAntiParticle( part );
125 
126  part = theDatabase_->AddParticle( "alpha", "alpha", 3.727417, kTRUE, 0.0, 3, "Nucleus", 1022 );
127  antipart = theDatabase_->AddAntiParticle( "anti-alpha", -1022 );
128  part->SetAntiParticle( antipart );
129  antipart->SetAntiParticle( part );
130 
131  part =
132  theDatabase_->AddParticle( "eta_c(2S)", "eta_c(2S)", 3.628, kTRUE, 0.0195, 0, "Meson", 20441 );
133 
134  part =
135  theDatabase_->AddParticle( "psi(3770)", "psi(3770)", 3.7699, kTRUE, 0.0236, 0, "Meson", 40443 );
136 
137  part = theDatabase_->AddParticle( "rho(2S)0", "rho(2S)0", 1.46, kTRUE, 0.31, 0, "Meson", 30113 );
138  part = theDatabase_->AddParticle( "rho(2S)+", "rho(2S)+", 1.46, kTRUE, 0.31, 3, "Meson", 30213 );
139  antipart = theDatabase_->AddAntiParticle( "rho(2S)-", -30213 );
140  part->SetAntiParticle( antipart );
141  antipart->SetAntiParticle( part );
142 
143  part = theDatabase_->AddParticle( "rho(3S)0", "rho(3S)0", 1.46, kTRUE, 0.31, 0, "Meson", 40113 );
144  part = theDatabase_->AddParticle( "rho(3S)+", "rho(3S)+", 1.46, kTRUE, 0.31, 3, "Meson", 40213 );
145  antipart = theDatabase_->AddAntiParticle( "rho(3S)-", -40213 );
146  part->SetAntiParticle( antipart );
147  antipart->SetAntiParticle( part );
148 
149  part = theDatabase_->AddParticle( "Xsu", "Xsu", 1.6, kTRUE, 0.5, 3, "Meson", 30353 );
150  antipart = theDatabase_->AddAntiParticle( "anti-Xsu", -30353 );
151  part->SetAntiParticle( antipart );
152  antipart->SetAntiParticle( part );
153 
154  part = theDatabase_->AddParticle( "Xu0", "Xu0", 1., kTRUE, 0., 0, "Special", 41 );
155  part = theDatabase_->AddParticle( "Xu+", "Xu+", 1., kTRUE, 0., 3, "Special", 42 );
156  antipart = theDatabase_->AddAntiParticle( "Xu-", -42 );
157  part->SetAntiParticle( antipart );
158  antipart->SetAntiParticle( part );
159 
160  part = theDatabase_->AddParticle( "Xsd", "Xsd", 1.6, kTRUE, 0.5, 0, "Meson", 30343 );
161  antipart = theDatabase_->AddAntiParticle( "anti-Xsd", -30343 );
162  part->SetAntiParticle( antipart );
163  antipart->SetAntiParticle( part );
164 
165  part = theDatabase_->AddParticle( "K'*0", "K'*0", 1.414, kTRUE, 0.232, 0, "Meson", 100313 );
166  antipart = theDatabase_->AddAntiParticle( "anti-K'*0", -100313 );
167  part->SetAntiParticle( antipart );
168  antipart->SetAntiParticle( part );
169 
170  part = theDatabase_->AddParticle( "K'*+", "K'*+", 1.414, kTRUE, 0.232, 3, "Meson", 100323 );
171  antipart = theDatabase_->AddAntiParticle( "K'*-", -100323 );
172  part->SetAntiParticle( antipart );
173  antipart->SetAntiParticle( part );
174 
175  part = theDatabase_->AddParticle( "K''*0", "K''*0", 1.717, kTRUE, 0.322, 0, "Meson", 30313 );
176  antipart = theDatabase_->AddAntiParticle( "anti-K''*0", -30313 );
177  part->SetAntiParticle( antipart );
178  antipart->SetAntiParticle( part );
179 
180  part = theDatabase_->AddParticle( "K''*+", "K''*+", 1.717, kTRUE, 0.322, 3, "Meson", 30323 );
181  antipart = theDatabase_->AddAntiParticle( "K''*-", -30323 );
182  part->SetAntiParticle( antipart );
183  antipart->SetAntiParticle( part );
184 }
185 
186 // These next two methods are the ones that actually build-up our database.
187 
188 const LauParticlePDG* LauDatabasePDG::createParticle( Int_t theCode )
189 {
190  // if we've already created this one simply return it
191  LauPDGList::iterator iter = particles_.find( theCode );
192  if ( iter != particles_.end() ) {
193  return iter->second;
194  }
195 
196  // otherwise we'll have to make it...
197 
198  // first get the particle from the database
199  TParticlePDG* theTParticle = theDatabase_->GetParticle( theCode );
200  if ( theTParticle == 0 ) {
201  cerr << "ERROR in LauDatabasePDG::createParticle : Invalid PDG code: " << theCode << endl;
202  return 0;
203  }
204 
205  // then create a new particle from it and store it in the map
206  LauParticlePDG* theParticle = new LauParticlePDG( theTParticle );
207  std::pair<LauPDGList::iterator, bool> insertResult = particles_.insert(
208  std::make_pair( theCode, theParticle ) );
209  if ( ! insertResult.second ) {
210  cerr << "ERROR in LauDatabasePDG::createParticle : Something went wrong inserting particle "
211  << theCode << " into the map." << endl;
212  delete theParticle;
213  return 0;
214  }
215 
216  // then get the anti-particle from the database
217  TParticlePDG* theTAntiParticle = theTParticle->AntiParticle();
218 
219  // check if we have a self-conjugate particle
220  if ( theTAntiParticle == 0 || theTAntiParticle == theTParticle ) {
221  // if so then set it to be it's own anti-particle and return
222  theParticle->setAntiParticle( theParticle );
223  if ( debug_ ) {
224  cout << "INFO in LauDatabasePDG::createParticle : Created self-conjugate particle "
225  << theTParticle->GetName() << endl;
226  }
227  return theParticle;
228  }
229 
230  // otherwise make the particle's antiparticle and store it in the map
231  LauParticlePDG* antiParticle = new LauParticlePDG( theTAntiParticle );
232  Int_t conjCode = antiParticle->code();
233  insertResult = particles_.insert( std::make_pair( conjCode, antiParticle ) );
234  if ( ! insertResult.second ) {
235  cerr << "ERROR in LauDatabasePDG::createParticle : Something went wrong inserting anti-particle "
236  << conjCode << " into the map." << endl;
237  particles_.erase( theCode );
238  delete theParticle;
239  delete antiParticle;
240  return 0;
241  }
242 
243  // set the particle and anti-particle to be each others conjugate
244  theParticle->setAntiParticle( antiParticle );
245  antiParticle->setAntiParticle( theParticle );
246 
247  // and finally return the particle we've created
248  if ( debug_ ) {
249  cout << "INFO in LauDatabasePDG::createParticle : Created particle "
250  << theTParticle->GetName() << " and its conjugate " << theTAntiParticle->GetName()
251  << endl;
252  }
253  return theParticle;
254 }
255 
256 const LauParticlePDG* LauDatabasePDG::createParticle( const TString& theString )
257 {
258  // turn the string into a PDG code
259  Int_t theCode = this->pdgCode( theString );
260  if ( theCode == 0 ) {
261  cerr << "ERROR in LauDatabasePDG::createParticle : Invalid particle string: " << theString
262  << endl;
263  return 0;
264  }
265  // self-message to get the particle
266  return this->createParticle( theCode );
267 }
268 
269 // These last two methods have to be independent of our own database since
270 // they are used by the methods that create the particles and so we'd end
271 // up with an infinite loop.
272 
273 Int_t LauDatabasePDG::pdgCode( const TString& theString )
274 {
275  TParticlePDG* theParticle = theDatabase_->GetParticle( theString );
276  if ( theParticle == 0 ) {
277  cerr << "ERROR in LauDatabasePDG::pdgCode : Invalid particle string: " << theString << endl;
278  return 0;
279  }
280  return theParticle->PdgCode();
281 }
282 
283 TString LauDatabasePDG::pdgName( Int_t theCode )
284 {
285  TParticlePDG* theParticle = theDatabase_->GetParticle( theCode );
286  if ( theParticle == 0 ) {
287  cerr << "ERROR in LauDatabasePDG::pdgName : Invalid particle code: " << theCode << endl;
288  return "";
289  }
290  return theParticle->GetName();
291 }
LauDatabasePDG
Singleton class that provides access to particle property records.
Definition: LauDatabasePDG.hh:47
LauDatabasePDG::~LauDatabasePDG
virtual ~LauDatabasePDG()
Destructor.
Definition: LauDatabasePDG.cc:52
LauDatabasePDG::createParticle
const LauParticlePDG * createParticle(Int_t theCode)
Create particle in the database for a given PDG code and return the new particle.
Definition: LauDatabasePDG.cc:188
LauDatabasePDG::theDatabase_
TDatabasePDG * theDatabase_
The ROOT database.
Definition: LauDatabasePDG.hh:133
LauParticlePDG::setAntiParticle
void setAntiParticle(const LauParticlePDG *antiPart)
Set the antiparticle.
Definition: LauParticlePDG.hh:161
LauDatabasePDG::LauDatabasePDG
LauDatabasePDG()
Constructor.
Definition: LauDatabasePDG.cc:43
LauParticlePDG.hh
File containing declaration of LauParticlePDG class.
LauDatabasePDG::addMissingParticles
void addMissingParticles()
Add particles to the ROOT database that are missing from the default setup.
Definition: LauDatabasePDG.cc:102
LauDatabasePDG::theInstance_
static LauDatabasePDG * theInstance_
The singleton instance.
Definition: LauDatabasePDG.hh:130
LauDatabasePDG::string
static TString string(Int_t code)
Method to convert from a PDG code to a particle name string.
Definition: LauDatabasePDG.cc:93
LauDatabasePDG::get
static LauDatabasePDG & get()
Get the database instance.
Definition: LauDatabasePDG.cc:65
LauDatabasePDG::debug_
const Bool_t debug_
Debug flag - set in constructor.
Definition: LauDatabasePDG.hh:142
LauParticlePDG
Class for storing particle properties.
Definition: LauParticlePDG.hh:43
LauDatabasePDG::pdgName
TString pdgName(Int_t theCode)
Get the associated name string for a given pdgCode.
Definition: LauDatabasePDG.cc:283
LauDatabasePDG.hh
File containing declaration of LauDatabasePDG class.
LauParticlePDG::code
Int_t code() const
The particle PDG code.
Definition: LauParticlePDG.cc:98
LauDatabasePDG::particle
static const LauParticlePDG * particle(Int_t code)
Get particle object based on the PDG code.
Definition: LauDatabasePDG.cc:78
LauDatabasePDG::particles_
LauPDGList particles_
The list of particle objects.
Definition: LauDatabasePDG.hh:139
LauDatabasePDG::code
static Int_t code(const TString &string)
Method to convert from a particle name string into a PDG code.
Definition: LauDatabasePDG.cc:88
LauDatabasePDG::pdgCode
Int_t pdgCode(const TString &theString)
Get the associated pdgCode for a given particle name string.
Definition: LauDatabasePDG.cc:273
Generated by   doxygen 1.8.18