BOSS 8.0.0
BESIII Offline Software System
Loading...
Searching...
No Matches
NeutralDReconstruction.cxx
Go to the documentation of this file.
1//
2// All D0 decay modes Reconstruction
3//
4
5#include "GaudiKernel/IDataProviderSvc.h"
6#include "GaudiKernel/ISvcLocator.h"
7#include "GaudiKernel/MsgStream.h"
8#include "GaudiKernel/SmartDataPtr.h"
9
10#include "EventModel/EventHeader.h"
11#include "EventModel/EventModel.h"
12
13#include "EvtRecEvent/EvtRecDTag.h"
14#include "EvtRecEvent/EvtRecEtaToGG.h"
15#include "EvtRecEvent/EvtRecEvent.h"
16#include "EvtRecEvent/EvtRecPi0.h"
17#include "EvtRecEvent/EvtRecTrack.h"
18#include "EvtRecEvent/EvtRecVeeVertex.h"
19
20#include "BesDChain/CDChargedKaonList.h"
21#include "BesDChain/CDChargedPionList.h"
22#include "BesDChain/CDDecayList.h"
23#include "BesDChain/CDEtaList.h"
24#include "BesDChain/CDKsList.h"
25#include "BesDChain/CDPhotonList.h"
26#include "BesDChain/CDPi0List.h"
27
28#include "NeutralDReconstruction.h"
29#include "utility.h"
30
31#include <fstream>
32
33using namespace Event;
34
35DECLARE_COMPONENT( NeutralDReconstruction )
36//*******************************************************************************************
37NeutralDReconstruction::NeutralDReconstruction( const std::string& name,
38 ISvcLocator* pSvcLocator )
39 : Algorithm( name, pSvcLocator ) {
40 // Declare the properties
41 declareProperty( "debug", m_debug = false );
42 declareProperty( "ReadBeamEFromDB", m_ReadBeamEFromDB = false );
43 declareProperty( "UseCalibBeamE", m_usecalibBeamE = false );
44 declareProperty( "UseVertexfit", m_usevertexfit = false );
45 declareProperty( "BeamE", m_beamE = 1.8865 );
46 declareProperty( "D0List", m_decaylist = "test.txt" );
47 declareProperty( "UseVFRefine", m_useVFrefine = true );
48 declareProperty( "UseBFieldCorr", m_useBFC = true );
49}
50
51//******************************************************************************************
52StatusCode NeutralDReconstruction::initialize() {
53 MsgStream log( msgSvc(), name() );
54 log << MSG::INFO << "in initialize()" << endmsg;
55
56 m_irun = -100;
57 m_beta.setX( 0.011 );
58 m_beta.setY( 0 );
59 m_beta.setZ( 0 );
60
61 chanlist = getlist( m_decaylist );
62
63 auto sc = toolSvc()->retrieveTool( "LocalPionSelector", m_pionSelector );
64 sc &= toolSvc()->retrieveTool( "LocalKaonSelector", m_kaonSelector );
65 sc &= toolSvc()->retrieveTool( "LocalPhotonSelector", m_photonSelector );
66 sc &= toolSvc()->retrieveTool( "LocalKsSelector", m_ksSelector );
67 sc &= toolSvc()->retrieveTool( "LocalPi0Selector", m_pi0Selector );
68 sc &= toolSvc()->retrieveTool( "LocalEtatoGGSelector", m_etatoGGSelector );
69 sc &= toolSvc()->retrieveTool( "NeutralDSelector", m_neutralDSelector );
70 sc &= toolSvc()->retrieveTool( "LocalEptoPiPiEtaSelector", m_eptoPiPiEtaSelector );
71 sc &= toolSvc()->retrieveTool( "LocalRhotoPiPiSelector", m_rhotoPiPiSelector );
72 sc &= toolSvc()->retrieveTool( "LocalEptoRhoGamSelector", m_eptoRhoGamSelector );
73
74 if ( !sc.isSuccess() )
75 {
76 log << MSG::FATAL << "Could not retrieve all selector tools!" << endmsg;
77 return sc;
78 }
79
80 return StatusCode::SUCCESS;
81}
82
83//********************************************************************************************
84StatusCode NeutralDReconstruction::finalize() {
85 MsgStream log( msgSvc(), name() );
86 log << MSG::INFO << "in finalize()" << endmsg;
87
88 chanlist.clear();
89
90 return StatusCode::SUCCESS;
91}
92
93StatusCode NeutralDReconstruction::registerEvtRecDTagCol( EvtRecDTagCol* aNewEvtRecDTagCol,
94 MsgStream& log ) {
95 StatusCode sc =
96 eventSvc()->registerObject( "/Event/EvtRec/EvtRecDTagCol", aNewEvtRecDTagCol );
97 if ( sc != StatusCode::SUCCESS )
98 { log << MSG::FATAL << "Could not register EvtRecDTagCol in TDS!" << endmsg; }
99 return sc;
100}
101
102//*********************************************************************************************
103StatusCode NeutralDReconstruction::execute() {
104 MsgStream log( msgSvc(), name() );
105 log << MSG::INFO << "in execute()" << endmsg;
106
107 StatusCode sc;
108
109 //////////////////
110 // Read REC data
111 /////////////////
112 SmartDataPtr<Event::EventHeader> eventHeader( eventSvc(), "/Event/EventHeader" );
113 int event = eventHeader->eventNumber();
114 // if ( m_debug || ( (event & 0x3FF) == 0 ) )
115 // std::cout << "event: " << event << std::endl;
116
117 SmartDataPtr<EvtRecEvent> recEvent( eventSvc(), EventModel::EvtRec::EvtRecEvent );
118 SmartDataPtr<EvtRecTrackCol> recTrackCol( eventSvc(), EventModel::EvtRec::EvtRecTrackCol );
119 log << MSG::DEBUG << "run and event = " << eventHeader->runNumber() << " "
120 << eventHeader->eventNumber() << endmsg;
121 log << MSG::DEBUG << "ncharg, nneu, tottks = " << recEvent->totalCharged() << " , "
122 << recEvent->totalNeutral() << " , " << recEvent->totalTracks() << endmsg;
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 SmartDataPtr<EvtRecPi0Col> recPi0Col( eventSvc(), "/Event/EvtRec/EvtRecPi0Col" );
131 if ( !recPi0Col )
132 {
133 log << MSG::FATAL << "Could not find EvtRecPi0Col" << endmsg;
134 return StatusCode::FAILURE;
135 }
136
137 SmartDataPtr<EvtRecEtaToGGCol> recEtaToGGCol( eventSvc(), "/Event/EvtRec/EvtRecEtaToGGCol" );
138 if ( !recEtaToGGCol )
139 {
140 log << MSG::FATAL << "Could not find EvtRecEtaToGGCol" << endmsg;
141 return StatusCode::FAILURE;
142 }
143
144 SmartDataPtr<EvtRecVeeVertexCol> recVeeVertexCol( eventSvc(),
145 "/Event/EvtRec/EvtRecVeeVertexCol" );
146 if ( !recVeeVertexCol )
147 {
148 log << MSG::FATAL << "Could not find EvtRecVeeVertexCol" << endmsg;
149 return StatusCode::FAILURE;
150 }
151
152 SmartDataPtr<EvtRecDTagCol> recDTagCol( eventSvc(), EventModel::EvtRec::EvtRecDTagCol );
153 if ( !recDTagCol )
154 {
155 log << MSG::FATAL << "EvtRecDTagCol is not registered in TDS" << endmsg;
156 return StatusCode::FAILURE;
157 }
158
159 // get primary vertex from db
160 Hep3Vector xorigin( 0, 0, 0 );
161 IVertexDbSvc* vtxsvc;
162 sc = serviceLocator()->service( "VertexDbSvc", vtxsvc );
163 if ( vtxsvc->isVertexValid() )
164 {
165
166 // vertex[0] = vx; vertex[1]= vy; vertex[2] = vz;
167 double* vertex = vtxsvc->PrimaryVertex();
168 xorigin.setX( vertex[0] );
169 xorigin.setY( vertex[1] );
170 xorigin.setZ( vertex[2] );
171 }
172 utility util;
173
174 // registered in the parent file DTag.cxx
175 /*
176 if (!recDTagCol) {
177 recDTagCol = new EvtRecDTagCol;
178 sc = registerEvtRecDTagCol(recDTagCol, log);
179 if (sc != StatusCode::SUCCESS) {
180 return sc;
181 }
182 }
183 */
184
185 /////////////////////////////
186 // reconstruct particle lists
187 /////////////////////////////
188
189 m_pionSelector->setpidtype( 0 );
190 m_kaonSelector->setpidtype( 0 );
191 CDChargedPionList pionList( charged_begin, charged_end, *m_pionSelector );
192 CDChargedKaonList kaonList( charged_begin, charged_end, *m_kaonSelector );
193 CDPhotonList photonList( neutral_begin, neutral_end, *m_photonSelector );
194
195 CDKsList ksList( *m_ksSelector );
196 dc_fill( ksList, recVeeVertexCol->begin(), recVeeVertexCol->end() );
197
198 // do a secondary vertex fit and cut on the results
199 map<EvtRecVeeVertex*, vector<double>> fitinfo;
200 for ( CDKsList::iterator ksit = ksList.particle_begin(); ksit != ksList.particle_end();
201 ++ksit )
202 {
203 EvtRecVeeVertex* ks = const_cast<EvtRecVeeVertex*>( ( *ksit ).particle().navKshort() );
204
205 if ( m_useVFrefine ) { fitinfo[ks] = util.SecondaryVFitref( ks, vtxsvc ); }
206 else { fitinfo[ks] = util.SecondaryVFit( ks, vtxsvc ); }
207 }
208
209 CDPi0List pi0List( *m_pi0Selector );
210 dc_fill( pi0List, recPi0Col->begin(), recPi0Col->end() );
211
212 CDEtaList etaList( *m_etatoGGSelector );
213 dc_fill( etaList, recEtaToGGCol->begin(), recEtaToGGCol->end() );
214
215 // pion/kaon list with PID
216 m_pionSelector->setpidtype( 1 );
217 m_kaonSelector->setpidtype( 1 );
218 CDChargedPionList pionList_tight( charged_begin, charged_end, *m_pionSelector );
219 CDChargedKaonList kaonList_tight( charged_begin, charged_end, *m_kaonSelector );
220
221 int run = eventHeader->runNumber();
222 m_ievt = eventHeader->eventNumber();
223 m_nChrg = recEvent->totalCharged();
224 m_nNeu = recEvent->totalNeutral();
225 m_nPion = pionList.size();
226 m_nKaon = kaonList.size();
227 m_nPi0 = pi0List.size();
228 m_nKs = ksList.size();
229
230 ///////////////////////
231 // get beam energy and beta
232 ///////////////////////
233
234 if ( m_ReadBeamEFromDB && m_irun != run )
235 {
236 m_irun = run;
237 if ( m_usecalibBeamE ) m_readDb.setcalib( true );
238 m_beamE = m_readDb.getbeamE( m_irun, m_beamE );
239 if ( run > 0 ) m_beta = m_readDb.getbeta();
240
241 // cout<<"use beam E from data base:"<<m_beamE<<endl;
242 }
243 double ebeam = m_beamE;
244
245 //////////////////////////////
246 // reconstruct decay lists
247 /////////////////////////////
248
249 for ( int list = 0; list < chanlist.size(); list++ )
250 {
251
252 string channel = chanlist[list];
253 vector<int> numchan;
254 m_neutralDSelector->setebeam( ebeam );
255 m_neutralDSelector->setbeta( m_beta );
256 CDDecayList decaylist( *m_neutralDSelector );
257
258 bool isFlavorMode = false;
259
260 // K+/-: 1, Pi+/-:2, Pi0:3, Eta: 4, Ks:5, Eta'(pipiEta):6, Eta'(rhogam):7
261 // the fist element of the vector stands for decay mode,
262 // the rest will be particles, and size of the vector minus 1 will be number of daughers.
263 // the first particle in the vector will be used to get charm
264
265 if ( channel == "D0toKPi" )
266 {
267 numchan.push_back( EvtRecDTag::kD0toKPi );
268 numchan.push_back( 1 );
269 numchan.push_back( 2 );
270 decaylist = kaonList.minus() * pionList.plus();
271 isFlavorMode = true;
272 }
273 else if ( channel == "D0toKPiPi0" )
274 {
275 numchan.push_back( EvtRecDTag::kD0toKPiPi0 );
276 numchan.push_back( 1 );
277 numchan.push_back( 2 );
278 numchan.push_back( 3 );
279 decaylist = kaonList.minus() * pionList.plus() * pi0List;
280 isFlavorMode = true;
281 }
282 else if ( channel == "D0toKPiPi0Pi0" )
283 {
284 numchan.push_back( EvtRecDTag::kD0toKPiPi0Pi0 );
285 numchan.push_back( 1 );
286 numchan.push_back( 2 );
287 numchan.push_back( 3 );
288 numchan.push_back( 3 );
289 decaylist = kaonList.minus() * pionList.plus() * pi0List * pi0List;
290 isFlavorMode = true;
291 }
292 else if ( channel == "D0toKPiPiPi" )
293 {
294 numchan.push_back( EvtRecDTag::kD0toKPiPiPi );
295 numchan.push_back( 1 );
296 numchan.push_back( 2 );
297 numchan.push_back( 2 );
298 numchan.push_back( 2 );
299 decaylist = kaonList.minus() * pionList.plus() * pionList.plus() * pionList.minus();
300 isFlavorMode = true;
301 }
302 else if ( channel == "D0toKPiPiPiPi0" )
303 {
304 numchan.push_back( EvtRecDTag::kD0toKPiPiPiPi0 );
305 numchan.push_back( 1 );
306 numchan.push_back( 2 );
307 numchan.push_back( 2 );
308 numchan.push_back( 2 );
309 numchan.push_back( 3 );
310 decaylist =
311 kaonList.minus() * pionList.plus() * pionList.plus() * pionList.minus() * pi0List;
312 isFlavorMode = true;
313 }
314 else if ( channel == "D0toKPiEta" )
315 {
316 numchan.push_back( EvtRecDTag::kD0toKPiEta );
317 numchan.push_back( 1 );
318 numchan.push_back( 2 );
319 numchan.push_back( 4 );
320 decaylist = kaonList.minus() * pionList.plus() * etaList;
321 isFlavorMode = true;
322 }
323 else if ( channel == "D0toKPiPi0Pi0Pi0" )
324 {
325 numchan.push_back( EvtRecDTag::kD0toKPiPi0Pi0Pi0 );
326 numchan.push_back( 1 );
327 numchan.push_back( 2 );
328 numchan.push_back( 3 );
329 numchan.push_back( 3 );
330 numchan.push_back( 3 );
331 decaylist = kaonList.minus() * pionList.plus() * pi0List * pi0List * pi0List;
332 isFlavorMode = true;
333 }
334 else if ( channel == "D0toKPiPi0Eta" )
335 {
336 numchan.push_back( EvtRecDTag::kD0toKPiPi0Eta );
337 numchan.push_back( 1 );
338 numchan.push_back( 2 );
339 numchan.push_back( 3 );
340 numchan.push_back( 4 );
341 decaylist = kaonList.minus() * pionList.plus() * pi0List * etaList;
342 isFlavorMode = true;
343 }
344 else if ( channel == "D0toKPiEPPiPiEta" )
345 {
346 numchan.push_back( EvtRecDTag::kD0toKPiEPPiPiEta );
347 numchan.push_back( 1 );
348 numchan.push_back( 2 );
349 numchan.push_back( 6 );
350 CDDecayList epList( *m_eptoPiPiEtaSelector );
351 epList = pionList.plus() * pionList.minus() * etaList;
352 decaylist = kaonList.minus() * pionList.plus() * epList;
353 isFlavorMode = true;
354 }
355 else if ( channel == "D0toKPiEPRhoGam" )
356 {
357 numchan.push_back( EvtRecDTag::kD0toKPiEPRhoGam );
358 numchan.push_back( 1 );
359 numchan.push_back( 2 );
360 numchan.push_back( 7 );
361 CDDecayList rhoList( *m_rhotoPiPiSelector );
362 rhoList = pionList.plus() * pionList.minus();
363 CDDecayList epList( *m_eptoRhoGamSelector );
364 epList = rhoList * photonList;
365 decaylist = kaonList.minus() * pionList.plus() * epList;
366 isFlavorMode = true;
367 }
368 else if ( channel == "D0toKKKPi" )
369 {
370 numchan.push_back( EvtRecDTag::kD0toKKKPi );
371 numchan.push_back( 1 );
372 numchan.push_back( 1 );
373 numchan.push_back( 1 );
374 numchan.push_back( 2 );
375 decaylist = kaonList.minus() * kaonList.plus() * kaonList.minus() * pionList.plus();
376 isFlavorMode = true;
377 }
378 else if ( channel == "D0toKsKPi" )
379 {
380 numchan.push_back( EvtRecDTag::kD0toKsKPi );
381 numchan.push_back( 5 );
382 numchan.push_back( 1 );
383 numchan.push_back( 2 );
384 decaylist = ksList * kaonList.minus() * pionList.plus();
385 }
386 else if ( channel == "D0toKsKPiPi0" )
387 {
388 numchan.push_back( EvtRecDTag::kD0toKsKPiPi0 );
389 numchan.push_back( 5 );
390 numchan.push_back( 1 );
391 numchan.push_back( 2 );
392 numchan.push_back( 3 );
393 decaylist = ksList * kaonList.minus() * pionList.plus() * pi0List;
394 }
395 else if ( channel == "D0toKsPiPi" )
396 {
397 numchan.push_back( EvtRecDTag::kD0toKsPiPi );
398 numchan.push_back( 5 );
399 numchan.push_back( 2 );
400 numchan.push_back( 2 );
401 decaylist = ksList * pionList.plus() * pionList.minus();
402 }
403 else if ( channel == "D0toKsPiPiPi0" )
404 {
405 numchan.push_back( EvtRecDTag::kD0toKsPiPiPi0 );
406 numchan.push_back( 5 );
407 numchan.push_back( 2 );
408 numchan.push_back( 2 );
409 numchan.push_back( 3 );
410 decaylist = ksList * pionList.plus() * pionList.minus() * pi0List;
411 }
412 else if ( channel == "D0toKsPi0" )
413 {
414 numchan.push_back( EvtRecDTag::kD0toKsPi0 );
415 numchan.push_back( 5 );
416 numchan.push_back( 3 );
417 decaylist = ksList * pi0List;
418 }
419 else if ( channel == "D0toPiPiPi0" )
420 {
421 numchan.push_back( EvtRecDTag::kD0toPiPiPi0 );
422 numchan.push_back( 2 );
423 numchan.push_back( 2 );
424 numchan.push_back( 3 );
425 decaylist = pionList.plus() * pionList.minus() * pi0List;
426 }
427 else if ( channel == "D0toPiPi" )
428 {
429 numchan.push_back( EvtRecDTag::kD0toPiPi );
430 numchan.push_back( 2 );
431 numchan.push_back( 2 );
432 decaylist = pionList.plus() * pionList.minus();
433 }
434 else if ( channel == "D0toKK" )
435 {
436 numchan.push_back( EvtRecDTag::kD0toKK );
437 numchan.push_back( 1 );
438 numchan.push_back( 1 );
439 decaylist = kaonList.minus() * kaonList.plus();
440 }
441 else if ( channel == "D0toKKPi0" )
442 {
443 numchan.push_back( EvtRecDTag::kD0toKKPi0 );
444 numchan.push_back( 1 );
445 numchan.push_back( 1 );
446 numchan.push_back( 3 );
447 decaylist = kaonList.minus() * kaonList.plus() * pi0List;
448 }
449 else if ( channel == "D0toPi0Pi0" )
450 {
451 numchan.push_back( EvtRecDTag::kD0toPi0Pi0 );
452 numchan.push_back( 3 );
453 numchan.push_back( 3 );
454 decaylist = pi0List * pi0List;
455 }
456 else if ( channel == "D0toKsKs" )
457 {
458 numchan.push_back( EvtRecDTag::kD0toKsKs );
459 numchan.push_back( 5 );
460 numchan.push_back( 5 );
461 decaylist = ksList * ksList;
462 }
463 else if ( channel == "D0toKsKsPi0" )
464 {
465 numchan.push_back( EvtRecDTag::kD0toKsKsPi0 );
466 numchan.push_back( 5 );
467 numchan.push_back( 5 );
468 numchan.push_back( 3 );
469 decaylist = ksList * ksList * pi0List;
470 }
471 else if ( channel == "D0toKsPi0Pi0" )
472 {
473 numchan.push_back( EvtRecDTag::kD0toKsPi0Pi0 );
474 numchan.push_back( 5 );
475 numchan.push_back( 3 );
476 numchan.push_back( 3 );
477 decaylist = ksList * pi0List * pi0List;
478 }
479 else if ( channel == "D0toKsKK" )
480 {
481 numchan.push_back( EvtRecDTag::kD0toKsKK );
482 numchan.push_back( 5 );
483 numchan.push_back( 1 );
484 numchan.push_back( 1 );
485 decaylist = ksList * kaonList.minus() * kaonList.plus();
486 }
487 else if ( channel == "D0toKsEta" )
488 {
489 numchan.push_back( EvtRecDTag::kD0toKsEta );
490 numchan.push_back( 5 );
491 numchan.push_back( 4 );
492 decaylist = ksList * etaList;
493 }
494 else if ( channel == "D0toPi0Pi0Pi0" )
495 {
496 numchan.push_back( EvtRecDTag::kD0toPi0Pi0Pi0 );
497 numchan.push_back( 3 );
498 numchan.push_back( 3 );
499 numchan.push_back( 3 );
500 decaylist = pi0List * pi0List * pi0List;
501 }
502 else if ( channel == "D0toKsKsKs" )
503 {
504 numchan.push_back( EvtRecDTag::kD0toKsKsKs );
505 numchan.push_back( 5 );
506 numchan.push_back( 5 );
507 numchan.push_back( 5 );
508 decaylist = ksList * ksList * ksList;
509 }
510 else if ( channel == "D0toPiPiPiPi" )
511 {
512 numchan.push_back( EvtRecDTag::kD0toPiPiPiPi );
513 numchan.push_back( 2 );
514 numchan.push_back( 2 );
515 numchan.push_back( 2 );
516 numchan.push_back( 2 );
517 decaylist = pionList.plus() * pionList.plus() * pionList.minus() * pionList.minus();
518 }
519 else if ( channel == "D0toPiPiPi0Pi0" )
520 {
521 numchan.push_back( EvtRecDTag::kD0toPiPiPi0Pi0 );
522 numchan.push_back( 2 );
523 numchan.push_back( 2 );
524 numchan.push_back( 3 );
525 numchan.push_back( 3 );
526 decaylist = pionList.plus() * pionList.minus() * pi0List * pi0List;
527 }
528 else if ( channel == "D0toKKPiPi" )
529 {
530 numchan.push_back( EvtRecDTag::kD0toKKPiPi );
531 numchan.push_back( 1 );
532 numchan.push_back( 1 );
533 numchan.push_back( 2 );
534 numchan.push_back( 2 );
535 decaylist = kaonList.minus() * kaonList.plus() * pionList.plus() * pionList.minus();
536 }
537 else if ( channel == "D0toKKPi0Pi0" )
538 {
539 numchan.push_back( EvtRecDTag::kD0toKKPi0Pi0 );
540 numchan.push_back( 1 );
541 numchan.push_back( 1 );
542 numchan.push_back( 3 );
543 numchan.push_back( 3 );
544 decaylist = kaonList.minus() * kaonList.plus() * pi0List * pi0List;
545 }
546 else if ( channel == "D0toKsKsPiPi" )
547 {
548 numchan.push_back( EvtRecDTag::kD0toKsKsPiPi );
549 numchan.push_back( 5 );
550 numchan.push_back( 5 );
551 numchan.push_back( 2 );
552 numchan.push_back( 2 );
553 decaylist = ksList * ksList * pionList.plus() * pionList.minus();
554 }
555 else if ( channel == "D0toPiPiPiPiPi0" )
556 {
557 numchan.push_back( EvtRecDTag::kD0toPiPiPiPiPi0 );
558 numchan.push_back( 2 );
559 numchan.push_back( 2 );
560 numchan.push_back( 2 );
561 numchan.push_back( 2 );
562 numchan.push_back( 3 );
563 decaylist =
564 pionList.plus() * pionList.plus() * pionList.minus() * pionList.minus() * pi0List;
565 }
566 else if ( channel == "D0toKsPiPiPiPi" )
567 {
568 numchan.push_back( EvtRecDTag::kD0toKsPiPiPiPi );
569 numchan.push_back( 5 );
570 numchan.push_back( 2 );
571 numchan.push_back( 2 );
572 numchan.push_back( 2 );
573 numchan.push_back( 2 );
574 decaylist =
575 ksList * pionList.plus() * pionList.plus() * pionList.minus() * pionList.minus();
576 }
577 else if ( channel == "D0toKKPiPiPi0" )
578 {
579 numchan.push_back( EvtRecDTag::kD0toKKPiPiPi0 );
580 numchan.push_back( 1 );
581 numchan.push_back( 1 );
582 numchan.push_back( 2 );
583 numchan.push_back( 2 );
584 numchan.push_back( 3 );
585 decaylist =
586 kaonList.minus() * kaonList.plus() * pionList.plus() * pionList.minus() * pi0List;
587 }
588 else if ( channel == "D0toKsPi0Eta" )
589 {
590 numchan.push_back( EvtRecDTag::kD0toKsPi0Eta );
591 numchan.push_back( 5 );
592 numchan.push_back( 3 );
593 numchan.push_back( 4 );
594 decaylist = ksList * pi0List * etaList;
595 }
596 else if ( channel == "D0toKsEPPiPiEta" )
597 {
598 numchan.push_back( EvtRecDTag::kD0toKsEPPiPiEta );
599 numchan.push_back( 5 );
600 numchan.push_back( 6 );
601 CDDecayList epList( *m_eptoPiPiEtaSelector );
602 epList = pionList.plus() * pionList.minus() * etaList;
603 decaylist = ksList * epList;
604 }
605 else if ( channel == "D0toKsEPRhoGam" )
606 {
607 numchan.push_back( EvtRecDTag::kD0toKsEPRhoGam );
608 numchan.push_back( 5 );
609 numchan.push_back( 7 );
610 CDDecayList rhoList( *m_rhotoPiPiSelector );
611 rhoList = pionList.plus() * pionList.minus();
612 CDDecayList epList( *m_eptoRhoGamSelector );
613 epList = rhoList * photonList;
614 decaylist = ksList * epList;
615 }
616 else if ( channel == "D0toKsPi0Pi0Pi0" )
617 {
618 numchan.push_back( EvtRecDTag::kD0toKsPi0Pi0Pi0 );
619 numchan.push_back( 5 );
620 numchan.push_back( 3 );
621 numchan.push_back( 3 );
622 numchan.push_back( 3 );
623 decaylist = ksList * pi0List * pi0List * pi0List;
624 }
625 else if ( channel == "D0toKsPiPiPi0Pi0" )
626 {
627 numchan.push_back( EvtRecDTag::kD0toKsPiPiPi0Pi0 );
628 numchan.push_back( 5 );
629 numchan.push_back( 2 );
630 numchan.push_back( 2 );
631 numchan.push_back( 3 );
632 numchan.push_back( 3 );
633 decaylist = ksList * pionList.plus() * pionList.minus() * pi0List * pi0List;
634 }
635 else if ( channel == "D0toKsPiPiEta" )
636 {
637 numchan.push_back( EvtRecDTag::kD0toKsPiPiEta );
638 numchan.push_back( 5 );
639 numchan.push_back( 2 );
640 numchan.push_back( 2 );
641 numchan.push_back( 4 );
642 decaylist = ksList * pionList.plus() * pionList.minus() * etaList;
643 }
644 else if ( channel == "D0toKsPi0EPPiPiEta" )
645 {
646 numchan.push_back( EvtRecDTag::kD0toKsPi0EPPiPiEta );
647 numchan.push_back( 5 );
648 numchan.push_back( 3 );
649 numchan.push_back( 6 );
650 CDDecayList epList( *m_eptoPiPiEtaSelector );
651 epList = pionList.plus() * pionList.minus() * etaList;
652 decaylist = ksList * pi0List * epList;
653 }
654 else if ( channel == "D0toKsPi0EPRhoGam" )
655 {
656 numchan.push_back( EvtRecDTag::kD0toKsPi0EPRhoGam );
657 numchan.push_back( 5 );
658 numchan.push_back( 3 );
659 numchan.push_back( 7 );
660 CDDecayList rhoList( *m_rhotoPiPiSelector );
661 rhoList = pionList.plus() * pionList.minus();
662 CDDecayList epList( *m_eptoRhoGamSelector );
663 epList = rhoList * photonList;
664 decaylist = ksList * pi0List * epList;
665 }
666 else if ( channel == "D0toPiPiEta" )
667 {
668 numchan.push_back( EvtRecDTag::kD0toPiPiEta );
669 numchan.push_back( 2 );
670 numchan.push_back( 2 );
671 numchan.push_back( 4 );
672 decaylist = pionList.plus() * pionList.minus() * etaList;
673 }
674 else if ( channel == "D0toPiPiPi0Eta" )
675 {
676 numchan.push_back( EvtRecDTag::kD0toPiPiPi0Eta );
677 numchan.push_back( 2 );
678 numchan.push_back( 2 );
679 numchan.push_back( 3 );
680 numchan.push_back( 4 );
681 decaylist = pionList.plus() * pionList.minus() * pi0List * etaList;
682 }
683 else if ( channel == "D0toPiPiEPPiPiEta" )
684 {
685 numchan.push_back( EvtRecDTag::kD0toPiPiEPPiPiEta );
686 numchan.push_back( 2 );
687 numchan.push_back( 2 );
688 numchan.push_back( 6 );
689 CDDecayList epList( *m_eptoPiPiEtaSelector );
690 epList = pionList.plus() * pionList.minus() * etaList;
691 decaylist = pionList.plus() * pionList.minus() * epList;
692 }
693 else if ( channel == "D0toPiPiEPRhoGam" )
694 {
695 numchan.push_back( EvtRecDTag::kD0toPiPiEPRhoGam );
696 numchan.push_back( 2 );
697 numchan.push_back( 2 );
698 numchan.push_back( 7 );
699 CDDecayList rhoList( *m_rhotoPiPiSelector );
700 rhoList = pionList.plus() * pionList.minus();
701 CDDecayList epList( *m_eptoRhoGamSelector );
702 epList = rhoList * photonList;
703 decaylist = pionList.plus() * pionList.minus() * epList;
704 }
705 else if ( channel == "D0toKKEta" )
706 {
707 numchan.push_back( EvtRecDTag::kD0toKKEta );
708 numchan.push_back( 1 );
709 numchan.push_back( 1 );
710 numchan.push_back( 4 );
711 decaylist = kaonList.minus() * kaonList.plus() * etaList;
712 }
713
714 CDDecayList::iterator D_begin = decaylist.particle_begin();
715 CDDecayList::iterator D_end = decaylist.particle_end();
716
717 for ( CDDecayList::iterator it = D_begin; it != D_end; it++ )
718 {
719
720 EvtRecDTag* recDTag = new EvtRecDTag;
721 recDTag->setdecayMode( (EvtRecDTag::DecayMode)numchan[0] );
722
723 vector<int> trackid, showerid;
724 vector<int> kaonid, pionid;
725 int charm = 0;
726 int numofchildren = numchan.size() - 1;
727
728 for ( int i = 0; i < numofchildren; i++ )
729 {
730
731 const CDCandidate& daughter = ( *it ).particle().child( i );
732 if ( isFlavorMode && i == 0 ) charm = -daughter.charge();
733
734 if ( numchan[i + 1] == 1 )
735 {
736 const EvtRecTrack* track = daughter.track();
737 trackid.push_back( track->trackId() );
738 kaonid.push_back( track->trackId() );
739 }
740 else if ( numchan[i + 1] == 2 )
741 {
742 const EvtRecTrack* track = daughter.track();
743 trackid.push_back( track->trackId() );
744 pionid.push_back( track->trackId() );
745 }
746 else if ( numchan[i + 1] == 3 )
747 {
748 const EvtRecTrack* hiEnGamma = daughter.navPi0()->hiEnGamma();
749 const EvtRecTrack* loEnGamma = daughter.navPi0()->loEnGamma();
750 showerid.push_back( hiEnGamma->trackId() );
751 showerid.push_back( loEnGamma->trackId() );
752 }
753 else if ( numchan[i + 1] == 4 )
754 {
755 const EvtRecTrack* hiEnGamma = daughter.navEta()->hiEnGamma();
756 const EvtRecTrack* loEnGamma = daughter.navEta()->loEnGamma();
757 showerid.push_back( hiEnGamma->trackId() );
758 showerid.push_back( loEnGamma->trackId() );
759 }
760 else if ( numchan[i + 1] == 5 )
761 {
762 EvtRecVeeVertex* aKsCand = const_cast<EvtRecVeeVertex*>( daughter.navKshort() );
763 // fill fit info
764 recDTag->addToFitInfo( aKsCand->mass(), fitinfo[aKsCand][0], fitinfo[aKsCand][1],
765 fitinfo[aKsCand][2] );
766 // fill tracks
767 EvtRecTrack* pion1Trk = aKsCand->daughter( 0 );
768 EvtRecTrack* pion2Trk = aKsCand->daughter( 1 );
769 trackid.push_back( pion1Trk->trackId() );
770 trackid.push_back( pion2Trk->trackId() );
771 }
772 else if ( numchan[i + 1] == 6 )
773 {
774 const CDCandidate& apion = daughter.decay().child( 0 );
775 const CDCandidate& spion = daughter.decay().child( 1 );
776 const CDCandidate& eta = daughter.decay().child( 2 );
777 const EvtRecTrack* apiontrk = apion.track();
778 const EvtRecTrack* spiontrk = spion.track();
779 const EvtRecTrack* hiEnGamma = eta.navEta()->hiEnGamma();
780 const EvtRecTrack* loEnGamma = eta.navEta()->loEnGamma();
781
782 trackid.push_back( apiontrk->trackId() );
783 trackid.push_back( spiontrk->trackId() );
784 showerid.push_back( hiEnGamma->trackId() );
785 showerid.push_back( loEnGamma->trackId() );
786 }
787 else if ( numchan[i + 1] == 7 )
788 {
789 const CDCandidate& rho = daughter.decay().child( 0 );
790 const CDCandidate& gamma = daughter.decay().child( 1 );
791 const CDCandidate& apion = rho.decay().child( 0 );
792 const CDCandidate& spion = rho.decay().child( 1 );
793
794 const EvtRecTrack* apiontrk = apion.track();
795 const EvtRecTrack* spiontrk = spion.track();
796 const EvtRecTrack* gammatrk = gamma.photon();
797
798 trackid.push_back( apiontrk->trackId() );
799 trackid.push_back( spiontrk->trackId() );
800 showerid.push_back( gammatrk->trackId() );
801 }
802
803 } // end of filling track and shower ids
804
805 saveD0Info( it, ebeam, charm, numofchildren, recDTag );
806 if ( m_useBFC )
807 {
808 // After use BFC package, we need to update information of Ks and Lambda to calculate
809 // D.
810 updateKsInfo( it, ebeam, charm, numofchildren, recDTag, numchan, vtxsvc,
811 m_useVFrefine );
812 }
813 savetrack( trackid, showerid, charged_begin, charged_end, neutral_begin, neutral_end,
814 recDTag );
815 pidtag( kaonid, pionid, kaonList_tight, pionList_tight, recDTag );
816
817 if ( m_usevertexfit )
818 {
819 if ( m_debug ) cout << "beforevfit:" << endl;
820
821 HepLorentzVector p4change_vfit;
822
823 if ( m_useVFrefine )
824 { p4change_vfit = util.vfitref( channel, kaonid, pionid, xorigin, charged_begin ); }
825 else { p4change_vfit = util.vfit( channel, kaonid, pionid, xorigin, charged_begin ); }
826
827 recDTag->setp4( recDTag->p4() + p4change_vfit );
828 }
829
830 trackid.clear();
831 showerid.clear();
832 kaonid.clear();
833 pionid.clear();
834
835 // write recdtag out
836 recDTagCol->push_back( recDTag );
837
838 } // end of decay list iterator
839
840 numchan.clear();
841
842 } // end of reconstrucing all D0 decay lists
843
844 return StatusCode::SUCCESS;
845}
846
847void NeutralDReconstruction::saveD0Info( CDDecayList::iterator it, double ebeam, int charm,
848 int numofchildren, EvtRecDTag* recDTag ) {
849
850 double mass = ( *it ).particle().mass();
851 HepLorentzVector p4( ( *it ).particle().momentum(), ( *it ).particle().energy() );
852 recDTag->setp4( p4 );
853
854 p4.boost( -m_beta );
855 double mbc2_CMS = ebeam * ebeam - p4.v().mag2();
856 double mbc_CMS = mbc2_CMS > 0 ? sqrt( mbc2_CMS ) : -10;
857 double deltaE_CMS = p4.t() - ebeam;
858
859 int tag = ( *it ).particle().userTag();
860 if ( tag == 1 ) recDTag->settype( EvtRecDTag::Tight );
861 else recDTag->settype( EvtRecDTag::Loose );
862 recDTag->setcharge( 0 );
863 recDTag->setcharm( charm );
864 recDTag->setnumOfChildren( numofchildren );
865 recDTag->setmass( mass );
866 recDTag->setmBC( mbc_CMS );
867 recDTag->setbeamE( ebeam );
868 recDTag->setdeltaE( deltaE_CMS );
869}
870
871void NeutralDReconstruction::savetrack( vector<int> trackid, vector<int> showerid,
872 EvtRecTrackIterator charged_begin,
873 EvtRecTrackIterator charged_end,
874 EvtRecTrackIterator neutral_begin,
875 EvtRecTrackIterator neutral_end,
876 EvtRecDTag* recDTag ) {
877
878 vector<EvtRecTrackIterator> trktemp;
879 vector<EvtRecTrackIterator> shrtemp;
880
881 // fill tracks
882 for ( EvtRecTrackIterator trk = charged_begin; trk < charged_end; trk++ )
883 {
884
885 bool isothertrack = true;
886 for ( int i = 0; i < trackid.size(); i++ )
887 {
888 if ( ( *trk )->trackId() == trackid[i] )
889 {
890 trktemp.push_back( trk );
891 isothertrack = false;
892 break;
893 }
894 }
895 if ( isothertrack ) recDTag->addOtherTrack( *trk );
896 }
897 for ( int i = 0; i < trackid.size(); i++ )
898 {
899 for ( int j = 0; j < trktemp.size(); j++ )
900 {
901 EvtRecTrackIterator trk = trktemp[j];
902 if ( ( *trk )->trackId() == trackid[i] ) recDTag->addTrack( *trktemp[j] );
903 }
904 }
905
906 // fill showers
907 for ( EvtRecTrackIterator shr = neutral_begin; shr < neutral_end; shr++ )
908 {
909 bool isothershower = true;
910 for ( int i = 0; i < showerid.size(); i++ )
911 {
912 if ( ( *shr )->trackId() == showerid[i] )
913 {
914 shrtemp.push_back( shr );
915 isothershower = false;
916 break;
917 }
918 }
919 if ( isothershower ) recDTag->addOtherShower( *shr );
920 }
921
922 for ( int i = 0; i < showerid.size(); i++ )
923 {
924 for ( int j = 0; j < shrtemp.size(); j++ )
925 {
926 EvtRecTrackIterator shr = shrtemp[j];
927 if ( ( *shr )->trackId() == showerid[i] ) recDTag->addShower( *shrtemp[j] );
928 }
929 }
930}
931
932void NeutralDReconstruction::pidtag( vector<int> kaonid, vector<int> pionid,
933 CDChargedKaonList& kaonList, CDChargedPionList& pionList,
934 EvtRecDTag* recDTag ) {
935
936 bool iskaon = false, ispion = false;
937
938 // save track ids which passed pion/kaon cuts
939
940 for ( CDChargedKaonList::iterator kit = kaonList.particle_begin();
941 kit != kaonList.particle_end(); kit++ )
942 { recDTag->addKaonId( ( *kit ).particle().track() ); }
943
944 for ( CDChargedPionList::iterator pit = pionList.particle_begin();
945 pit != pionList.particle_end(); pit++ )
946 { recDTag->addPionId( ( *pit ).particle().track() ); }
947
948 /*
949 for(int i=0; i<kaonid.size(); i++){
950 bool ithkaon=false;
951 for (CDChargedKaonList::iterator kit = kaonList.particle_begin(); kit !=
952 kaonList.particle_end(); kit++) { if((*kit).particle().track()->trackId()==kaonid[i]){
953 ithkaon=true;
954 break;
955 }
956 }
957 if(!ithkaon) break;
958 if(i==kaonid.size()-1)
959 iskaon=true;
960 }
961
962 for(int i=0; i<pionid.size(); i++){
963 bool ithpion=false;
964 for (CDChargedPionList::iterator pit = pionList.particle_begin(); pit !=
965 pionList.particle_end(); pit++) { if((*pit).particle().track()->trackId()==pionid[i]){
966 ithpion=true;
967 break;
968 }
969 }
970 if(!ithpion) break;
971 if(i==pionid.size()-1)
972 ispion=true;
973 }
974
975
976 if( iskaon && ispion)
977 recDTag->settype( EvtRecDTag::Tight );
978 else if( (kaonid.size()==0 && ispion) || (pionid.size()==0 && iskaon))
979 recDTag->settype( EvtRecDTag::Tight );
980 else if( kaonid.size()==0 && pionid.size()==0 )
981 recDTag->settype( EvtRecDTag::Tight );
982 */
983}
984
985vector<string> NeutralDReconstruction::getlist( string& filename ) {
986
987 string channel;
988 vector<string> temp;
989
990 ifstream inFile;
991
992 inFile.open( filename.c_str() );
993 if ( !inFile )
994 {
995 cout << "Unable to open decay list file";
996 exit( 1 ); // terminate with error
997 }
998
999 while ( inFile >> channel ) { temp.push_back( channel ); }
1000
1001 inFile.close();
1002
1003 return temp;
1004}
1005
1006void NeutralDReconstruction::updateKsInfo( CDDecayList::iterator it, double ebeam, int charm,
1007 int numofchildren, EvtRecDTag* recDTag,
1008 vector<int> numchan, IVertexDbSvc* vtxsvc,
1009 bool m_useVFrefine ) {
1010
1011 // This function is used to update the information of Ks and Lambda. Because DTagAlg package
1012 // uses the list from VeeVertexFit package which input the information of Ks and Lambda while
1013 // reconstructing the dst, the information of them don't use the MBF correction and we need
1014 // to update them here.
1015
1016 // If we don't use BF Correctoin, please close this function.
1017
1018 HepLorentzVector p4D0( ( *it ).particle().momentum(), ( *it ).particle().energy() );
1019 HepLorentzVector p4D0_New;
1020
1021 for ( int i = 0; i < numofchildren; i++ )
1022 {
1023 const CDCandidate& daughter = ( *it ).particle().child( i );
1024
1025 if ( numchan[i + 1] == 5 )
1026 {
1027 EvtRecVeeVertex* aKsCand = const_cast<EvtRecVeeVertex*>( daughter.navKshort() );
1028 HepVector veewks = aKsCand->w(); // px, py, pz, E, x, y, z
1029 HepLorentzVector p4KsCand;
1030 p4KsCand.setX( veewks[0] );
1031 p4KsCand.setY( veewks[1] );
1032 p4KsCand.setZ( veewks[2] );
1033 p4KsCand.setE( veewks[3] );
1034 HepLorentzVector p4wks = p4KsCand;
1035
1036 utility util;
1037
1038 // by default: px, py, pz, E, chisq, ifok
1039 vector<double> vp4ks_new = util.UpdatedKsIfo( aKsCand, vtxsvc, m_useVFrefine );
1040 HepLorentzVector p4wks_new;
1041 p4wks_new.setX( vp4ks_new[0] );
1042 p4wks_new.setY( vp4ks_new[1] );
1043 p4wks_new.setZ( vp4ks_new[2] );
1044 p4wks_new.setE( vp4ks_new[3] );
1045
1046 p4D0 = p4D0 - p4wks + p4wks_new;
1047 }
1048 }
1049
1050 p4D0_New = p4D0;
1051
1052 double mass = p4D0_New.m();
1053 recDTag->setp4( p4D0_New );
1054 p4D0_New.boost( -m_beta );
1055 double mbc2_CMS = ebeam * ebeam - p4D0_New.v().mag2();
1056 double mbc_CMS = mbc2_CMS > 0 ? sqrt( mbc2_CMS ) : -10;
1057 double deltaE_CMS = p4D0_New.t() - ebeam;
1058
1059 int tag = ( *it ).particle().userTag();
1060 if ( tag == 1 ) recDTag->settype( EvtRecDTag::Tight );
1061 else recDTag->settype( EvtRecDTag::Loose );
1062 recDTag->setcharge( 0 );
1063 recDTag->setcharm( charm );
1064 recDTag->setnumOfChildren( numofchildren );
1065 recDTag->setmass( mass );
1066 recDTag->setmBC( mbc_CMS );
1067 recDTag->setbeamE( ebeam );
1068 recDTag->setdeltaE( deltaE_CMS );
1069}
DECLARE_COMPONENT
DECLARE_COMPONENT(BesBdkRc)
mass
double mass
Definition CosmicGenerator.cxx:128
CDChargedKaonList
DCFillableChargedList< CDChargedKaon > CDChargedKaonList
Definition Event/BesDChain/include/BesDChain/CDChargedKaonList.h:50
CDChargedPionList
DCFillableChargedList< CDChargedPion > CDChargedPionList
Definition Event/BesDChain/include/BesDChain/CDChargedPionList.h:49
CDDecayList
DCDecayList< CDDecay, CDDecay::CandidateClass > CDDecayList
Definition Event/BesDChain/include/BesDChain/CDDecayList.h:46
CDPhotonList
DCFillableNeutralList< CDPhoton > CDPhotonList
Definition Event/BesDChain/include/BesDChain/CDPhotonList.h:46
dc_fill
void dc_fill(DCFillableChargedList< Charged > &aFillableList, WitnessIterator first, WitnessIterator last)
Definition Event/DecayChain/include/DecayChain/List/DCFillableChargedList.h:149
EvtRecDTagCol
ObjectVector< EvtRecDTag > EvtRecDTagCol
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecDTag.h:306
EvtRecTrackIterator
EvtRecTrackCol::iterator EvtRecTrackIterator
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecTrack.h:106
ebeam
double ebeam
Definition EvtPhokharaDef.hh:18
msgSvc
IMessageSvc * msgSvc()
Definition ServiceAccessor.h:12
CDCandidate::decay
virtual const DecayEvidence & decay() const
Definition CDCandidate.cxx:268
CDCandidate::photon
virtual const EvtRecTrack * photon() const
Definition CDCandidate.cxx:198
CDCandidate::track
virtual const EvtRecTrack * track() const
Definition CDCandidate.cxx:184
CDCandidate::charge
int charge() const
Definition CDCandidate.cxx:127
CDCandidate::navKshort
virtual const EvtRecVeeVertex * navKshort() const
Definition CDCandidate.cxx:240
CDCandidate::navPi0
virtual const EvtRecPi0 * navPi0() const
Definition CDCandidate.cxx:212
CDCandidate::navEta
virtual const EvtRecEtaToGG * navEta() const
Definition CDCandidate.cxx:226
CDDecay::child
const CDCandidate & child(unsigned int aPosition) const
Definition CDDecay.cxx:231
EvtRecDTag::addOtherTrack
void addOtherTrack(const SmartRef< EvtRecTrack > track)
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecDTag.h:262
EvtRecDTag::addToFitInfo
void addToFitInfo(double ksmass, double chi2, double length, double error)
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecDTag.h:253
EvtRecDTag::addOtherShower
void addOtherShower(const SmartRef< EvtRecTrack > shower)
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecDTag.h:263
EvtRecDTag::addKaonId
void addKaonId(const SmartRef< EvtRecTrack > kaonId)
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecDTag.h:267
EvtRecDTag::addPionId
void addPionId(const SmartRef< EvtRecTrack > pionId)
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecDTag.h:266
EvtRecDTag::addShower
void addShower(const SmartRef< EvtRecTrack > shower)
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecDTag.h:261
EvtRecDTag::addTrack
void addTrack(const SmartRef< EvtRecTrack > track)
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecDTag.h:260
EvtRecPi0::loEnGamma
const EvtRecTrack * loEnGamma() const
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecPi0.h:30
EvtRecPi0::hiEnGamma
const EvtRecTrack * hiEnGamma() const
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecPi0.h:29
IVertexDbSvc::isVertexValid
virtual bool isVertexValid()=0
IVertexDbSvc::PrimaryVertex
virtual double * PrimaryVertex()=0
NeutralDReconstruction::updateKsInfo
void updateKsInfo(CDDecayList::iterator, double, int, int, EvtRecDTag *, vector< int >, IVertexDbSvc *, bool)
Definition NeutralDReconstruction.cxx:1006
NeutralDReconstruction::NeutralDReconstruction
NeutralDReconstruction(const std::string &name, ISvcLocator *pSvcLocator)
Definition NeutralDReconstruction.cxx:37
NeutralDReconstruction::savetrack
void savetrack(vector< int >, vector< int >, EvtRecTrackIterator, EvtRecTrackIterator, EvtRecTrackIterator, EvtRecTrackIterator, EvtRecDTag *)
Definition NeutralDReconstruction.cxx:871
NeutralDReconstruction::getlist
vector< string > getlist(string &filename)
Definition NeutralDReconstruction.cxx:985
NeutralDReconstruction::pidtag
void pidtag(vector< int >, vector< int >, CDChargedKaonList &, CDChargedPionList &, EvtRecDTag *)
Definition NeutralDReconstruction.cxx:932
NeutralDReconstruction::saveD0Info
void saveD0Info(CDDecayList::iterator, double, int, int, EvtRecDTag *)
Definition NeutralDReconstruction.cxx:847
dchain::CandidateList::iterator
dchain::MuteWholeCandidateItr< CandidateClass > iterator
Definition Event/DecayChain/include/DecayChain/List/CandidateList.h:79
utility::vfitref
HepLorentzVector vfitref(string channel, vector< int > kaonid, vector< int > pionid, HepPoint3D vx, EvtRecTrackIterator charged_begin)
Definition utility.cxx:59
utility::SecondaryVFitref
vector< double > SecondaryVFitref(EvtRecVeeVertex *ks, IVertexDbSvc *vtxsvc)
Definition utility.cxx:203
utility::UpdatedKsIfo
vector< double > UpdatedKsIfo(EvtRecVeeVertex *ks, IVertexDbSvc *vtxsvc, bool m_useVFrefine)
Definition utility.cxx:793
utility::vfit
HepLorentzVector vfit(string channel, vector< int > kaonid, vector< int > pionid, HepPoint3D vx, EvtRecTrackIterator charged_begin)
Definition utility.cxx:425
utility::SecondaryVFit
vector< double > SecondaryVFit(EvtRecVeeVertex *ks, IVertexDbSvc *vtxsvc)
Definition utility.cxx:567