BOSS 6.6.4.p01
BESIII Offline Software System
Loading...
Searching...
No Matches
Public Member Functions | List of all members
ChargedDReconstruction Class Reference

#include <ChargedDReconstruction.h>

+ Inheritance diagram for ChargedDReconstruction:

Public Member Functions

 ChargedDReconstruction (const std::string &name, ISvcLocator *pSvcLocator)
 
StatusCode initialize ()
 
StatusCode execute ()
 
StatusCode finalize ()
 
void saveDpInfo (CDDecayList::iterator, double, int, EvtRecDTag *)
 
void savetrack (vector< int >, vector< int >, EvtRecTrackIterator, EvtRecTrackIterator, EvtRecTrackIterator, EvtRecTrackIterator, EvtRecDTag *)
 
vector< string > getlist (string &filename)
 
void pidtag (vector< int >, vector< int >, CDChargedKaonList &, CDChargedPionList &, EvtRecDTag *)
 

Detailed Description

Definition at line 20 of file ChargedDReconstruction.h.

Constructor & Destructor Documentation

◆ ChargedDReconstruction()

ChargedDReconstruction::ChargedDReconstruction ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 50 of file ChargedDReconstruction.cxx.

50 :
51Algorithm(name, pSvcLocator) {
52 //Declare the properties
53 declareProperty( "debug", m_debug = false );
54 declareProperty( "ReadBeamEFromDB", m_ReadBeamEFromDB = false );
55 declareProperty( "UseCalibBeamE", m_usecalibBeamE = false );
56 declareProperty( "BeamE", m_beamE = 1.8865 );
57 declareProperty( "DpList", m_decaylist = "test.txt" );
58}

Member Function Documentation

◆ execute()

StatusCode ChargedDReconstruction::execute ( )

Definition at line 95 of file ChargedDReconstruction.cxx.

95 {
96 MsgStream log(msgSvc(), name());
97 log << MSG::INFO << "in execute()" << endreq;
98
99 StatusCode sc;
100
101 //////////////////
102 // Read REC data
103 /////////////////
104 SmartDataPtr<Event::EventHeader> eventHeader(eventSvc(),"/Event/EventHeader");
105 int event= eventHeader->eventNumber();
106 // if ( m_debug || ( (event & 0x3FF) == 0 ) )
107 //std::cout << "event: " << event << std::endl;
108
109 SmartDataPtr<EvtRecEvent> recEvent(eventSvc(), EventModel::EvtRec::EvtRecEvent);
110 SmartDataPtr<EvtRecTrackCol> recTrackCol(eventSvc(), EventModel::EvtRec::EvtRecTrackCol);
111 log << MSG::DEBUG << "run and event = " << eventHeader->runNumber()
112 << " " << eventHeader->eventNumber() << endreq;
113 log << MSG::DEBUG <<"ncharg, nneu, tottks = "
114 << recEvent->totalCharged() << " , "
115 << recEvent->totalNeutral() << " , "
116 << recEvent->totalTracks() <<endreq;
117
118 EvtRecTrackIterator charged_begin = recTrackCol->begin();
119 EvtRecTrackIterator charged_end = charged_begin + recEvent->totalCharged();
120
121 EvtRecTrackIterator neutral_begin = recTrackCol->begin()+recEvent->totalCharged();
122 EvtRecTrackIterator neutral_end = recTrackCol->begin()+recEvent->totalTracks();
123
124
125 SmartDataPtr<EvtRecPi0Col> recPi0Col(eventSvc(), "/Event/EvtRec/EvtRecPi0Col");
126 if ( ! recPi0Col ) {
127 log << MSG::FATAL << "Could not find EvtRecPi0Col" << endreq;
128 return StatusCode::FAILURE;
129 }
130
131
132 SmartDataPtr<EvtRecEtaToGGCol> recEtaToGGCol(eventSvc(), "/Event/EvtRec/EvtRecEtaToGGCol");
133 if ( ! recEtaToGGCol ) {
134 log << MSG::FATAL << "Could not find EvtRecEtaToGGCol" << endreq;
135 return StatusCode::FAILURE;
136 }
137
138
139 SmartDataPtr<EvtRecVeeVertexCol> recVeeVertexCol(eventSvc(), "/Event/EvtRec/EvtRecVeeVertexCol");
140 if ( ! recVeeVertexCol ) {
141 log << MSG::FATAL << "Could not find EvtRecVeeVertexCol" << endreq;
142 return StatusCode::FAILURE;
143 }
144
145
146 SmartDataPtr<EvtRecDTagCol> recDTagCol(eventSvc(), EventModel::EvtRec::EvtRecDTagCol);
147 if (!recDTagCol) {
148 log << MSG::FATAL << "EvtRecDTagCol is not registered yet" << endreq;
149 return StatusCode::FAILURE;
150 }
151 //registered in DTag.cxx
152 /*
153 if (!recDTagCol) {
154 recDTagCol = new EvtRecDTagCol;
155 sc = registerEvtRecDTagCol(recDTagCol, log);
156 if (sc != StatusCode::SUCCESS) {
157 return sc;
158 }
159 }
160 */
161
162 /////////////////////////////
163 //reconstruct particle lists
164 /////////////////////////////
165 pionSelector.setpidtype(0);
166 kaonSelector.setpidtype(0);
167 CDChargedPionList pionList(charged_begin, charged_end, pionSelector);
168 CDChargedKaonList kaonList(charged_begin, charged_end, kaonSelector);
169
170
171 CDKsList ksList(ksSelector);
172 dc_fill(ksList, recVeeVertexCol->begin(), recVeeVertexCol->end());
173
174 CDPi0List pi0List(pi0Selector);
175 dc_fill(pi0List, recPi0Col->begin(), recPi0Col->end());
176
177 CDEtaList etaList(etatoGGSelector);
178 dc_fill(etaList, recEtaToGGCol->begin(), recEtaToGGCol->end());
179
180 //pion/kaon list with PID
181 pionSelector.setpidtype(1);
182 kaonSelector.setpidtype(1);
183 CDChargedPionList pionList_tight(charged_begin, charged_end, pionSelector);
184 CDChargedKaonList kaonList_tight(charged_begin, charged_end, kaonSelector);
185
186
187
188 int run = eventHeader->runNumber();
189 m_ievt = eventHeader->eventNumber();
190 m_nChrg = recEvent->totalCharged();
191 m_nNeu = recEvent->totalNeutral();
192 m_nPion = pionList.size();
193 m_nKaon = kaonList.size();
194 m_nPi0 = pi0List.size();
195 m_nKs = ksList.size();
196
197
198 ///////////////////////
199 // get beam energy and beta
200 ///////////////////////
201
202
203 if(m_ReadBeamEFromDB && m_irun!=run){
204 m_irun=run;
205 if(m_usecalibBeamE)
206 m_readDb.setcalib(true);
207 m_beamE=m_readDb.getbeamE(m_irun,m_beamE);
208 if(run>0)
209 m_beta=m_readDb.getbeta();
210 // cout<<"use beam E from data base:"<<m_beamE<<endl;
211 }
212 double ebeam=m_beamE;
213
214
215 //////////////////////////////
216 //reconstruct decay lists
217 /////////////////////////////
218
219
220 for(int list=0;list<chanlist.size();list++){
221
222 string channel=chanlist[list];
223 vector<int> numchan;
224 chargedDSelector.setebeam(ebeam);
225 chargedDSelector.setbeta(m_beta);
226 CDDecayList decaylist(chargedDSelector);
227
228 //K+/-: 1, Pi+/-:2, Pi0:3, Eta: 4, Ks:5
229 //the fist element of the vector stands for decay mode,
230 //the rest will be particles, and size of the vector minus 1 will be number of daughers.
231
232 if(channel=="DptoKPiPi") {
233 numchan.push_back( EvtRecDTag::kDptoKPiPi );
234 numchan.push_back(1);
235 numchan.push_back(2);
236 numchan.push_back(2);
237 decaylist=kaonList.minus()* pionList.plus()* pionList.plus();
238 }
239 else if(channel=="DptoKPiPiPi0") {
240 numchan.push_back( EvtRecDTag::kDptoKPiPiPi0 );
241 numchan.push_back(1);
242 numchan.push_back(2);
243 numchan.push_back(2);
244 numchan.push_back(3);
245 decaylist=kaonList.minus()* pionList.plus()* pionList.plus()* pi0List;
246 }
247 else if(channel=="DptoKsPi") {
248 numchan.push_back( EvtRecDTag::kDptoKsPi );
249 numchan.push_back(5);
250 numchan.push_back(2);
251 decaylist=ksList* pionList.plus();
252 }
253 else if(channel=="DptoKsPiPi0") {
254 numchan.push_back( EvtRecDTag::kDptoKsPiPi0 );
255 numchan.push_back(5);
256 numchan.push_back(2);
257 numchan.push_back(3);
258 decaylist=ksList* pionList.plus()* pi0List;
259 }
260 else if(channel=="DptoKsPiPiPi") {
261 numchan.push_back( EvtRecDTag::kDptoKsPiPiPi );
262 numchan.push_back(5);
263 numchan.push_back(2);
264 numchan.push_back(2);
265 numchan.push_back(2);
266 decaylist=ksList* pionList.plus()* pionList.plus()* pionList.minus();
267 }
268 else if(channel=="DptoKKPi") {
269 numchan.push_back( EvtRecDTag::kDptoKKPi );
270 numchan.push_back(1);
271 numchan.push_back(1);
272 numchan.push_back(2);
273 decaylist=kaonList.minus()* kaonList.plus()* pionList.plus();
274 }
275 else if(channel=="DptoPiPi0") {
276 numchan.push_back( EvtRecDTag::kDptoPiPi0 );
277 numchan.push_back(2);
278 numchan.push_back(3);
279 decaylist=pionList.plus()* pi0List;
280 }
281 else if(channel=="DptoKPi0") {
282 numchan.push_back( EvtRecDTag::kDptoKPi0 );
283 numchan.push_back(1);
284 numchan.push_back(3);
285 decaylist=kaonList.plus()* pi0List;
286 }
287 else if(channel=="DptoKsK") {
288 numchan.push_back( EvtRecDTag::kDptoKsK );
289 numchan.push_back(5);
290 numchan.push_back(1);
291 decaylist=ksList* kaonList.plus();
292 }
293 else if(channel=="DptoPiPiPi") {
294 numchan.push_back( EvtRecDTag::kDptoPiPiPi );
295 numchan.push_back(2);
296 numchan.push_back(2);
297 numchan.push_back(2);
298 decaylist=pionList.plus()* pionList.plus()* pionList.minus() ;
299 }
300 else if(channel=="DptoPiPi0Pi0") {
301 numchan.push_back( EvtRecDTag::kDptoPiPi0Pi0 );
302 numchan.push_back(2);
303 numchan.push_back(3);
304 numchan.push_back(3);
305 decaylist=pionList.plus()* pi0List* pi0List;
306 }
307 else if(channel=="DptoKsKsPi") {
308 numchan.push_back( EvtRecDTag::kDptoKsKsPi );
309 numchan.push_back(5);
310 numchan.push_back(5);
311 numchan.push_back(2);
312 decaylist=ksList* ksList* pionList.plus();
313 }
314 else if(channel=="DptoKsKPi0") {
315 numchan.push_back( EvtRecDTag::kDptoKsKPi0 );
316 numchan.push_back(5);
317 numchan.push_back(1);
318 numchan.push_back(3);
319 decaylist=ksList* kaonList.plus()* pi0List;
320 }
321 else if(channel=="DptoKsKsK") {
322 numchan.push_back( EvtRecDTag::kDptoKsKsK );
323 numchan.push_back(5);
324 numchan.push_back(5);
325 numchan.push_back(1);
326 decaylist=ksList* ksList* kaonList.plus();
327 }
328 else if(channel=="DptoPiPiPiPi0") {
329 numchan.push_back( EvtRecDTag::kDptoPiPiPiPi0 );
330 numchan.push_back(2);
331 numchan.push_back(2);
332 numchan.push_back(2);
333 numchan.push_back(3);
334 decaylist=pionList.plus()* pionList.plus()* pionList.minus()* pi0List;
335 }
336 else if(channel=="DptoKsPiPi0Pi0") {
337 numchan.push_back( EvtRecDTag::kDptoKsPiPi0Pi0 );
338 numchan.push_back(5);
339 numchan.push_back(2);
340 numchan.push_back(3);
341 numchan.push_back(3);
342 decaylist=ksList* pionList.plus()* pi0List* pi0List;
343 }
344 else if(channel=="DptoKsKplusPiPi") {
345 numchan.push_back( EvtRecDTag::kDptoKsKplusPiPi );
346 numchan.push_back(5);
347 numchan.push_back(1);
348 numchan.push_back(2);
349 numchan.push_back(2);
350 decaylist=ksList* kaonList.plus()* pionList.plus()* pionList.minus();
351 }
352 else if(channel=="DptoKsKminusPiPi") {
353 numchan.push_back( EvtRecDTag::kDptoKsKminusPiPi );
354 numchan.push_back(5);
355 numchan.push_back(1);
356 numchan.push_back(2);
357 numchan.push_back(2);
358 decaylist=ksList* kaonList.minus()* pionList.plus()* pionList.plus();
359 }
360 else if(channel=="DptoKKPiPi0") {
361 numchan.push_back( EvtRecDTag::kDptoKKPiPi0 );
362 numchan.push_back(1);
363 numchan.push_back(1);
364 numchan.push_back(2);
365 numchan.push_back(3);
366 decaylist=kaonList.minus()* kaonList.plus()* pionList.plus()* pi0List;
367 }
368 else if(channel=="DptoPiPiPiPiPi") {
369 numchan.push_back( EvtRecDTag::kDptoPiPiPiPiPi );
370 numchan.push_back(2);
371 numchan.push_back(2);
372 numchan.push_back(2);
373 numchan.push_back(2);
374 numchan.push_back(2);
375 decaylist=pionList.plus()* pionList.plus()* pionList.plus()* pionList.minus()* pionList.minus();
376 }
377 else if(channel=="DptoKPiPiPiPi") {
378 numchan.push_back( EvtRecDTag::kDptoKPiPiPiPi );
379 numchan.push_back(1);
380 numchan.push_back(2);
381 numchan.push_back(2);
382 numchan.push_back(2);
383 numchan.push_back(2);
384 decaylist=kaonList.plus()* pionList.plus()* pionList.plus()* pionList.minus()* pionList.minus();
385 }
386 else if(channel=="DptoPiEta") {
387 numchan.push_back( EvtRecDTag::kDptoPiEta );
388 numchan.push_back(2);
389 numchan.push_back(4);
390 decaylist=pionList.plus()* etaList;
391 }
392 else if(channel=="DptoKsPiEta") {
393 numchan.push_back( EvtRecDTag::kDptoKsPiEta );
394 numchan.push_back(5);
395 numchan.push_back(2);
396 numchan.push_back(4);
397 decaylist=ksList* pionList.plus()* etaList;
398 }
399
400 CDDecayList::iterator D_begin =decaylist.particle_begin();
401 CDDecayList::iterator D_end =decaylist.particle_end();
402
403 for ( CDDecayList::iterator it = D_begin; it != D_end; it++ ) {
404
405 EvtRecDTag* recDTag = new EvtRecDTag;
406 recDTag->setdecayMode( (EvtRecDTag::DecayMode)numchan[0] );
407
408 vector<int> trackid, showerid;
409 vector<int> kaonid, pionid;
410 int numofchildren=numchan.size()-1;
411
412 for(int i=0; i< numofchildren;i++){
413
414 const CDCandidate& daughter=(*it).particle().child(i);
415
416 if(numchan[i+1]==1){
417 const EvtRecTrack* track=daughter.track();
418 trackid.push_back(track->trackId());
419 kaonid.push_back(track->trackId());
420 }
421 else if(numchan[i+1]==2){
422 const EvtRecTrack* track=daughter.track();
423 trackid.push_back(track->trackId());
424 pionid.push_back(track->trackId());
425 }
426 else if ( numchan[i+1]==3){
427 const EvtRecTrack* hiEnGamma=daughter.navPi0()->hiEnGamma();
428 const EvtRecTrack* loEnGamma=daughter.navPi0()->loEnGamma();
429 showerid.push_back(hiEnGamma->trackId());
430 showerid.push_back(loEnGamma->trackId());
431 }
432 else if ( numchan[i+1]==4){
433 const EvtRecTrack* hiEnGamma=daughter.navEta()->hiEnGamma();
434 const EvtRecTrack* loEnGamma=daughter.navEta()->loEnGamma();
435 showerid.push_back(hiEnGamma->trackId());
436 showerid.push_back(loEnGamma->trackId());
437 }
438 else if ( numchan[i+1]==5){
439 EvtRecVeeVertex* aKsCand = const_cast<EvtRecVeeVertex*>( daughter.navKshort() );
440 EvtRecTrack* pion1Trk = aKsCand->daughter(0);
441 EvtRecTrack* pion2Trk = aKsCand->daughter(1);
442 trackid.push_back(pion1Trk->trackId());
443 trackid.push_back(pion2Trk->trackId());
444 }
445
446 }//end of filling track and shower ids
447
448
449 saveDpInfo(it, ebeam, numofchildren, recDTag);
450 savetrack(trackid,showerid,charged_begin,charged_end,neutral_begin,neutral_end,recDTag);
451 pidtag(kaonid,pionid,kaonList_tight, pionList_tight,recDTag);
452
453 trackid.clear();
454 showerid.clear();
455 kaonid.clear();
456 pionid.clear();
457
458
459 //write dtag object out
460 recDTagCol->push_back(recDTag);
461
462 }//end of decaylist iterator
463
464 numchan.clear();
465
466 }//end of reconstrucing all D+ decay lists
467
468
469
470 return StatusCode::SUCCESS;
471}
chargedDSelector
ChargedDSelector chargedDSelector
Definition: ChargedDSelector.cxx:55
dc_fill
void dc_fill(DCFillableChargedList< Charged > &aFillableList, WitnessIterator first, WitnessIterator last)
Definition: DCFillableChargedList.h:152
EvtRecTrackIterator
EvtRecTrackCol::iterator EvtRecTrackIterator
Definition: EvtRecTrack.h:111
etatoGGSelector
LocalEtatoGGSelector etatoGGSelector
Definition: LocalEtatoGGSelector.cxx:37
kaonSelector
LocalKaonSelector kaonSelector
Definition: LocalKaonSelector.cxx:112
ksSelector
LocalKsSelector ksSelector
Definition: LocalKsSelector.cxx:40
pi0Selector
LocalPi0Selector pi0Selector
Definition: LocalPi0Selector.cxx:39
pionSelector
LocalPionSelector pionSelector
Definition: LocalPionSelector.cxx:113
msgSvc
IMessageSvc * msgSvc()
Definition: ServiceAccessor.h:13
CDCandidate::track
virtual const EvtRecTrack * track() const
Definition: CDCandidate.cxx:236
CDCandidate::navKshort
virtual const EvtRecVeeVertex * navKshort() const
Definition: CDCandidate.cxx:316
CDCandidate::navPi0
virtual const EvtRecPi0 * navPi0() const
Definition: CDCandidate.cxx:276
CDCandidate::navEta
virtual const EvtRecEtaToGG * navEta() const
Definition: CDCandidate.cxx:296
ChargedDReconstruction::saveDpInfo
void saveDpInfo(CDDecayList::iterator, double, int, EvtRecDTag *)
Definition: ChargedDReconstruction.cxx:474
ChargedDReconstruction::pidtag
void pidtag(vector< int >, vector< int >, CDChargedKaonList &, CDChargedPionList &, EvtRecDTag *)
Definition: ChargedDReconstruction.cxx:554
ChargedDReconstruction::savetrack
void savetrack(vector< int >, vector< int >, EvtRecTrackIterator, EvtRecTrackIterator, EvtRecTrackIterator, EvtRecTrackIterator, EvtRecDTag *)
Definition: ChargedDReconstruction.cxx:500
ChargedDSelector::setbeta
void setbeta(Hep3Vector beta)
Definition: ChargedDSelector.h:14
ChargedDSelector::setebeam
void setebeam(double ebeam)
Definition: ChargedDSelector.h:13
EvtRecDTag::kDptoKsPiPi0
@ kDptoKsPiPi0
Definition: EvtRecDTag.h:93
EvtRecDTag::kDptoKsKminusPiPi
@ kDptoKsKminusPiPi
Definition: EvtRecDTag.h:108
EvtRecDTag::kDptoKPiPiPi0
@ kDptoKPiPiPi0
Definition: EvtRecDTag.h:91
EvtRecDTag::kDptoKPiPiPiPi
@ kDptoKPiPiPiPi
Definition: EvtRecDTag.h:111
EvtRecDTag::kDptoKsPiPi0Pi0
@ kDptoKsPiPi0Pi0
Definition: EvtRecDTag.h:106
EvtRecDTag::kDptoKsPiPiPi
@ kDptoKsPiPiPi
Definition: EvtRecDTag.h:94
EvtRecDTag::kDptoKsKplusPiPi
@ kDptoKsKplusPiPi
Definition: EvtRecDTag.h:107
EvtRecDTag::kDptoPiPiPiPiPi
@ kDptoPiPiPiPiPi
Definition: EvtRecDTag.h:110
EvtRecDTag::kDptoPiPiPiPi0
@ kDptoPiPiPiPi0
Definition: EvtRecDTag.h:105
EvtRecDTag::setdecayMode
void setdecayMode(DecayMode decayMode)
Definition: EvtRecDTag.h:171
EvtRecEtaToGG::hiEnGamma
const EvtRecTrack * hiEnGamma() const
Definition: EvtRecEtaToGG.h:30
EvtRecEtaToGG::loEnGamma
const EvtRecTrack * loEnGamma() const
Definition: EvtRecEtaToGG.h:31
EvtRecPi0::loEnGamma
const EvtRecTrack * loEnGamma() const
Definition: EvtRecPi0.h:31
EvtRecPi0::hiEnGamma
const EvtRecTrack * hiEnGamma() const
Definition: EvtRecPi0.h:30
EvtRecTrack::trackId
int trackId() const
Definition: EvtRecTrack.h:32
EvtRecVeeVertex::daughter
SmartRef< EvtRecTrack > & daughter(int i)
Definition: EvtRecVeeVertex.h:89
LocalKaonSelector::setpidtype
void setpidtype(int type)
Definition: LocalKaonSelector.h:15
LocalPionSelector::setpidtype
void setpidtype(int type)
Definition: LocalPionSelector.h:14
EventModel::EvtRec::EvtRecEvent
_EXTERN_ std::string EvtRecEvent
Definition: EventModel.h:111
EventModel::EvtRec::EvtRecDTagCol
_EXTERN_ std::string EvtRecDTagCol
Definition: EventModel.h:117
EventModel::EvtRec::EvtRecTrackCol
_EXTERN_ std::string EvtRecTrackCol
Definition: EventModel.h:112

◆ finalize()

StatusCode ChargedDReconstruction::finalize ( )

Definition at line 75 of file ChargedDReconstruction.cxx.

75 {
76 MsgStream log(msgSvc(), name());
77 log << MSG::INFO << "in finalize()" << endreq;
78
79 chanlist.clear();
80
81 return StatusCode::SUCCESS;
82}

◆ getlist()

vector< string > ChargedDReconstruction::getlist ( string &  filename)

Definition at line 610 of file ChargedDReconstruction.cxx.

610 {
611
612 string channel;
613 vector<string> temp;
614
615 ifstream inFile;
616
617 inFile.open(filename.c_str());
618 if (!inFile) {
619 cout << "Unable to open decay list file";
620 exit(1); // terminate with error
621 }
622
623 while (inFile >> channel) {
624 temp.push_back(channel);
625 }
626
627 inFile.close();
628
629 return temp;
630
631}
bpkt::ifstream
std::ifstream ifstream
Definition: bpkt_streams.h:44

Referenced by initialize().

◆ initialize()

StatusCode ChargedDReconstruction::initialize ( )

Definition at line 61 of file ChargedDReconstruction.cxx.

61 {
62 MsgStream log(msgSvc(), name());
63 log << MSG::INFO << "in initialize()" <<endreq;
64
65 m_irun=-100;
66 m_beta.setX(0.011);
67 m_beta.setY(0);
68 m_beta.setZ(0);
69 chanlist=getlist(m_decaylist);
70
71 return StatusCode::SUCCESS;
72}
ChargedDReconstruction::getlist
vector< string > getlist(string &filename)
Definition: ChargedDReconstruction.cxx:610

◆ pidtag()

void ChargedDReconstruction::pidtag ( vector< int >  kaonid,
vector< int >  pionid,
CDChargedKaonList &  kaonList,
CDChargedPionList &  pionList,
EvtRecDTag *  recDTag 
)

Definition at line 554 of file ChargedDReconstruction.cxx.

554 {
555
556 bool iskaon=false,ispion=false;
557
558
559 // save track ids which passed pion/kaon cuts
560
561 for (CDChargedKaonList::iterator kit = kaonList.particle_begin(); kit != kaonList.particle_end(); kit++) {
562 recDTag->addKaonId( (*kit).particle().track() );
563 }
564
565 for (CDChargedPionList::iterator pit = pionList.particle_begin(); pit != pionList.particle_end(); pit++) {
566 recDTag->addPionId( (*pit).particle().track() );
567 }
568
569
570 /*
571 for(int i=0; i<kaonid.size(); i++){
572 bool ithkaon=false;
573 for (CDChargedKaonList::iterator kit = kaonList.particle_begin(); kit != kaonList.particle_end(); kit++) {
574 if((*kit).particle().track()->trackId()==kaonid[i]){
575 ithkaon=true;
576 break;
577 }
578 }
579 if(!ithkaon) break;
580 if(i==kaonid.size()-1)
581 iskaon=true;
582 }
583
584 for(int i=0; i<pionid.size(); i++){
585 bool ithpion=false;
586 for (CDChargedPionList::iterator pit = pionList.particle_begin(); pit != pionList.particle_end(); pit++) {
587 if((*pit).particle().track()->trackId()==pionid[i]){
588 ithpion=true;
589 break;
590 }
591 }
592 if(!ithpion) break;
593 if(i==pionid.size()-1)
594 ispion=true;
595 }
596
597
598 if( iskaon && ispion)
599 recDTag->settype( EvtRecDTag::Tight );
600 else if( (kaonid.size()==0 && ispion) || (pionid.size()==0 && iskaon))
601 recDTag->settype( EvtRecDTag::Tight );
602 else if( kaonid.size()==0 && pionid.size()==0 )
603 recDTag->settype( EvtRecDTag::Tight );
604 */
605
606}
EvtRecDTag::addKaonId
void addKaonId(const SmartRef< EvtRecTrack > kaonId)
Definition: EvtRecDTag.h:192
EvtRecDTag::addPionId
void addPionId(const SmartRef< EvtRecTrack > pionId)
Definition: EvtRecDTag.h:190

Referenced by execute().

◆ saveDpInfo()

void ChargedDReconstruction::saveDpInfo ( CDDecayList::iterator  it,
double  ebeam,
int  numofchildren,
EvtRecDTag *  recDTag 
)

Definition at line 474 of file ChargedDReconstruction.cxx.

474 {
475
476 double mass = (*it).particle().mass();
477 int charge= (*it).particle().charge();
478 HepLorentzVector p4((*it).particle().momentum(), (*it).particle().energy());
479 recDTag->setp4(p4);
480
481 p4.boost(-m_beta);
482 double mbc2_CMS = ebeam*ebeam - p4.v().mag2();
483 double mbc_CMS = mbc2_CMS > 0 ? sqrt( mbc2_CMS ) : -10;
484 double deltaE_CMS = p4.t() - ebeam;
485
486 if((*it).particle().userTag()==1)
487 recDTag->settype( EvtRecDTag::Tight );
488 else
489 recDTag->settype( EvtRecDTag::Loose );
490 recDTag->setcharge(charge);
491 recDTag->setcharm(charge);
492 recDTag->setnumOfChildren(numofchildren);
493 recDTag->setmass(mass);
494 recDTag->setmBC(mbc_CMS);
495 recDTag->setbeamE(ebeam);
496 recDTag->setdeltaE(deltaE_CMS);
497
498}
mass
double mass
Definition: CosmicGenerator.cxx:138
EvtRecDTag::settype
void settype(SelType type)
Definition: EvtRecDTag.h:172
EvtRecDTag::setp4
void setp4(HepLorentzVector p4)
Definition: EvtRecDTag.h:180
EvtRecDTag::setmass
void setmass(double mass)
Definition: EvtRecDTag.h:174
EvtRecDTag::setdeltaE
void setdeltaE(double deltaE)
Definition: EvtRecDTag.h:176
EvtRecDTag::setcharm
void setcharm(int charm)
Definition: EvtRecDTag.h:178
EvtRecDTag::setmBC
void setmBC(double mBC)
Definition: EvtRecDTag.h:175
EvtRecDTag::setcharge
void setcharge(int charge)
Definition: EvtRecDTag.h:177
EvtRecDTag::setbeamE
void setbeamE(double beamE)
Definition: EvtRecDTag.h:173
EvtRecDTag::setnumOfChildren
void setnumOfChildren(int numOfChildren)
Definition: EvtRecDTag.h:179

Referenced by execute().

◆ savetrack()

void ChargedDReconstruction::savetrack ( vector< int >  trackid,
vector< int >  showerid,
EvtRecTrackIterator  charged_begin,
EvtRecTrackIterator  charged_end,
EvtRecTrackIterator  neutral_begin,
EvtRecTrackIterator  neutral_end,
EvtRecDTag *  recDTag 
)

Definition at line 500 of file ChargedDReconstruction.cxx.

501 {
502
503 vector<EvtRecTrackIterator> trktemp;
504 vector<EvtRecTrackIterator> shrtemp;
505
506 //fill tracks
507 for(EvtRecTrackIterator trk=charged_begin; trk<charged_end;trk++){
508
509 bool isothertrack=true;
510 for(int i=0; i<trackid.size(); i++){
511 if( (*trk)->trackId()==trackid[i] ){
512 trktemp.push_back(trk);
513 isothertrack=false;
514 break;
515 }
516 }
517 if(isothertrack)
518 recDTag->addOtherTrack(*trk);
519 }
520 for(int i=0; i<trackid.size();i++){
521 for(int j=0; j<trktemp.size(); j++){
522 EvtRecTrackIterator trk=trktemp[j];
523 if( (*trk)->trackId()==trackid[i])
524 recDTag->addTrack(*trktemp[j]);
525 }
526 }
527
528
529 //fill showers
530 for(EvtRecTrackIterator shr=neutral_begin; shr<neutral_end;shr++){
531 bool isothershower=true;
532 for(int i=0; i<showerid.size(); i++){
533 if( (*shr)->trackId()==showerid[i] ){
534 shrtemp.push_back(shr);
535 isothershower=false;
536 break;
537 }
538 }
539 if(isothershower)
540 recDTag->addOtherShower(*shr);
541 }
542
543 for(int i=0; i<showerid.size();i++){
544 for(int j=0; j<shrtemp.size(); j++){
545 EvtRecTrackIterator shr=shrtemp[j];
546 if( (*shr)->trackId()==showerid[i])
547 recDTag->addShower(*shrtemp[j]);
548 }
549 }
550
551
552}
EvtRecDTag::addOtherTrack
void addOtherTrack(const SmartRef< EvtRecTrack > track)
Definition: EvtRecDTag.h:186
EvtRecDTag::addOtherShower
void addOtherShower(const SmartRef< EvtRecTrack > shower)
Definition: EvtRecDTag.h:188
EvtRecDTag::addShower
void addShower(const SmartRef< EvtRecTrack > shower)
Definition: EvtRecDTag.h:184
EvtRecDTag::addTrack
void addTrack(const SmartRef< EvtRecTrack > track)
Definition: EvtRecDTag.h:182

Referenced by execute().

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