EFEventLoopMgr Class Reference

#include <EFEventLoopMgr.h>

Inheritance diagram for EFEventLoopMgr:


Public Member Functions
virtual StatusCode	initialize ()
	implementation of IAppMgrUI::initalize
virtual StatusCode	finalize ()
	implementation of IAppMgrUI::finalize
virtual StatusCode	executeEvent (void *par)
	implementation of IEventProcessor::executeEvent(void* par)
StatusCode	getEventRoot (IOpaqueAddress *&refpAddr)
	Create event address using event selector.
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface)
	implementation of IInterface: queryInterface
virtual StatusCode	prepareForRun (int ef_run_number)
	prepare for run step
virtual bool	getTrigChn (uint32_t *data, uint32_t ndata)
	whether it is a RrandomTrg
virtual std::string	EF_Decision ()
	return data from EF decision
virtual uint32_t	EF_Version ()
	return version number
virtual uint32_t	EF_Algorithm_Tag ()
	return algorithm tag
virtual uint32_t	EF_Total_Energy ()
	return total energy
virtual uint32_t *	EF_Fragment_Address ()
	Return a pointer to the local memory containing the EF subdetector fragment.
Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Retrieve interface ID.
Protected Member Functions
	EFEventLoopMgr (const std::string &nam, ISvcLocator *svcLoc)
	Standard Constructor.
virtual	~EFEventLoopMgr ()
	Standard Destructor.
Protected Attributes
IIncidentSvc *	m_incidentSvc
	Reference to the indicent service.
HltStoreSvc *	m_HltStoreSvc
	Reference to HltStoreSvc;.
IEvtSelector *	m_evtSelector
	Reference to the Event Selector.
IEvtSelector::Context *	m_evtContext
	Event Context.
std::string	m_evtsel
	Event selector.
IDataManagerSvc *	m_evtDataMgrSvc
	Reference to the Event Data Service's IDataManagerSvc interface.
IDataProviderSvc *	m_evtDataSvc
	Reference to the Event Data Service's IDataProviderSvc interface.
IDataManagerSvc *	m_histoDataMgrSvc
	Reference to the Histogram Data Service.
IConversionSvc *	m_histoPersSvc
	Reference to the Histogram Persistency Service.
std::string	m_histPersName
	Name of the Hist Pers type.
EventID::number_type	m_currentRun
	current run number
bool	m_firstRun
Private Attributes
int	m_total_nevt
IRawDataInputSvc *	m_inputSvc
bool	m_disableEFResult
bool	m_okexecuteEvent
int	m_timeTest
EFResult *	m_efResult
EFResult *	m_evtType
char *	m_serializedEFAddress
	Pointer to the local memory containing the EF Fragment.
uint32_t	m_trgType
bool	m_firstEvent
RAWEVENT *	m_re
Friends
class	SvcFactory< EFEventLoopMgr >
	Creator friend class.

Detailed Description

Class definition of EFEventLoopMgr. This is the default processing manager of the application manager. This object handles the minimal requirements needed by the application manager. It also handles the default user configuration setup for standard event processing.

handling of the incidents when starting event processing
handling of the event loop

History:

    +---------+----------------------------------------------+---------+
    |    Date |                 Comment                      | Who     |
    +---------+----------------------------------------------+---------+
    |13/12/00 | Initial version                              | M.Frank |
    +---------+----------------------------------------------+---------+

Author:: Markus Frank

Version:: 1.0

Definition at line 58 of file EFEventLoopMgr.h.

Constructor & Destructor Documentation

EFEventLoopMgr::EFEventLoopMgr	(	const std::string &	nam,
		ISvcLocator *	svcLoc
	)			`[protected]`

Standard Constructor.

Definition at line 54 of file EFEventLoopMgr.cxx.

References m_currentRun, m_disableEFResult, m_evtContext, m_evtDataMgrSvc, m_evtDataSvc, m_evtsel, m_evtSelector, m_firstEvent, m_firstRun, m_histoDataMgrSvc, m_histoPersSvc, m_histPersName, m_incidentSvc, m_okexecuteEvent, m_timeTest, m_total_nevt, and m_trgType.

00056 : MinimalEventLoopMgr(nam, svcLoc)
00057 {
00058   declareProperty( "EvtSel", m_evtsel );
00059   declareProperty( "HistogramPersistency", m_histPersName = "");
00060   declareProperty( "DisableEFResult", m_disableEFResult = true);
00061   declareProperty( "OkexecuteEvent", m_okexecuteEvent = true);
00062   declareProperty( "OutputLevel", m_outputLevel = MSG::ALWAYS);
00063   declareProperty( "TimeTest", m_timeTest = 0);
00064   m_histoDataMgrSvc   = 0;
00065   m_histoPersSvc      = 0;
00066   m_total_nevt        = 0;
00067   m_currentRun        = 0;
00068   m_evtDataMgrSvc     = 0;
00069   m_evtDataSvc        = 0;
00070   m_evtSelector       = 0;
00071   m_evtContext        = 0;
00072   m_firstRun          = true;
00073   m_incidentSvc       = 0;
00074   m_trgType           = 0;
00075   m_firstEvent        = true;
00076 }

EFEventLoopMgr::~EFEventLoopMgr ( ) [protected, virtual]

Standard Destructor.

Definition at line 81 of file EFEventLoopMgr.cxx.

References m_evtContext, m_evtDataMgrSvc, m_evtDataSvc, m_evtSelector, m_histoDataMgrSvc, m_histoPersSvc, and m_incidentSvc.

00082 {
00083   if( m_histoDataMgrSvc ) m_histoDataMgrSvc->release();
00084   if( m_histoPersSvc ) m_histoPersSvc->release();
00085   if( m_incidentSvc ) m_incidentSvc->release();
00086   if( m_evtDataMgrSvc ) m_evtDataMgrSvc->release();
00087   if( m_evtDataSvc ) m_evtDataSvc->release();
00088   if( m_evtSelector ) m_evtSelector->release();
00089   if( m_evtContext ) delete m_evtContext;
00090 }

Member Function Documentation

uint32_t EFEventLoopMgr::EF_Algorithm_Tag ( ) [virtual]

return algorithm tag

Implements IEFEventLoopMgr.

Definition at line 576 of file EFEventLoopMgr.cxx.

References Bes_Common::DEBUG, EFResult::getEFVec(), EFResult::getMidAnswerIndex(), m_efResult, m_evtType, and msgSvc().

00577 {
00578   MsgStream log( msgSvc(), name() );
00579   uint32_t alg=m_efResult->getEFVec(0);
00580   //log << MSG::INFO << "The algorithm tag is " << alg<<endreq;
00581   int itype=m_evtType->getMidAnswerIndex();
00582   //cout <<itype<<endl;
00583   if(itype != -1) alg += (1<<itype);
00584   uint32_t alg16=alg>>16;
00585   log << MSG::DEBUG << "The algorithm tag is " << alg <<":"
00586       << (alg&1)<<((alg>>1)&1)<<((alg>>2)&1)<<((alg>>3)&1)
00587       <<((alg>>4)&1)<<((alg>>5)&1)<<((alg>>6)&1)<<((alg>>7)&1)
00588       << ":%# "<< alg16<<endreq;
00589   return alg;
00590 }

std::string EFEventLoopMgr::EF_Decision ( ) [virtual]

return data from EF decision

Implements IEFEventLoopMgr.

Definition at line 533 of file EFEventLoopMgr.cxx.

References Bes_Common::DEBUG, EFResult::getAnswer(), EFResult::getAnswerIndex(), Bes_Common::INFO, m_disableEFResult, m_evtType, m_okexecuteEvent, msgSvc(), deljobs::string, and Bes_Common::WARNING.

00534 {
00535   MsgStream log( msgSvc(), name() );
00536   if (m_disableEFResult) {
00537     std::string defaultEFDecision = "Other" ;
00538     log << MSG::WARNING 
00539         << "EFEventLoopMgr:EF_Decision():---> EFResult handling is disabled. Default EFDecision = "
00540         << defaultEFDecision 
00541         << endreq;
00542     if (m_okexecuteEvent!=1){
00543       std::string defaultEFDecision = "Error";
00544       log << MSG::WARNING
00545           << "EFEventLoopMgr:EF_Decision():---> Error in executeEvent, setting EFDecision to: "<< defaultEFDecision << endreq;
00546       return defaultEFDecision;
00547     }
00548     return defaultEFDecision;
00549   } 
00550   else {
00551     //log << MSG::DEBUG << "Try to get the EFDecision" << endreq;
00552 
00553     //StatusCode sc = m_HltStoreSvc->get("EFResult", m_efResult);
00554     //enrich the result returned to online
00555     //by Fu Chengdong
00556     if (m_evtType->getAnswerIndex() == -1) {
00557       log << MSG::DEBUG << "EF_Decision(): Unvalid EFResult(AnswerIndex=-1)" << endreq;
00558       return "Error";
00559     }
00560     std::string answer = m_evtType->getAnswer();
00561     log << MSG::INFO << "The answer is " << answer << endreq;
00562     return answer;
00563   }
00564 }

uint32_t * EFEventLoopMgr::EF_Fragment_Address ( ) [virtual]

Return a pointer to the local memory containing the EF subdetector fragment.

EF ROD

Create an emply RawEvent and fill the RODs into the RawEvent (FullEventFragment) re

Implements IEFEventLoopMgr.

Definition at line 600 of file EFEventLoopMgr.cxx.

References Bes_Common::DEBUG, Bes_Common::FATAL, EFResult::getDecNum(), EFResult::getEFVec(), genRecEmupikp::i, Bes_Common::INFO, ganga-rec::j, m_disableEFResult, m_efResult, msgSvc(), num, ONLINE_DATA_HEAD, ONLINE_DATA_TAIL, and Bes_Common::WARNING.

00601 {
00602   //std::cout << "jak:"<<__FILE__<<std::endl;
00603   MsgStream log( msgSvc(), name() );
00604 
00605   if (m_disableEFResult) {
00606     log << MSG::WARNING << "EFEventLoopMgr:EF_Fragment_Address():---> EFResult handling is disabled!!!! No pointer to EF Fragment will be given." << endreq;
00607     return NULL;
00608 
00609   } 
00610   else {
00611     
00612     //log << MSG::DEBUG << "EFEventLoopMgr:EF_Fragment_Address():---> Going to retrieve EFResult, for the Fragment Address"<<endreq;
00613     uint32_t alg=m_efResult->getEFVec(0);
00614     log << MSG::DEBUG << "alg="<<alg<<endreq;
00615     uint32_t num=m_efResult->getEFVec(1);
00616     int nmdc=num&0xFF;
00617     int ntof=(num>>8)&0xFF;
00618     int nemc=(num>>16)&0xFF;
00619     int nmuc=(num>>24)&0xFF;
00620     int ndata=1;
00621     uint32_t ndatap = nmdc+ntof+nemc+nmuc;
00622     ndata += ndatap;
00623     int ndec=m_efResult->getDecNum();
00624     if(ndec>0) ndata +=(ndec+1);
00625     if((alg&4)&&(!(alg&2))) log << MSG::WARNING<<"sub-algorithms error!"<<endreq;
00626     if((ONLINE_DATA_HEAD+ONLINE_DATA_TAIL)!=40){
00627       log << MSG::FATAL << "data length error!" <<endreq;
00628       return NULL;
00629     }
00630     log << MSG::INFO<< "sent data lenth=" << ndata+40<<endreq;//byjak
00631     //uint32_t* efAddress=malloc((ndata+ONLINE_DATA_HEAD+ONLINE_DATA_TAIL)*sizeof(uint32_t));
00632     uint32_t* efAddress=new uint32_t[ndata+ONLINE_DATA_HEAD+ONLINE_DATA_TAIL];
00633     //std::cout << "fucd-->Address" << efAddress << "; ndata="<<ndata<<std::endl;
00634     if(efAddress==NULL) return NULL;
00635     efAddress[0]=0xbb1234bb;
00636     efAddress[1]=ndata+ONLINE_DATA_HEAD+ONLINE_DATA_TAIL;
00637     efAddress[2]=8;
00638     efAddress[3]=0x3000000;
00639     efAddress[4]=0x7c0000;
00640     efAddress[5]=1;
00641     efAddress[6]=0;
00642     efAddress[7]=0;
00643     efAddress[8]=0xcc1234cc;
00644     efAddress[9]=efAddress[1]-efAddress[2];
00645     efAddress[10]=0xb;
00646     efAddress[11]=0x3000000;
00647     efAddress[12]=0x7c0000;
00648     efAddress[13]=1;
00649     efAddress[14]=0;
00650     efAddress[15]=3;
00651     efAddress[16]=0;
00652     efAddress[17]=0;
00653     efAddress[18]=0;
00654     efAddress[19]=0xdd1234dd;
00655     efAddress[20]=efAddress[9]-efAddress[10];
00656     efAddress[21]=8;
00657     efAddress[22]=0x3000000;
00658     efAddress[23]=0x7c0000;
00659     efAddress[24]=1;
00660     efAddress[25]=0;
00661     efAddress[26]=0;
00662     efAddress[27]=0xee1234ee;
00663     efAddress[28]=9;
00664     efAddress[29]=0x3000000;
00665     efAddress[30]=0x7c0000;
00666     efAddress[31]=0;
00667     efAddress[32]=0;
00668     efAddress[33]=0;
00669     efAddress[34]=0;
00670     efAddress[35]=0;
00671     //efAddress[36]=0;
00672     efAddress[36+ndata]=0;
00673     efAddress[37+ndata]=1;
00674     efAddress[38+ndata]=ndata;
00675     efAddress[39+ndata]=1;
00676     efAddress[ONLINE_DATA_HEAD]=m_efResult->getEFVec(1);
00677     if(ndata==1){
00678       return efAddress;
00679     }
00680     else{
00681       unsigned int i=1;
00682       for(int j=5;j<5+nmdc;j++){
00683         efAddress[ONLINE_DATA_HEAD+i]=m_efResult->getEFVec(j);
00684         ++i;
00685       }
00686       for(int j=25;j<25+ntof;j++){
00687         efAddress[ONLINE_DATA_HEAD+i]=m_efResult->getEFVec(j);
00688         ++i;
00689       }
00690       for(int j=30;j<30+nemc;j++){
00691         efAddress[ONLINE_DATA_HEAD+i]=m_efResult->getEFVec(j);
00692         ++i;
00693       }
00694       for(int j=52;j<52+nmuc;j++){
00695         efAddress[ONLINE_DATA_HEAD+i]=m_efResult->getEFVec(j);
00696         ++i;
00697       }
00698       if(ndec>0) {
00699         efAddress[ONLINE_DATA_HEAD+i]=ndec;
00700         ++i;
00701         for(int j=54;j<54+ndec;++j){
00702           efAddress[ONLINE_DATA_HEAD+i]=m_efResult->getEFVec(j);
00703           ++i;
00704         }
00705       }
00706       log << MSG::DEBUG <<"0th eff data is "
00707           <<((efAddress[ONLINE_DATA_HEAD]>>24)&0xFF)
00708           <<((efAddress[ONLINE_DATA_HEAD]>>16)&0xFF)
00709           <<((efAddress[ONLINE_DATA_HEAD]>>8)&0xFF)
00710           <<((efAddress[ONLINE_DATA_HEAD]>>0)&0xFF)<<endreq;
00711       for(int i=1;i<ndatap+1;i++){
00712         log << MSG::DEBUG <<i<<"th eff data is " <<*((float*)&(efAddress[ONLINE_DATA_HEAD+i]))<<endreq;
00713       }
00714       for(int i=ndatap+1;i<ndata;i++){
00715         log << MSG::DEBUG <<i<<"th eff data is " << efAddress[ONLINE_DATA_HEAD+i]<<endreq;
00716       }
00717       return efAddress;
00718     }
00719 
00720     return NULL;
00721     
00722     //FullEventAssembler<EFSrcIdMap> fea ; 
00723 
00725       //FullEventAssembler<EFSrcIdMap>::RODDATA*  EFROD ; 
00726       //EventFormat::SourceID helpEFID(EventFormat::TDAQ_EVENT_FILTER,EventFormat::ROD_TYPE,0);
00727       //uint32_t rodIdEF = helpEFID.source_id(); 
00728   
00729      /* Create the ROD data container to be filled later */
00730      //EFROD  = fea.getRodData( rodIdEF ); 
00731   
00732      //std::vector<uint32_t> efVec(m_efResult->getEFVec());
00733   
00734      //for (std::vector<uint32_t>::iterator i=efVec.begin();
00735       //   i!=efVec.end();++i)
00736       //{
00737       // EFROD->push_back(*i);
00738       // }
00739   
00740   
00743      //Get ByteStreamCnvSvc
00744      
00745       //     StatusCode sc;
00746      
00747      
00748      //Get ByteStreamCnvSvc
00749 //hxt     if(StatusCode::SUCCESS != service("ByteStreamCnvSvc",m_ByteStreamEventAccess)){
00750 //hxt       log << MSG::ERROR << " EFEventLoopMgr:EF_Fragment_Address():Can't get ByteStreamEventAccess interface " << endreq;
00751 //hxt       return NULL;
00752 //hxt     }
00753 
00754     //Obtain the RawEvent
00755     /*
00756     log <<MSG::INFO<< "EFEventLoopMgr:EF_Fragment_Address(): Abans del get RawEvent" << endreq;
00757 
00758     RawEvent* re = m_ByteStreamEventAccess->getRawEvent(); 
00759      
00760     log << MSG::INFO <<"EFEventLoopMgr:EF_Fragment_Address(): Despres del get RawEvent" << endreq;
00761     */
00762      
00763     //fea.fill(re,log); 
00764      
00765      
00766      //To serialize RawEvent and obtain a pointer to the memory address
00767      //where the EF SubdetectorFragment is
00768      
00769      
00770      //Now get SubdetectorFragment from Raw Event
00771      /*
00772      const VDETF& vdetf=re->compounds();
00773      
00774      log << MSG::DEBUG<< " EFEventLoopMgr:EF_Fragment_Address(): Full Event:" << hex << "Full source ID: " << re->header().source_id() <<endreq;
00775      log << MSG::DEBUG<< " EFEventLoopMgr:EF_Fragment_Address(): Fragment size in words:" << re->header().fragment_size_word()<<endreq;
00776      log << MSG::DEBUG<< " EFEventLoopMgr:EF_Fragment_Address(): # of subdetectors:" <<vdetf.size()<<endreq;
00777      
00778      
00779      VDETF::const_iterator it_detf = vdetf.begin(); 
00780      VDETF::const_iterator it_detf_end = vdetf.end();
00781      
00782 
00783      //Loop over all Subdetectors
00784      
00785      for(; it_detf!=it_detf_end; ++it_detf){  
00786        
00787        
00788        
00789        if(!((*it_detf)->is_valid())){
00790          
00791          log<< MSG::ERROR << "EFEventLoopMgr:EF_Fragment_Address():Got invalid subdetector fragment!. A null pointer will be returned" << endreq;
00792          return NULL;
00793        }
00794        
00795        // Get the size of the SubDet fragment in WORDS
00796        int fragSize = (*it_detf)->size_word();
00797        
00798        //Now like in ptdummy::Steering
00799        
00800        
00801        // Create a NEW memory storage (it mallocs a new region in "local" memory)
00802        EventFormat::RawMemoryStorage store(fragSize*4);
00803        
00804        // Serialize the subDetector fragment on the store (on the "local" buffer)
00805        (*it_detf)->serialise(store);
00806        
00807        log << MSG::DEBUG<< " EFEventLoopMgr:EF_Fragment_Address():SubDetectorFragment serialized on 'local memory.'" <<endreq;
00808        
00809        
00810        
00811        // Return to pt::Worker the address (p) of the "local" memory region
00812        // containing the serialized EF fragment
00813        
00814        m_serializedEFAddress=(char*)store.address();
00815        
00816        // Release the ownership of the 'local' memory region containing the
00817        // serialized Fragment (i.e.: exiting from process() the storage distructor
00818        // will not delete this memory region)
00819        // The memory region MUST be deleted by pt::worker !!!
00820        
00821        store.release_memory();
00822      }
00823      return m_serializedEFAddress; 
00824      */     
00825   }
00826 
00827   return NULL;
00828 }

uint32_t EFEventLoopMgr::EF_Total_Energy ( ) [virtual]

return total energy

Implements IEFEventLoopMgr.

Definition at line 592 of file EFEventLoopMgr.cxx.

References EFResult::getEFVec(), Bes_Common::INFO, m_efResult, and msgSvc().

00593 {
00594   MsgStream log( msgSvc(), name() );
00595   uint32_t etot=m_efResult->getEFVec(31);
00596   log << MSG::INFO << "The total energy is " <<*((float*)&etot) <<"GeV"<<endreq;
00597   return etot;
00598 }

uint32_t EFEventLoopMgr::EF_Version ( ) [virtual]

return version number

Implements IEFEventLoopMgr.

Definition at line 566 of file EFEventLoopMgr.cxx.

References Bes_Common::INFO, msgSvc(), and x.

00567 {
00568   MsgStream log( msgSvc(), name() );
00569   uint32_t x=1;
00570   uint32_t y=0;
00571   uint32_t z=0;
00572   uint32_t version=(x<<16)+(y<<8)+z;
00573   log << MSG::INFO << "The version is " <<version << endreq;
00574   return version;
00575 }

StatusCode EFEventLoopMgr::executeEvent ( void * par ) [virtual]

implementation of IEventProcessor::executeEvent(void* par)

Definition at line 249 of file EFEventLoopMgr.cxx.

References RAWEVENT::addReEmcDigi(), RAWEVENT::addReMdcDigi(), RAWEVENT::addReMucDigi(), RAWEVENT::addReTofDigi(), eformat::FullEventFragment< TPointer >::check_tree(), Bes_Common::DEBUG, calibUtil::ERROR, Bes_Common::FATAL, eformat::Header< TPointer >::fragment_size_word(), eformat::get_robs(), getTrigChn(), eformat::FullEventFragment< TPointer >::global_id(), m_efResult, m_evtContext, m_evtDataMgrSvc, m_evtDataSvc, m_evtSelector, m_evtType, m_firstEvent, m_incidentSvc, m_inputSvc, m_re, m_total_nevt, msgSvc(), eformat::Header< TPointer >::nchildren(), EFResult::reset(), RAWEVENT::reset(), eformat::FullEventFragment< TPointer >::run_no(), EFResult::setAnswer(), IRawDataInputSvc::setCurrentEvent(), RAWEVENT::setEventNo(), RAWEVENT::setRunNo(), RAWEVENT::setTime(), deljobs::string, eformat::FullEventFragment< TPointer >::time(), Bes_Common::WARNING, and ers::Issue::what().

00250 {
00251   
00252   StatusCode        sc;
00253   DataObject*       pObject = 0;
00254   MsgStream log( msgSvc(), name() );
00255   //return StatusCode::SUCCESS;
00256   //log << MSG::DEBUG << "EFEventLoopMgr:executeEvent(void* par):Declaring  Fragment" << endreq;
00257   //if(pBesTimer&&m_timeTest==1){
00258   //    pBesTimer->start();
00259   //    pStart=true;
00260       //cout<<"time test: start!!!!!!!!!!!!!!!!!!!"<<endl;
00261   //}
00262   if(m_firstEvent){
00263     m_re = new RAWEVENT;
00264     m_firstEvent=false;
00265   }
00266   else{
00267     m_re->reset();
00268   }
00269 
00270   eformat::FullEventFragment<uint32_t*> pre((uint32_t*)par);
00271   try {
00272     pre.check_tree();
00273   }
00274   catch (eformat::Issue& ex) {
00275     std::cerr << std::endl
00276       << "Uncaught eformat issue: " << ex.what() << std::endl;
00277     return StatusCode::FAILURE ;
00278   }
00279   catch (ers::Issue& ex) {
00280     std::cerr << std::endl
00281       << "Uncaught ERS issue: " << ex.what() << std::endl;
00282     return StatusCode::FAILURE ;
00283   }
00284   catch (std::exception& ex) {
00285     std::cerr << std::endl
00286       << "Uncaught std exception: " << ex.what() << std::endl;
00287     return StatusCode::FAILURE ;
00288   }
00289   catch (...) {
00290     std::cerr << std::endl << "Uncaught unknown exception" << std::endl;
00291     return StatusCode::FAILURE ;
00292   }
00293   
00294   log << MSG::DEBUG << "[Event No. #" << pre.global_id()
00295             << "] " << pre.fragment_size_word() << " words in "
00296             << pre.nchildren() << " subdetectors "
00297             << endreq;
00298 
00299   m_re->setRunNo(pre.run_no());
00300   m_re->setEventNo(pre.global_id());
00301   m_re->setTime(pre.time());
00302 
00303   uint32_t *robs[100];
00304   int nrobs = eformat::get_robs((uint32_t*)par, (const uint32_t **)robs, 100);
00305   if(nrobs>100) log<<MSG::ERROR<< "ROBFragments' number exceeds than 100!"<<endreq;
00306 
00307   for (int robi = 0; robi < nrobs; robi++) {
00308     eformat::ROBFragment<uint32_t*> rob(robs[robi]);
00309     uint32_t status= rob.rod_detev_type();
00310     uint32_t sourceid = rob.rod_source_id();
00311     if((status&0x2)&&(sourceid!=0xa50000)) {
00312       std::string answer="Error";
00313       m_efResult->reset();
00314       m_evtType->reset();
00315       m_evtType->setAnswer(answer);
00316       log << MSG::DEBUG << "detector status is "<<status<<endreq;
00317       //delete m_re;
00318       return StatusCode::SUCCESS;
00319     }
00320   }
00321 
00322   bool trg=false;
00323   for (int robi = 0; robi < nrobs; robi++) {
00324     eformat::ROBFragment<uint32_t*> rob(robs[robi]);
00325     uint32_t* dataptr = NULL;
00326     rob.rod_data(dataptr);
00327     vector<uint32_t> DetElements(dataptr, (dataptr+rob.rod_ndata()));
00328 
00329     uint32_t source_id_number = rob.rod_source_id();
00330     //std::cout<<"#####source_id_number#####"<<source_id_number<<std::endl;
00331     source_id_number <<= 8;
00332     source_id_number >>= 24;
00333     //std::cout<<"#####(source_id_number<<24)>>29#####"<<source_id_number<<std::endl;
00334     //be careful here!!!
00335     log<<MSG::DEBUG<< source_id_number << " Digi size="<<DetElements.size()<<endreq;
00336     switch(source_id_number)   
00337     {
00338       case 161:
00339         m_re->addReMdcDigi(dataptr,DetElements.size());
00340         //if(DetElements.size()>0)std::cout<<hex<<DetElements[0]<<std::endl;
00341         break;
00342       case 163:
00343         m_re->addReEmcDigi(dataptr,DetElements.size());
00344         break;
00345       case 162:
00346         //std::cout<<"EFEventLoopMgr::TOFDigi size="<<DetElements.size()<<std::endl;
00347         m_re->addReTofDigi(dataptr,DetElements.size());
00348         break;
00349       case 164:
00350         //std::cout<<"EFEventLoopMgr::MUCDigi size="<<DetElements.size()<<std::endl;
00351         m_re->addReMucDigi(dataptr,DetElements.size());
00352         break;
00353       case 165:
00354         trg=getTrigChn(dataptr,rob.rod_ndata());
00355         break;
00356       default:
00357         //std::cerr << "no such subdetector type!" << std::endl;
00358         break;
00359     }
00360     if(trg){
00361       std::string answer="RandomTrg";
00362       m_efResult->reset();
00363       m_evtType->reset();
00364       m_evtType->setAnswer(answer);
00365       log << MSG::DEBUG << "a random trigger event is taken" << endreq;
00366       m_re->reset();
00367       return StatusCode::SUCCESS;
00368     }
00369   }
00370   //if(pBesTimer&&m_timeTest==2){
00371   //    pBesTimer->start();
00372   //    pStart=true;
00373       //cout<<"time test: start!!!!!!!!!!!!!!!!!!!"<<endl;
00374   //}
00375   if(!(m_inputSvc->setCurrentEvent(m_re))) {
00376     log << MSG::FATAL << "m_inputSvc->setCurrentEvent(m_re) Failed!" << endreq;
00377     exit(1);
00378   }
00379 
00380   if( 0 != m_total_nevt ) {
00381      sc = m_evtDataMgrSvc->clearStore();
00382      if( !sc.isSuccess() )  {
00383         log << MSG::DEBUG << "Clear of Event data store failed" << endreq;
00384      }
00385   }
00386   /*
00387   if( m_evtContext ) {
00388     IOpaqueAddress* addr = 0;
00389     sc = getEventRoot(addr);
00390     if( !sc.isSuccess() ) {
00391       log << MSG::INFO << "No more events in event selection " << endreq;
00392       return StatusCode::FAILURE;
00393     }
00394     sc = m_evtDataMgrSvc->setRoot ("/Event", addr);
00395     if( !sc.isSuccess() ) {
00396       log << MSG::WARNING << "Error declaring event root address." << endreq;
00397       return StatusCode::FAILURE;
00398     }
00399     SmartDataPtr<Event::EventHeader> evt(m_evtDataSvc,"/Event/EventHeader");
00400     if(!evt) {
00401       sc = m_evtDataMgrSvc->registerAddress ("/Event/EventHeader", addr);
00402       if( !sc.isSuccess() ) {
00403         log << MSG::WARNING << "Error register EventHeader address." << endreq;
00404       }
00405     }
00406     sc = m_evtDataSvc->retrieveObject("/Event", pObject);
00407     if( !sc.isSuccess() ) {
00408       log << MSG::WARNING << "Unable to retrieve Event root object" << endreq;
00409       return StatusCode::FAILURE;
00410     }
00411   }
00412   else {
00413     sc = m_evtDataMgrSvc->setRoot ("/Event", new DataObject());
00414     if( !sc.isSuccess() ) {
00415       log << MSG::WARNING << "Error declaring event root DataObject" << endreq;
00416     }
00417   }
00418   */
00419 
00420   // Create event address in the event store
00421   //IOpaqueAddress* addr = new RawDataAddress(CLID_Event, "EventHeader", "EventHeader");
00422   IOpaqueAddress* addr = 0;
00423   sc = m_evtSelector->createAddress(*m_evtContext,addr);
00424   if( !sc.isSuccess() ) {
00425     log << MSG::WARNING << "Error creating IOpaqueAddress." << endreq;
00426     return sc;
00427   }
00428   // Set root clears the event data store first
00429   sc = m_evtDataMgrSvc->setRoot ("/Event", addr);
00430   if( !sc.isSuccess() )  {
00431     log << MSG::WARNING << "Error declaring event root address." << endreq;
00432     return sc;
00433   }
00434   sc = m_evtDataSvc->retrieveObject("/Event", pObject);
00435   if( !sc.isSuccess() ) {
00436     log << MSG::WARNING << "Unable to retrieve Event root object" << endreq;
00437     return sc;
00438   }
00439   
00440   m_total_nevt++;
00441   // Fire BeginEvent "Incident"
00442   m_incidentSvc->fireIncident(Incident(name(), "BeginEvent"));
00443   // Execute Algorithms
00444   sc = MinimalEventLoopMgr::executeEvent(NULL);
00445   // Fire EndEvent "Incident"
00446   m_incidentSvc->fireIncident(Incident(name(), "EndEvent"));
00447         
00448   //if(pBesTimer){
00449   //   pBesTimer->stop();
00450   //   double time=pBesTimer->elapsed();
00451   //   std::cout<<"Run time="<<time<<std::endl;
00452   //}
00453   //delete addr;
00454   //delete m_re;
00455   return sc;
00456 }

StatusCode EFEventLoopMgr::finalize ( ) [virtual]

implementation of IAppMgrUI::finalize

Definition at line 223 of file EFEventLoopMgr.cxx.

References Bes_Common::INFO, m_evtContext, m_evtDataMgrSvc, m_evtDataSvc, m_evtSelector, m_histoPersSvc, m_incidentSvc, m_total_nevt, and msgSvc().

00224 {
00225   MsgStream log(msgSvc(), name());
00226   log << MSG::INFO << " EFEventLoopMgr:finalize():Number of events processed : " << m_total_nevt << endreq;
00227 
00228   if ( m_evtSelector && m_evtContext )   {
00229      m_evtSelector->releaseContext(m_evtContext);
00230      m_evtContext = 0;
00231   }
00232 
00233   m_histoPersSvc    = releaseInterface(m_histoPersSvc);
00234 
00235   m_evtSelector   = releaseInterface(m_evtSelector);
00236   m_incidentSvc   = releaseInterface(m_incidentSvc);
00237   m_evtDataSvc      = releaseInterface(m_evtDataSvc);
00238   m_evtDataMgrSvc   = releaseInterface(m_evtDataMgrSvc);
00239   StatusCode sc = MinimalEventLoopMgr::finalize();
00240    
00241   return sc;
00242 }

StatusCode EFEventLoopMgr::getEventRoot ( IOpaqueAddress *& refpAddr )

Create event address using event selector.

Definition at line 459 of file EFEventLoopMgr.cxx.

References m_evtContext, m_evtSelector, msgSvc(), and Bes_Common::WARNING.

00459                                                                   {
00460   refpAddr = 0;
00461   StatusCode sc = m_evtSelector->next(*m_evtContext);
00462   if ( !sc.isSuccess() )  {
00463     return sc;
00464   }
00465   // Create root address and assign address to data service
00466   sc = m_evtSelector->createAddress(*m_evtContext,refpAddr);
00467   if( !sc.isSuccess() )  {
00468     sc = m_evtSelector->next(*m_evtContext);
00469     if ( sc.isSuccess() )  {
00470       sc = m_evtSelector->createAddress(*m_evtContext,refpAddr);
00471       if ( !sc.isSuccess() )  {
00472         MsgStream log( msgSvc(), name() );
00473         log << MSG::WARNING << "Error creating IOpaqueAddress." << endreq;
00474       }
00475     }
00476   }
00477   return sc;
00478 }

bool EFEventLoopMgr::getTrigChn	(	uint32_t *	data,
		uint32_t	ndata
	)			`[virtual]`

whether it is a RrandomTrg

Implements IEFEventLoopMgr.

Definition at line 830 of file EFEventLoopMgr.cxx.

References Bes_Common::DEBUG, Bes_Common::FATAL, ganga-rec::j, m_trgType, msgSvc(), and delete_small_size::size.

Referenced by executeEvent().

00830                                                              {
00831   MsgStream log( msgSvc(), name() );
00832   log << MSG::DEBUG << ndata<<":"<<(*data)<<","<<endreq;
00833   uint32_t index = 0;
00834 
00835   while (ndata - index > 1) {
00836     uint32_t header= *(data+index);
00837     uint32_t blockSize = ( (header>>14) & 0x3FF);
00838     uint32_t id = (header>>24);
00839     //std::cout << "TriggerChannel:" << hex<<header << "==>" << blockSize<<","<<id
00840     //        << ","<<((header >> 8)  & 0x3F) << dec<<std::endl;
00841     if (blockSize == 0 || (index+blockSize) > ndata) break;
00842     if (id==0xD3) {
00843       uint32_t window = ((header >> 8)  & 0x3F); //Time window, bit8 to bit13, total: 0--31
00844       uint32_t size= blockSize-1;
00845       if(window==0){
00846         log << MSG::FATAL << "window=0" << endreq;
00847         //return false;
00848       }
00849       else if(size%window != 0) {
00850         log << MSG::FATAL << "GTL data is NOT completed" << endreq;
00851         //return false;
00852       }
00853       //vector<uint32_t> trigData(data+index+1, data+index+size);
00854       for(uint32_t j = 0; j < size; j++) {
00855         uint32_t trgdata = *(data+index+1+j);
00856         uint32_t dataId = ((trgdata >> 24) & 0x7);
00857         //std::cout <<hex<< trgdata << "==>"<< dataId <<","  << (trgdata&0xFFFFFF)<<dec<<std::endl;
00858         if(dataId!=5) continue;
00859         //std::cout <<hex<< trgdata <<dec<<std::endl;
00860         m_trgType= m_trgType|(trgdata&0xFFFF);
00861         if(trgdata&(1<<9)) return true;
00862         //if(trgdata&(1<<8)) return true;
00863         //if(trgdata&(1<<10)) return true;
00864       }
00865     }
00866     index += blockSize;
00867   }
00868   //cout<<m_trgType<<endl;
00869 
00870   return false;
00871 }

StatusCode EFEventLoopMgr::initialize ( ) [virtual]

implementation of IAppMgrUI::initalize

Definition at line 95 of file EFEventLoopMgr.cxx.

References calibUtil::ERROR, Bes_Common::FATAL, HltStoreSvc::get(), Bes_Common::INFO, m_efResult, m_evtContext, m_evtDataMgrSvc, m_evtDataSvc, m_evtsel, m_evtSelector, m_evtType, m_HltStoreSvc, m_incidentSvc, m_inputSvc, m_timeTest, msgSvc(), and Bes_Common::WARNING.

00096 {
00097   MsgStream log(msgSvc(), name());
00098   // initialize the base class
00099   cout << "EFEventLoopMgr::initialize()   there are " << m_topAlgList.size() << " topAlg now" << endl;
00100   StatusCode sc = MinimalEventLoopMgr::initialize();  
00101   // leave this after initialization of base class, otherwise msgSvc is not correctly set up
00102   //            -----
00103   log << MSG::INFO << "EFEventLoopMgr:initalize(): ---> EventLoopMgr = " << name() << " initializing " << endreq;
00104   if ( !sc.isSuccess() ) {
00105       log << MSG::ERROR
00106           << "EFEventLoopMgr:initalize():Failed to initialize base class MinimalEventLoopMgr"
00107           << endreq;
00108       return sc;
00109   }
00110   // Setup access to event data services
00111   sc = serviceLocator()->service("EventDataSvc", m_evtDataMgrSvc, true);
00112   if( !sc.isSuccess() )  {
00113     log << MSG::FATAL << "Error retrieving EventDataSvc interface IDataManagerSvc." << endreq;
00114     return sc;
00115   }
00116   sc = serviceLocator()->service("EventDataSvc", m_evtDataSvc, true);
00117   if( !sc.isSuccess() )  {
00118     log << MSG::FATAL << "Error retrieving EventDataSvc interface IDataProviderSvc." << endreq;
00119     return sc;
00120   }
00121   //-------------------------------------------------------------------------------
00122   // Get the references to the services that are needed by the ApplicationMgr itself
00123   //--------------------------------------------------------------------------------
00124   sc = serviceLocator()->service("IncidentSvc" , m_incidentSvc, true);
00125  
00126   if( !sc.isSuccess() ) {
00127       log << MSG::FATAL << "EFEventLoopMgr:initalize():Error retrieving IncidentSvc"  << endreq;
00128       return sc;
00129   }
00130   
00131   //-------------------------------------------------------------------------------
00132   // Get the references to the services that are needed by the ApplicationMgr itself
00133   //--------------------------------------------------------------------------------
00134   sc = serviceLocator()->service("HltStoreSvc" , m_HltStoreSvc, true);
00135   if( !sc.isSuccess() ) {
00136       log << MSG::FATAL << "EFEventLoopMgr:initalize():Error retrieving HltStoreSvc"  << endreq;
00137       return sc;
00138   }
00139 
00140   //--------------------------------------------------------------------------
00141   // Access Property Manager interface:
00142   //--------------------------------------------------------------------------
00143   SmartIF<IProperty> prpMgr(serviceLocator());
00144   if ( !prpMgr.isValid() ) {
00145       log << MSG::FATAL 
00146           << "EFEventLoopMgr:initalize():IProperty interface not found in ApplicationMgr." 
00147           << endreq;
00148       return StatusCode::FAILURE;
00149   }
00150   
00151   //-------------------------------------------------------------------------
00152   // Setup Event Setector
00153   //-------------------------------------------------------------------------
00154   // We do not expect a Event Selector necessarily being declared
00155   setProperty(prpMgr->getProperty("EvtSel"));
00156   
00157   if( m_evtsel != "NONE" || m_evtsel.length() == 0) {
00158 
00159     sc = serviceLocator()->service( "EventSelector" , m_evtSelector, true );
00160     if( sc.isSuccess() ) {  // Setup Event Selector
00161       sc=m_evtSelector->createContext(m_evtContext);
00162       if( !sc.isSuccess() )   {
00163         log << MSG::FATAL << "Can not create the event selector Context." << endreq;
00164         return sc;
00165       }
00166     } else {
00167       log << MSG::FATAL << "EFEventLoopMgr:initalize():EventSelector  not found." << endreq;
00168       return StatusCode::FAILURE;
00169     }
00170   } else {
00171     m_evtSelector = 0;
00172     m_evtContext = 0;
00173     log << MSG::WARNING 
00174         << "EFEventLoopMgr:initalize():No service \"EventSelector\" provided : assume \"online\" running "
00175         << endreq;  
00176   }
00177   //--------------------------------------------------------------------
00178   // Get the RawDataInputSvc
00179   //--------------------------------------------------------------------
00180   IService* svc ;
00181   sc = serviceLocator()->getService("RawDataInputSvc", svc); 
00182   if(sc != StatusCode::SUCCESS ) {
00183     log<<MSG::WARNING << " Cant get RawDataInputSvc " <<endreq;
00184     return sc ;
00185   }
00186   
00187   m_inputSvc = dynamic_cast<IRawDataInputSvc*> (svc); 
00188   if(m_inputSvc == 0 ) {
00189     log<<MSG::WARNING << " Cant cast to  RawDataInputSvc " <<endreq; 
00190     return StatusCode::FAILURE ;
00191   }
00192 
00193   sc = m_HltStoreSvc->get("EventType", m_evtType);
00194   if ( sc.isFailure() ) {
00195     log << MSG::ERROR << "Could not find EventType" << endreq;
00196     return StatusCode::FAILURE ;
00197   }
00198   sc = m_HltStoreSvc->get("EFResult", m_efResult);
00199   if ( sc.isFailure() ) {
00200     log << MSG::ERROR << "Could not find EFResult" << endreq;
00201     return StatusCode::FAILURE ;
00202   }
00203   //cout <<"000000000000000000000000000000 "<<m_timeTest<<endl;
00204   if(m_timeTest){
00205      //cout <<"111111111111111111111111111111111111"<<endl;
00206      //IBesTimerSvc* timerSvc;    
00207      //sc = service( "BesTimerSvc", timerSvc);
00208      //if( sc.isFailure() ) {
00209      //   log << MSG::WARNING << ": Unable to locate BesTimer Service" << endreq;
00210      //}
00211      //else{
00212         //cout <<"222222222222222222222222222222222222222"<<endl;
00213      // pBesTimer=timerSvc->addItem("EventFilterHandler");
00214      //   if(pBesTimer)pBesTimer->propName("nEventFilterHandler");
00215      //}
00216   }
00217   return StatusCode::SUCCESS;
00218 }

static const InterfaceID& IEFEventLoopMgr::interfaceID ( ) [inline, static, inherited]

Retrieve interface ID.

Definition at line 14 of file IEFEventLoopMgr.h.

References IID_IEFEventLoopMgr().

Referenced by queryInterface().

00014 { return IID_IEFEventLoopMgr; }

StatusCode EFEventLoopMgr::prepareForRun ( int ef_run_number ) [virtual]

prepare for run step

Implements IEFEventLoopMgr.

Definition at line 497 of file EFEventLoopMgr.cxx.

References Bes_Common::DEBUG, m_currentRun, m_incidentSvc, msgSvc(), and Bes_Common::WARNING.

00498 {
00499   MsgStream log( msgSvc(), name() );
00500   StatusCode sc;
00501   int run_num = ef_run_number;
00502   log << MSG::DEBUG << " ---> EFprepareForRun::Received run number from PT = " 
00503       << run_num << endreq;
00504   
00505   log << MSG::DEBUG 
00506       << " ---> EFprepareForRun::Setup IOVSvc for run number = " 
00507       << run_num << endreq;
00508   const EventInfo* pEvent = new EventInfo(new EventID(run_num,0), new EventType());
00509 
00510   if(m_currentRun!=run_num){
00511     m_incidentSvc-> fireIncident(Incident(name(),"NewRun"));
00512     m_currentRun = run_num;
00513   }
00514   m_incidentSvc-> fireIncident(Incident(name(),"BeginRun"));
00515   ListAlg::iterator ita;
00516   bool failed = false;
00517   for (ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ita++ ) {
00518     sc = (*ita)->sysBeginRun();
00519     if( !sc.isSuccess() ) {
00520       log << MSG::WARNING << "beginRun() of algorithm " << (*ita)->name() << " failed" << endmsg;
00521       failed = true; 
00522     }
00523   }
00524   //hxt sc = m_StoreGateSvc->record(pEvent,"");
00525   if(failed) return StatusCode::FAILURE;
00526   else       return StatusCode::SUCCESS;
00527 }

StatusCode EFEventLoopMgr::queryInterface	(	const InterfaceID &	riid,
		void **	ppvInterface
	)			`[virtual]`

implementation of IInterface: queryInterface

Definition at line 483 of file EFEventLoopMgr.cxx.

References IEFEventLoopMgr::interfaceID().

00483                                                                                         {
00484   if ( IEFEventLoopMgr::interfaceID().versionMatch(riid) )  {
00485     *ppvInterface = (IEFEventLoopMgr*)this;
00486   }
00487   else  {
00488     return MinimalEventLoopMgr::queryInterface(riid, ppvInterface);
00489   }
00490   addRef();
00491   return StatusCode::SUCCESS;
00492 }