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

#include <SpectrumUpdater.hpp>

Detailed Description

Definition at line 28 of file SpectrumUpdater.hpp.

Public Member Functions

void clearDecay ()
 
bool isHoldingDecay () const
 
void recordDecayHeader (std::string const &decayerCode, std::string const &decayWidth)
 
void recordDecayLine (BOL::VectorlikeArray< std::string > const &decayLine)
 
void setFmasserrMap (std::multimap< int, RunningConstantError > const *fmasserrMap)
 
void setFmassMap (std::multimap< int, RunningConstant > const *fmassMap)
 
void setMassMap (std::map< int, double > const *massMap)
 
 SpectrumUpdater ()
 
void updateMassEigenstates (MassEigenstateCodeToPointerMap &codeMap) const
 
 ~SpectrumUpdater ()
 

Protected Attributes

std::pair< double, std::vector< int > > branchingRatioAndProducts
 
std::vector< std::pair< double, std::vector< int > > > decayChannels
 
int decayerCode
 
double decayWidth
 
std::multimap< int, RunningConstantError > const * fmasserrMap
 
std::multimap< int, RunningConstant > const * fmassMap
 
bool isHoldingDecayFlag
 
std::map< int, double > const * massMap
 

Constructor & Destructor Documentation

◆ SpectrumUpdater()

LHPC::SpectrumUpdater::SpectrumUpdater ( )

Definition at line 18 of file SpectrumUpdater.cpp.

18 :
19 fmassMap( NULL ),
20 fmasserrMap( NULL ),
21 massMap( NULL ),
22 isHoldingDecayFlag( false ),
23 decayerCode( 0 ),
24 decayWidth( BOL::UsefulStuff::notANumber ),
25 decayChannels(),
26 branchingRatioAndProducts()
27 {
28 // just an initialization list.
29 }
BOL::UsefulStuff::notANumber
static double const notANumber
Definition: UsefulStuff.hpp:28
LHPC::SpectrumUpdater::massMap
std::map< int, double > const * massMap
Definition: SpectrumUpdater.hpp:57
LHPC::SpectrumUpdater::fmasserrMap
std::multimap< int, RunningConstantError > const * fmasserrMap
Definition: SpectrumUpdater.hpp:56
LHPC::SpectrumUpdater::fmassMap
std::multimap< int, RunningConstant > const * fmassMap
Definition: SpectrumUpdater.hpp:55
LHPC::SpectrumUpdater::branchingRatioAndProducts
std::pair< double, std::vector< int > > branchingRatioAndProducts
Definition: SpectrumUpdater.hpp:63
LHPC::SpectrumUpdater::decayChannels
std::vector< std::pair< double, std::vector< int > > > decayChannels
Definition: SpectrumUpdater.hpp:62

◆ ~SpectrumUpdater()

LHPC::SpectrumUpdater::~SpectrumUpdater ( )

Definition at line 31 of file SpectrumUpdater.cpp.

32 {
33 // does nothing.
34 }

Member Function Documentation

◆ clearDecay()

void LHPC::SpectrumUpdater::clearDecay ( )
inline

Definition at line 97 of file SpectrumUpdater.hpp.

98 {
99 decayChannels.clear();
100 isHoldingDecayFlag = false;
101 }

◆ isHoldingDecay()

bool LHPC::SpectrumUpdater::isHoldingDecay ( ) const
inline

Definition at line 91 of file SpectrumUpdater.hpp.

92 {
93 return isHoldingDecayFlag;
94 }

◆ recordDecayHeader()

void LHPC::SpectrumUpdater::recordDecayHeader ( std::string const &  decayerCode,
std::string const &  decayWidth 
)
inline

Definition at line 104 of file SpectrumUpdater.hpp.

106 {
107 this->decayerCode = BOL::StringParser::stringToInt( decayerCode );
108 this->decayWidth = BOL::StringParser::stringToDouble( decayWidth );
109 isHoldingDecayFlag = true;
110 }
BOL::StringParser::stringToDouble
static double stringToDouble(std::string const &stringToInterpret)
Definition: StringParser.hpp:422
BOL::StringParser::stringToInt
static int stringToInt(std::string const &stringToInterpret)
Definition: StringParser.hpp:414

◆ recordDecayLine()

void LHPC::SpectrumUpdater::recordDecayLine ( BOL::VectorlikeArray< std::string > const &  decayLine)
inline

Definition at line 113 of file SpectrumUpdater.hpp.

115 {
116 branchingRatioAndProducts.first
117 = BOL::StringParser::stringToDouble( decayLine[ 0 ] );
118 branchingRatioAndProducts.second.clear();
119 for( int whichWord( decayLine.getLastIndex() );
120 1 < whichWord;
121 --whichWord )
122 {
123 branchingRatioAndProducts.second.push_back(
124 BOL::StringParser::stringToInt( decayLine[ whichWord ] ) );
125 }
126 decayChannels.push_back( branchingRatioAndProducts );
127 }

◆ setFmasserrMap()

void LHPC::SpectrumUpdater::setFmasserrMap ( std::multimap< int, RunningConstantError > const *  fmasserrMap)
inline

Definition at line 78 of file SpectrumUpdater.hpp.

80 {
81 this->fmasserrMap = fmasserrMap;
82 }

◆ setFmassMap()

void LHPC::SpectrumUpdater::setFmassMap ( std::multimap< int, RunningConstant > const *  fmassMap)
inline

Definition at line 71 of file SpectrumUpdater.hpp.

73 {
74 this->fmassMap = fmassMap;
75 }

◆ setMassMap()

void LHPC::SpectrumUpdater::setMassMap ( std::map< int, double > const *  massMap)
inline

Definition at line 85 of file SpectrumUpdater.hpp.

86 {
87 this->massMap = massMap;
88 }

◆ updateMassEigenstates()

void LHPC::SpectrumUpdater::updateMassEigenstates ( MassEigenstateCodeToPointerMap &  codeMap) const

Definition at line 38 of file SpectrumUpdater.cpp.

40 {
41 MassEigenstate* massEigenstateFiller( NULL );
42 // 1st the masses from the MASS block are recorded:
43
44 if( NULL != massMap )
45 {
46 std::map< int, double >::const_iterator
47 massMapIterator( massMap->begin() );
48 while( massMap->end() != massMapIterator )
49 {
50 massEigenstateFiller
51 = MassEigenstate::findPointerWithCode( massMapIterator->first,
52 codeMap );
53 if( NULL != massEigenstateFiller )
54 {
55 massEigenstateFiller->recordMass( massMapIterator->second );
56 // now the charge-conjugate is considered:
57 if( !(massEigenstateFiller->getChargeConjugate(
58 ).hasMassBeenRecorded()) )
59 {
60 massEigenstateFiller->getChargeConjugate().recordMass(
61 massMapIterator->second );
62 }
63 }
64 ++massMapIterator;
65 }
66 }
67
68 // then the masses from the FMASS block are recorded:
69 if( NULL != fmassMap )
70 {
71 std::multimap< int, RunningConstant >::const_iterator
72 fmassMapIterator( fmassMap->begin() );
73 while( fmassMap->end() != fmassMapIterator )
74 {
75 massEigenstateFiller
76 = MassEigenstate::findPointerWithCode( fmassMapIterator->first,
77 codeMap );
78 if( NULL != massEigenstateFiller )
79 {
80 massEigenstateFiller->recordMass(
81 fmassMapIterator->second.getValue(),
82 0.0,
83 0.0,
84 fmassMapIterator->second.getScheme(),
85 fmassMapIterator->second.getScale() );
86 // now the charge-conjugate is considered:
87 if( massEigenstateFiller->getChargeConjugate(
88 ).getAllRecordedMasses().size()
89 < massEigenstateFiller->getAllRecordedMasses().size() )
90 {
91 massEigenstateFiller->getChargeConjugate().recordMass(
92 fmassMapIterator->second.getValue(),
93 0.0,
94 0.0,
95 fmassMapIterator->second.getScheme(),
96 fmassMapIterator->second.getScale() );
97 }
98 }
99 ++fmassMapIterator;
100 }
101 }
102
103 // then the mass errors from the FMASSERR block are recorded:
104 if( NULL != fmasserrMap )
105 {
106 std::multimap< int, RunningConstantError >::const_iterator
107 fmasserrMapIterator( fmasserrMap->begin() );
108 while( fmasserrMap->end() != fmasserrMapIterator )
109 {
110 massEigenstateFiller
111 = MassEigenstate::findPointerWithCode( fmasserrMapIterator->first,
112 codeMap );
113 if( NULL != massEigenstateFiller )
114 {
115 massEigenstateFiller->recordMassError(
116 fmasserrMapIterator->second.getMinusUncertainty(),
117 fmasserrMapIterator->second.getPlusUncertainty(),
118 fmasserrMapIterator->second.getScheme(),
119 fmasserrMapIterator->second.getScale() );
120 // now the charge-conjugate is considered:
121 if( !(massEigenstateFiller->isSelfConjugate()) )
122 {
123 massEigenstateFiller->getChargeConjugate().recordMassError(
124 fmasserrMapIterator->second.getMinusUncertainty(),
125 fmasserrMapIterator->second.getPlusUncertainty(),
126 fmasserrMapIterator->second.getScheme(),
127 fmasserrMapIterator->second.getScale() );
128 // recordMassError does nothing if it doesn't find a matching
129 // running mass.
130 }
131 }
132 ++fmasserrMapIterator;
133 }
134 }
135
136 // finally the given decay is recorded:
137 if( isHoldingDecayFlag )
138 {
139 MassEigenstate::MassEigenstatesPairedWithBr decayRecorder;
140 massEigenstateFiller
141 = MassEigenstate::findPointerWithCode( decayerCode,
142 codeMap );
143 massEigenstateFiller->setDecayWidth( decayWidth );
144 size_t numberOfChannels( decayChannels.size() );
145 for( size_t whichChannel( 0 );
146 numberOfChannels > whichChannel;
147 ++whichChannel )
148 {
149 decayRecorder.clearPointers();
150 for( int whichProduct( decayChannels[ whichChannel ].second.size()
151 - 1 );
152 0 <= whichProduct;
153 --whichProduct )
154 {
155 decayRecorder.addPointer( MassEigenstate::findPointerWithCode(
156 decayChannels[ whichChannel ].second[ whichProduct ],
157 codeMap ) );
158 }
159 decayRecorder.setPairedValueAndSortPointers(
160 decayChannels[ whichChannel ].first );
161 massEigenstateFiller->recordDecay( decayRecorder );
162 }
163
164 /* next, the mass eigenstate is checked for whether it has a charge
165 * conjugate & whether it has already recorded a decay (so that
166 * charge-conjugate pairs do not necessarily have the same decay widths
167 * & branching ratios: they are initially set to be so when the 1st of a
168 * pair is recorded, but if its charge conjugate is found, only the
169 * charge conjugate gets its decays overwritten.
170 */
171 if( !(massEigenstateFiller->isSelfConjugate())
172 &&
173 !(massEigenstateFiller->getChargeConjugate(
174 ).haveDecaysBeenRecorded()) )
175 {
176 numberOfChannels = massEigenstateFiller->getDecaySet().size();
177 for( size_t whichDecay( 0 );
178 numberOfChannels > whichDecay;
179 ++whichDecay )
180 {
181 massEigenstateFiller->getChargeConjugate(
182 ).recordChargeConjugateOfDecay(
183 *(massEigenstateFiller->getDecaySet()[ whichDecay ]) );
184 }
185 massEigenstateFiller->getChargeConjugate().setDecayWidth( decayWidth );
186 }
187 }
188 }
LHPC::MassEigenstate::findPointerWithCode
static MassEigenstate * findPointerWithCode(int pdgCode, MassEigenstateCodeMap const &codeMap)
Definition: MassEigenstate.cpp:19
LHPC::MassEigenstate::MassEigenstatesPairedWithBr
PointersWithValue< MassEigenstate const *, double > MassEigenstatesPairedWithBr
Definition: MassEigenstate.hpp:39

Member Data Documentation

◆ branchingRatioAndProducts

std::pair< double, std::vector< int > > LHPC::SpectrumUpdater::branchingRatioAndProducts
protected

Definition at line 63 of file SpectrumUpdater.hpp.

◆ decayChannels

std::vector< std::pair< double, std::vector< int > > > LHPC::SpectrumUpdater::decayChannels
protected

Definition at line 62 of file SpectrumUpdater.hpp.

◆ decayerCode

int LHPC::SpectrumUpdater::decayerCode
protected

Definition at line 59 of file SpectrumUpdater.hpp.

◆ decayWidth

double LHPC::SpectrumUpdater::decayWidth
protected

Definition at line 60 of file SpectrumUpdater.hpp.

◆ fmasserrMap

std::multimap< int, RunningConstantError > const* LHPC::SpectrumUpdater::fmasserrMap
protected

Definition at line 56 of file SpectrumUpdater.hpp.

◆ fmassMap

std::multimap< int, RunningConstant > const* LHPC::SpectrumUpdater::fmassMap
protected

Definition at line 55 of file SpectrumUpdater.hpp.

◆ isHoldingDecayFlag

bool LHPC::SpectrumUpdater::isHoldingDecayFlag
protected

Definition at line 58 of file SpectrumUpdater.hpp.

◆ massMap

std::map< int, double > const* LHPC::SpectrumUpdater::massMap
protected

Definition at line 57 of file SpectrumUpdater.hpp.

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