00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #define GAUDISVC_EFEVENTLOOPMGR_CPP
00014 #include <stdlib.h>
00015
00016 #include "GaudiKernel/IAlgorithm.h"
00017 #include "GaudiKernel/SmartIF.h"
00018 #include "GaudiKernel/Incident.h"
00019 #include "GaudiKernel/MsgStream.h"
00020 #include "GaudiKernel/DataSelectionAgent.h"
00021 #include "GaudiKernel/DataObject.h"
00022 #include "GaudiKernel/IIncidentSvc.h"
00023 #include "GaudiKernel/IEvtSelector.h"
00024 #include "GaudiKernel/IDataManagerSvc.h"
00025 #include "GaudiKernel/IDataProviderSvc.h"
00026 #include "GaudiKernel/IConversionSvc.h"
00027 #include "GaudiKernel/ThreadGaudi.h"
00028 #include "GaudiKernel/SmartDataPtr.h"
00029 #include "GaudiKernel/IAlgManager.h"
00030
00031 #include "HltDataTypes/EventIncident.h"
00032 #include "HltDataTypes/EventInfo.h"
00033 #include "HltDataTypes/EventID.h"
00034 #include "HltDataTypes/EventType.h"
00035 #include "HltDataTypes/EFResult.h"
00036
00037
00038 #include "EventModel/EventModel.h"
00039 #include "EventModel/Event.h"
00040 #include "EventModel/EventHeader.h"
00041
00042 #include "EFServices/EFEventLoopMgr.h"
00043
00044 #include "eformat/eformat.h"
00045
00046
00047 #include "RawDataCnv/EventManagement/RAWEVENT.h"
00048 #include "RawDataCnv/RawDataAddress.h"
00049
00050 extern const CLID& CLID_Event;
00051
00052
00053
00054 EFEventLoopMgr::EFEventLoopMgr(const std::string& nam,
00055 ISvcLocator* svcLoc)
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 }
00077
00078
00079
00080
00081 EFEventLoopMgr::~EFEventLoopMgr()
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 }
00091
00092
00093
00094
00095 StatusCode EFEventLoopMgr::initialize()
00096 {
00097 MsgStream log(msgSvc(), name());
00098
00099 cout << "EFEventLoopMgr::initialize() there are " << m_topAlgList.size() << " topAlg now" << endl;
00100 StatusCode sc = MinimalEventLoopMgr::initialize();
00101
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
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
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
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
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
00153
00154
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() ) {
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
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
00204 if(m_timeTest){
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216 }
00217 return StatusCode::SUCCESS;
00218 }
00219
00220
00221
00222
00223 StatusCode EFEventLoopMgr::finalize()
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 }
00243
00244
00245
00246
00247
00248
00249 StatusCode EFEventLoopMgr::executeEvent(void* par)
00250 {
00251
00252 StatusCode sc;
00253 DataObject* pObject = 0;
00254 MsgStream log( msgSvc(), name() );
00255
00256
00257
00258
00259
00260
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
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
00331 source_id_number <<= 8;
00332 source_id_number >>= 24;
00333
00334
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
00341 break;
00342 case 163:
00343 m_re->addReEmcDigi(dataptr,DetElements.size());
00344 break;
00345 case 162:
00346
00347 m_re->addReTofDigi(dataptr,DetElements.size());
00348 break;
00349 case 164:
00350
00351 m_re->addReMucDigi(dataptr,DetElements.size());
00352 break;
00353 case 165:
00354 trg=getTrigChn(dataptr,rob.rod_ndata());
00355 break;
00356 default:
00357
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
00371
00372
00373
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
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421
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
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
00442 m_incidentSvc->fireIncident(Incident(name(), "BeginEvent"));
00443
00444 sc = MinimalEventLoopMgr::executeEvent(NULL);
00445
00446 m_incidentSvc->fireIncident(Incident(name(), "EndEvent"));
00447
00448
00449
00450
00451
00452
00453
00454
00455 return sc;
00456 }
00457
00459 StatusCode EFEventLoopMgr::getEventRoot(IOpaqueAddress*& refpAddr) {
00460 refpAddr = 0;
00461 StatusCode sc = m_evtSelector->next(*m_evtContext);
00462 if ( !sc.isSuccess() ) {
00463 return sc;
00464 }
00465
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 }
00479
00480
00481
00482
00483 StatusCode EFEventLoopMgr::queryInterface(const InterfaceID& riid, void** ppvInterface) {
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 }
00493
00494
00495
00496
00497 StatusCode EFEventLoopMgr::prepareForRun(int ef_run_number)
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
00525 if(failed) return StatusCode::FAILURE;
00526 else return StatusCode::SUCCESS;
00527 }
00528
00529
00530
00531
00532
00533 std::string EFEventLoopMgr::EF_Decision()
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
00552
00553
00554
00555
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 }
00565
00566 uint32_t EFEventLoopMgr::EF_Version()
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 }
00576 uint32_t EFEventLoopMgr::EF_Algorithm_Tag()
00577 {
00578 MsgStream log( msgSvc(), name() );
00579 uint32_t alg=m_efResult->getEFVec(0);
00580
00581 int itype=m_evtType->getMidAnswerIndex();
00582
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 }
00591
00592 uint32_t EFEventLoopMgr::EF_Total_Energy()
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 }
00599
00600 uint32_t* EFEventLoopMgr::EF_Fragment_Address()
00601 {
00602
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
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;
00631
00632 uint32_t* efAddress=new uint32_t[ndata+ONLINE_DATA_HEAD+ONLINE_DATA_TAIL];
00633
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
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
00723
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825 }
00826
00827 return NULL;
00828 }
00829
00830 bool EFEventLoopMgr::getTrigChn(uint32_t* data, uint32_t ndata){
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
00840
00841 if (blockSize == 0 || (index+blockSize) > ndata) break;
00842 if (id==0xD3) {
00843 uint32_t window = ((header >> 8) & 0x3F);
00844 uint32_t size= blockSize-1;
00845 if(window==0){
00846 log << MSG::FATAL << "window=0" << endreq;
00847
00848 }
00849 else if(size%window != 0) {
00850 log << MSG::FATAL << "GTL data is NOT completed" << endreq;
00851
00852 }
00853
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
00858 if(dataId!=5) continue;
00859
00860 m_trgType= m_trgType|(trgdata&0xFFFF);
00861 if(trgdata&(1<<9)) return true;
00862
00863
00864 }
00865 }
00866 index += blockSize;
00867 }
00868
00869
00870 return false;
00871 }