Bug Summary

File:libraries/ANALYSIS/DParticleCombo_factory.cc
Location:line 252, column 5
Description:Value stored to 'locPID' is never read

Annotated Source Code

1#ifdef VTRACE
2#include "vt_user.h"
3#endif
4
5#include "DParticleCombo_factory.h"
6
7//------------------
8// init
9//------------------
10jerror_t DParticleCombo_factory::init(void)
11{
12 MAX_DParticleComboStepPoolSize = 200;
13 MAX_DKinematicDataPoolSize = 40;
14
15 //Setting this flag makes it so that JANA does not delete the objects in _data. This factory will manage this memory.
16 //All combos that fail the kinematic fit, or aren't fit at all, are identical to the pre-combo versions.
17 //For these combos, just save the pointers to the previous objects in _data.
18 SetFactoryFlag(NOT_OBJECT_OWNER);
19 return NOERROR;
20}
21
22//------------------
23// brun
24//------------------
25jerror_t DParticleCombo_factory::brun(jana::JEventLoop* locEventLoop, int32_t runnumber)
26{
27 DApplication* locApplication = dynamic_cast<DApplication*>(locEventLoop->GetJApplication());
28 const DMagneticFieldMap* locMagneticFieldMap = locApplication->GetBfield(runnumber);
29
30 double locTargetZCenter = 65.0;
31 DGeometry* locGeometry = locApplication->GetDGeometry(locEventLoop->GetJEvent().GetRunNumber());
32 locGeometry->GetTargetZ(locTargetZCenter);
33
34 double locBx, locBy, locBz;
35 locMagneticFieldMap->GetField(0.0, 0.0, locTargetZCenter, locBx, locBy, locBz);
36 TVector3 locBField(locBx, locBy, locBz);
37 if(locBField.Mag() > 0.0)
38 dKinFitter.Set_BField(locMagneticFieldMap);
39
40 // Get # of DReactions:
41 // Get list of factories and find all the ones producing
42 // DReaction objects. (A simpler way to do this would be to
43 // just use locEventLoop->Get(...), but then only one plugin could
44 // be used at a time.)
45 size_t locNumReactions = 0;
46 vector<JFactory_base*> locFactories = locEventLoop->GetFactories();
47 for(size_t loc_i = 0; loc_i < locFactories.size(); ++loc_i)
48 {
49 JFactory<DReaction>* locFactory = dynamic_cast<JFactory<DReaction>* >(locFactories[loc_i]);
50 if(locFactory == NULL__null)
51 continue;
52 if(string(locFactory->Tag()) == "Thrown")
53 continue;
54 // Found a factory producing DReactions. The reaction objects are
55 // produced at the init stage and are persistent through all event
56 // processing so we can grab the list here and append it to our
57 // overall list.
58 vector<const DReaction*> locReactionsSubset;
59 locFactory->Get(locReactionsSubset);
60 locNumReactions += locReactionsSubset.size();
61 }
62
63 MAX_DParticleComboStepPoolSize = 100*locNumReactions;
64 MAX_DKinematicDataPoolSize = 100*locNumReactions;
65
66 return NOERROR;
67}
68
69//------------------
70// evnt
71//------------------
72jerror_t DParticleCombo_factory::evnt(JEventLoop* locEventLoop, uint64_t eventnumber)
73{
74#ifdef VTRACE
75 VT_TRACER("DParticleCombo_factory::evnt()");
76#endif
77
78 Reset_Data();
79 Reset_Pools();
80
81 vector<const DKinFitResults*> locKinFitResultsVector;
82 locEventLoop->Get(locKinFitResultsVector);
83
84 vector<const DAnalysisResults*> locAnalysisResultsVector;
85 locEventLoop->Get(locAnalysisResultsVector, "PreKinFit");
86
87 set<const DParticleCombo*> locParticleCombos_FailedKinFit; //fill with all eligible, will erase as they are validated
88 for(size_t loc_i = 0; loc_i < locAnalysisResultsVector.size(); ++loc_i)
89 {
90 deque<const DParticleCombo*> locSurvivedParticleCombos;
91 locAnalysisResultsVector[loc_i]->Get_PassedParticleCombos(locSurvivedParticleCombos);
92
93 const DReaction* locReaction = locAnalysisResultsVector[loc_i]->Get_Reaction();
94 if(locReaction->Get_KinFitType() == d_NoFit) //kinfit not requested, just clone the original objects
95 {
96 for(size_t loc_j = 0; loc_j < locSurvivedParticleCombos.size(); ++loc_j)
97 _data.push_back(const_cast<DParticleCombo*>(locSurvivedParticleCombos[loc_j]));
98 continue;
99 }
100 for(size_t loc_j = 0; loc_j < locSurvivedParticleCombos.size(); ++loc_j)
101 locParticleCombos_FailedKinFit.insert(locSurvivedParticleCombos[loc_j]);
102 }
103
104 if(locKinFitResultsVector.empty())
105 {
106 //all failed! save 'em and bail
107 set<const DParticleCombo*>::iterator locIterator = locParticleCombos_FailedKinFit.begin();
108 for(; locIterator != locParticleCombos_FailedKinFit.end(); ++locIterator)
109 _data.push_back(const_cast<DParticleCombo*>(*locIterator));
110 return NOERROR; //kinfit not requested (or all kinfits failed): done
111 }
112
113 vector<const DChargedTrackHypothesis*> locChargedTrackHypotheses;
114 locEventLoop->Get(locChargedTrackHypotheses, "KinFit");
115
116 vector<const DNeutralParticleHypothesis*> locNeutralParticleHypotheses;
117 locEventLoop->Get(locNeutralParticleHypotheses, "KinFit");
118
119 vector<const DBeamPhoton*> locBeamPhotons;
120 locEventLoop->Get(locBeamPhotons, "KinFit");
121
122 DKinematicData* locKinematicData;
123 const DKinFitParticle* locKinFitParticle;
124 vector<const DParticleComboBlueprint*> locParticleComboBlueprints_Associated;
125 vector<const DParticleCombo*> locParticleCombos_Associated;
126 Particle_t locPID;
127 map<pair<Particle_t, deque<const DKinematicData*> >, const DKinFitParticle*> locDecayingParticles;
128
129 map<const DParticleCombo*, DParticleCombo*> locKinFitParticleComboMap;
130 for(size_t loc_i = 0; loc_i < locKinFitResultsVector.size(); ++loc_i)
131 {
132 DKinFitType locKinFitType = locKinFitResultsVector[loc_i]->Get_KinFitType();
133
134 set<const DParticleCombo*> locParticleCombos;
135 locKinFitResultsVector[loc_i]->Get_ParticleCombos(locParticleCombos); //each result may be for several combos (duplicate results)
136
137 set<const DParticleCombo*>::iterator locComboIterator = locParticleCombos.begin();
138 for(; locComboIterator != locParticleCombos.end(); ++locComboIterator)
139 {
140 const DParticleCombo* locParticleCombo = *locComboIterator;
141 const DReaction* locReaction = locParticleCombo->Get_Reaction();
142
143 locParticleCombos_FailedKinFit.erase(locParticleCombo); //kinfit successful, don't copy pointer later
144
145 DParticleCombo* locNewParticleCombo = new DParticleCombo();
146 dCreatedParticleCombos.push_back(locNewParticleCombo);
147 locNewParticleCombo->Set_Reaction(locParticleCombo->Get_Reaction());
148 locNewParticleCombo->Set_KinFitResults(locKinFitResultsVector[loc_i]);
149 locNewParticleCombo->Set_EventRFBunch(locParticleCombo->Get_EventRFBunch());
150
151 locParticleCombo->GetT(locParticleComboBlueprints_Associated);
152 locNewParticleCombo->AddAssociatedObject(locParticleComboBlueprints_Associated[0]);
153 locNewParticleCombo->AddAssociatedObject(locParticleCombo);
154
155 //search to see if the results were the same as a previous combo. if so, copy them:
156 //note that it is possible for two combos with different steps to have the same kinfit results (e.g. one has an omega or phi, and the other doesn't)
157 bool locMatchFlag = false;
158 set<const DParticleCombo*>::iterator locPreviousComboIterator = locParticleCombos.begin();
159 for(; locPreviousComboIterator != locComboIterator; ++locPreviousComboIterator)
160 {
161 const DParticleCombo* locPreviousParticleCombo = *locPreviousComboIterator;
162 if(locParticleCombo->Get_Reaction() == locPreviousParticleCombo->Get_Reaction()) //probably shouldn't be possible
163 continue; //dreaction is the same: particle combos were different for a reason, even if the kinfit results are the same (e.g. ???): keep both
164
165 //see if steps are identical //may have an omega or phi resonance
166 if(!locReaction->Check_AreStepsIdentical(locPreviousParticleCombo->Get_Reaction()))
167 continue; //steps are not identical
168 //see if particles are identical //particles may be in a different order
169 if(!locParticleCombo->Check_AreMeasuredParticlesIdentical(locPreviousParticleCombo))
170 continue; //particles are not identical
171
172 //everything is identical: copy results
173 const DParticleCombo* locPreviousNewParticleCombo = locKinFitParticleComboMap[locPreviousParticleCombo];
174 for(size_t loc_k = 0; loc_k < locPreviousNewParticleCombo->Get_NumParticleComboSteps(); ++loc_k)
175 locNewParticleCombo->Add_ParticleComboStep(locPreviousNewParticleCombo->Get_ParticleComboStep(loc_k));
176 locMatchFlag = true;
177 break;
178 }
179 if(locMatchFlag)
180 {
181 _data.push_back(locNewParticleCombo);
182 continue;
183 }
184
185 //unique combo: build steps
186 locKinFitResultsVector[loc_i]->Get_DecayingParticles(locDecayingParticles);
187 for(size_t loc_j = 0; loc_j < locParticleCombo->Get_NumParticleComboSteps(); ++loc_j)
188 {
189 const DParticleComboStep* locParticleComboStep = locParticleCombo->Get_ParticleComboStep(loc_j);
190 DParticleComboStep* locNewParticleComboStep = Get_ParticleComboStepResource();
191 locNewParticleComboStep->Set_MeasuredParticleComboStep(locParticleComboStep);
192 locNewParticleComboStep->Set_ParticleComboBlueprintStep(locParticleComboStep->Get_ParticleComboBlueprintStep());
193 locNewParticleComboStep->Set_SpacetimeVertex(locParticleComboStep->Get_SpacetimeVertex()); //overridden if kinematic fit
194 bool locWasVertexKinFitFlag = ((locKinFitType != d_NoFit) && (locKinFitType != d_P4Fit));
195 bool locWasTimeKinFitFlag = ((locKinFitType == d_SpacetimeFit) || (locKinFitType == d_P4AndSpacetimeFit));
196
197 //INITIAL PARTICLE & SPACETIME VERTEX
198 locPID = locParticleComboStep->Get_InitialParticleID();
199 if(locParticleComboStep->Is_InitialParticleDetected()) //set beam photon
200 {
201 for(size_t loc_k = 0; loc_k < locBeamPhotons.size(); ++loc_k)
202 {
203 locBeamPhotons[loc_k]->GetT(locParticleCombos_Associated);
204 bool locMatchFlag = false;
205 for(size_t loc_m = 0; loc_m < locParticleCombos_Associated.size(); ++loc_m)
206 {
207 if(locParticleCombos_Associated[loc_m] != locParticleCombo)
208 continue;
209 locMatchFlag = true;
210 break;
211 }
212 if(!locMatchFlag)
213 continue; // beam photon created for a different particle combo
214 locNewParticleComboStep->Set_InitialParticle(locBeamPhotons[loc_k]);
215 if(locWasVertexKinFitFlag)
216 locNewParticleComboStep->Set_Position(locBeamPhotons[loc_k]->position());
217 if(locWasTimeKinFitFlag)
218 locNewParticleComboStep->Set_Time(locBeamPhotons[loc_k]->time());
219 break;
220 }
221 }
222 else //decaying particle!
223 {
224 deque<const DKinematicData*> locDecayProducts;
225 locParticleCombo->Get_DecayChainParticles_Measured(loc_j, locDecayProducts);
226 pair<Particle_t, deque<const DKinematicData*> > locDecayInfoPair(locPID, locDecayProducts);
227 locKinFitParticle = locDecayingParticles[locDecayInfoPair];
228 if(locKinFitParticle != NULL__null)
229 {
230 locKinematicData = Build_KinematicData(locPID, locKinFitParticle);
231 //if true: propagate the track info from the production vertex to the decay vertex
232 if(locKinFitParticle->Get_DecayingParticleAtProductionVertexFlag() && (locKinFitParticle->Get_NumVertexFits() == 2))
233 dKinFitter.Propagate_TrackInfoToCommonVertex(locKinematicData, locKinFitParticle, locKinFitResultsVector[loc_i]->Get_VXi());
234 if(locWasVertexKinFitFlag)
235 locNewParticleComboStep->Set_Position(locKinematicData->position());
236 if(locWasTimeKinFitFlag)
237 locNewParticleComboStep->Set_Time(locKinematicData->time());
238 }
239 else
240 {
241 locKinematicData = NULL__null;
242 //if initial step, or vertex not fit, get from pre-kinfit
243 //resonance: get spacetime vertex from step where this particle was produced
244 int locInitialParticleDecayFromStepIndex = locParticleComboStep->Get_InitialParticleDecayFromStepIndex();
245 const DParticleComboStep* locPreviousParticleComboStep = locParticleCombo->Get_ParticleComboStep(locInitialParticleDecayFromStepIndex);
246 locNewParticleComboStep->Set_SpacetimeVertex(locPreviousParticleComboStep->Get_SpacetimeVertex());
247 }
248 locNewParticleComboStep->Set_InitialParticle(locKinematicData);
249 }
250
251 //TARGET PARTICLE //set position and time??
252 locPID = locParticleComboStep->Get_InitialParticleID();
Value stored to 'locPID' is never read
253 if(locParticleComboStep->Is_TargetPresent())
254 locNewParticleComboStep->Set_TargetParticle(locParticleComboStep->Get_TargetParticle());
255
256 //FINAL PARTICLES
257 for(size_t loc_k = 0; loc_k < locParticleComboStep->Get_NumFinalParticles(); ++loc_k)
258 {
259 const DKinematicData* locKinematicData_Measured = locParticleComboStep->Get_FinalParticle_Measured(loc_k);
260 locPID = locParticleComboStep->Get_FinalParticleID(loc_k);
261 if(locParticleComboStep->Is_FinalParticleMissing(loc_k)) //missing!
262 {
263 locKinFitParticle = locKinFitResultsVector[loc_i]->Get_MissingParticle();;
264 locKinematicData = (locKinFitParticle != NULL__null) ? Build_KinematicData(locPID, locKinFitParticle) : NULL__null;
265 locNewParticleComboStep->Add_FinalParticle(locKinematicData);
266 }
267 else if(locParticleComboStep->Is_FinalParticleDecaying(loc_k)) //decaying!
268 {
269 deque<const DKinematicData*> locDecayProducts;
270 locParticleCombo->Get_DecayChainParticles_Measured(locParticleComboStep->Get_DecayStepIndex(loc_k), locDecayProducts);
271 pair<Particle_t, deque<const DKinematicData*> > locDecayInfoPair(locPID, locDecayProducts);
272 locKinFitParticle = locDecayingParticles[locDecayInfoPair];
273 if(locKinFitParticle != NULL__null)
274 {
275 locKinematicData = Build_KinematicData(locPID, locKinFitParticle);
276 //if true: propagate the track info from the decay vertex to the production vertex
277 if(!locKinFitParticle->Get_DecayingParticleAtProductionVertexFlag() && (locKinFitParticle->Get_NumVertexFits() == 2))
278 dKinFitter.Propagate_TrackInfoToCommonVertex(locKinematicData, locKinFitParticle, locKinFitResultsVector[loc_i]->Get_VXi());
279 }
280 else
281 locKinematicData = NULL__null;
282 locNewParticleComboStep->Add_FinalParticle(locKinematicData);
283 }
284 else if(locParticleComboStep->Is_FinalParticleNeutral(loc_k)) //neutral
285 {
286 for(size_t loc_l = 0; loc_l < locNeutralParticleHypotheses.size(); ++loc_l)
287 {
288 vector<const DNeutralParticleHypothesis*> locNeutralParticleHypotheses_Associated;
289 locNeutralParticleHypotheses[loc_l]->Get(locNeutralParticleHypotheses_Associated);
290 //loop over associated: default tag, "Combo" tag, etc.
291 bool locMatchFlag = false;
292 for(size_t loc_m = 0; loc_m < locNeutralParticleHypotheses_Associated.size(); ++loc_m)
293 {
294 if(locNeutralParticleHypotheses_Associated[loc_m] != locKinematicData_Measured)
295 continue; //wrong neutral hypothesis
296 locNeutralParticleHypotheses[loc_l]->Get(locParticleCombos_Associated);
297 for(size_t loc_n = 0; loc_n < locParticleCombos_Associated.size(); ++loc_n)
298 {
299 if(locParticleCombos_Associated[loc_n] != locParticleCombo)
300 continue;
301 locMatchFlag = true;
302 break;
303 }
304 if(!locMatchFlag)
305 continue; // track created for a different particle combo
306 locNewParticleComboStep->Add_FinalParticle(locNeutralParticleHypotheses[loc_l]);
307 break;
308 }
309 if(locMatchFlag)
310 break;
311 }
312 }
313 else //charged
314 {
315 for(size_t loc_l = 0; loc_l < locChargedTrackHypotheses.size(); ++loc_l)
316 {
317 vector<const DChargedTrackHypothesis*> locChargedTrackHypotheses_Associated;
318 locChargedTrackHypotheses[loc_l]->Get(locChargedTrackHypotheses_Associated);
319 //loop over associated: default tag, "Combo" tag, etc.
320 bool locMatchFlag = false;
321 for(size_t loc_m = 0; loc_m < locChargedTrackHypotheses_Associated.size(); ++loc_m)
322 {
323 if(locChargedTrackHypotheses_Associated[loc_m] != locKinematicData_Measured)
324 continue; //wrong track hypothesis
325 locChargedTrackHypotheses[loc_l]->Get(locParticleCombos_Associated);
326 for(size_t loc_n = 0; loc_n < locParticleCombos_Associated.size(); ++loc_n)
327 {
328 if(locParticleCombos_Associated[loc_n] != locParticleCombo)
329 continue;
330 locMatchFlag = true;
331 break;
332 }
333 if(!locMatchFlag)
334 continue; // track created for a different particle combo
335 locNewParticleComboStep->Add_FinalParticle(locChargedTrackHypotheses[loc_l]);
336 break;
337 }
338 if(locMatchFlag)
339 break;
340 }
341 }
342 }
343 locNewParticleCombo->Add_ParticleComboStep(locNewParticleComboStep);
344 }
345
346 locKinFitParticleComboMap[locParticleCombo] = locNewParticleCombo;
347 _data.push_back(locNewParticleCombo);
348 }
349 }
350
351 //directly save all combos for which the kinfits failed
352 set<const DParticleCombo*>::iterator locIterator = locParticleCombos_FailedKinFit.begin();
353 for(; locIterator != locParticleCombos_FailedKinFit.end(); ++locIterator)
354 _data.push_back(const_cast<DParticleCombo*>(*locIterator));
355
356 return NOERROR;
357}
358
359void DParticleCombo_factory::Reset_Data(void)
360{
361 //delete objects that this factory created (since the NOT_OBJECT_OWNER flag is set)
362 //if there are no kinfit results then they were simply copied from the other factory
363 for(size_t loc_i = 0; loc_i < dCreatedParticleCombos.size(); ++loc_i)
364 delete dCreatedParticleCombos[loc_i];
365 _data.clear();
366 dCreatedParticleCombos.clear();
367}
368
369DKinematicData* DParticleCombo_factory::Build_KinematicData(Particle_t locPID, const DKinFitParticle* locKinFitParticle)
370{
371 DKinematicData* locKinematicData = Get_KinematicDataResource();
372 locKinematicData->setPID(locPID);
373 locKinematicData->setCharge(ParticleCharge(locPID));
374 if(locPID != Unknown)
375 locKinematicData->setMass(ParticleMass(locPID));
376 else
377 locKinematicData->setMass(locKinFitParticle->Get_Mass());
378 locKinematicData->setMomentum(DVector3(locKinFitParticle->Get_Momentum().X(),locKinFitParticle->Get_Momentum().Y(),locKinFitParticle->Get_Momentum().Z()));
379 locKinematicData->setPosition(DVector3(locKinFitParticle->Get_Position().X(),locKinFitParticle->Get_Position().Y(),locKinFitParticle->Get_Position().Z()));
380 locKinematicData->setTime(locKinFitParticle->Get_Time());
381 if(locKinFitParticle->Get_CovarianceMatrix() != NULL__null)
382 locKinematicData->setErrorMatrix(*(locKinFitParticle->Get_CovarianceMatrix()));
383 locKinematicData->setPathLength(locKinFitParticle->Get_PathLength(), locKinFitParticle->Get_PathLengthUncertainty());
384
385 return locKinematicData;
386}
387
388void DParticleCombo_factory::Reset_Pools(void)
389{
390 // delete pool sizes if too large, preventing memory-leakage-like behavor.
391 if(dParticleComboStepPool_All.size() > MAX_DParticleComboStepPoolSize){
392 for(size_t loc_i = MAX_DParticleComboStepPoolSize; loc_i < dParticleComboStepPool_All.size(); ++loc_i)
393 delete dParticleComboStepPool_All[loc_i];
394 dParticleComboStepPool_All.resize(MAX_DParticleComboStepPoolSize);
395 }
396 dParticleComboStepPool_Available = dParticleComboStepPool_All;
397
398 if(dKinematicDataPool_All.size() > MAX_DKinematicDataPoolSize){
399 for(size_t loc_i = MAX_DKinematicDataPoolSize; loc_i < dKinematicDataPool_All.size(); ++loc_i)
400 delete dKinematicDataPool_All[loc_i];
401 dKinematicDataPool_All.resize(MAX_DKinematicDataPoolSize);
402 }
403 dKinematicDataPool_Available = dKinematicDataPool_All;
404}
405
406DKinematicData* DParticleCombo_factory::Get_KinematicDataResource(void)
407{
408 DKinematicData* locKinematicData;
409 if(dKinematicDataPool_Available.empty())
410 {
411 locKinematicData = new DKinematicData;
412 dKinematicDataPool_All.push_back(locKinematicData);
413 }
414 else
415 {
416 locKinematicData = dKinematicDataPool_Available.back();
417 Reset_KinematicData(locKinematicData);
418 locKinematicData->ClearAssociatedObjects();
419 dKinematicDataPool_Available.pop_back();
420 }
421 return locKinematicData;
422}
423
424DParticleComboStep* DParticleCombo_factory::Get_ParticleComboStepResource(void)
425{
426 DParticleComboStep* locParticleComboStep;
427 if(dParticleComboStepPool_Available.empty())
428 {
429 locParticleComboStep = new DParticleComboStep;
430 dParticleComboStepPool_All.push_back(locParticleComboStep);
431 }
432 else
433 {
434 locParticleComboStep = dParticleComboStepPool_Available.back();
435 locParticleComboStep->Reset();
436 dParticleComboStepPool_Available.pop_back();
437 }
438 return locParticleComboStep;
439}
440
441void DParticleCombo_factory::Reset_KinematicData(DKinematicData* locKinematicData)
442{
443 locKinematicData->setPID(Unknown);
444 locKinematicData->setMassFixed();
445 locKinematicData->setCharge(0);
446 locKinematicData->setMass(0.0);
447
448 locKinematicData->setMomentum(DVector3());
449 locKinematicData->setPosition(DVector3());
450 locKinematicData->setTime(0.0);
451
452 locKinematicData->setdEdx(0.0);
453 locKinematicData->setPathLength(0.0, 0.0);
454 locKinematicData->setTrackingStateVector(0.0, 0.0, 0.0, 0.0, 0.0);
455
456 locKinematicData->setT0(0.0, 0.0, SYS_NULL);
457 locKinematicData->setT1(0.0, 0.0, SYS_NULL);
458
459 locKinematicData->clearErrorMatrix();
460 locKinematicData->clearTrackingErrorMatrix();
461}
462
463//------------------
464// erun
465//------------------
466jerror_t DParticleCombo_factory::erun(void)
467{
468 return NOERROR;
469}
470
471//------------------
472// fini
473//------------------
474jerror_t DParticleCombo_factory::fini(void)
475{
476 for(size_t loc_i = 0; loc_i < dParticleComboStepPool_All.size(); ++loc_i)
477 delete dParticleComboStepPool_All[loc_i];
478
479 for(size_t loc_i = 0; loc_i < dKinematicDataPool_All.size(); ++loc_i)
480 delete dKinematicDataPool_All[loc_i];
481
482 return NOERROR;
483}
484