CGEM BOSS 6.6.5.g
BESIII Offline Software System
Loading...
Searching...
No Matches
ChargedDReconstruction.cxx
Go to the documentation of this file.
1//
2// All D+ decay modes Reconstruction
3//
4#include <fstream>
5#include "GaudiKernel/MsgStream.h"
6#include "GaudiKernel/AlgFactory.h"
7#include "GaudiKernel/ISvcLocator.h"
8#include "GaudiKernel/SmartDataPtr.h"
9#include "GaudiKernel/IDataProviderSvc.h"
10
11
12#include "EventModel/EventHeader.h"
13#include "EventModel/Event.h"
14#include "EventModel/EventModel.h"
15
16#include "EvtRecEvent/EvtRecEvent.h"
17#include "EvtRecEvent/EvtRecTrack.h"
18#include "EvtRecEvent/EvtRecDTag.h"
19#include "EvtRecEvent/EvtRecPi0.h"
20#include "EvtRecEvent/EvtRecEtaToGG.h"
21#include "EvtRecEvent/EvtRecVeeVertex.h"
22
23#include "BesDChain/CDChargedPionList.h"
24#include "BesDChain/CDChargedKaonList.h"
25#include "BesDChain/CDPhotonList.h"
26#include "BesDChain/CDPi0List.h"
27#include "BesDChain/CDEtaList.h"
28#include "BesDChain/CDKsList.h"
29#include "BesDChain/CDDecayList.h"
30
31#include "McTruth/McParticle.h"
32#include "ParticleID/ParticleID.h"
33#include "VertexFit/VertexFit.h"
34#include "VertexFit/SecondVertexFit.h"
35#include "VertexFit/IVertexDbSvc.h"
36
37#include "DTagAlg/ChargedDReconstruction.h"
38#include "DTagAlg/LocalKaonSelector.h"
39#include "DTagAlg/LocalPionSelector.h"
40#include "DTagAlg/LocalPhotonSelector.h"
41#include "DTagAlg/LocalKsSelector.h"
42#include "DTagAlg/LocalPi0Selector.h"
43#include "DTagAlg/LocalEtatoGGSelector.h"
44#include "DTagAlg/LocalEptoPiPiEtaSelector.h"
45#include "DTagAlg/LocalEptoRhoGamSelector.h"
46#include "DTagAlg/LocalRhotoPiPiSelector.h"
47#include "DTagAlg/ChargedDSelector.h"
48
49
50#include "DTagAlg/utility.h"
51
52using namespace Event;
53
54//*******************************************************************************************
55ChargedDReconstruction::ChargedDReconstruction(const std::string& name, ISvcLocator* pSvcLocator):
56Algorithm(name, pSvcLocator) {
57 //Declare the properties
58 declareProperty( "debug", m_debug = false );
59 declareProperty( "ReadBeamEFromDB", m_ReadBeamEFromDB = false );
60 declareProperty( "UseCalibBeamE", m_usecalibBeamE = false );
61 declareProperty( "UseVertexfit", m_usevertexfit = false );
62 declareProperty( "BeamE", m_beamE = 1.8865 );
63 declareProperty( "DpList", m_decaylist = "test.txt" );
64}
65
66//******************************************************************************************
67StatusCode ChargedDReconstruction::initialize() {
68 MsgStream log(msgSvc(), name());
69 log << MSG::INFO << "in initialize()" <<endreq;
70
71 m_irun=-100;
72 m_beta.setX(0.011);
73 m_beta.setY(0);
74 m_beta.setZ(0);
75 chanlist=getlist(m_decaylist);
76
77 return StatusCode::SUCCESS;
78}
79
80//********************************************************************************************
81StatusCode ChargedDReconstruction::finalize() {
82 MsgStream log(msgSvc(), name());
83 log << MSG::INFO << "in finalize()" << endreq;
84
85 chanlist.clear();
86
87 return StatusCode::SUCCESS;
88}
89
90StatusCode ChargedDReconstruction::registerEvtRecDTagCol(
91 EvtRecDTagCol* aNewEvtRecDTagCol, MsgStream& log) {
92 StatusCode sc = eventSvc()->registerObject("/Event/EvtRec/EvtRecDTagCol",
93 aNewEvtRecDTagCol);
94 if (sc != StatusCode::SUCCESS) {
95 log << MSG::FATAL << "Could not register EvtRecDTagCol in TDS!" << endreq;
96 }
97 return sc;
98}
99
100//*********************************************************************************************
101StatusCode ChargedDReconstruction::execute() {
102 MsgStream log(msgSvc(), name());
103 log << MSG::INFO << "in execute()" << endreq;
104
105 StatusCode sc;
106
107 //////////////////
108 // Read REC data
109 /////////////////
110 SmartDataPtr<Event::EventHeader> eventHeader(eventSvc(),"/Event/EventHeader");
111 int event= eventHeader->eventNumber();
112 // if ( m_debug || ( (event & 0x3FF) == 0 ) )
113 //std::cout << "event: " << event << std::endl;
114
115 SmartDataPtr<EvtRecEvent> recEvent(eventSvc(), EventModel::EvtRec::EvtRecEvent);
116 SmartDataPtr<EvtRecTrackCol> recTrackCol(eventSvc(), EventModel::EvtRec::EvtRecTrackCol);
117 log << MSG::DEBUG << "run and event = " << eventHeader->runNumber()
118 << " " << eventHeader->eventNumber() << endreq;
119 log << MSG::DEBUG <<"ncharg, nneu, tottks = "
120 << recEvent->totalCharged() << " , "
121 << recEvent->totalNeutral() << " , "
122 << recEvent->totalTracks() <<endreq;
123
124 EvtRecTrackIterator charged_begin = recTrackCol->begin();
125 EvtRecTrackIterator charged_end = charged_begin + recEvent->totalCharged();
126
127 EvtRecTrackIterator neutral_begin = recTrackCol->begin()+recEvent->totalCharged();
128 EvtRecTrackIterator neutral_end = recTrackCol->begin()+recEvent->totalTracks();
129
130
131 SmartDataPtr<EvtRecPi0Col> recPi0Col(eventSvc(), "/Event/EvtRec/EvtRecPi0Col");
132 if ( ! recPi0Col ) {
133 log << MSG::FATAL << "Could not find EvtRecPi0Col" << endreq;
134 return StatusCode::FAILURE;
135 }
136
137
138 SmartDataPtr<EvtRecEtaToGGCol> recEtaToGGCol(eventSvc(), "/Event/EvtRec/EvtRecEtaToGGCol");
139 if ( ! recEtaToGGCol ) {
140 log << MSG::FATAL << "Could not find EvtRecEtaToGGCol" << endreq;
141 return StatusCode::FAILURE;
142 }
143
144
145 SmartDataPtr<EvtRecVeeVertexCol> recVeeVertexCol(eventSvc(), "/Event/EvtRec/EvtRecVeeVertexCol");
146 if ( ! recVeeVertexCol ) {
147 log << MSG::FATAL << "Could not find EvtRecVeeVertexCol" << endreq;
148 return StatusCode::FAILURE;
149 }
150
151
152 SmartDataPtr<EvtRecDTagCol> recDTagCol(eventSvc(), EventModel::EvtRec::EvtRecDTagCol);
153 if (!recDTagCol) {
154 log << MSG::FATAL << "EvtRecDTagCol is not registered yet" << endreq;
155 return StatusCode::FAILURE;
156 }
157
158
159
160 //get primary vertex from db
161 Hep3Vector xorigin(0,0,0);
162
163 IVertexDbSvc* vtxsvc;
164 Gaudi::svcLocator()->service("VertexDbSvc", vtxsvc);
165 if (vtxsvc->isVertexValid()) {
166
167 //vertex[0] = vx; vertex[1]= vy; vertex[2] = vz;
168 double* vertex = vtxsvc->PrimaryVertex();
169 xorigin.setX(vertex[0]);
170 xorigin.setY(vertex[1]);
171 xorigin.setZ(vertex[2]);
172 }
173
174 utility util;
175
176
177 //registered in DTag.cxx
178 /*
179 if (!recDTagCol) {
180 recDTagCol = new EvtRecDTagCol;
181 sc = registerEvtRecDTagCol(recDTagCol, log);
182 if (sc != StatusCode::SUCCESS) {
183 return sc;
184 }
185 }
186 */
187
188 /////////////////////////////
189 //reconstruct particle lists
190 /////////////////////////////
191 pionSelector.setpidtype(0);
192 kaonSelector.setpidtype(0);
193 CDChargedPionList pionList(charged_begin, charged_end, pionSelector);
194 CDChargedKaonList kaonList(charged_begin, charged_end, kaonSelector);
195
196
197 CDKsList ksList(ksSelector);
198 dc_fill(ksList, recVeeVertexCol->begin(), recVeeVertexCol->end());
199
200 CDPi0List pi0List(pi0Selector);
201 dc_fill(pi0List, recPi0Col->begin(), recPi0Col->end());
202
203 CDEtaList etaList(etatoGGSelector);
204 dc_fill(etaList, recEtaToGGCol->begin(), recEtaToGGCol->end());
205
206 //pion/kaon list with PID
207 pionSelector.setpidtype(1);
208 kaonSelector.setpidtype(1);
209 CDChargedPionList pionList_tight(charged_begin, charged_end, pionSelector);
210 CDChargedKaonList kaonList_tight(charged_begin, charged_end, kaonSelector);
211
212
213
214 int run = eventHeader->runNumber();
215 m_ievt = eventHeader->eventNumber();
216 m_nChrg = recEvent->totalCharged();
217 m_nNeu = recEvent->totalNeutral();
218 m_nPion = pionList.size();
219 m_nKaon = kaonList.size();
220 m_nPi0 = pi0List.size();
221 m_nKs = ksList.size();
222
223
224 ///////////////////////
225 // get beam energy and beta
226 ///////////////////////
227
228
229 if(m_ReadBeamEFromDB && m_irun!=run){
230 m_irun=run;
231 if(m_usecalibBeamE)
232 m_readDb.setcalib(true);
233 m_beamE=m_readDb.getbeamE(m_irun,m_beamE);
234 if(run>0)
235 m_beta=m_readDb.getbeta();
236 // cout<<"use beam E from data base:"<<m_beamE<<endl;
237 }
238 double ebeam=m_beamE;
239
240
241 //////////////////////////////
242 //reconstruct decay lists
243 /////////////////////////////
244
245
246 for(int list=0;list<chanlist.size();list++){
247
248 string channel=chanlist[list];
249 vector<int> numchan;
250 chargedDSelector.setebeam(ebeam);
251 chargedDSelector.setbeta(m_beta);
252 CDDecayList decaylist(chargedDSelector);
253
254 //K+/-: 1, Pi+/-:2, Pi0:3, Eta: 4, Ks:5
255 //the fist element of the vector stands for decay mode,
256 //the rest will be particles, and size of the vector minus 1 will be number of daughers.
257
258 if(channel=="DptoKPiPi") {
259 numchan.push_back( EvtRecDTag::kDptoKPiPi );
260 numchan.push_back(1);
261 numchan.push_back(2);
262 numchan.push_back(2);
263 decaylist=kaonList.minus()* pionList.plus()* pionList.plus();
264 }
265 else if(channel=="DptoKPiPiPi0") {
266 numchan.push_back( EvtRecDTag::kDptoKPiPiPi0 );
267 numchan.push_back(1);
268 numchan.push_back(2);
269 numchan.push_back(2);
270 numchan.push_back(3);
271 decaylist=kaonList.minus()* pionList.plus()* pionList.plus()* pi0List;
272 }
273 else if(channel=="DptoKsPi") {
274 numchan.push_back( EvtRecDTag::kDptoKsPi );
275 numchan.push_back(5);
276 numchan.push_back(2);
277 decaylist=ksList* pionList.plus();
278 }
279 else if(channel=="DptoKsPiPi0") {
280 numchan.push_back( EvtRecDTag::kDptoKsPiPi0 );
281 numchan.push_back(5);
282 numchan.push_back(2);
283 numchan.push_back(3);
284 decaylist=ksList* pionList.plus()* pi0List;
285 }
286 else if(channel=="DptoKsPiPiPi") {
287 numchan.push_back( EvtRecDTag::kDptoKsPiPiPi );
288 numchan.push_back(5);
289 numchan.push_back(2);
290 numchan.push_back(2);
291 numchan.push_back(2);
292 decaylist=ksList* pionList.plus()* pionList.plus()* pionList.minus();
293 }
294 else if(channel=="DptoKKPi") {
295 numchan.push_back( EvtRecDTag::kDptoKKPi );
296 numchan.push_back(1);
297 numchan.push_back(1);
298 numchan.push_back(2);
299 decaylist=kaonList.minus()* kaonList.plus()* pionList.plus();
300 }
301 else if(channel=="DptoPiPi0") {
302 numchan.push_back( EvtRecDTag::kDptoPiPi0 );
303 numchan.push_back(2);
304 numchan.push_back(3);
305 decaylist=pionList.plus()* pi0List;
306 }
307 else if(channel=="DptoKPi0") {
308 numchan.push_back( EvtRecDTag::kDptoKPi0 );
309 numchan.push_back(1);
310 numchan.push_back(3);
311 decaylist=kaonList.plus()* pi0List;
312 }
313 else if(channel=="DptoKsK") {
314 numchan.push_back( EvtRecDTag::kDptoKsK );
315 numchan.push_back(5);
316 numchan.push_back(1);
317 decaylist=ksList* kaonList.plus();
318 }
319 else if(channel=="DptoPiPiPi") {
320 numchan.push_back( EvtRecDTag::kDptoPiPiPi );
321 numchan.push_back(2);
322 numchan.push_back(2);
323 numchan.push_back(2);
324 decaylist=pionList.plus()* pionList.plus()* pionList.minus() ;
325 }
326 else if(channel=="DptoPiPi0Pi0") {
327 numchan.push_back( EvtRecDTag::kDptoPiPi0Pi0 );
328 numchan.push_back(2);
329 numchan.push_back(3);
330 numchan.push_back(3);
331 decaylist=pionList.plus()* pi0List* pi0List;
332 }
333 else if(channel=="DptoKsKsPi") {
334 numchan.push_back( EvtRecDTag::kDptoKsKsPi );
335 numchan.push_back(5);
336 numchan.push_back(5);
337 numchan.push_back(2);
338 decaylist=ksList* ksList* pionList.plus();
339 }
340 else if(channel=="DptoKsKPi0") {
341 numchan.push_back( EvtRecDTag::kDptoKsKPi0 );
342 numchan.push_back(5);
343 numchan.push_back(1);
344 numchan.push_back(3);
345 decaylist=ksList* kaonList.plus()* pi0List;
346 }
347 else if(channel=="DptoKsKsK") {
348 numchan.push_back( EvtRecDTag::kDptoKsKsK );
349 numchan.push_back(5);
350 numchan.push_back(5);
351 numchan.push_back(1);
352 decaylist=ksList* ksList* kaonList.plus();
353 }
354 else if(channel=="DptoPiPiPiPi0") {
355 numchan.push_back( EvtRecDTag::kDptoPiPiPiPi0 );
356 numchan.push_back(2);
357 numchan.push_back(2);
358 numchan.push_back(2);
359 numchan.push_back(3);
360 decaylist=pionList.plus()* pionList.plus()* pionList.minus()* pi0List;
361 }
362 else if(channel=="DptoKsPiPi0Pi0") {
363 numchan.push_back( EvtRecDTag::kDptoKsPiPi0Pi0 );
364 numchan.push_back(5);
365 numchan.push_back(2);
366 numchan.push_back(3);
367 numchan.push_back(3);
368 decaylist=ksList* pionList.plus()* pi0List* pi0List;
369 }
370 else if(channel=="DptoKsKplusPiPi") {
371 numchan.push_back( EvtRecDTag::kDptoKsKplusPiPi );
372 numchan.push_back(5);
373 numchan.push_back(1);
374 numchan.push_back(2);
375 numchan.push_back(2);
376 decaylist=ksList* kaonList.plus()* pionList.plus()* pionList.minus();
377 }
378 else if(channel=="DptoKsKminusPiPi") {
379 numchan.push_back( EvtRecDTag::kDptoKsKminusPiPi );
380 numchan.push_back(5);
381 numchan.push_back(1);
382 numchan.push_back(2);
383 numchan.push_back(2);
384 decaylist=ksList* kaonList.minus()* pionList.plus()* pionList.plus();
385 }
386 else if(channel=="DptoKKPiPi0") {
387 numchan.push_back( EvtRecDTag::kDptoKKPiPi0 );
388 numchan.push_back(1);
389 numchan.push_back(1);
390 numchan.push_back(2);
391 numchan.push_back(3);
392 decaylist=kaonList.minus()* kaonList.plus()* pionList.plus()* pi0List;
393 }
394 else if(channel=="DptoPiPiPiPiPi") {
395 numchan.push_back( EvtRecDTag::kDptoPiPiPiPiPi );
396 numchan.push_back(2);
397 numchan.push_back(2);
398 numchan.push_back(2);
399 numchan.push_back(2);
400 numchan.push_back(2);
401 decaylist=pionList.plus()* pionList.plus()* pionList.plus()* pionList.minus()* pionList.minus();
402 }
403 else if(channel=="DptoKPiPiPiPi") {
404 numchan.push_back( EvtRecDTag::kDptoKPiPiPiPi );
405 numchan.push_back(1);
406 numchan.push_back(2);
407 numchan.push_back(2);
408 numchan.push_back(2);
409 numchan.push_back(2);
410 decaylist=kaonList.minus()* pionList.plus()* pionList.plus()* pionList.plus()* pionList.minus();
411 }
412 else if(channel=="DptoPiEta") {
413 numchan.push_back( EvtRecDTag::kDptoPiEta );
414 numchan.push_back(2);
415 numchan.push_back(4);
416 decaylist=pionList.plus()* etaList;
417 }
418 else if(channel=="DptoKsPiEta") {
419 numchan.push_back( EvtRecDTag::kDptoKsPiEta );
420 numchan.push_back(5);
421 numchan.push_back(2);
422 numchan.push_back(4);
423 decaylist=ksList* pionList.plus()* etaList;
424 }
425
426 CDDecayList::iterator D_begin =decaylist.particle_begin();
427 CDDecayList::iterator D_end =decaylist.particle_end();
428
429 for ( CDDecayList::iterator it = D_begin; it != D_end; it++ ) {
430
431 EvtRecDTag* recDTag = new EvtRecDTag;
432 recDTag->setdecayMode( (EvtRecDTag::DecayMode)numchan[0] );
433
434 vector<int> trackid, showerid;
435 vector<int> kaonid, pionid;
436 int numofchildren=numchan.size()-1;
437
438 for(int i=0; i< numofchildren;i++){
439
440 const CDCandidate& daughter=(*it).particle().child(i);
441
442 if(numchan[i+1]==1){
443 const EvtRecTrack* track=daughter.track();
444 trackid.push_back(track->trackId());
445 kaonid.push_back(track->trackId());
446 }
447 else if(numchan[i+1]==2){
448 const EvtRecTrack* track=daughter.track();
449 trackid.push_back(track->trackId());
450 pionid.push_back(track->trackId());
451 }
452 else if ( numchan[i+1]==3){
453 const EvtRecTrack* hiEnGamma=daughter.navPi0()->hiEnGamma();
454 const EvtRecTrack* loEnGamma=daughter.navPi0()->loEnGamma();
455 showerid.push_back(hiEnGamma->trackId());
456 showerid.push_back(loEnGamma->trackId());
457 }
458 else if ( numchan[i+1]==4){
459 const EvtRecTrack* hiEnGamma=daughter.navEta()->hiEnGamma();
460 const EvtRecTrack* loEnGamma=daughter.navEta()->loEnGamma();
461 showerid.push_back(hiEnGamma->trackId());
462 showerid.push_back(loEnGamma->trackId());
463 }
464 else if ( numchan[i+1]==5){
465 EvtRecVeeVertex* aKsCand = const_cast<EvtRecVeeVertex*>( daughter.navKshort() );
466 EvtRecTrack* pion1Trk = aKsCand->daughter(0);
467 EvtRecTrack* pion2Trk = aKsCand->daughter(1);
468 trackid.push_back(pion1Trk->trackId());
469 trackid.push_back(pion2Trk->trackId());
470 }
471
472 }//end of filling track and shower ids
473
474
475 saveDpInfo(it, ebeam, numofchildren, recDTag);
476 savetrack(trackid,showerid,charged_begin,charged_end,neutral_begin,neutral_end,recDTag);
477 pidtag(kaonid,pionid,kaonList_tight, pionList_tight,recDTag);
478
479 if(m_usevertexfit){
480 HepLorentzVector p4change_vfit=util.vfit(channel, kaonid, pionid, xorigin, charged_begin);
481 recDTag->setp4(recDTag->p4()+p4change_vfit);
482 }
483
484
485 trackid.clear();
486 showerid.clear();
487 kaonid.clear();
488 pionid.clear();
489
490
491 //write dtag object out
492 recDTagCol->push_back(recDTag);
493
494 }//end of decaylist iterator
495
496 numchan.clear();
497
498 }//end of reconstrucing all D+ decay lists
499
500
501
502 return StatusCode::SUCCESS;
503}
504
505
506void ChargedDReconstruction::saveDpInfo(CDDecayList::iterator it, double ebeam, int numofchildren, EvtRecDTag* recDTag){
507
508 double mass = (*it).particle().mass();
509 int charge= (*it).particle().charge();
510 HepLorentzVector p4((*it).particle().momentum(), (*it).particle().energy());
511 recDTag->setp4(p4);
512
513 p4.boost(-m_beta);
514 double mbc2_CMS = ebeam*ebeam - p4.v().mag2();
515 double mbc_CMS = mbc2_CMS > 0 ? sqrt( mbc2_CMS ) : -10;
516 double deltaE_CMS = p4.t() - ebeam;
517
518 if((*it).particle().userTag()==1)
519 recDTag->settype( EvtRecDTag::Tight );
520 else
521 recDTag->settype( EvtRecDTag::Loose );
522 recDTag->setcharge(charge);
523 recDTag->setcharm(charge);
524 recDTag->setnumOfChildren(numofchildren);
525 recDTag->setmass(mass);
526 recDTag->setmBC(mbc_CMS);
527 recDTag->setbeamE(ebeam);
528 recDTag->setdeltaE(deltaE_CMS);
529
530}
531
532void ChargedDReconstruction::savetrack(vector<int> trackid, vector<int> showerid, EvtRecTrackIterator charged_begin, EvtRecTrackIterator charged_end,
533 EvtRecTrackIterator neutral_begin, EvtRecTrackIterator neutral_end,EvtRecDTag* recDTag){
534
535 vector<EvtRecTrackIterator> trktemp;
536 vector<EvtRecTrackIterator> shrtemp;
537
538 //fill tracks
539 for(EvtRecTrackIterator trk=charged_begin; trk<charged_end;trk++){
540
541 bool isothertrack=true;
542 for(int i=0; i<trackid.size(); i++){
543 if( (*trk)->trackId()==trackid[i] ){
544 trktemp.push_back(trk);
545 isothertrack=false;
546 break;
547 }
548 }
549 if(isothertrack)
550 recDTag->addOtherTrack(*trk);
551 }
552 for(int i=0; i<trackid.size();i++){
553 for(int j=0; j<trktemp.size(); j++){
554 EvtRecTrackIterator trk=trktemp[j];
555 if( (*trk)->trackId()==trackid[i])
556 recDTag->addTrack(*trktemp[j]);
557 }
558 }
559
560
561 //fill showers
562 for(EvtRecTrackIterator shr=neutral_begin; shr<neutral_end;shr++){
563 bool isothershower=true;
564 for(int i=0; i<showerid.size(); i++){
565 if( (*shr)->trackId()==showerid[i] ){
566 shrtemp.push_back(shr);
567 isothershower=false;
568 break;
569 }
570 }
571 if(isothershower)
572 recDTag->addOtherShower(*shr);
573 }
574
575 for(int i=0; i<showerid.size();i++){
576 for(int j=0; j<shrtemp.size(); j++){
577 EvtRecTrackIterator shr=shrtemp[j];
578 if( (*shr)->trackId()==showerid[i])
579 recDTag->addShower(*shrtemp[j]);
580 }
581 }
582
583
584}
585
586void ChargedDReconstruction::pidtag(vector<int> kaonid, vector<int> pionid, CDChargedKaonList& kaonList, CDChargedPionList& pionList,EvtRecDTag* recDTag){
587
588 bool iskaon=false,ispion=false;
589
590
591 // save track ids which passed pion/kaon cuts
592
593 for (CDChargedKaonList::iterator kit = kaonList.particle_begin(); kit != kaonList.particle_end(); kit++) {
594 recDTag->addKaonId( (*kit).particle().track() );
595 }
596
597 for (CDChargedPionList::iterator pit = pionList.particle_begin(); pit != pionList.particle_end(); pit++) {
598 recDTag->addPionId( (*pit).particle().track() );
599 }
600
601
602 /*
603 for(int i=0; i<kaonid.size(); i++){
604 bool ithkaon=false;
605 for (CDChargedKaonList::iterator kit = kaonList.particle_begin(); kit != kaonList.particle_end(); kit++) {
606 if((*kit).particle().track()->trackId()==kaonid[i]){
607 ithkaon=true;
608 break;
609 }
610 }
611 if(!ithkaon) break;
612 if(i==kaonid.size()-1)
613 iskaon=true;
614 }
615
616 for(int i=0; i<pionid.size(); i++){
617 bool ithpion=false;
618 for (CDChargedPionList::iterator pit = pionList.particle_begin(); pit != pionList.particle_end(); pit++) {
619 if((*pit).particle().track()->trackId()==pionid[i]){
620 ithpion=true;
621 break;
622 }
623 }
624 if(!ithpion) break;
625 if(i==pionid.size()-1)
626 ispion=true;
627 }
628
629
630 if( iskaon && ispion)
631 recDTag->settype( EvtRecDTag::Tight );
632 else if( (kaonid.size()==0 && ispion) || (pionid.size()==0 && iskaon))
633 recDTag->settype( EvtRecDTag::Tight );
634 else if( kaonid.size()==0 && pionid.size()==0 )
635 recDTag->settype( EvtRecDTag::Tight );
636 */
637
638}
639
640
641
642vector<string> ChargedDReconstruction::getlist(string& filename ){
643
644 string channel;
645 vector<string> temp;
646
647 ifstream inFile;
648
649 inFile.open(filename.c_str());
650 if (!inFile) {
651 cout << "Unable to open decay list file";
652 exit(1); // terminate with error
653 }
654
655 while (inFile >> channel) {
656 temp.push_back(channel);
657 }
658
659 inFile.close();
660
661 return temp;
662
663}
chargedDSelector
ChargedDSelector chargedDSelector
Definition: ChargedDSelector.cxx:55
mass
double mass
Definition: CosmicGenerator.cxx:138
dc_fill
void dc_fill(DCFillableChargedList< Charged > &aFillableList, WitnessIterator first, WitnessIterator last)
Definition: DCFillableChargedList.h:152
EvtRecDTagCol
ObjectVector< EvtRecDTag > EvtRecDTagCol
Definition: EvtRecDTag.h:234
EvtRecTrackIterator
EvtRecTrackCol::iterator EvtRecTrackIterator
Definition: EvtRecTrack.h:131
etatoGGSelector
LocalEtatoGGSelector etatoGGSelector
Definition: LocalEtatoGGSelector.cxx:37
kaonSelector
LocalKaonSelector kaonSelector
Definition: LocalKaonSelector.cxx:132
ksSelector
LocalKsSelector ksSelector
Definition: LocalKsSelector.cxx:40
pi0Selector
LocalPi0Selector pi0Selector
Definition: LocalPi0Selector.cxx:39
pionSelector
LocalPionSelector pionSelector
Definition: LocalPionSelector.cxx:132
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:506
ChargedDReconstruction::getlist
vector< string > getlist(string &filename)
Definition: ChargedDReconstruction.cxx:642
ChargedDReconstruction::pidtag
void pidtag(vector< int >, vector< int >, CDChargedKaonList &, CDChargedPionList &, EvtRecDTag *)
Definition: ChargedDReconstruction.cxx:586
ChargedDReconstruction::savetrack
void savetrack(vector< int >, vector< int >, EvtRecTrackIterator, EvtRecTrackIterator, EvtRecTrackIterator, EvtRecTrackIterator, EvtRecDTag *)
Definition: ChargedDReconstruction.cxx:532
ChargedDReconstruction::ChargedDReconstruction
ChargedDReconstruction(const std::string &name, ISvcLocator *pSvcLocator)
Definition: ChargedDReconstruction.cxx:55
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:94
EvtRecDTag::kDptoKsKminusPiPi
@ kDptoKsKminusPiPi
Definition: EvtRecDTag.h:109
EvtRecDTag::kDptoKPiPiPi0
@ kDptoKPiPiPi0
Definition: EvtRecDTag.h:92
EvtRecDTag::kDptoKPiPiPiPi
@ kDptoKPiPiPiPi
Definition: EvtRecDTag.h:112
EvtRecDTag::kDptoKsPiPi0Pi0
@ kDptoKsPiPi0Pi0
Definition: EvtRecDTag.h:107
EvtRecDTag::kDptoKsPiPiPi
@ kDptoKsPiPiPi
Definition: EvtRecDTag.h:95
EvtRecDTag::kDptoKsKplusPiPi
@ kDptoKsKplusPiPi
Definition: EvtRecDTag.h:108
EvtRecDTag::kDptoPiPiPiPiPi
@ kDptoPiPiPiPiPi
Definition: EvtRecDTag.h:111
EvtRecDTag::kDptoPiPiPiPi0
@ kDptoPiPiPiPi0
Definition: EvtRecDTag.h:106
EvtRecDTag::addOtherTrack
void addOtherTrack(const SmartRef< EvtRecTrack > track)
Definition: EvtRecDTag.h:187
EvtRecDTag::settype
void settype(SelType type)
Definition: EvtRecDTag.h:173
EvtRecDTag::setdecayMode
void setdecayMode(DecayMode decayMode)
Definition: EvtRecDTag.h:172
EvtRecDTag::p4
HepLorentzVector p4() const
Definition: EvtRecDTag.h:161
EvtRecDTag::setp4
void setp4(HepLorentzVector p4)
Definition: EvtRecDTag.h:181
EvtRecDTag::setmass
void setmass(double mass)
Definition: EvtRecDTag.h:175
EvtRecDTag::addOtherShower
void addOtherShower(const SmartRef< EvtRecTrack > shower)
Definition: EvtRecDTag.h:189
EvtRecDTag::addKaonId
void addKaonId(const SmartRef< EvtRecTrack > kaonId)
Definition: EvtRecDTag.h:193
EvtRecDTag::setdeltaE
void setdeltaE(double deltaE)
Definition: EvtRecDTag.h:177
EvtRecDTag::setcharm
void setcharm(int charm)
Definition: EvtRecDTag.h:179
EvtRecDTag::setmBC
void setmBC(double mBC)
Definition: EvtRecDTag.h:176
EvtRecDTag::setcharge
void setcharge(int charge)
Definition: EvtRecDTag.h:178
EvtRecDTag::addPionId
void addPionId(const SmartRef< EvtRecTrack > pionId)
Definition: EvtRecDTag.h:191
EvtRecDTag::setbeamE
void setbeamE(double beamE)
Definition: EvtRecDTag.h:174
EvtRecDTag::addShower
void addShower(const SmartRef< EvtRecTrack > shower)
Definition: EvtRecDTag.h:185
EvtRecDTag::setnumOfChildren
void setnumOfChildren(int numOfChildren)
Definition: EvtRecDTag.h:180
EvtRecDTag::addTrack
void addTrack(const SmartRef< EvtRecTrack > track)
Definition: EvtRecDTag.h:183
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:36
EvtRecVeeVertex::daughter
SmartRef< EvtRecTrack > & daughter(int i)
Definition: EvtRecVeeVertex.h:89
IVertexDbSvc::isVertexValid
virtual bool isVertexValid()=0
IVertexDbSvc::PrimaryVertex
virtual double * PrimaryVertex()=0
LocalKaonSelector::setpidtype
void setpidtype(int type)
Definition: LocalKaonSelector.h:15
LocalPionSelector::setpidtype
void setpidtype(int type)
Definition: LocalPionSelector.h:14
dchain::CandidateList::size
virtual int size() const
Definition: CandidateList.cc:143
dchain::ChargedVisibleList::plus
ChosenChargeList< Charged, CandidateClass > & plus() const
Definition: ChargedVisibleList.cc:176
dchain::ChargedVisibleList::minus
ChosenChargeList< Charged, CandidateClass > & minus() const
Definition: ChargedVisibleList.cc:186
dchain::DecayList::particle_begin
virtual iterator particle_begin()
Definition: DecayList.cc:169
dchain::DecayList::particle_end
virtual iterator particle_end()
Definition: DecayList.cc:176
utility
Definition: utility.h:9
utility::vfit
HepLorentzVector vfit(string channel, vector< int > kaonid, vector< int > pionid, HepPoint3D vx, EvtRecTrackIterator charged_begin)
Definition: utility.cxx:57
EventModel::EvtRec::EvtRecEvent
_EXTERN_ std::string EvtRecEvent
Definition: EventModel.h:134
EventModel::EvtRec::EvtRecDTagCol
_EXTERN_ std::string EvtRecDTagCol
Definition: EventModel.h:140
EventModel::EvtRec::EvtRecTrackCol
_EXTERN_ std::string EvtRecTrackCol
Definition: EventModel.h:135
Event
Definition: Event.h:21