a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
LHPC::MassEigenstate Class Reference

#include <MassEigenstate.hpp>

Detailed Description

Definition at line 31 of file MassEigenstate.hpp.

Public Types

typedef std::map< int, MassEigenstate * > MassEigenstateCodeMap
 
typedef MapAndVectorAndBools< MassEigenstate * > MassEigenstateMapVectorBools
 
typedef PointersWithValue< MassEigenstate const *, double > MassEigenstatesPairedWithBr
 
typedef std::vector< MassEigenstate * > MassEigenstateVector
 

Public Member Functions

MassEigenstate & addCode (int extraCode)
 
MassEigenstate * clearMassesAndDecays ()
 
MassEigenstate * findPointerWithCode (int const pdgCode)
 
MassEigenstate const * findPointerWithCode (int const pdgCode) const
 
double getAbsoluteMass () const
 
std::vector< int > const & getAllCodes () const
 
std::vector< ExtendedMass * > const & getAllRecordedMasses () const
 
std::string const & getAsciiName () const
 
MassEigenstate & getChargeConjugate ()
 
MassEigenstate const & getChargeConjugate () const
 
int getCode () const
 
MassEigenstatesPairedWithBr & getDecay (int const whichDecay)
 
MassEigenstatesPairedWithBr const & getDecay (int const whichDecay) const
 
std::vector< MassEigenstatesPairedWithBr * > & getDecaySet ()
 
std::vector< MassEigenstatesPairedWithBr * > const & getDecaySet () const
 
double getDecayWidth () const
 
double getExactMatchBranchingRatio (int const firstProductCode, int const secondProductCode) const
 
double getExactMatchBranchingRatio (int const firstProductCode, int const secondProductCode, int const thirdProductCode) const
 
double getExactMatchBranchingRatio (MassEigenstate const &firstProduct, MassEigenstate const &secondProduct) const
 
double getExactMatchBranchingRatio (MassEigenstate const &firstProduct, MassEigenstate const &secondProduct, MassEigenstate const &thirdProduct) const
 
double getExactMatchBranchingRatio (std::list< int > const &productCodeList) const
 
double getExactMatchBranchingRatio (std::list< MassEigenstate const * > &productList) const
 
double getExactMatchBranchingRatio (std::vector< int > const &productCodeList) const
 
double getExactMatchBranchingRatio (std::vector< MassEigenstate const * > const &productList) const
 
double getExactMatchBranchingRatioWithSortedList (std::list< MassEigenstate const * > const &sortedProductList) const
 
ExtendedMass const & getExtendedMass () const
 
std::vector< bool > const & getFlags () const
 
std::string const & getLatexName () const
 
double getSignedMass () const
 
double getSubsetMatchBranchingRatio (std::list< int > const &soughtCodeList, std::list< int > const &vetoedCodeList) const
 
double getSubsetMatchBranchingRatio (std::list< MassEigenstate const * > &soughtList, std::list< MassEigenstate const * > &vetoedList) const
 
double getSubsetMatchBranchingRatio (std::vector< int > const &soughtCodeVector, std::vector< int > const &vetoedCodeVector) const
 
double getSubsetMatchBranchingRatio (std::vector< MassEigenstate const * > const &soughtVector, std::vector< MassEigenstate const * > const &vetoedVector) const
 
double getSubsetMatchBranchingRatioWithSortedLists (std::list< MassEigenstate const * > const &soughtList, std::list< MassEigenstate const * > const &vetoedList) const
 
bool getVerbosity () const
 
bool hasCode (int const pdgCode) const
 
bool hasMassBeenRecorded () const
 
bool haveDecaysBeenRecorded () const
 
bool isSelfConjugate () const
 
 MassEigenstate (int const firstPdgCode, int const secondPdgCode, MassEigenstateMapVectorBools &mapAndVectorAndBools, bool const isSelfConjugate, std::string const &asciiName, std::string const &latexName, double const defaultResetMass=BOL::UsefulStuff::notANumber, double const defaultDecayWidth=BOL::UsefulStuff::notANumber)
 
 MassEigenstate (int const pdgCode, MassEigenstateMapVectorBools &mapAndVectorAndBools, bool const isSelfConjugate, std::string const &asciiName, std::string const &latexName, double const defaultResetMass=BOL::UsefulStuff::notANumber, double const defaultDecayWidth=BOL::UsefulStuff::notANumber)
 
 MassEigenstate (MassEigenstate &copySource, std::string const &asciiName, std::string const &latexName)
 
 MassEigenstate (MassEigenstate const &copySource, MassEigenstateMapVectorBools &mapAndVectorAndBools)
 
 MassEigenstate (std::vector< int > const &pdgCodes, MassEigenstateMapVectorBools &mapAndVectorAndBools, bool const isSelfConjugate, std::string const &asciiName, std::string const &latexName, double const defaultResetMass=BOL::UsefulStuff::notANumber, double const defaultDecayWidth=BOL::UsefulStuff::notANumber)
 
void recordChargeConjugateOfDecay (MassEigenstatesPairedWithBr const &decayToRecord)
 
void recordChargeConjugateOfDecayAsDefault (MassEigenstatesPairedWithBr const &decayToRecord)
 
void recordDecay (MassEigenstatesPairedWithBr const &decayToRecord)
 
void recordDecayAsDefault (MassEigenstatesPairedWithBr const &decayToRecord)
 
void recordMass (double const massValue, double const minusUncertainty=0.0, double const plusUncertainty=0.0, int const schemeType=0, double const evaluationScale=0.0)
 
void recordMassError (double const minusUncertainty, double const plusUncertainty, int const schemeType, double const evaluationScale)
 
MassEigenstate & setAsciiName (std::string const &asciiName)
 
void setChargeConjugate (MassEigenstate *const chargeConjugate)
 
void setDecayWidth (double const decayWidth)
 
MassEigenstate & setFlags (std::vector< bool > const *const flagBools)
 
MassEigenstate & setLatexName (std::string const &latexName)
 
void setToBeChargeConjugate (MassEigenstate *const chargeConjugate)
 
void setToBeSelfConjugate ()
 
 ~MassEigenstate ()
 

Static Public Member Functions

static MassEigenstate * findPointerWithCode (int pdgCode, MassEigenstateCodeMap const &codeMap)
 
static bool pointerHasCode (MassEigenstate const *const massEigenstatePointer, int const pdgCode)
 

Protected Member Functions

void addToCodeMap (int const positiveExtraCode)
 
void constructorBodyFunction ()
 
void prepareToRecordDecay ()
 

Protected Attributes

double absoluteDefaultMass
 
std::string asciiName
 
MassEigenstate * chargeConjugate
 
BOL::VectorlikeArray< MassEigenstatesPairedWithBr > decaySet
 
std::vector< MassEigenstatesPairedWithBr * > decaySetAsVector
 
bool decaysRecorded
 
double decayWidth
 
BOL::VectorlikeArray< MassEigenstatesPairedWithBr > defaultDecaySet
 
double const defaultDecayWidth
 
double const defaultResetMass
 
std::vector< bool > const * flagBools
 
std::vector< int > identifyingPdgCodes
 
bool isSelfConjugateFlag
 
bool const isVerbose
 
std::string latexName
 
std::pair< int, MassEigenstate * > mapFiller
 
bool massRecorded
 
MassEigenstateCodeMap & pdgCodeMap
 
BOL::VectorlikeArray< ExtendedMass > runningMasses
 
std::vector< ExtendedMass * > runningMassesAsVector
 
MassEigenstateVector & setOfPointersOfMassEigenstateGroup
 
double signedDefaultMass
 

Member Typedef Documentation

◆ MassEigenstateCodeMap

typedef std::map< int, MassEigenstate* > LHPC::MassEigenstate::MassEigenstateCodeMap

Definition at line 36 of file MassEigenstate.hpp.

◆ MassEigenstateMapVectorBools

typedef MapAndVectorAndBools< MassEigenstate* > LHPC::MassEigenstate::MassEigenstateMapVectorBools

Definition at line 35 of file MassEigenstate.hpp.

◆ MassEigenstatesPairedWithBr

typedef PointersWithValue< MassEigenstate const*, double > LHPC::MassEigenstate::MassEigenstatesPairedWithBr

Definition at line 39 of file MassEigenstate.hpp.

◆ MassEigenstateVector

typedef std::vector< MassEigenstate* > LHPC::MassEigenstate::MassEigenstateVector

Definition at line 40 of file MassEigenstate.hpp.

Constructor & Destructor Documentation

◆ MassEigenstate() [1/5]

LHPC::MassEigenstate::MassEigenstate ( int const  pdgCode,
MassEigenstateMapVectorBools &  mapAndVectorAndBools,
bool const  isSelfConjugate,
std::string const &  asciiName,
std::string const &  latexName,
double const  defaultResetMass = BOL::UsefulStuff::notANumber,
double const  defaultDecayWidth = BOL::UsefulStuff::notANumber 
)

Definition at line 50 of file MassEigenstate.cpp.

56 :
57 chargeConjugate( NULL ),
58 isSelfConjugateFlag( isSelfConjugate ),
59 identifyingPdgCodes( 1,
60 pdgCode ),
61 pdgCodeMap( mapAndVectorAndBools.getMap() ),
62 mapFiller( 0,
63 NULL ),
64 massRecorded( false ),
65 defaultResetMass( defaultResetMass ),
66 signedDefaultMass( defaultResetMass ),
67 absoluteDefaultMass( defaultResetMass ),
68 runningMasses(),
69 runningMassesAsVector(),
70 decaysRecorded( false ),
71 defaultDecayWidth( defaultDecayWidth ),
72 decayWidth( defaultDecayWidth ),
73 defaultDecaySet(),
74 decaySet(),
75 decaySetAsVector(),
76 asciiName( asciiName ),
77 latexName( latexName ),
78 isVerbose( mapAndVectorAndBools.getBool() ),
79 flagBools( mapAndVectorAndBools.getFlags() ),
80 setOfPointersOfMassEigenstateGroup( mapAndVectorAndBools.getVector() )
81 {
82 constructorBodyFunction();
83 /* constructorBodyFunction puts pointers to this instance into pdgCodeMap
84 * for each of this instance's positive codes. if this instance has
85 * negative codes, they will only get into pdgCodeMap through the
86 * charge-conjugate's constructor (or by manually adding them, but that's
87 * not recommended).
88 */
89 }
LHPC::MassEigenstate::defaultDecaySet
BOL::VectorlikeArray< MassEigenstatesPairedWithBr > defaultDecaySet
Definition: MassEigenstate.hpp:233
LHPC::MassEigenstate::decaySet
BOL::VectorlikeArray< MassEigenstatesPairedWithBr > decaySet
Definition: MassEigenstate.hpp:234
LHPC::MassEigenstate::runningMassesAsVector
std::vector< ExtendedMass * > runningMassesAsVector
Definition: MassEigenstate.hpp:229
LHPC::MassEigenstate::chargeConjugate
MassEigenstate * chargeConjugate
Definition: MassEigenstate.hpp:217
LHPC::MassEigenstate::flagBools
std::vector< bool > const * flagBools
Definition: MassEigenstate.hpp:239
LHPC::MassEigenstate::decaySetAsVector
std::vector< MassEigenstatesPairedWithBr * > decaySetAsVector
Definition: MassEigenstate.hpp:235
LHPC::MassEigenstate::defaultResetMass
double const defaultResetMass
Definition: MassEigenstate.hpp:223
LHPC::MassEigenstate::runningMasses
BOL::VectorlikeArray< ExtendedMass > runningMasses
Definition: MassEigenstate.hpp:228
LHPC::MassEigenstate::setOfPointersOfMassEigenstateGroup
MassEigenstateVector & setOfPointersOfMassEigenstateGroup
Definition: MassEigenstate.hpp:240
LHPC::MassEigenstate::mapFiller
std::pair< int, MassEigenstate * > mapFiller
Definition: MassEigenstate.hpp:221
LHPC::MassEigenstate::isSelfConjugate
bool isSelfConjugate() const
Definition: MassEigenstate.hpp:265
LHPC::MassEigenstate::pdgCodeMap
MassEigenstateCodeMap & pdgCodeMap
Definition: MassEigenstate.hpp:220
LHPC::MassEigenstate::defaultDecayWidth
double const defaultDecayWidth
Definition: MassEigenstate.hpp:231
LHPC::MassEigenstate::identifyingPdgCodes
std::vector< int > identifyingPdgCodes
Definition: MassEigenstate.hpp:219

◆ MassEigenstate() [2/5]

LHPC::MassEigenstate::MassEigenstate ( int const  firstPdgCode,
int const  secondPdgCode,
MassEigenstateMapVectorBools &  mapAndVectorAndBools,
bool const  isSelfConjugate,
std::string const &  asciiName,
std::string const &  latexName,
double const  defaultResetMass = BOL::UsefulStuff::notANumber,
double const  defaultDecayWidth = BOL::UsefulStuff::notANumber 
)

Definition at line 91 of file MassEigenstate.cpp.

98 :
99 chargeConjugate( NULL ),
100 isSelfConjugateFlag( isSelfConjugate ),
101 identifyingPdgCodes( 2,
102 secondPdgCode ),
103 pdgCodeMap( mapAndVectorAndBools.getMap() ),
104 mapFiller( 0,
105 NULL ),
106 massRecorded( false ),
107 defaultResetMass( defaultResetMass ),
108 signedDefaultMass( defaultResetMass ),
109 absoluteDefaultMass( defaultResetMass ),
110 runningMasses(),
111 runningMassesAsVector(),
112 decaysRecorded( false ),
113 defaultDecayWidth( defaultDecayWidth ),
114 decayWidth( defaultDecayWidth ),
115 defaultDecaySet(),
116 decaySet(),
117 decaySetAsVector(),
118 asciiName( asciiName ),
119 latexName( latexName ),
120 isVerbose( mapAndVectorAndBools.getBool() ),
121 flagBools( mapAndVectorAndBools.getFlags() ),
122 setOfPointersOfMassEigenstateGroup( mapAndVectorAndBools.getVector() )
123 {
124 identifyingPdgCodes.front() = firstPdgCode;
125 // this, along with the initialization of identifyingPdgCodes, sorts out
126 // the 2 particle codes.
127 constructorBodyFunction();
128 /* constructorBodyFunction puts pointers to this instance into pdgCodeMap
129 * for each of this instance's positive codes. if this instance has
130 * negative codes, they will only get into pdgCodeMap through the
131 * charge-conjugate's constructor (or by manually adding them, but that's
132 * not recommended).
133 */
134 }

◆ MassEigenstate() [3/5]

LHPC::MassEigenstate::MassEigenstate ( std::vector< int > const &  pdgCodes,
MassEigenstateMapVectorBools &  mapAndVectorAndBools,
bool const  isSelfConjugate,
std::string const &  asciiName,
std::string const &  latexName,
double const  defaultResetMass = BOL::UsefulStuff::notANumber,
double const  defaultDecayWidth = BOL::UsefulStuff::notANumber 
)

Definition at line 136 of file MassEigenstate.cpp.

142 :
143 chargeConjugate( NULL ),
144 isSelfConjugateFlag( isSelfConjugate ),
145 identifyingPdgCodes( pdgCodes.begin(),
146 pdgCodes.end() ),
147 pdgCodeMap( mapAndVectorAndBools.getMap() ),
148 mapFiller( 0,
149 NULL ),
150 massRecorded( false ),
151 defaultResetMass( defaultResetMass ),
152 signedDefaultMass( defaultResetMass ),
153 absoluteDefaultMass( defaultResetMass ),
154 runningMasses(),
155 runningMassesAsVector(),
156 decaysRecorded( false ),
157 defaultDecayWidth( defaultDecayWidth ),
158 decayWidth( defaultDecayWidth ),
159 defaultDecaySet(),
160 decaySet(),
161 decaySetAsVector(),
162 asciiName( asciiName ),
163 latexName( latexName ),
164 isVerbose( mapAndVectorAndBools.getBool() ),
165 flagBools( mapAndVectorAndBools.getFlags() ),
166 setOfPointersOfMassEigenstateGroup( mapAndVectorAndBools.getVector() )
167 {
168 constructorBodyFunction();
169 /* constructorBodyFunction puts pointers to this instance into pdgCodeMap
170 * for each of this instance's positive codes. if this instance has
171 * negative codes, they will only get into pdgCodeMap through the
172 * charge-conjugate's constructor (or by manually adding them, but that's
173 * not recommended).
174 */
175 }

◆ MassEigenstate() [4/5]

LHPC::MassEigenstate::MassEigenstate ( MassEigenstate const &  copySource,
MassEigenstateMapVectorBools &  mapAndVectorAndBools 
)

Definition at line 177 of file MassEigenstate.cpp.

178 :
179 chargeConjugate( NULL ),
180 isSelfConjugateFlag( copySource.isSelfConjugateFlag ),
181 identifyingPdgCodes( copySource.identifyingPdgCodes.begin(),
182 copySource.identifyingPdgCodes.end() ),
183 pdgCodeMap( mapAndVectorAndBools.getMap() ),
184 mapFiller( 0,
185 NULL ),
186 massRecorded( false ),
187 defaultResetMass( copySource.defaultResetMass ),
188 signedDefaultMass( copySource.signedDefaultMass ),
189 absoluteDefaultMass( copySource.absoluteDefaultMass ),
190 runningMasses(),
191 runningMassesAsVector(),
192 decaysRecorded( copySource.decaysRecorded ),
193 defaultDecayWidth( copySource.defaultDecayWidth ),
194 decayWidth( copySource.decayWidth ),
195 defaultDecaySet( copySource.defaultDecaySet ),
196 decaySet( copySource.decaySet ),
197 decaySetAsVector( copySource.decaySetAsVector ),
198 asciiName( copySource.asciiName ),
199 latexName( copySource.latexName ),
200 isVerbose( mapAndVectorAndBools.getBool() ),
201 flagBools( mapAndVectorAndBools.getFlags() ),
202 setOfPointersOfMassEigenstateGroup( mapAndVectorAndBools.getVector() )
203 {
204 constructorBodyFunction();
205 /* constructorBodyFunction puts pointers to this instance into pdgCodeMap
206 * for each of this instance's positive codes. if this instance has
207 * negative codes, they will only get into pdgCodeMap through the
208 * charge-conjugate's constructor (or by manually adding them, but that's
209 * not recommended).
210 */
211 }

◆ MassEigenstate() [5/5]

LHPC::MassEigenstate::MassEigenstate ( MassEigenstate &  copySource,
std::string const &  asciiName,
std::string const &  latexName 
)

Definition at line 214 of file MassEigenstate.cpp.

216 :
217 chargeConjugate( &copySource ),
218 isSelfConjugateFlag( copySource.isSelfConjugateFlag ),
219 identifyingPdgCodes( copySource.identifyingPdgCodes.size(),
220 -(copySource.getCode()) ),
221 pdgCodeMap( copySource.pdgCodeMap ),
222 mapFiller( 0,
223 NULL ),
224 massRecorded( false ),
225 defaultResetMass( copySource.defaultResetMass ),
226 signedDefaultMass( copySource.signedDefaultMass ),
227 absoluteDefaultMass( copySource.absoluteDefaultMass ),
228 runningMasses(),
229 runningMassesAsVector(),
230 decaysRecorded( false ),
231 defaultDecayWidth( copySource.defaultDecayWidth ),
232 decayWidth( copySource.decayWidth ),
233 defaultDecaySet(),
234 decaySet(),
235 decaySetAsVector(),
236 asciiName( asciiName ),
237 latexName( latexName ),
238 isVerbose( copySource.isVerbose ),
239 flagBools( copySource.flagBools ),
240 setOfPointersOfMassEigenstateGroup(
241 copySource.setOfPointersOfMassEigenstateGroup )
242 {
243 // this for loop doesn't copy the front element because it was already
244 // copied into all the entries when identifyingPdgCodes was initialized.
245 for( int codeIndex( copySource.identifyingPdgCodes.size() - 1 );
246 0 < codeIndex;
247 --codeIndex )
248 {
249 identifyingPdgCodes[ codeIndex ]
250 = -(copySource.identifyingPdgCodes[ codeIndex ]);
251 // this gets the negatives of copySource's codes.
252 }
253 copySource.setChargeConjugate( this );
254 constructorBodyFunction();
255 /* constructorBodyFunction sorts out getting copySource's negative codes
256 * into pdgCodeMap as the positive codes for this instance, with this
257 * instance's pointer.
258 */
259 }

◆ ~MassEigenstate()

LHPC::MassEigenstate::~MassEigenstate ( )

Definition at line 261 of file MassEigenstate.cpp.

262 {
263 // does nothing, since there was no dynamic allocation.
264 }

Member Function Documentation

◆ addCode()

MassEigenstate & LHPC::MassEigenstate::addCode ( int  extraCode)

Definition at line 268 of file MassEigenstate.cpp.

269 {
270 if( isSelfConjugate() )
271 {
272 if( 0 > extraCode )
273 {
274 extraCode = -extraCode;
275 }
276 // self-conjugate states was forced into having only positive codes.
277 }
278 else if( NULL != chargeConjugate )
279 {
280 // the charge-conjugate should get the opposite-signed codes, &
281 // pdgCodeMap should know which is mapped to by the positive code:
282 chargeConjugate->identifyingPdgCodes.push_back( -extraCode );
283 if( 0 > extraCode )
284 {
285 chargeConjugate->addToCodeMap( -extraCode );
286 }
287 }
288 // extraCode can now be added to identifyingPdgCodes:
289 identifyingPdgCodes.push_back( extraCode );
290 // if the code is positive, pdgCodeMap should know that it maps to this
291 // instance:
292 if( 0 <= extraCode )
293 {
294 addToCodeMap( extraCode );
295 }
296 return *this;
297 }
LHPC::MassEigenstate::addToCodeMap
void addToCodeMap(int const positiveExtraCode)
Definition: MassEigenstate.hpp:807

◆ addToCodeMap()

void LHPC::MassEigenstate::addToCodeMap ( int const  positiveExtraCode)
inlineprotected

Definition at line 807 of file MassEigenstate.hpp.

808 {
809 mapFiller.first = positiveExtraCode;
810 mapFiller.second = this;
811 pdgCodeMap.insert( mapFiller );
812 }

◆ clearMassesAndDecays()

MassEigenstate * LHPC::MassEigenstate::clearMassesAndDecays ( )
inline

Definition at line 442 of file MassEigenstate.hpp.

443 {
444 runningMasses.clearEntries();
445 runningMassesAsVector.clear();
446 signedDefaultMass = defaultResetMass;
447 absoluteDefaultMass = defaultResetMass;
448 if( 0.0 > absoluteDefaultMass )
449 {
450 absoluteDefaultMass = -absoluteDefaultMass;
451 }
452 massRecorded = false;
453 decaySet.becomeCopyOf( defaultDecaySet );
454 decaySetAsVector.clear();
455 for( int whichDecay( 0 );
456 decaySet.getSize() > whichDecay;
457 ++whichDecay )
458 {
459 decaySetAsVector.push_back( decaySet.getPointer( whichDecay ) );
460 }
461 decayWidth = defaultDecayWidth;
462 decaysRecorded = false;
463 return this;
464 }

◆ constructorBodyFunction()

void LHPC::MassEigenstate::constructorBodyFunction ( )
protected

Definition at line 365 of file MassEigenstate.cpp.

366 {
367 if( isSelfConjugate() )
368 {
369 chargeConjugate = this;
370 for( int codeIndex( identifyingPdgCodes.size() - 1 );
371 0 <= codeIndex;
372 --codeIndex )
373 {
374 if( 0 > identifyingPdgCodes[ codeIndex ] )
375 {
376 identifyingPdgCodes[ codeIndex ] = -identifyingPdgCodes[ codeIndex ];
377 }
378 addToCodeMap( identifyingPdgCodes[ codeIndex ] );
379 // self-conjugate particles are set to have only positive codes, &
380 // the codes are mapped to this MassEigenstate.
381 }
382 }
383 else
384 {
385 for( int codeIndex( identifyingPdgCodes.size() - 1 );
386 0 <= codeIndex;
387 --codeIndex )
388 {
389 if( 0 < identifyingPdgCodes[ codeIndex ] )
390 {
391 addToCodeMap( identifyingPdgCodes[ codeIndex ] );
392 /* only this instance's positive codes are mapped to its pointer in
393 * pdgCodeMap. if this instance has negative codes, they will only
394 * get into pdgCodeMap through the charge-conjugate's constructor (or
395 * by manually adding them, but that's not recommended).
396 */
397 }
398 }
399 }
400 setOfPointersOfMassEigenstateGroup.push_back( this );
401 }

◆ findPointerWithCode() [1/3]

MassEigenstate * LHPC::MassEigenstate::findPointerWithCode ( int const  pdgCode)
inline

Definition at line 787 of file MassEigenstate.hpp.

788 {
789 return findPointerWithCode( pdgCode,
790 pdgCodeMap );
791 }
LHPC::MassEigenstate::findPointerWithCode
static MassEigenstate * findPointerWithCode(int pdgCode, MassEigenstateCodeMap const &codeMap)
Definition: MassEigenstate.cpp:19

◆ findPointerWithCode() [2/3]

MassEigenstate const * LHPC::MassEigenstate::findPointerWithCode ( int const  pdgCode) const
inline

Definition at line 794 of file MassEigenstate.hpp.

795 {
796 return findPointerWithCode( pdgCode,
797 pdgCodeMap );
798 }

◆ findPointerWithCode() [3/3]

MassEigenstate * LHPC::MassEigenstate::findPointerWithCode ( int  pdgCode,
MassEigenstateCodeMap const &  codeMap 
)
static

Definition at line 19 of file MassEigenstate.cpp.

23 {
24 MassEigenstate* returnPointer( NULL );
25 bool flipToChargeConjugate( false );
26 // codeMap only knows about positive codes, but negatives codes will
27 // return charge-conjugates of the MassEigenstates with the positive codes:
28 if( 0 > pdgCode )
29 {
30 flipToChargeConjugate = true;
31 pdgCode = -pdgCode;
32 }
33 MassEigenstateCodeMap::const_iterator
34 returnFromMap( codeMap.find( pdgCode ) );
35 if( codeMap.end() != returnFromMap )
36 // if pdgCode was found in codeMap...
37 {
38 if( flipToChargeConjugate )
39 {
40 returnPointer = (*returnFromMap).second->chargeConjugate;
41 }
42 else
43 {
44 returnPointer = (*returnFromMap).second;
45 }
46 }
47 return returnPointer;
48 }
LHPC::MassEigenstate::MassEigenstate
MassEigenstate(int const pdgCode, MassEigenstateMapVectorBools &mapAndVectorAndBools, bool const isSelfConjugate, std::string const &asciiName, std::string const &latexName, double const defaultResetMass=BOL::UsefulStuff::notANumber, double const defaultDecayWidth=BOL::UsefulStuff::notANumber)
Definition: MassEigenstate.cpp:50

◆ getAbsoluteMass()

double LHPC::MassEigenstate::getAbsoluteMass ( ) const
inline

Definition at line 356 of file MassEigenstate.hpp.

358 {
359 return absoluteDefaultMass;
360 }

◆ getAllCodes()

std::vector< int > const & LHPC::MassEigenstate::getAllCodes ( ) const
inline

Definition at line 337 of file MassEigenstate.hpp.

338 {
339 return identifyingPdgCodes;
340 }

◆ getAllRecordedMasses()

std::vector< ExtendedMass * > const & LHPC::MassEigenstate::getAllRecordedMasses ( ) const
inline

Definition at line 370 of file MassEigenstate.hpp.

371 {
372 return runningMassesAsVector;
373 }

◆ getAsciiName()

std::string const & LHPC::MassEigenstate::getAsciiName ( ) const
inline

Definition at line 748 of file MassEigenstate.hpp.

749 {
750 return asciiName;
751 }

◆ getChargeConjugate() [1/2]

MassEigenstate & LHPC::MassEigenstate::getChargeConjugate ( )
inline

Definition at line 271 of file MassEigenstate.hpp.

272 {
273 return *chargeConjugate;
274 }

◆ getChargeConjugate() [2/2]

MassEigenstate const & LHPC::MassEigenstate::getChargeConjugate ( ) const
inline

Definition at line 277 of file MassEigenstate.hpp.

278 {
279 return *chargeConjugate;
280 }

◆ getCode()

int LHPC::MassEigenstate::getCode ( ) const
inline

Definition at line 331 of file MassEigenstate.hpp.

332 {
333 return identifyingPdgCodes.front();
334 }

◆ getDecay() [1/2]

MassEigenstate::MassEigenstatesPairedWithBr & LHPC::MassEigenstate::getDecay ( int const  whichDecay)
inline

Definition at line 430 of file MassEigenstate.hpp.

431 {
432 return *(decaySetAsVector[ whichDecay ]);
433 }

◆ getDecay() [2/2]

MassEigenstate::MassEigenstatesPairedWithBr const & LHPC::MassEigenstate::getDecay ( int const  whichDecay) const
inline

Definition at line 436 of file MassEigenstate.hpp.

437 {
438 return *(decaySetAsVector[ whichDecay ]);
439 }

◆ getDecaySet() [1/2]

std::vector< MassEigenstate::MassEigenstatesPairedWithBr * > & LHPC::MassEigenstate::getDecaySet ( )
inline

Definition at line 418 of file MassEigenstate.hpp.

419 {
420 return decaySetAsVector;
421 }

◆ getDecaySet() [2/2]

std::vector< MassEigenstate::MassEigenstatesPairedWithBr * > const & LHPC::MassEigenstate::getDecaySet ( ) const
inline

Definition at line 424 of file MassEigenstate.hpp.

425 {
426 return decaySetAsVector;
427 }

◆ getDecayWidth()

double LHPC::MassEigenstate::getDecayWidth ( ) const
inline

Definition at line 403 of file MassEigenstate.hpp.

404 {
405 return decayWidth;
406 }

◆ getExactMatchBranchingRatio() [1/8]

double LHPC::MassEigenstate::getExactMatchBranchingRatio ( int const  firstProductCode,
int const  secondProductCode 
) const
inline

Definition at line 636 of file MassEigenstate.hpp.

638 {
639 double returnValue( 0.0 );
640 for( int whichDecay( decaySet.getLastIndex() );
641 0 <= whichDecay;
642 --whichDecay )
643 {
644 if( decaySet[ whichDecay ].matchesExactly( firstProductCode,
645 secondProductCode,
646 &pointerHasCode ) )
647 {
648 returnValue = decaySet[ whichDecay ].getPairedValue();
649 whichDecay = -1;
650 }
651 }
652 return returnValue;
653 }
LHPC::MassEigenstate::pointerHasCode
static bool pointerHasCode(MassEigenstate const *const massEigenstatePointer, int const pdgCode)
Definition: MassEigenstate.hpp:256

◆ getExactMatchBranchingRatio() [2/8]

double LHPC::MassEigenstate::getExactMatchBranchingRatio ( int const  firstProductCode,
int const  secondProductCode,
int const  thirdProductCode 
) const
inline

Definition at line 656 of file MassEigenstate.hpp.

659 {
660 std::list< MassEigenstate const* > comparisonList( 1,
661 findPointerWithCode( firstProductCode ) );
662 comparisonList.push_back( findPointerWithCode( secondProductCode ) );
663 comparisonList.push_back( findPointerWithCode( thirdProductCode ) );
664 return getExactMatchBranchingRatio( comparisonList );
665 }
LHPC::MassEigenstate::getExactMatchBranchingRatio
double getExactMatchBranchingRatio(MassEigenstate const &firstProduct, MassEigenstate const &secondProduct) const
Definition: MassEigenstate.hpp:523

◆ getExactMatchBranchingRatio() [3/8]

double LHPC::MassEigenstate::getExactMatchBranchingRatio ( MassEigenstate const &  firstProduct,
MassEigenstate const &  secondProduct 
) const
inline

Definition at line 523 of file MassEigenstate.hpp.

526 {
527 double returnValue( 0.0 );
528 for( int whichDecay( decaySet.getLastIndex() );
529 0 <= whichDecay;
530 --whichDecay )
531 {
532 if( decaySet[ whichDecay ].matchesExactly( &firstProduct,
533 &secondProduct ) )
534 {
535 returnValue = decaySet[ whichDecay ].getPairedValue();
536 whichDecay = -1;
537 }
538 }
539 return returnValue;
540 }

◆ getExactMatchBranchingRatio() [4/8]

double LHPC::MassEigenstate::getExactMatchBranchingRatio ( MassEigenstate const &  firstProduct,
MassEigenstate const &  secondProduct,
MassEigenstate const &  thirdProduct 
) const
inline

Definition at line 543 of file MassEigenstate.hpp.

547 {
548 std::list< MassEigenstate const* > comparisonList( 1,
549 &firstProduct );
550 comparisonList.push_back( &secondProduct );
551 comparisonList.push_back( &thirdProduct );
552 return getExactMatchBranchingRatio( comparisonList );
553 }

◆ getExactMatchBranchingRatio() [5/8]

double LHPC::MassEigenstate::getExactMatchBranchingRatio ( std::list< int > const &  productCodeList) const
inline

Definition at line 668 of file MassEigenstate.hpp.

670 {
671 std::list< MassEigenstate const* > comparisonList;
672 for( std::list< int >::const_iterator
673 codeIterator( productCodeList.begin() );
674 productCodeList.end() != codeIterator;
675 ++codeIterator )
676 {
677 comparisonList.push_back( findPointerWithCode( *codeIterator ) );
678 }
679 return getExactMatchBranchingRatio( comparisonList );
680 }

◆ getExactMatchBranchingRatio() [6/8]

double LHPC::MassEigenstate::getExactMatchBranchingRatio ( std::list< MassEigenstate const * > &  productList) const
inline

Definition at line 574 of file MassEigenstate.hpp.

576 {
577 productList.sort();
578 return getExactMatchBranchingRatioWithSortedList( productList );
579 }
LHPC::MassEigenstate::getExactMatchBranchingRatioWithSortedList
double getExactMatchBranchingRatioWithSortedList(std::list< MassEigenstate const * > const &sortedProductList) const
Definition: MassEigenstate.hpp:556

◆ getExactMatchBranchingRatio() [7/8]

double LHPC::MassEigenstate::getExactMatchBranchingRatio ( std::vector< int > const &  productCodeList) const
inline

Definition at line 683 of file MassEigenstate.hpp.

685 {
686 std::list< MassEigenstate const* > comparisonList;
687 for( int codeIndex( productCodeList.size() - 1 );
688 0 <= codeIndex;
689 --codeIndex )
690 {
691 comparisonList.push_back( findPointerWithCode(
692 productCodeList[ codeIndex ] ) );
693 }
694 return getExactMatchBranchingRatio( comparisonList );
695 }

◆ getExactMatchBranchingRatio() [8/8]

double LHPC::MassEigenstate::getExactMatchBranchingRatio ( std::vector< MassEigenstate const * > const &  productList) const
inline

Definition at line 582 of file MassEigenstate.hpp.

584 {
585 std::list< MassEigenstate const* > comparisonList( productList.begin(),
586 productList.end() );
587 comparisonList.sort();
588 return getExactMatchBranchingRatioWithSortedList( comparisonList );
589 }

◆ getExactMatchBranchingRatioWithSortedList()

double LHPC::MassEigenstate::getExactMatchBranchingRatioWithSortedList ( std::list< MassEigenstate const * > const &  sortedProductList) const
inline

Definition at line 556 of file MassEigenstate.hpp.

558 {
559 double returnValue( 0.0 );
560 for( int whichDecay( decaySet.getLastIndex() );
561 0 <= whichDecay;
562 --whichDecay )
563 {
564 if( decaySet[ whichDecay ].matchesExactly( sortedProductList ) )
565 {
566 returnValue = decaySet[ whichDecay ].getPairedValue();
567 whichDecay = -1;
568 }
569 }
570 return returnValue;
571 }

◆ getExtendedMass()

ExtendedMass const & LHPC::MassEigenstate::getExtendedMass ( ) const
inline

Definition at line 363 of file MassEigenstate.hpp.

365 {
366 return runningMasses.getFront();
367 }

◆ getFlags()

std::vector< bool > const & LHPC::MassEigenstate::getFlags ( ) const
inline

Definition at line 774 of file MassEigenstate.hpp.

775 {
776 return *flagBools;
777 }

◆ getLatexName()

std::string const & LHPC::MassEigenstate::getLatexName ( ) const
inline

Definition at line 761 of file MassEigenstate.hpp.

762 {
763 return latexName;
764 }

◆ getSignedMass()

double LHPC::MassEigenstate::getSignedMass ( ) const
inline

Definition at line 349 of file MassEigenstate.hpp.

351 {
352 return signedDefaultMass;
353 }

◆ getSubsetMatchBranchingRatio() [1/4]

double LHPC::MassEigenstate::getSubsetMatchBranchingRatio ( std::list< int > const &  soughtCodeList,
std::list< int > const &  vetoedCodeList 
) const
inline

Definition at line 698 of file MassEigenstate.hpp.

701 {
702 std::list< MassEigenstate const* > soughtPointerList;
703 for( std::list< int >::const_iterator
704 codeIterator( soughtCodeList.begin() );
705 soughtCodeList.end() != codeIterator;
706 ++codeIterator )
707 {
708 soughtPointerList.push_back( findPointerWithCode( *codeIterator ) );
709 }
710 std::list< MassEigenstate const* > vetoedPointerList;
711 for( std::list< int >::const_iterator
712 codeIterator( vetoedCodeList.begin() );
713 vetoedCodeList.end() != codeIterator;
714 ++codeIterator )
715 {
716 vetoedPointerList.push_back( findPointerWithCode( *codeIterator ) );
717 }
718 return getSubsetMatchBranchingRatio( soughtPointerList,
719 vetoedPointerList );
720 }
LHPC::MassEigenstate::getSubsetMatchBranchingRatio
double getSubsetMatchBranchingRatio(std::list< MassEigenstate const * > &soughtList, std::list< MassEigenstate const * > &vetoedList) const
Definition: MassEigenstate.hpp:612

◆ getSubsetMatchBranchingRatio() [2/4]

double LHPC::MassEigenstate::getSubsetMatchBranchingRatio ( std::list< MassEigenstate const * > &  soughtList,
std::list< MassEigenstate const * > &  vetoedList 
) const
inline

Definition at line 612 of file MassEigenstate.hpp.

615 {
616 soughtList.sort();
617 vetoedList.sort();
618 return getSubsetMatchBranchingRatioWithSortedLists( soughtList,
619 vetoedList );
620 }
LHPC::MassEigenstate::getSubsetMatchBranchingRatioWithSortedLists
double getSubsetMatchBranchingRatioWithSortedLists(std::list< MassEigenstate const * > const &soughtList, std::list< MassEigenstate const * > const &vetoedList) const
Definition: MassEigenstate.hpp:592

◆ getSubsetMatchBranchingRatio() [3/4]

double LHPC::MassEigenstate::getSubsetMatchBranchingRatio ( std::vector< int > const &  soughtCodeVector,
std::vector< int > const &  vetoedCodeVector 
) const
inline

Definition at line 723 of file MassEigenstate.hpp.

726 {
727 std::list< MassEigenstate const* > soughtPointerList;
728 for( int codeIndex( soughtCodeList.size() - 1 );
729 0 <= codeIndex;
730 --codeIndex )
731 {
732 soughtPointerList.push_back( findPointerWithCode(
733 soughtCodeList[ codeIndex ] ) );
734 }
735 std::list< MassEigenstate const* > vetoedPointerList;
736 for( int codeIndex( vetoedCodeList.size() - 1 );
737 0 <= codeIndex;
738 --codeIndex )
739 {
740 vetoedPointerList.push_back( findPointerWithCode(
741 vetoedCodeList[ codeIndex ] ) );
742 }
743 return getSubsetMatchBranchingRatio( soughtPointerList,
744 vetoedPointerList );
745 }

◆ getSubsetMatchBranchingRatio() [4/4]

double LHPC::MassEigenstate::getSubsetMatchBranchingRatio ( std::vector< MassEigenstate const * > const &  soughtVector,
std::vector< MassEigenstate const * > const &  vetoedVector 
) const
inline

Definition at line 623 of file MassEigenstate.hpp.

626 {
627 std::list< MassEigenstate const* > soughtList( soughtVector.begin(),
628 soughtVector.end() );
629 std::list< MassEigenstate const* > vetoedList( vetoedVector.begin(),
630 vetoedVector.end() );
631 return getSubsetMatchBranchingRatio( soughtList,
632 vetoedList );
633 }

◆ getSubsetMatchBranchingRatioWithSortedLists()

double LHPC::MassEigenstate::getSubsetMatchBranchingRatioWithSortedLists ( std::list< MassEigenstate const * > const &  soughtList,
std::list< MassEigenstate const * > const &  vetoedList 
) const
inline

Definition at line 592 of file MassEigenstate.hpp.

595 {
596 double returnValue( 0.0 );
597 for( int whichDecay( decaySet.getLastIndex() );
598 0 <= whichDecay;
599 --whichDecay )
600 {
601 if( decaySet[ whichDecay ].containsAllAsSubset( sortedSoughtList )
602 &&
603 !(decaySet[ whichDecay ].containsAnyAsSubset( sortedVetoedList )) )
604 {
605 returnValue += decaySet[ whichDecay ].getPairedValue();
606 }
607 }
608 return returnValue;
609 }

◆ getVerbosity()

bool LHPC::MassEigenstate::getVerbosity ( ) const
inline

Definition at line 801 of file MassEigenstate.hpp.

802 {
803 return isVerbose;
804 }

◆ hasCode()

bool LHPC::MassEigenstate::hasCode ( int const  pdgCode) const
inline

Definition at line 314 of file MassEigenstate.hpp.

315 {
316 bool returnBool( false );
317 for( int codeSeeker( identifyingPdgCodes.size() - 1 );
318 0 <= codeSeeker;
319 --codeSeeker )
320 {
321 if( pdgCode == identifyingPdgCodes[ codeSeeker ] )
322 {
323 returnBool = true;
324 codeSeeker = -1;
325 }
326 }
327 return returnBool;
328 }

◆ hasMassBeenRecorded()

bool LHPC::MassEigenstate::hasMassBeenRecorded ( ) const
inline

Definition at line 343 of file MassEigenstate.hpp.

344 {
345 return massRecorded;
346 }

◆ haveDecaysBeenRecorded()

bool LHPC::MassEigenstate::haveDecaysBeenRecorded ( ) const
inline

Definition at line 397 of file MassEigenstate.hpp.

398 {
399 return decaysRecorded;
400 }

◆ isSelfConjugate()

bool LHPC::MassEigenstate::isSelfConjugate ( ) const
inline

Definition at line 265 of file MassEigenstate.hpp.

266 {
267 return isSelfConjugateFlag;
268 }

◆ pointerHasCode()

bool LHPC::MassEigenstate::pointerHasCode ( MassEigenstate const *const  massEigenstatePointer,
int const  pdgCode 
)
inlinestatic

Definition at line 256 of file MassEigenstate.hpp.

259 {
260 return massEigenstatePointer->hasCode( pdgCode );
261 }

◆ prepareToRecordDecay()

void LHPC::MassEigenstate::prepareToRecordDecay ( )
inlineprotected

Definition at line 815 of file MassEigenstate.hpp.

816 {
817 if( !decaysRecorded )
818 {
819 // this ensures that any present default decays are wiped if any decays
820 // are recorded.
821 decaySet.clearEntries();
822 decaySetAsVector.clear();
823 decaysRecorded = true;
824 }
825 }

◆ recordChargeConjugateOfDecay()

void LHPC::MassEigenstate::recordChargeConjugateOfDecay ( MassEigenstatesPairedWithBr const &  decayToRecord)
inline

Definition at line 478 of file MassEigenstate.hpp.

480 {
481 prepareToRecordDecay();
482 MassEigenstatesPairedWithBr& decayRecorder( decaySet.newEnd() );
483 decaySetAsVector.push_back( &decayRecorder );
484 // I decided to keep a separate std::vector in parallel rather than
485 // constantly converting decaySet with getAsVector(...).
486 decayRecorder.clearPointers();
487 for( std::list< MassEigenstate const* >::const_iterator
488 productIterator( decayToRecord.getPointerList().begin() );
489 decayToRecord.getPointerList().end() != productIterator;
490 ++productIterator )
491 {
492 decayRecorder.addPointer( &((*productIterator)->getChargeConjugate()) );
493 }
494 decayRecorder.setPairedValueAndSortPointers(
495 decayToRecord.getPairedValue() );
496 }
LHPC::MassEigenstate::MassEigenstatesPairedWithBr
PointersWithValue< MassEigenstate const *, double > MassEigenstatesPairedWithBr
Definition: MassEigenstate.hpp:39

◆ recordChargeConjugateOfDecayAsDefault()

void LHPC::MassEigenstate::recordChargeConjugateOfDecayAsDefault ( MassEigenstatesPairedWithBr const &  decayToRecord)
inline

Definition at line 506 of file MassEigenstate.hpp.

508 {
509 MassEigenstatesPairedWithBr& decayRecorder( defaultDecaySet.newEnd() );
510 decayRecorder.clearPointers();
511 for( std::list< MassEigenstate const* >::const_iterator
512 productIterator( decayToRecord.getPointerList().begin() );
513 decayToRecord.getPointerList().end() != productIterator;
514 ++productIterator )
515 {
516 decayRecorder.addPointer( &((*productIterator)->getChargeConjugate()) );
517 }
518 decayRecorder.setPairedValueAndSortPointers(
519 decayToRecord.getPairedValue() );
520 }

◆ recordDecay()

void LHPC::MassEigenstate::recordDecay ( MassEigenstatesPairedWithBr const &  decayToRecord)
inline

Definition at line 467 of file MassEigenstate.hpp.

469 {
470 prepareToRecordDecay();
471 decaySetAsVector.push_back( decaySet.newEnd().copyAndReturnPointer(
472 decayToRecord ) );
473 // I decided to keep a separate std::vector in parallel rather than
474 // constantly converting decaySet with getAsVector(...).
475 }

◆ recordDecayAsDefault()

void LHPC::MassEigenstate::recordDecayAsDefault ( MassEigenstatesPairedWithBr const &  decayToRecord)
inline

Definition at line 499 of file MassEigenstate.hpp.

501 {
502 defaultDecaySet.newEnd().becomeCopyOf( decayToRecord );
503 }

◆ recordMass()

void LHPC::MassEigenstate::recordMass ( double const  massValue,
double const  minusUncertainty = 0.0,
double const  plusUncertainty = 0.0,
int const  schemeType = 0,
double const  evaluationScale = 0.0 
)

Definition at line 330 of file MassEigenstate.cpp.

335 {
336 runningMasses.newEnd().setValues( massValue,
337 minusUncertainty,
338 plusUncertainty,
339 schemeType,
340 evaluationScale );
341 runningMassesAsVector.push_back( runningMasses.getPointer(
342 runningMasses.getLastIndex() ) );
343 // I decided to keep a separate std::vector in parallel rather than
344 // constantly converting runningMasses with getAsVector(...).
345 if( !massRecorded
346 ||
347 ( 0 == schemeType ) )
348 // the pole mass becomes the default mass, unless there is no mass
349 // already recorded.
350 {
351 signedDefaultMass = massValue;
352 if( 0 > massValue )
353 {
354 absoluteDefaultMass = -massValue;
355 }
356 else
357 {
358 absoluteDefaultMass = massValue;
359 }
360 massRecorded = true;
361 }
362 }

◆ recordMassError()

void LHPC::MassEigenstate::recordMassError ( double const  minusUncertainty,
double const  plusUncertainty,
int const  schemeType,
double const  evaluationScale 
)
inline

Definition at line 376 of file MassEigenstate.hpp.

380 {
381 for( int whichMass( runningMasses.getLastIndex() );
382 0 <= whichMass;
383 --whichMass )
384 {
385 if( ( schemeType == runningMasses[ whichMass ].getScheme() )
386 &&
387 ( evaluationScale == runningMasses[ whichMass ].getScale() ) )
388 {
389 runningMasses[ whichMass ].setUncertainties( minusUncertainty,
390 plusUncertainty );
391 whichMass = -1;
392 }
393 }
394 }

◆ setAsciiName()

MassEigenstate & LHPC::MassEigenstate::setAsciiName ( std::string const &  asciiName)
inline

Definition at line 754 of file MassEigenstate.hpp.

755 {
756 this->asciiName.assign( asciiName );
757 return *this;
758 }

◆ setChargeConjugate()

void LHPC::MassEigenstate::setChargeConjugate ( MassEigenstate *const  chargeConjugate)
inline

Definition at line 283 of file MassEigenstate.hpp.

284 {
285 this->chargeConjugate = chargeConjugate;
286 }

◆ setDecayWidth()

void LHPC::MassEigenstate::setDecayWidth ( double const  decayWidth)
inline

Definition at line 409 of file MassEigenstate.hpp.

410 {
411 this->decayWidth = decayWidth;
412 decaysRecorded = true;
413 // I don't think that I want to set up an elaborate check that a width
414 // & 100% sum of BRs have been recorded to set decaysRecorded.
415 }

◆ setFlags()

MassEigenstate & LHPC::MassEigenstate::setFlags ( std::vector< bool > const *const  flagBools)
inline

Definition at line 780 of file MassEigenstate.hpp.

781 {
782 this->flagBools = flagBools;
783 return *this;
784 }

◆ setLatexName()

MassEigenstate & LHPC::MassEigenstate::setLatexName ( std::string const &  latexName)
inline

Definition at line 767 of file MassEigenstate.hpp.

768 {
769 this->latexName.assign( latexName );
770 return *this;
771 }

◆ setToBeChargeConjugate()

void LHPC::MassEigenstate::setToBeChargeConjugate ( MassEigenstate *const  chargeConjugate)

Definition at line 300 of file MassEigenstate.cpp.

302 {
303 this->chargeConjugate = chargeConjugate;
304 /* not only does the pointer to the charge conjugate need to be set, but
305 * the codes need to be signed. chargeConjugate's codes are assumed to be
306 * the right signs.
307 */
308 for( int codeIndex( identifyingPdgCodes.size() - 1 );
309 0 <= codeIndex;
310 --codeIndex )
311 {
312 MassEigenstateCodeMap::iterator codeFinder;
313 if( chargeConjugate->hasCode( identifyingPdgCodes[ codeIndex ] ) )
314 // if chargeConjugate should have the positive code...
315 {
316 // ensure that pdgCodeMap associates chargeConjugate with the positive
317 // code:
318 codeFinder = pdgCodeMap.find( identifyingPdgCodes[ codeIndex ] );
319 if( pdgCodeMap.end() != codeFinder )
320 {
321 codeFinder->second = chargeConjugate;
322 }
323 identifyingPdgCodes[ codeIndex ] = -(identifyingPdgCodes[ codeIndex ]);
324 // now this instance can set its code to be negative.
325 }
326 }
327 }
LHPC::MassEigenstate::hasCode
bool hasCode(int const pdgCode) const
Definition: MassEigenstate.hpp:314

◆ setToBeSelfConjugate()

void LHPC::MassEigenstate::setToBeSelfConjugate ( )
inline

Definition at line 289 of file MassEigenstate.hpp.

290 {
291 chargeConjugate = this;
292 /* not only does this need to set its chargeConjugate pointer back to
293 * itself, but the codes need to be set to positive & pdgCodeMap needs to
294 * only look for this instance rather than its old chargeConjugate.
295 */
296 for( int codeIndex( identifyingPdgCodes.size() - 1 );
297 0 <= codeIndex;
298 --codeIndex )
299 {
300 MassEigenstateCodeMap::iterator codeFinder;
301 if( 0 > identifyingPdgCodes[ codeIndex ] )
302 {
303 identifyingPdgCodes[ codeIndex ] = -identifyingPdgCodes[ codeIndex ];
304 codeFinder = pdgCodeMap.find( identifyingPdgCodes[ codeIndex ] );
305 if( pdgCodeMap.end() != codeFinder )
306 {
307 codeFinder->second = this;
308 }
309 }
310 }
311 }

Member Data Documentation

◆ absoluteDefaultMass

double LHPC::MassEigenstate::absoluteDefaultMass
protected

Definition at line 226 of file MassEigenstate.hpp.

◆ asciiName

std::string LHPC::MassEigenstate::asciiName
protected

Definition at line 236 of file MassEigenstate.hpp.

◆ chargeConjugate

MassEigenstate* LHPC::MassEigenstate::chargeConjugate
protected

Definition at line 217 of file MassEigenstate.hpp.

◆ decaySet

BOL::VectorlikeArray< MassEigenstatesPairedWithBr > LHPC::MassEigenstate::decaySet
protected

Definition at line 234 of file MassEigenstate.hpp.

◆ decaySetAsVector

std::vector< MassEigenstatesPairedWithBr* > LHPC::MassEigenstate::decaySetAsVector
protected

Definition at line 235 of file MassEigenstate.hpp.

◆ decaysRecorded

bool LHPC::MassEigenstate::decaysRecorded
protected

Definition at line 230 of file MassEigenstate.hpp.

◆ decayWidth

double LHPC::MassEigenstate::decayWidth
protected

Definition at line 232 of file MassEigenstate.hpp.

◆ defaultDecaySet

BOL::VectorlikeArray< MassEigenstatesPairedWithBr > LHPC::MassEigenstate::defaultDecaySet
protected

Definition at line 233 of file MassEigenstate.hpp.

◆ defaultDecayWidth

double const LHPC::MassEigenstate::defaultDecayWidth
protected

Definition at line 231 of file MassEigenstate.hpp.

◆ defaultResetMass

double const LHPC::MassEigenstate::defaultResetMass
protected

Definition at line 223 of file MassEigenstate.hpp.

◆ flagBools

std::vector< bool > const* LHPC::MassEigenstate::flagBools
protected

Definition at line 239 of file MassEigenstate.hpp.

◆ identifyingPdgCodes

std::vector< int > LHPC::MassEigenstate::identifyingPdgCodes
protected

Definition at line 219 of file MassEigenstate.hpp.

◆ isSelfConjugateFlag

bool LHPC::MassEigenstate::isSelfConjugateFlag
protected

Definition at line 218 of file MassEigenstate.hpp.

◆ isVerbose

bool const LHPC::MassEigenstate::isVerbose
protected

Definition at line 238 of file MassEigenstate.hpp.

◆ latexName

std::string LHPC::MassEigenstate::latexName
protected

Definition at line 237 of file MassEigenstate.hpp.

◆ mapFiller

std::pair< int, MassEigenstate* > LHPC::MassEigenstate::mapFiller
protected

Definition at line 221 of file MassEigenstate.hpp.

◆ massRecorded

bool LHPC::MassEigenstate::massRecorded
protected

Definition at line 222 of file MassEigenstate.hpp.

◆ pdgCodeMap

MassEigenstateCodeMap& LHPC::MassEigenstate::pdgCodeMap
protected

Definition at line 220 of file MassEigenstate.hpp.

◆ runningMasses

BOL::VectorlikeArray< ExtendedMass > LHPC::MassEigenstate::runningMasses
protected

Definition at line 228 of file MassEigenstate.hpp.

◆ runningMassesAsVector

std::vector< ExtendedMass* > LHPC::MassEigenstate::runningMassesAsVector
protected

Definition at line 229 of file MassEigenstate.hpp.

◆ setOfPointersOfMassEigenstateGroup

MassEigenstateVector& LHPC::MassEigenstate::setOfPointersOfMassEigenstateGroup
protected

Definition at line 240 of file MassEigenstate.hpp.

◆ signedDefaultMass

double LHPC::MassEigenstate::signedDefaultMass
protected

Definition at line 224 of file MassEigenstate.hpp.

The documentation for this class was generated from the following files: