BOSS 8.0.0
BESIII Offline Software System
Loading...
Searching...
No Matches
MixerAlg Class Reference

#include <MixerAlg.h>

Inheritance diagram for MixerAlg:

Public Member Functions

 MixerAlg (const std::string &name, ISvcLocator *pSvcLocator)
StatusCode initialize ()
StatusCode execute ()
StatusCode finalize ()
 ~MixerAlg ()

Protected Member Functions

bool nextEvent (int nskip=0, int evtbyte=0, int eventsToEnd=0)
void mixDigi (SmartDataPtr< MdcDigiCol > &mdcMcDigits, SmartDataPtr< EmcDigiCol > &emcMcDigits, SmartDataPtr< MucDigiCol > &mucMcDigits, SmartDataPtr< TofDigiCol > &tofMcDigits)
void decodeMdc (MdcDigiCol *digiCol)
void decodeMuc (MucDigiCol *digiCol)
void decodeEmc (EmcDigiCol *digiCol)
void decodeTof (TofDigiCol *digiCol)
int getTiming ()
std::string eventType ()
std::string prepareDbQuery ()
bool file_sort (std::vector< std::string > &files, std::vector< int > &ranEvtNums)

Detailed Description

Definition at line 43 of file MixerAlg.h.

Constructor & Destructor Documentation

◆ MixerAlg()

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

Definition at line 39 of file MixerAlg.cxx.

40 : Algorithm( name, pSvcLocator ) {
41 declareProperty( "MixMdcDigi", b_mdc = true );
42 declareProperty( "MixEmcDigi", b_emc = true );
43 declareProperty( "MixMucDigi", b_muc = true );
44 declareProperty( "MixTofDigi", b_tof = true );
45
46 declareProperty( "DBUserRequest", m_dbUserRequest = false );
47 declareProperty( "RandomTrgRun", m_run );
48 declareProperty( "RandomTrgRunRange", m_runs );
49 declareProperty( "RandomTrgTimeRange", m_dates );
50
51 declareProperty( "BackgroundDataFiles", m_bgfiles );
52 declareProperty( "NumRanTrgEvents", m_ranTrgEvents );
53 declareProperty( "NBgEventsToSignal", m_nevent = 1 );
54 // declareProperty("LoopBgData", b_loop=true);
55 declareProperty( "ReplaceDataPath", m_pattern );
56 declareProperty( "UseNewDataDir", m_newdatadir );
57 declareProperty( "IfSkip", m_skip = true );
58 declareProperty( "NSkip", m_NSkip = 150 );
59 declareProperty( "OutPut", m_ifOutPut = false );
60 declareProperty( "MixingMethod", m_mixingMethod = 1 );
61 declareProperty( "MaxLoop", m_maxLoop = 10 );
62 declareProperty( "SmearT0", m_ifSmearT0 = true );
63 declareProperty( "ReadBGMethod", m_readBGMethod = 1 );
64
65 declareProperty( "UsingFilter", m_usingFilter = true );
66 declareProperty( "dump", m_dump = false );
67 declareProperty( "RawDataReviseConfFile", m_rawReviseConfig );
68
69 m_raw_event = 0;
70 m_fr = 0;
71 m_runNo = 0;
72 m_skipCount = 0;
73 currentBGFile = "";
74 currentMCFile = "";
75 m_totalEvent = 0;
76 m_totEvtNumInCurFile = 0;
77 m_nEventsToEnd = 0;
78 m_ranStepLenInCurrentFile.clear();
79}

Referenced by MixerAlg().

◆ ~MixerAlg()

MixerAlg::~MixerAlg ( )
inline

Definition at line 49 of file MixerAlg.h.

49{}

Member Function Documentation

◆ decodeEmc()

void MixerAlg::decodeEmc ( EmcDigiCol * digiCol)
protected

Definition at line 1175 of file MixerAlg.cxx.

1175 {
1176 const BufferHolder& emcBuf = m_raw_event->getEmcBuf();
1177 m_emcCnv->convert( emcBuf, digiCol );
1178}

Referenced by mixDigi().

◆ decodeMdc()

void MixerAlg::decodeMdc ( MdcDigiCol * digiCol)
protected

Definition at line 1165 of file MixerAlg.cxx.

1165 {
1166 const BufferHolder& mdcBuf = m_raw_event->getMdcBuf();
1167 m_mdcCnv->convert( mdcBuf, digiCol );
1168}

Referenced by mixDigi().

◆ decodeMuc()

void MixerAlg::decodeMuc ( MucDigiCol * digiCol)
protected

Definition at line 1170 of file MixerAlg.cxx.

1170 {
1171 const BufferHolder& mucBuf = m_raw_event->getMucBuf();
1172 m_mucCnv->convert( mucBuf, digiCol );
1173}

Referenced by mixDigi().

◆ decodeTof()

void MixerAlg::decodeTof ( TofDigiCol * digiCol)
protected

Definition at line 1180 of file MixerAlg.cxx.

1180 {
1181 const BufferHolder& tofBuf = m_raw_event->getTofBuf();
1182 const BufferHolder& etfBuf = m_raw_event->getEtfBuf();
1183 if ( etfBuf.nBuf() > 0 ) { m_tofCnv->convert( tofBuf, etfBuf, digiCol ); }
1184 else { m_tofCnv->convert( tofBuf, digiCol ); }
1185}

Referenced by mixDigi().

◆ eventType()

std::string MixerAlg::eventType ( )
protected

Definition at line 1187 of file MixerAlg.cxx.

1187 {
1188 const BufferHolder& hltBuf = m_raw_event->getHltBuf();
1189 DstHltInf* hlt = new DstHltInf();
1190 hlt->setEventType( hltBuf( 0 )[0] );
1191
1192 std::string evtType = hlt->getEventName();
1193
1194 if ( hlt ) delete hlt;
1195
1196 return evtType;
1197}
DstHltInf::setEventType
void setEventType(const unsigned int i)
Definition Event/HltEvent/include/HltEvent/DstHltInf.h:29
DstHltInf::getEventName
const string & getEventName() const
Definition DstHltInf.cxx:59

Referenced by nextEvent().

◆ execute()

StatusCode MixerAlg::execute ( )

Definition at line 283 of file MixerAlg.cxx.

283 {
284 // calculate time
285 if ( m_ifOutPut ) { m_timer->start(); }
286
287 // caogf add
288 SmartDataPtr<Event::EventHeader> evt( eventSvc(), "/Event/EventHeader" );
289 if ( !evt ) { return StatusCode::FAILURE; }
290
291 if ( m_RealizationSvc->UseDBFlag() == true && m_RealizationSvc->ifReadRandTrg() == true &&
292 m_dbUserRequest == false )
293 {
294 int runNo = evt->runNumber();
295 if ( ( runNo != m_runNo ) ||
296 ( RootInterface::Instance( name() )->getCurrentFileName() != currentMCFile ) )
297 {
298 m_runNo = runNo;
299 currentMCFile = RootInterface::Instance( name() )->getCurrentFileName();
300 m_mdcCnv->setRunId( runNo );
301 std::vector<std::string> bgfiles = m_RealizationSvc->getBgFileName();
302 if ( bgfiles.size() == 0 )
303 {
304 ( *log ) << MSG::ERROR << "No random trigger files are found in the run " << m_runNo
305 << std::endl;
306 exit( -1 );
307 }
308 // m_ranTrgEvents = m_RealizationSvc->getRanTrgEvtNum();
309 if ( !m_pattern.empty() )
310 {
311 for ( unsigned int k = 0; k < bgfiles.size(); k++ )
312 {
313 size_t pos_round = bgfiles[k].rfind( "round" );
314 ( *log ) << MSG::INFO << "bgfiles: " << bgfiles[k] << endmsg;
315 if ( pos_round != string::npos )
316 {
317 bgfiles[k].replace( bgfiles[k].begin(), bgfiles[k].begin() + pos_round,
318 m_pattern );
319 ( *log ) << MSG::INFO << "new random trigger data path: " << bgfiles[k] << endmsg;
320 }
321 else
322 {
323 ( *log ) << MSG::ERROR << "string 'round' not found in random trigger path!"
324 << endmsg;
325 exit( -1 );
326 }
327 }
328 }
329 if ( !m_newdatadir.empty() )
330 {
331 for ( unsigned int k = 0; k < bgfiles.size(); k++ )
332 {
333 char tmp[255];
334 std::strcpy( tmp, bgfiles[k].c_str() );
335 string fname = basename( tmp );
336 bgfiles[k].replace( bgfiles[k].begin(), bgfiles[k].end(),
337 m_newdatadir + '/' + fname );
338 ( *log ) << MSG::INFO << "new random trigger data path: " << bgfiles[k] << endmsg;
339 }
340 }
341
342 // achieve bg index files
343 std::vector<std::string> bgfilesIndex;
344 bgfilesIndex.clear();
345 for ( unsigned int bg_index = 0; bg_index < bgfiles.size(); bg_index++ )
346 { bgfilesIndex.push_back( bgfiles[bg_index] + ".idx" ); }
347
348 // get event number of each bg file
349 if ( m_fr ) delete m_fr;
350 m_fr = new RawFileReader( bgfiles );
351 std::vector<int> ranTrgEvents = m_fr->getEventNumber( bgfilesIndex );
352
353 // remove bg files with 0 event
354 m_bgfiles.clear();
355 m_bgfilesIndex.clear();
356 m_ranTrgEvents.clear();
357 for ( unsigned int bg_index = 0; bg_index < bgfiles.size(); bg_index++ )
358 {
359 if ( ranTrgEvents[bg_index] > 0 )
360 {
361 m_bgfiles.push_back( bgfiles[bg_index] );
362 m_bgfilesIndex.push_back( bgfilesIndex[bg_index] );
363 m_ranTrgEvents.push_back( ranTrgEvents[bg_index] );
364 }
365 }
366
367 // get event number of each bg file
368 if ( m_fr ) delete m_fr;
369 m_fr = new RawFileReader( m_bgfiles );
370
371 // clear temp vector
372 bgfiles.clear();
373 bgfilesIndex.clear();
374 ranTrgEvents.clear();
375
376 // bg files exist?
377 if ( m_bgfiles.empty() || m_ranTrgEvents.empty() )
378 {
379 ( *log ) << MSG::WARNING << "No background datafiles found!!!" << endmsg;
380 return StatusCode::SUCCESS;
381 }
382
383 if ( m_skip == true )
384 {
385 if ( m_mixingMethod == 1 )
386 {
387 // Initialize
388 m_ranStepLenInCurrentFile.clear();
389 currentBGFile = "";
390 m_skipCount = 0;
391 m_totalEvent = 0;
392
393 // sort random trigger files by time increasing
394 bool ifsucc = file_sort( m_bgfiles, m_ranTrgEvents );
395 if ( !ifsucc ) return StatusCode::FAILURE;
396
397 // achieve bg index files
398 m_bgfilesIndex.clear();
399 for ( unsigned int bg_index = 0; bg_index < m_bgfiles.size(); bg_index++ )
400 { m_bgfilesIndex.push_back( m_bgfiles[bg_index] + ".idx" ); }
401
402 // count number of sets, total bg events in each set and total bg events in this run
403 m_vRanEvtNumInSubSet.clear();
404 m_vStreamNumInSubSet.clear();
405 m_totRanEvtNum = 0;
406 int set_no = -1;
407 int ranEvtNumInSubSet = 0;
408 int nstream = 0;
409 for ( unsigned int i = 0; i < m_ranTrgEvents.size(); i++ )
410 {
411 if ( i == 0 ) set_no = m_numSets[i];
412 if ( ( i != 0 ) && ( set_no != m_numSets[i] ) )
413 {
414 m_vRanEvtNumInSubSet.push_back( ranEvtNumInSubSet );
415 m_vStreamNumInSubSet.push_back( nstream );
416 ranEvtNumInSubSet = 0;
417 nstream = 0;
418 set_no = m_numSets[i];
419 }
420
421 m_totRanEvtNum += m_ranTrgEvents[i];
422 ranEvtNumInSubSet += m_ranTrgEvents[i];
423 nstream++;
424 if ( i == m_ranTrgEvents.size() - 1 )
425 {
426 m_vRanEvtNumInSubSet.push_back( ranEvtNumInSubSet );
427 m_vStreamNumInSubSet.push_back( nstream );
428 }
429 }
430
431 // get total event number in this run
432 int evtNumInRun = -1;
433 std::vector<int> vtotEvtNo = m_jobInfoSvc->getTotEvtNo();
434 for ( unsigned int ii = 0; ii < vtotEvtNo.size(); ii += 2 )
435 {
436 if ( std::abs( runNo ) == std::abs( vtotEvtNo[ii] ) )
437 evtNumInRun = vtotEvtNo[ii + 1];
438 }
439
440 // generate step length(event number) for each MC event to select background event
441 double tau = m_RealizationSvc->getTauValue();
442 double totalTime = m_RealizationSvc->getRunTotalTime();
443 if ( m_RealizationSvc->getTauValue() == 0. ||
444 m_RealizationSvc->getRunTotalTime() == 0. )
445 {
446 std::cout << "ERROR: In MixerAlg::execute() ---> The tau value or total run time "
447 "is 0, please check it. Exit! "
448 << std::endl;
449 exit( 1 );
450 }
451
452 bool using_exp = true;
453 if ( totalTime * 100 < tau ) using_exp = false;
454 m_vStepLength.clear();
455 while ( 1 )
456 {
457 double ranNum;
458 if ( using_exp == true ) ranNum = RandExponential::shoot( tau );
459 else ranNum = RandFlat::shoot( 0., totalTime );
460 if ( ranNum > totalTime ) continue;
461 ranNum = ranNum * m_totRanEvtNum / totalTime;
462 m_vStepLength.push_back( (int)ranNum );
463 if ( m_vStepLength.size() == evtNumInRun * m_nevent ) break;
464 }
465
466 sort( m_vStepLength.begin(), m_vStepLength.end() );
467
468 //
469 // Add a protect here
470 //
471 if ( evtNumInRun <= 0 || m_totRanEvtNum <= 0 )
472 {
473 ( *log ) << MSG::ERROR
474 << "The event number (or random trigger event number) in run "
475 << evt->runNumber() << " is zero" << endmsg;
476 return StatusCode::FAILURE;
477 }
478
479 //
480 // assigned step length and the number of selected bg events for each bg file
481 //
482 // 1. define a map to store step length selected from each bg file
483 map_stepLength.clear();
484 for ( unsigned int i = 0; i < m_ranTrgEvents.size(); i++ )
485 {
486 std::vector<int> vstepLength;
487 typedef pair<int, std::vector<int>> vpair;
488 map_stepLength.insert( vpair( i, vstepLength ) );
489 }
490 // 2. assign step length for each bg file
491 for ( unsigned int i = 0; i < m_ranTrgEvents.size(); )
492 {
493 // 2.1 calculate total bg event number in this set and previous sets
494 int pre_ranEvtNumSubSet = 0;
495 int cur_ranEvtNumSubSet = 0;
496 set_no = m_numSets[i];
497 for ( int j = 0; j < set_no; j++ )
498 {
499 if ( j != ( set_no - 1 ) ) pre_ranEvtNumSubSet += m_vRanEvtNumInSubSet[j];
500 cur_ranEvtNumSubSet += m_vRanEvtNumInSubSet[j];
501 }
502 // 2.2 assign step length
503 for ( unsigned j = 0; j < m_vStepLength.size(); j++ )
504 {
505 // if current step length is in current set
506 if ( ( m_vStepLength[j] >= pre_ranEvtNumSubSet ) &&
507 ( m_vStepLength[j] < cur_ranEvtNumSubSet ) )
508 {
509 int sub_stepLength = int( ( m_vStepLength[j] - pre_ranEvtNumSubSet ) /
510 m_vStreamNumInSubSet[set_no - 1] );
511 int file_id = 0;
512 int begin_fileId = -1, end_fileId = -1;
513 for ( std::map<int, std::vector<int>>::iterator iter = map_stepLength.begin();
514 iter != map_stepLength.end(); iter++ )
515 {
516 // check current set number
517 if ( set_no == m_numSets[iter->first] )
518 {
519 if ( begin_fileId == -1 ) begin_fileId = iter->first;
520 file_id++;
521 }
522 }
523 end_fileId = begin_fileId + file_id;
524 bool add_succ = false;
525 long loop_count = 0;
526
527 while ( 1 )
528 {
529 int random_file = int( RandFlat::shootInt(
530 long( begin_fileId ), long( end_fileId ) ) ); // exclude end_fileId
531 if ( sub_stepLength < m_ranTrgEvents[random_file] )
532 {
533 map_stepLength[random_file].push_back( sub_stepLength );
534 add_succ = true;
535 loop_count = 0;
536 }
537 if ( add_succ ) break;
538 loop_count++;
539 if ( loop_count >= MAX_LOOP_TIMES )
540 {
541 ( *log ) << MSG::ALWAYS << "Loop time is larger than MAX_LOOP_TIMES("
542 << MAX_LOOP_TIMES
543 << ") in MixAlg, when assigning step length for each bg file."
544 << endmsg;
545 exit( 1 );
546 }
547 }
548 } // endif current step length is in current set
549 } // end assign step length
550 i += m_vStreamNumInSubSet[set_no - 1];
551 }
552
553 // check selected bg events number, equal to MC events?
554 unsigned int ranSelectedNum = 0;
555 for ( std::map<int, std::vector<int>>::iterator iter = map_stepLength.begin();
556 iter != map_stepLength.end(); iter++ )
557 {
558 ranSelectedNum += ( iter->second ).size();
559 // std::cout << "file_id: " << iter->first << " ranEvtNumSelected: " <<
560 // (iter->second).size() << std::endl;
561 }
562 if ( ranSelectedNum != m_vStepLength.size() )
563 {
564 ( *log )
565 << MSG::ERROR
566 << "In MixerAlg::excute()--> selected bg events number not equal to MC events"
567 << endmsg;
568 return StatusCode::FAILURE;
569 }
570 }
571 }
572
573 if ( m_mixingMethod == 2 )
574 {
575 // open background stream
576 if ( m_fr ) delete m_fr;
577 m_fr = NULL;
578 try
579 {
580 m_bgfilesIndex.clear();
581 for ( unsigned int bg_index = 0; bg_index < m_bgfiles.size(); bg_index++ )
582 { m_bgfilesIndex.push_back( m_bgfiles[bg_index] + ".idx" ); }
583 if ( m_skip == true && m_readBGMethod == 1 )
584 m_fr = new RawFileReader( m_bgfiles, m_bgfilesIndex );
585 else m_fr = new RawFileReader( m_bgfiles );
586 } catch ( RawFileException& ex )
587 {
588 ex.print();
589 return StatusCode::FAILURE;
590 }
591 }
592
593 m_raw_event->reset();
594 }
595 }
596 if ( m_ifOutPut )
597 {
598 m_timer->stop();
599 m_time1 = m_timer->elapsed();
600 m_timer->start();
601 }
602 // end caogf add
603 SmartDataPtr<MdcDigiCol> mdcMcDigits( eventSvc(), "/Event/Digi/MdcDigiCol" );
604 if ( !mdcMcDigits ) ( *log ) << MSG::ERROR << "Unable to retrieve MdcDigiCol" << endmsg;
605 else
606 ( *log ) << MSG::INFO << "MdcDigiCol retrieved of size " << mdcMcDigits->size() << endmsg;
607
608 SmartDataPtr<EmcDigiCol> emcMcDigits( eventSvc(), "/Event/Digi/EmcDigiCol" );
609 if ( !emcMcDigits ) ( *log ) << MSG::ERROR << "Unable to retrieve EmcDigiCol" << endmsg;
610 else
611 ( *log ) << MSG::INFO << "EmcDigiCol retrieved of size " << emcMcDigits->size() << endmsg;
612
613 SmartDataPtr<MucDigiCol> mucMcDigits( eventSvc(), "/Event/Digi/MucDigiCol" );
614 if ( !mucMcDigits ) ( *log ) << MSG::ERROR << "Unable to retrieve MucDigiCol" << endmsg;
615 else
616 ( *log ) << MSG::INFO << "MucDigiCol retrieved of size " << mucMcDigits->size() << endmsg;
617
618 SmartDataPtr<TofDigiCol> tofMcDigits( eventSvc(), "/Event/Digi/TofDigiCol" );
619 if ( !tofMcDigits ) ( *log ) << MSG::ERROR << "Unable to retrieve TofDigiCol" << endmsg;
620 else
621 ( *log ) << MSG::INFO << "TofDigiCol retrieved of size " << tofMcDigits->size() << endmsg;
622
623 for ( int ievent = 0; ievent < m_nevent; ievent++ )
624 {
625 ( *log ) << MSG::INFO << "Mixing BG Event " << ievent << endmsg;
626 // if(m_skip == true) {
627 // nskipped = 0;
628 // m_skipCount = (int(m_NSkip*(RandFlat::shoot())) + 1);
629 // }
630 bool next = false;
631 if ( m_skip == true )
632 {
633 int nskip = 0;
634 if ( m_mixingMethod == 1 )
635 {
636 if ( m_RealizationSvc->UseDBFlag() == true && m_dbUserRequest == false )
637 {
638 if ( m_skipCount >= m_ranStepLenInCurrentFile.size() )
639 {
640 m_ranStepLenInCurrentFile.clear();
641 for ( std::map<int, std::vector<int>>::iterator iter = map_stepLength.begin();
642 iter != map_stepLength.end(); iter++ )
643 {
644 if ( currentBGFile == "" )
645 {
646 if ( ( iter->second ).size() == 0 ) continue;
647 if ( m_fr ) delete m_fr;
648 try
649 {
650 if ( m_readBGMethod == 1 )
651 m_fr = new RawFileReader( m_bgfiles[iter->first],
652 m_bgfiles[iter->first] + ".idx" );
653 else m_fr = new RawFileReader( m_bgfiles[iter->first] );
654 m_totEvtNumInCurFile = m_ranTrgEvents[iter->first];
655 } catch ( RawFileException& ex )
656 { ex.print(); }
657 m_ranStepLenInCurrentFile = iter->second;
658 m_skipCount = 0;
659 currentBGFile = m_fr->currentFile();
660 break;
661 }
662 if ( currentBGFile == m_bgfiles[iter->first] )
663 {
664 iter++;
665 if ( iter == map_stepLength.end() ) return StatusCode::FAILURE;
666 if ( ( iter->second ).size() == 0 )
667 {
668 while ( 1 )
669 {
670 iter++;
671 if ( iter == map_stepLength.end() ) return StatusCode::FAILURE;
672 if ( ( iter->second ).size() > 0 ) break;
673 }
674 }
675 if ( m_fr ) delete m_fr;
676 try
677 {
678 if ( m_readBGMethod == 1 )
679 m_fr = new RawFileReader( m_bgfiles[iter->first],
680 m_bgfiles[iter->first] + ".idx" );
681 else m_fr = new RawFileReader( m_bgfiles[iter->first] );
682 m_totEvtNumInCurFile = m_ranTrgEvents[iter->first];
683 } catch ( RawFileException& ex )
684 { ex.print(); }
685 m_ranStepLenInCurrentFile = iter->second;
686 m_skipCount = 0;
687 currentBGFile = m_fr->currentFile();
688 break;
689 }
690 }
691 }
692 // std::cout << "skipcount: " << m_skipCount << " stepLength: " <<
693 // m_ranStepLenInCurrentFile[m_skipCount] <<" total event number: " <<
694 // m_totEvtNumInCurFile << std::endl;
695
696 if ( m_skipCount == 0 ) nskip = m_ranStepLenInCurrentFile[m_skipCount];
697 else
698 nskip = m_ranStepLenInCurrentFile[m_skipCount] -
699 m_ranStepLenInCurrentFile[m_skipCount - 1];
700
701 m_nEventsToEnd = ( m_totEvtNumInCurFile - 1 ) -
702 m_ranStepLenInCurrentFile[m_skipCount]; // number of events to the
703 // end of current file
704
705 if ( m_skipCount == 0 && nskip == 0 ) nskip = 1;
706 // std::cout << "nskip: " << nskip << std::endl;
707 m_skipCount++;
708 }
709 if ( m_RealizationSvc->UseDBFlag() == false || m_dbUserRequest == true )
710 nskip = int( 2 * m_NSkip * ( RandFlat::shoot() ) ) + 1;
711 if ( m_totalEvent == 0 && nskip == 0 ) nskip = 1;
712 }
713 if ( m_mixingMethod == 2 ) { nskip = int( 2 * m_NSkip * ( RandFlat::shoot() ) ) + 1; }
714 if ( m_ifOutPut )
715 {
716 m_timer->stop();
717 m_time2 = m_timer->elapsed();
718 m_timer->start();
719 }
720
721 // get that bg event
722 if ( m_readBGMethod == 0 )
723 {
724 // same with previous versions
725 for ( int j = 0; j < nskip; j++ )
726 {
727 next = nextEvent();
728 if ( !next )
729 {
730 ( *log ) << MSG::ERROR << "Cannot get next background event" << endmsg;
731 return StatusCode::FAILURE;
732 }
733 }
734 }
735 if ( m_readBGMethod == 1 )
736 {
737 // new method to read bg events, using index file.
738 next = nextEvent( nskip, 0, m_nEventsToEnd );
739 if ( !next )
740 {
741 ( *log ) << MSG::ERROR << "Cannot get next background event" << endmsg;
742 return StatusCode::FAILURE;
743 }
744 }
745 if ( m_readBGMethod == 2 )
746 {
747 // new method to read bg events, using rude localizer.
748 next = nextEvent( nskip, 14 * 1024 );
749 if ( !next )
750 {
751 ( *log ) << MSG::ERROR << "Cannot get next background event" << endmsg;
752 return StatusCode::FAILURE;
753 }
754 }
755 }
756 else
757 { // if skip = false
758 next = nextEvent();
759 }
760
761 if ( m_mixingMethod == 1 )
762 {
763 if ( !next && m_totalEvent == 0 )
764 {
765 ( *log ) << MSG::ERROR << "Cannot get next background event" << endmsg;
766 return StatusCode::FAILURE;
767 }
768 }
769
770 if ( m_mixingMethod == 2 )
771 {
772 if ( !next )
773 {
774 ( *log ) << MSG::ERROR << "Cannot get next background event" << endmsg;
775 return StatusCode::FAILURE;
776 }
777 }
778
779 mixDigi( mdcMcDigits, emcMcDigits, mucMcDigits, tofMcDigits );
780 }
781
782 m_totalEvent++;
783
784 if ( m_ifOutPut )
785 {
786 m_timer->stop();
787 m_time3 = m_timer->elapsed();
788 m_tuple1->write();
789 }
790 return StatusCode::SUCCESS;
791}
runNo
int runNo
Definition DQA_TO_DB.cxx:13
iter
EvtStreamInputIterator< typename Generator::result_type > iter(Generator gen, int N=0)
Definition EvtStreamInputIterator.hh:83
MAX_LOOP_TIMES
#define MAX_LOOP_TIMES
Definition MixerAlg.h:34
MixerAlg::file_sort
bool file_sort(std::vector< std::string > &files, std::vector< int > &ranEvtNums)
Definition MixerAlg.cxx:1264
MixerAlg::mixDigi
void mixDigi(SmartDataPtr< MdcDigiCol > &mdcMcDigits, SmartDataPtr< EmcDigiCol > &emcMcDigits, SmartDataPtr< MucDigiCol > &mucMcDigits, SmartDataPtr< TofDigiCol > &tofMcDigits)
Definition MixerAlg.cxx:1082
MixerAlg::nextEvent
bool nextEvent(int nskip=0, int evtbyte=0, int eventsToEnd=0)
Definition MixerAlg.cxx:801
RawFileException::print
virtual void print() const
Definition RawFileExceptions.cxx:4
RootInterface::Instance
static RootInterface * Instance(const std::string &name)
singleton behaviour
Definition RootInterface.cxx:24
EvtCyclic3::next
Index next(Index i)
Definition EvtCyclic3.cc:105
EvtCyclic3::c_str
char * c_str(Index i)
Definition EvtCyclic3.cc:240

◆ file_sort()

bool MixerAlg::file_sort ( std::vector< std::string > & files,
std::vector< int > & ranEvtNums )
protected

Definition at line 1264 of file MixerAlg.cxx.

1264 {
1265 std::vector<std::string> tmp_files = files;
1266 std::vector<int> tmp_ranEvtNums = ranEvtNums;
1267 files.clear();
1268 ranEvtNums.clear();
1269 m_numSets.clear();
1270
1271 const char* file_index[100];
1272 int num_index[100];
1273 int set_index[100];
1274 for ( int i = 0; i < 100; i++ )
1275 {
1276 file_index[i] = "";
1277 num_index[i] = 0;
1278 set_index[i] = 0;
1279 }
1280
1281 if ( tmp_files.size() >= 100 )
1282 {
1283 std::cout << "ERROR: In MixerAlg::file_sort(), please change bigger array size"
1284 << std::endl;
1285 return false;
1286 }
1287
1288 for ( unsigned int i = 0; i < tmp_files.size(); i++ )
1289 {
1290 int index = 0;
1291 const char* file1 = tmp_files[i].c_str();
1292 const char* substr1 = strstr( file1, "_file" );
1293 int strlen1 = strlen( substr1 );
1294 char cset1[4];
1295 char cnum1[2];
1296
1297 for ( int sub1 = 0; sub1 < strlen1; sub1++ )
1298 {
1299 if ( substr1[sub1] == 'e' )
1300 {
1301 cset1[0] = substr1[sub1 + 1];
1302 cset1[1] = substr1[sub1 + 2];
1303 cset1[2] = substr1[sub1 + 3];
1304 cset1[3] = '\0';
1305 }
1306 else if ( substr1[sub1] == '-' )
1307 {
1308 cnum1[0] = substr1[sub1 + 1];
1309 cnum1[1] = '\0';
1310 break;
1311 }
1312 else { continue; }
1313 }
1314
1315 int set1 = atoi( cset1 );
1316 int num1 = atoi( cnum1 );
1317 int encode_set1 = set1 * 100 + num1;
1318
1319 for ( unsigned int j = 0; j < tmp_files.size(); j++ )
1320 {
1321 if ( i == j ) continue;
1322 const char* file2 = tmp_files[j].c_str();
1323 const char* substr2 = strstr( file2, "_file" );
1324 int strlen2 = strlen( substr2 );
1325 char cset2[4];
1326 char cnum2[2];
1327 for ( int sub2 = 0; sub2 < strlen2; sub2++ )
1328 {
1329 if ( substr2[sub2] == 'e' )
1330 {
1331 cset2[0] = substr2[sub2 + 1];
1332 cset2[1] = substr2[sub2 + 2];
1333 cset2[2] = substr2[sub2 + 3];
1334 cset2[3] = '\0';
1335 }
1336 else if ( substr2[sub2] == '-' )
1337 {
1338 cnum2[0] = substr2[sub2 + 1];
1339 cnum2[1] = '\0';
1340 break;
1341 }
1342 else { continue; }
1343 }
1344 int set2 = atoi( cset2 );
1345 int num2 = atoi( cnum2 );
1346 int encode_set2 = set2 * 100 + num2;
1347 if ( encode_set1 > encode_set2 ) index++;
1348 }
1349 file_index[index] = tmp_files[i].c_str();
1350 num_index[index] = tmp_ranEvtNums[i];
1351 set_index[index] = set1;
1352 }
1353
1354 int setNo = -10;
1355 for ( unsigned int i = 0; i < tmp_files.size(); i++ )
1356 {
1357 files.push_back( file_index[i] );
1358 ranEvtNums.push_back( num_index[i] );
1359 if ( setNo != set_index[i] )
1360 {
1361 setNo = set_index[i];
1362 int numSets_size = m_numSets.size();
1363 if ( numSets_size == 0 ) m_numSets.push_back( 1 );
1364 if ( numSets_size != 0 ) m_numSets.push_back( m_numSets[numSets_size - 1] + 1 );
1365 }
1366 else
1367 {
1368 int numSets_size = m_numSets.size();
1369 m_numSets.push_back( m_numSets[numSets_size - 1] );
1370 }
1371 }
1372
1373 return true;
1374}
num1
const int num1
Definition InstallArea/x86_64-el9-gcc13-dbg/include/TofSim/BesTofDigitizerEcV3.hh:34

Referenced by execute().

◆ finalize()

StatusCode MixerAlg::finalize ( )

Definition at line 793 of file MixerAlg.cxx.

793 {
794 if ( m_raw_event ) delete m_raw_event;
795 if ( log ) delete log;
796 if ( m_fr ) delete m_fr;
797 return StatusCode::SUCCESS;
798}

◆ getTiming()

int MixerAlg::getTiming ( )
protected

Definition at line 1199 of file MixerAlg.cxx.

1199 {
1200 int timing = 0;
1201
1202 TrigGTD* trigGTD = NULL;
1203 TrigGTDCol* gtdCol = new TrigGTDCol;
1204
1205 const BufferHolder& gtdBuf = m_raw_event->getGTDBuf();
1206 uint32_t nbuf = gtdBuf.nBuf();
1207
1208 for ( uint32_t i = 0; i < nbuf; i++ )
1209 {
1210 uint32_t* buf = gtdBuf( i );
1211 uint32_t bufSize = gtdBuf.bufSize( i );
1212 uint32_t index = 0;
1213 while ( bufSize - index > 1 )
1214 {
1215 uint32_t blockSize = ( ( ( *( buf + index ) ) >> 14 ) & 0x3FF );
1216 uint32_t id = ( ( *( buf + index ) ) >> 24 );
1217 if ( blockSize == 0 || ( index + blockSize ) > bufSize ) break;
1218 if ( ( id > 0xD1 && id < 0xD8 && id != 0xD5 ) || id == 0xDA ||
1219 ( id > 0xE1 && id < 0xED ) )
1220 {
1221 trigGTD = new TrigGTD( buf + index );
1222 gtdCol->push_back( trigGTD );
1223 }
1224 index += blockSize;
1225 }
1226 }
1227
1228 TrigGTDCol::iterator iter = gtdCol->begin();
1229 for ( ; iter != gtdCol->end(); iter++ )
1230 {
1231 const uint32_t boardId =
1232 ( *iter )->getId(); // The board Id 0xd3: GTL, 0xD2: SAF1, 0xD4: SAF2, 0xD6: SAF3
1233 const uint32_t timeWindow =
1234 ( *iter )->getTimeWindow(); // Time window, bit8 to bit13, total: 0--31
1235 const uint32_t size =
1236 ( *iter )->getDataSize(); // The size of trigger data, not include head
1237 const uint32_t* trigData = ( *iter )->getDataPtr(); // Trigger data
1238
1239 // Get data group 5 in GTL, including trigger channel, timing and prescale.
1240 if ( boardId == 0xd3 )
1241 {
1242 if ( size % timeWindow != 0 )
1243 {
1244 std::cout << "GTL data is NOT completed, exit." << std::endl;
1245 exit( 0 );
1246 }
1247 for ( uint32_t j = 0; j < size; j++ )
1248 {
1249 uint32_t dataId = ( ( trigData[j] >> 24 ) & 0x7 );
1250 if ( dataId != 5 ) continue; // find data group 5
1251 for ( uint32_t i = 1, loop = 0; loop < 24; i <<= 1, loop++ )
1252 {
1253 if ( ( loop == 16 ) && ( trigData[j] & i ) ) timing = 1;
1254 if ( ( loop == 17 ) && ( trigData[j] & i ) && ( timing != 1 ) ) timing = 2;
1255 if ( ( loop == 18 ) && ( trigData[j] & i ) && ( timing == 0 ) ) timing = 3;
1256 }
1257 }
1258 }
1259 }
1260
1261 return timing;
1262}
TrigGTDCol
ObjectVector< TrigGTD > TrigGTDCol
Definition Event/TrigEvent/include/TrigEvent/TrigGTD.h:39

Referenced by mixDigi().

◆ initialize()

StatusCode MixerAlg::initialize ( )

Definition at line 110 of file MixerAlg.cxx.

110 {
111 log = new MsgStream( msgSvc(), name() );
112
113 info() << "Instancing MdcConverter" << endmsg;
114 m_mdcCnv = MdcConverter::instance();
115
116 info() << "Instancing MucConverter" << endmsg;
117 m_mucCnv = MucConverter::instance();
118
119 info() << "Instancing TofConverter" << endmsg;
120 m_tofCnv = TofConverter::instance();
121
122 info() << "Instancing EmcConverter" << endmsg;
123 m_emcCnv = EmcConverter::instance();
124
125 info() << "Instancing Done" << endmsg;
126
127 // Caogf add
128 StatusCode status = service( "RealizationSvc", m_RealizationSvc );
129 if ( !status.isSuccess() )
130 { ( *log ) << MSG::FATAL << " Could not initialize Realization Service" << endmsg; }
131
132 if ( m_RealizationSvc->UseDBFlag() == true && m_RealizationSvc->ifReadRandTrg() == true &&
133 m_dbUserRequest == true )
134 {
135 std::string query = prepareDbQuery();
136 m_bgfiles = m_RealizationSvc->getBgFileName( query );
137 }
138
139 if ( !m_pattern.empty() )
140 {
141 for ( unsigned int k = 0; k < m_bgfiles.size(); k++ )
142 {
143 size_t pos_round = m_bgfiles[k].rfind( "round" );
144 ( *log ) << MSG::INFO << "m_bgfiles: " << m_bgfiles[k] << endmsg;
145 if ( pos_round != string::npos )
146 {
147 m_bgfiles[k].replace( m_bgfiles[k].begin(), m_bgfiles[k].begin() + pos_round,
148 m_pattern );
149 ( *log ) << MSG::INFO << "new random trigger data path: " << m_bgfiles[k] << endmsg;
150 }
151 else
152 {
153 ( *log ) << MSG::ERROR << "string 'round' not found in random trigger path!" << endmsg;
154 exit( -1 );
155 }
156 }
157 }
158 if ( !m_newdatadir.empty() )
159 {
160 for ( unsigned int k = 0; k < m_bgfiles.size(); k++ )
161 {
162 char tmp[255];
163 std::strcpy( tmp, m_bgfiles[k].c_str() );
164 string fname = basename( tmp );
165 m_bgfiles[k].replace( m_bgfiles[k].begin(), m_bgfiles[k].end(),
166 m_newdatadir + '/' + fname );
167 ( *log ) << MSG::INFO << "new random trigger data path: " << m_bgfiles[k] << endmsg;
168 }
169 }
170
171 // initialize MDC converter
172 std::ifstream conff( m_rawReviseConfig.c_str() );
173 m_mdcCnv->init( SniperJSON::load( conff )["MDCID_FIX"] );
174
175 // caogf for random seed
176 static const bool CREATEIFNOTTHERE( true );
177 StatusCode RndmStatus = service( "BesRndmGenSvc", p_BesRndmGenSvc, CREATEIFNOTTHERE );
178 if ( !RndmStatus.isSuccess() || 0 == p_BesRndmGenSvc )
179 {
180 ( *log ) << MSG::ERROR << " Could not initialize Random Number Service" << endmsg;
181 return RndmStatus;
182 }
183
184 // get jobSvc
185 status = service( "DataInfoSvc", m_jobInfoSvc );
186 if ( status.isSuccess() ) { ( *log ) << MSG::INFO << "get the DataInfoSvc" << endmsg; }
187 else { ( *log ) << MSG::WARNING << "could not get the DataInfoSvc." << endmsg; }
188 // end caogf add
189
190 if ( m_RealizationSvc->UseDBFlag() == false || m_dbUserRequest == true )
191 {
192 if ( m_bgfiles.empty() )
193 {
194 ( *log ) << MSG::WARNING << "No background datafiles found" << endmsg;
195 return StatusCode::SUCCESS;
196 }
197
198 // open background stream
199 try
200 {
201 m_bgfilesIndex.clear();
202 for ( unsigned int bg_index = 0; bg_index < m_bgfiles.size(); bg_index++ )
203 { m_bgfilesIndex.push_back( m_bgfiles[bg_index] + ".idx" ); }
204 if ( m_skip == true && m_readBGMethod == 1 )
205 m_fr = new RawFileReader( m_bgfiles, m_bgfilesIndex );
206 else m_fr = new RawFileReader( m_bgfiles );
207 } catch ( RawFileException& ex )
208 {
209 ex.print();
210 return StatusCode::FAILURE;
211 }
212 }
213 m_raw_event = new RAWEVENT;
214
215 if ( m_ifOutPut )
216 {
217 NTuplePtr nt1( ntupleSvc(), "FILE1/n1" );
218 if ( nt1 ) m_tuple1 = nt1;
219 else
220 {
221 m_tuple1 = ntupleSvc()->book( "FILE1/n1", CLID_ColumnWiseTuple, "Field" );
222 if ( m_tuple1 )
223 {
224 status = m_tuple1->addItem( "time1", m_time1 );
225 status = m_tuple1->addItem( "time2", m_time2 );
226 status = m_tuple1->addItem( "time3", m_time3 );
227 }
228 else
229 {
230 ( *log ) << MSG::ERROR << " Cannot book N-tuple:" << long( m_tuple1 ) << endmsg;
231 return StatusCode::FAILURE;
232 }
233 }
234
235 NTuplePtr nt2( ntupleSvc(), "FILE1/n2" );
236 if ( nt2 ) m_tuple2 = nt2;
237 else
238 {
239 m_tuple2 = ntupleSvc()->book( "FILE1/n2", CLID_ColumnWiseTuple, "Field" );
240 if ( m_tuple2 ) { status = m_tuple2->addItem( "tdc", m_tdc ); }
241 else
242 {
243 ( *log ) << MSG::ERROR << " Cannot book N-tuple:" << long( m_tuple2 ) << endmsg;
244 return StatusCode::FAILURE;
245 }
246 }
247
248 NTuplePtr nt3( ntupleSvc(), "FILE1/n3" );
249 if ( nt3 ) m_tuple3 = nt3;
250 else
251 {
252 m_tuple3 = ntupleSvc()->book( "FILE1/n3", CLID_ColumnWiseTuple, "Field" );
253 if ( m_tuple3 )
254 {
255 status = m_tuple3->addItem( "time4", m_time4 );
256 status = m_tuple3->addItem( "time5", m_time5 );
257 }
258 else
259 {
260 ( *log ) << MSG::ERROR << " Cannot book N-tuple:" << long( m_tuple3 ) << endmsg;
261 return StatusCode::FAILURE;
262 }
263 }
264
265 status = service( "BesTimerSvc", m_timersvc );
266 if ( status.isFailure() )
267 {
268 ( *log ) << MSG::ERROR << name() << ": Unable to locate BesTimer Service" << endmsg;
269 return StatusCode::FAILURE;
270 }
271 m_timer = m_timersvc->addItem( "Read field Time" );
272 m_timer1 = m_timersvc->addItem( "Read raw files" );
273 }
274
275 // For random seed added by caogf. Note the position of the code, otherwise it is not
276 // available.
277 CLHEP::HepRandomEngine* engine = p_BesRndmGenSvc->GetEngine( "MIX" );
278 HepRandom::setTheEngine( engine );
279
280 return StatusCode::SUCCESS;
281}
ntupleSvc
INTupleSvc * ntupleSvc()
Definition ServiceAccessor.h:51
msgSvc
IMessageSvc * msgSvc()
Definition ServiceAccessor.h:12
EmcConverter::instance
static EmcConverter * instance(int runMode=2)
Definition EmcConverter.cxx:9
MdcConverter::instance
static MdcConverter * instance(int runMode=2)
Definition MdcConverter.cxx:7
MixerAlg::prepareDbQuery
std::string prepareDbQuery()
Definition MixerAlg.cxx:81
MucConverter::instance
static MucConverter * instance()
Definition MucConverter.cxx:5
SniperJSON::load
static SniperJSON load(std::istream &is)
Definition SniperJSON.cxx:66
TofConverter::instance
static TofConverter * instance()
Definition TofConverter.cxx:6

◆ mixDigi()

void MixerAlg::mixDigi ( SmartDataPtr< MdcDigiCol > & mdcMcDigits,
SmartDataPtr< EmcDigiCol > & emcMcDigits,
SmartDataPtr< MucDigiCol > & mucMcDigits,
SmartDataPtr< TofDigiCol > & tofMcDigits )
protected

Definition at line 1082 of file MixerAlg.cxx.

1085 {
1086 if ( b_mdc ) // MDC
1087 {
1088 MdcDigiCol mdcCol;
1089 decodeMdc( &mdcCol );
1090 // combineDigits<MdcDigiCol, MdcDigi>(mdcMcDigits, mdcCol, log->level());
1091
1092 // Find minimal tdc and maximum tdc and calculate mean tdc.
1093 if ( m_ifSmearT0 && getTiming() > 0 )
1094 {
1095 int tdc_min = -9, tdc_max = -9, tdc_tot = 0, tdc_num = 0;
1096 for ( MdcDigiCol::const_iterator bg = mdcCol.begin(); bg != mdcCol.end(); bg++ )
1097 {
1098 if ( ( *bg )->getTimeChannel() < 0x7FFFFFFF )
1099 {
1100 tdc_tot += ( *bg )->getTimeChannel();
1101 tdc_num++;
1102 if ( tdc_min < 0 ) tdc_min = ( *bg )->getTimeChannel();
1103 else
1104 {
1105 if ( tdc_min > ( *bg )->getTimeChannel() ) tdc_min = ( *bg )->getTimeChannel();
1106 }
1107 if ( tdc_max < 0 ) tdc_max = ( *bg )->getTimeChannel();
1108 else
1109 {
1110 if ( tdc_max < ( *bg )->getTimeChannel() ) tdc_max = ( *bg )->getTimeChannel();
1111 }
1112 }
1113 }
1114 int tdc_mean = (int)( (double)tdc_tot / (double)tdc_num );
1115 tdc_num = 0;
1116 int tdc_shift;
1117 while ( 1 )
1118 {
1119 tdc_shift =
1120 tdc_mean - CLHEP::RandFlat::shootInt( long( 0 ), long( 80 * 24 / 0.09375 ) );
1121 if ( ( tdc_min - tdc_shift ) >= 0 &&
1122 ( tdc_max - tdc_shift ) <= int( 80 * 24 / 0.09375 ) )
1123 break;
1124 tdc_num++;
1125 if ( tdc_num > m_maxLoop ) break;
1126 }
1127
1128 // Set new tdc
1129 for ( MdcDigiCol::const_iterator bg = mdcCol.begin(); bg != mdcCol.end(); bg++ )
1130 {
1131 if ( ( *bg )->getTimeChannel() >= 0x7FFFFFFF ) continue;
1132 int newTDC = ( *bg )->getTimeChannel() - tdc_shift;
1133 if ( newTDC < 0 || newTDC > int( 80 * 24 / 0.09375 ) )
1134 newTDC = int( CLHEP::RandFlat::shoot() * 80 * 24 / 0.09375 );
1135 ( *bg )->setTimeChannel( newTDC );
1136
1137 // m_tdc = (*bg)->getTimeChannel();
1138 // m_tuple2->write();
1139 }
1140 }
1141 // combineDigits<MdcDigiCol, MdcDigi>(mdcMcDigits, mdcCol, log->level());
1142 combineMdcDigits( mdcMcDigits, mdcCol, log->level() );
1143 }
1144 if ( b_emc ) // EMC
1145 {
1146 EmcDigiCol emcCol;
1147 decodeEmc( &emcCol );
1148 combineDigits<EmcDigiCol, EmcDigi>( emcMcDigits, emcCol, log->level() );
1149 }
1150 if ( b_muc ) // MUC
1151 {
1152 MucDigiCol mucCol;
1153 decodeMuc( &mucCol );
1154 combineDigits<MucDigiCol, MucDigi>( mucMcDigits, mucCol, log->level() );
1155 }
1156 if ( b_tof ) // TOF
1157 {
1158 TofDigiCol tofCol;
1159 decodeTof( &tofCol );
1160 // combineDigits<TofDigiCol, TofDigi>(tofMcDigits, tofCol, log->level());
1161 combineTofDigits( tofMcDigits, tofCol, log->level() );
1162 }
1163}
EmcDigiCol
ObjectVector< EmcDigi > EmcDigiCol
Definition Emc/EmcRawEvent/include/EmcRawEvent/EmcDigi.h:43
MdcDigiCol
ObjectVector< MdcDigi > MdcDigiCol
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcRawEvent/MdcDigi.h:38
MucDigiCol
ObjectVector< MucDigi > MucDigiCol
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MucRawEvent/MucDigi.h:28
TofDigiCol
ObjectVector< TofDigi > TofDigiCol
Definition InstallArea/x86_64-el9-gcc13-dbg/include/TofRawEvent/TofDigi.h:42
combineMdcDigits
void combineMdcDigits(SmartDataPtr< MdcDigiCol > &mcDigits, MdcDigiCol &bgDigits, int verbosity)
Definition MixerAlg.cxx:1019
combineTofDigits
void combineTofDigits(SmartDataPtr< TofDigiCol > &mcDigits, TofDigiCol &bgDigits, int verbosity)
Definition MixerAlg.cxx:1068
combineDigits
void combineDigits(SmartDataPtr< T1 > &mcDigits, T1 &bgDigits, int verbosity)
Definition MixerAlg.cxx:972
MixerAlg::decodeMuc
void decodeMuc(MucDigiCol *digiCol)
Definition MixerAlg.cxx:1170
MixerAlg::decodeEmc
void decodeEmc(EmcDigiCol *digiCol)
Definition MixerAlg.cxx:1175
MixerAlg::getTiming
int getTiming()
Definition MixerAlg.cxx:1199
MixerAlg::decodeMdc
void decodeMdc(MdcDigiCol *digiCol)
Definition MixerAlg.cxx:1165
MixerAlg::decodeTof
void decodeTof(TofDigiCol *digiCol)
Definition MixerAlg.cxx:1180

Referenced by execute().

◆ nextEvent()

bool MixerAlg::nextEvent ( int nskip = 0,
int evtbyte = 0,
int eventsToEnd = 0 )
protected

Definition at line 801 of file MixerAlg.cxx.

801 {
802
803 m_raw_event->reset();
804
805 try
806 {
807 if ( m_ifOutPut ) { m_timer1->start(); }
808
809 const uint32_t* fragment;
810 if ( m_skip == true && m_readBGMethod == 0 ) fragment = m_fr->nextEvent();
811 if ( m_skip == true && m_readBGMethod == 1 )
812 {
813 if ( nskip == 0 ) fragment = m_fr->currentEvent();
814 else fragment = m_fr->nextEvent( nskip - 1 );
815 }
816 if ( m_skip == true && m_readBGMethod == 2 )
817 {
818 if ( nskip == 0 ) fragment = m_fr->currentEvent();
819 else fragment = m_fr->roughlyNextEvent( nskip - 1, evtbyte );
820 }
821 if ( m_skip == false ) fragment = m_fr->nextEvent();
822
823 if ( m_ifOutPut )
824 {
825 m_timer1->stop();
826 m_time4 = m_timer1->elapsed();
827 m_timer1->start();
828 }
829 // if (fragment == NULL) {
830 // (*log) << MSG::ERROR << "RawFileReader::nextEvent() Failed!!!" << endmsg;
831 // exit(1);
832 // }
833
834 RawEvent f( fragment );
835 if ( !f.check() )
836 {
837 std::cerr << "Found invalid event (traceback):" << std::endl;
838 std::exit( 1 );
839 }
840 // 1.print basic event information
841 uint32_t fFragmentSize = f.fragment_size_word();
842 ( *log ) << MSG::DEBUG << "[Event No. #" << f.global_id() << "] " << f.fragment_size_word()
843 << " words in " << f.nchildren() << " subdetectors " << endmsg;
844 m_raw_event->setRunNo( f.run_no() );
845 m_raw_event->setEventNo( f.global_id() );
846
847 if ( m_dump ) { cout << "EventNo " << f.global_id() << endl; }
848
849 // fucd: get event filter information
850 const uint32_t* ef = NULL;
851 f.event_filter_info( ef );
852 if ( !ef )
853 {
854 ( *log ) << MSG::ERROR << "Event Filter Data Failed!!!" << endmsg;
855 exit( 1 );
856 }
857 else
858 {
859 ( *log ) << MSG::DEBUG << "Event Filter Information*********" << std::hex << endmsg
860 << *ef << " " << *( ef + 1 ) << " " << *( ef + 2 ) << " " << *( ef + 3 )
861 << std::dec << endmsg;
862 m_raw_event->addReHltRaw( (uint32_t*)ef, (uint32_t)4 );
863 }
864
865 uint32_t* robs[64];
866 int nrobs = eformat::get_robs( fragment, (const uint32_t**)robs, 64 );
867
868 for ( int robi = 0; robi < nrobs; robi++ )
869 {
870 eformat::ROBFragment<uint32_t*> rob( robs[robi] );
871 if ( ( rob.rod_detev_type() & 0x2 ) != 0 ) continue; // bad data caogf add
872 uint32_t* dataptr = NULL;
873 rob.rod_data( dataptr );
874
875 uint32_t source_id_number = rob.rod_source_id();
876 // std::cout<<"#####source_id_number#####"<<source_id_number<<std::endl;
877 source_id_number <<= 8;
878 source_id_number >>= 24;
879 // std::cout<<"#####(source_id_number<<24)>>29#####"<<source_id_number<<std::endl;
880 // be careful here!!!
881 switch ( source_id_number )
882 {
883 case 161: m_raw_event->addReMdcDigi( dataptr, rob.rod_ndata() ); break;
884 case 163: m_raw_event->addReEmcDigi( dataptr, rob.rod_ndata() ); break;
885 case 162: m_raw_event->addReTofDigi( dataptr, rob.rod_ndata() ); break;
886 case 167: m_raw_event->addReEtfDigi( dataptr, rob.rod_ndata() ); break;
887 case 164: m_raw_event->addReMucDigi( dataptr, rob.rod_ndata() ); break;
888 case 165: // trigger !!!
889 // std::cout << "Get Trigger Data -" << std::endl;
890 // for (int i = 0; i < rob.rod_ndata(); i++) {
891 // std::cout << "\t0x" << std::hex << dataptr[i] << std::dec << std::endl;
892 // }
893 m_raw_event->addReTrigGTD( dataptr, rob.rod_ndata() );
894 break;
895 case 124: // EventFilter
896 m_raw_event->addReHltRaw( dataptr, rob.rod_ndata() );
897 break;
898 case 241: // McParticle
899 m_raw_event->addMcParticle( dataptr, rob.rod_ndata() );
900 break;
901 default:
902 // std::cerr << "no such subdetector type: " << source_id_number << std::endl;
903 break;
904 }
905 }
906 if ( m_ifOutPut )
907 {
908 m_timer1->stop();
909 m_time5 = m_timer1->elapsed();
910 m_tuple3->write();
911 }
912
913 if ( m_usingFilter == true )
914 {
915 if ( eventType() == "GHadron" || eventType() == "GEBhabha" ||
916 eventType() == "GBBhabha" || eventType() == "GCosmic" || eventType() == "GDimuon" )
917 {
918 if ( m_skip == true && m_readBGMethod == 0 )
919 { return nextEvent( 1, evtbyte, eventsToEnd ); }
920 if ( m_skip == true && m_readBGMethod == 1 )
921 {
922 if ( m_RealizationSvc->UseDBFlag() == false || m_dbUserRequest == true )
923 return nextEvent( 1, evtbyte, eventsToEnd );
924 if ( eventsToEnd > 0 && m_RealizationSvc->UseDBFlag() == true &&
925 m_dbUserRequest == false )
926 {
927 eventsToEnd--;
928 return nextEvent( 1, evtbyte, eventsToEnd );
929 }
930 }
931 if ( m_skip == true && m_readBGMethod == 2 )
932 { return nextEvent( 1, evtbyte, eventsToEnd ); }
933 if ( m_skip == false ) return nextEvent( nskip, evtbyte, eventsToEnd );
934 }
935 }
936
937 return true;
938 } catch ( ReachEndOfFileList& ex )
939 {
940 ex.print();
941
942 delete m_fr;
943 try
944 {
945 if ( m_skip == true && m_readBGMethod == 1 )
946 m_fr = new RawFileReader( m_bgfiles, m_bgfilesIndex );
947 else m_fr = new RawFileReader( m_bgfiles );
948 } catch ( RawFileException& ex )
949 {
950 ex.print();
951 return false;
952 }
953
954 return nextEvent( nskip, evtbyte, eventsToEnd );
955 } catch ( RawFileException& ex )
956 { ex.print(); } catch ( eformat::Issue& ex )
957 {
958 std::cerr << std::endl << "Uncaught eformat issue: " << ex.what() << std::endl;
959 } catch ( ers::Issue& ex )
960 {
961 std::cerr << std::endl << "Uncaught ERS issue: " << ex.what() << std::endl;
962 } catch ( std::exception& ex )
963 {
964 std::cerr << std::endl << "Uncaught std exception: " << ex.what() << std::endl;
965 } catch ( ... )
966 { std::cerr << std::endl << "Uncaught unknown exception" << std::endl; }
967
968 return false;
969}
f
TFile f("ana_bhabha660a_dqa_mcPat_zy_old.root")
RawEvent
eformat::FullEventFragment< const uint32_t * > RawEvent
Definition Event/RawDataCnv/include/RawDataCnv/EventManagement/RawEventDef.h:8
MixerAlg::eventType
std::string eventType()
Definition MixerAlg.cxx:1187
ReachEndOfFileList::print
virtual void print() const
Definition RawFileExceptions.cxx:35
ers::Issue::what
const char * what() const
Human description message.
Definition ers/src/Issue.cxx:661
eformat::get_robs
size_t get_robs(const uint32_t *fragment, const uint32_t **rob, size_t max_count)
Definition util.cxx:104

Referenced by execute(), and nextEvent().

◆ prepareDbQuery()

std::string MixerAlg::prepareDbQuery ( )
protected

Definition at line 81 of file MixerAlg.cxx.

81 {
82 std::string query = "SELECT FilePath,FileName,NumEvent FROM RanTrgData";
83
84 if ( !m_run.empty() || m_runs.size() == 2 || m_dates.size() == 2 )
85 { // use additional parameters for query
86 query = query + " WHERE ";
87 bool use_and = false;
88 if ( !m_run.empty() )
89 {
90 query = query + " RunNo=" + m_run;
91 use_and = true;
92 }
93 if ( m_runs.size() == 2 )
94 {
95 if ( use_and ) query = query + " AND ";
96 query = query + " RunNo>=" + m_runs[0] + " AND RunNo<=" + m_runs[1];
97 use_and = true;
98 }
99 if ( m_dates.size() == 2 )
100 {
101 if ( use_and ) query = query + " AND ";
102 query = query + " TimeSOR>='" + m_dates[0] + "' AND TimeEOR<='" + m_dates[1] + "'";
103 }
104 }
105
106 query = query + ";";
107 return query;
108}

Referenced by initialize().

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