#include <BesTrigL1.h>
Public Member Functions | |
BesTrigL1 (const std::string &name, ISvcLocator *pSvcLocator) | |
Standard constructor. | |
virtual | ~BesTrigL1 () |
virtual StatusCode | initialize () |
Destructor Algorithm initialization. | |
virtual StatusCode | execute () |
Algorithm execution. | |
virtual StatusCode | finalize () |
Algorithm finalization. | |
void | findSETime (multimap< int, uint32_t, less< int > > mdc_hitmap, multimap< int, int, less< int > > tof_hitmap, multimap< int, uint32_t, less< int > > emc_TC, double &stime, double &etime) |
void | runAclock_mdc (int iclock, double stime, multimap< int, uint32_t, less< int > > mdc_hitmap) |
void | runAclock_tof (int iclock, double stime, int &idle_status, std::multimap< int, int, less< int > > tof_hitmap) |
void | runAclock_emc (int iclock, double stime, std::multimap< int, uint32_t, less< int > > emc_TC, EmcWaveform *blockWave) |
void | getEmcAnalogSig (EmcDigiCol *emcDigiCol, EmcWaveform(&blockWave)[16], multimap< int, uint32_t, less< int > > &emc_TC) |
void | findEmcPeakTime (double &peak_time, EmcWaveform *blockWave) |
void | stretchTrgCond (int nclock, int **&trgcond) |
void | trgSAFDelay (int nclock, int **&trgcond) |
void | trgGTLDelay (int nclock, int **&trgcond) |
Private Attributes | |
double | hit9 [76] |
double | hit10 [76] |
double | hit11 [88] |
double | hit12 [88] |
double | hit13 [100] |
double | hit14 [100] |
double | hit15 [112] |
double | hit16 [112] |
double | hit17 [128] |
double | hit18 [128] |
double | hit19 [140] |
double | hit20 [140] |
double | hit37 [256] |
double | hit38 [256] |
double | hit39 [256] |
double | hit40 [256] |
BesGlobalTrigSvc * | m_pIBGT |
IBesGlobalTrigSvc * | m_tmpSvc |
IRawDataProviderSvc * | m_rawDataProviderSvc |
IMdcGeomSvc * | m_MdcGeomSvc |
RealizationSvc * | m_RealizationSvc |
IEmcCalibConstSvc * | emcCalibConstSvc |
MdcTSF * | m_MdcTSF |
TofHitCount * | m_TofHitCount |
EmcTCFinder * | m_emcDigi |
MucTrigHit * | m_mucDigi |
ifstream | readin |
ofstream | readout |
ifstream | mdc_hit |
std::string | input |
std::string | output |
std::string | outEvtId |
std::string | indexfile |
bool | mTrigRootFlag |
int | m_runMode |
bool | ifpass |
int | passNo |
int | writeFile |
int | ifoutEvtId |
int | totalEvent |
int | totalTracks |
int | clock_shift |
NTuple::Tuple * | m_tuple |
NTuple::Item< float > | m_wire_x |
NTuple::Item< float > | m_wire_y |
NTuple::Item< long > | m_wire_evtId |
NTuple::Item< long > | m_delta_tdc |
NTuple::Tuple * | m_tuple1 |
NTuple::Item< long > | m_RunId |
NTuple::Item< long > | m_EventId |
NTuple::Item< float > | m_mc_totE_all |
NTuple::Item< float > | m_data_totE_all |
NTuple::Item< float > | m_wetotE |
NTuple::Item< float > | m_eetotE |
NTuple::Item< long > | m_data_wetotE |
NTuple::Item< long > | m_data_eetotE |
NTuple::Item< long > | m_index_btc |
NTuple::Array< float > | m_btc_e |
NTuple::Array< long > | m_data_btc |
NTuple::Item< long > | m_cond_id |
NTuple::Array< long > | m_mc_cond |
NTuple::Array< long > | m_data_cond |
NTuple::Item< long > | m_block_id |
NTuple::Array< float > | m_mc_blockE |
NTuple::Array< float > | m_data_blockE |
NTuple::Array< float > | m_R_blockE |
NTuple::Tuple * | m_tuple2 |
NTuple::Item< long > | m_index2 |
NTuple::Array< long > | m_fireLayer |
NTuple::Item< long > | m_index3 |
NTuple::Array< long > | m_hitLayer |
NTuple::Item< long > | m_index4 |
NTuple::Array< long > | m_hitSeg |
NTuple::Item< long > | m_index5 |
NTuple::Array< float > | m_costheta |
NTuple::Array< float > | m_phi |
NTuple::Array< float > | m_p |
NTuple::Array< float > | m_pdgcode |
NTuple::Item< long > | m_index6 |
NTuple::Array< float > | m_hitphi |
NTuple::Item< long > | m_nlayerEE |
NTuple::Item< long > | m_nlayerBR |
NTuple::Item< long > | m_nlayerWE |
NTuple::Item< long > | m_nlayerTotal |
NTuple::Item< long > | m_nhitEE |
NTuple::Item< long > | m_nhitWE |
NTuple::Item< long > | m_nhitBR |
NTuple::Item< long > | m_nhitTotal |
NTuple::Item< float > | m_mumcostheta |
NTuple::Item< float > | m_mumphi |
NTuple::Item< long > | m_trackfindall |
NTuple::Item< long > | m_trackfind3l |
NTuple::Item< long > | m_trackb |
NTuple::Item< long > | m_tracke |
NTuple::Item< long > | m_ntrack1 |
NTuple::Item< long > | m_ntrack2 |
NTuple::Item< long > | m_ntrack3 |
NTuple::Item< long > | m_ngoodevent |
NTuple::Item< long > | m_ngoodtrack |
NTuple::Tuple * | m_tuple3 |
NTuple::Item< long > | m_evtId |
NTuple::Item< long > | m_condNOne [48] |
NTuple::Item< long > | m_condNZero [48] |
int | nEvent |
ITHistSvc * | m_thistsvc |
TH1F * | m_trigCondi_MC |
TH1F * | m_trigCondi_Data |
TrigTOFT * | toftrig |
Definition at line 35 of file BesTrigL1.h.
BesTrigL1::BesTrigL1 | ( | const std::string & | name, | |
ISvcLocator * | pSvcLocator | |||
) |
Standard constructor.
Definition at line 57 of file BesTrigL1.cxx.
References clock_shift, ifoutEvtId, input, m_runMode, mTrigRootFlag, nEvent, outEvtId, output, and writeFile.
00057 : 00058 Algorithm(name, pSvcLocator), m_pIBGT(0),passNo(0) 00059 { 00060 declareProperty("WriteFile", writeFile=0); 00061 declareProperty("IfOutEvtId",ifoutEvtId=0); 00062 declareProperty("Input",input="boost.dat"); 00063 declareProperty("Output",output="boostOut.dat"); 00064 declareProperty("OutEvtIdFile",outEvtId="evtId.dat"); 00065 declareProperty("TrigRootFlag", mTrigRootFlag=false); 00066 declareProperty("RunMode", m_runMode=1); 00067 declareProperty("ClockShift", clock_shift=0); 00068 nEvent = 0; 00069 }
virtual BesTrigL1::~BesTrigL1 | ( | ) | [inline, virtual] |
StatusCode BesTrigL1::execute | ( | ) | [virtual] |
Algorithm execution.
Definition at line 281 of file BesTrigL1.cxx.
References TofID::barrel_ec(), Bes_Common::DEBUG, calibUtil::ERROR, Bes_Common::FATAL, findEmcPeakTime(), findSETime(), getEmcAnalogSig(), BesGlobalTrigSvc::getEmcClusId(), BesGlobalTrigSvc::getEmcEETotE(), BesGlobalTrigSvc::getEmcTotE(), BesGlobalTrigSvc::getEmcWETotE(), BesGlobalTrigSvc::getIfpass(), BesGlobalTrigSvc::getMdcLtrkId(), BesGlobalTrigSvc::getMdcStrkId(), MucTrigHit::getMucDigi(), BesGlobalTrigSvc::getMuchitLayer(), BesGlobalTrigSvc::getMuchitSeg(), BesGlobalTrigSvc::getMuclayerSeg(), BesGlobalTrigSvc::getTofHitPos(), BesGlobalTrigSvc::getTrigChan(), BesGlobalTrigSvc::getTrigCond(), BesGlobalTrigSvc::GlobalTrig(), genRecEmupikp::i, ifoutEvtId, ifpass, imag(), Bes_Common::INFO, input, iter(), ganga-rec::j, TofID::layer(), MdcID::layer(), m_cond_id, m_condNOne, m_condNZero, m_data_cond, m_eetotE, m_EventId, m_evtId, m_fireLayer, m_hitLayer, m_hitSeg, m_index2, m_index3, m_index4, m_mc_cond, m_mc_totE_all, m_mucDigi, m_ntrack1, m_ntrack2, m_ntrack3, m_pIBGT, m_rawDataProviderSvc, m_RunId, m_runMode, m_trigCondi_Data, m_trigCondi_MC, m_tuple1, m_tuple3, m_wetotE, msgSvc(), mTrigRootFlag, nEvent, outEvtId, output, passNo, TofID::phi_module(), TofData::quality(), readin, readout, runAclock_emc(), runAclock_mdc(), runAclock_tof(), BesGlobalTrigSvc::setTrigCond(), BesGlobalTrigSvc::setTrigCondition(), delete_small_size::size, stretchTrgCond(), TofData::tdc1(), TofData::tdc2(), IRawDataProviderSvc::tofDataMapEstime(), EventModel::Trig::TrigData, MdcID::wire(), and writeFile.
00281 { 00282 MsgStream log(msgSvc(),name()); 00283 00284 log<<MSG::DEBUG<< "in execute()" <<endreq; 00285 00286 int event, run; 00287 ifpass = false; 00288 00289 //------------------- 00290 // get event header 00291 //------------------- 00292 SmartDataPtr<Event::EventHeader> eventHeader(eventSvc(),"/Event/EventHeader"); 00293 if (!eventHeader) { 00294 log << MSG::FATAL << "Could not find Event Header" << endreq; 00295 return( StatusCode::FAILURE); 00296 } 00297 run = eventHeader->runNumber(); 00298 event = eventHeader->eventNumber(); 00299 00300 if(mTrigRootFlag) { 00301 // fill run id and event id into ntuple 00302 m_RunId = run; 00303 m_EventId = event; 00304 } 00305 00306 //------------------------------------------------------------------- 00307 // using ascii file for output, but an ascii input file is needed. 00308 //------------------------------------------------------------------- 00309 if(writeFile==1 && event == 0) 00310 { 00311 readin.open(input.c_str(),ios_base::in); 00312 if(readin) cout<<"Input File is ok "<<input<<endl; 00313 readout.open(output.c_str(),ios_base::out); 00314 if(readout) cout<<"Output File is ok "<<output<<endl; 00315 VERSIONNUM version; 00316 readin >> version; 00317 readout << version; 00318 } 00319 00320 //--------------------------------- 00321 // define a map to store mdc hits 00322 //--------------------------------- 00323 multimap<int,uint32_t,less<int> > mdc_hitmap; 00324 mdc_hitmap.clear(); 00325 00326 //--------------------------------- 00327 // define a map to store tof hits 00328 //--------------------------------- 00329 multimap<int,int,less<int> > tof_hitmap; 00330 tof_hitmap.clear(); 00331 00332 //---------------------------------------------------- 00333 // get mdc digits from TDS and save them into a map 00334 //---------------------------------------------------- 00335 SmartDataPtr<MdcDigiCol> mdcDigiCol(eventSvc(),"/Event/Digi/MdcDigiCol"); 00336 if (!mdcDigiCol) { 00337 log << MSG::FATAL << "Could not find MDC digi" << endreq; 00338 return( StatusCode::FAILURE); 00339 } 00340 for(MdcDigiCol::iterator iter3=mdcDigiCol->begin();iter3!=mdcDigiCol->end();iter3++) 00341 { 00342 Identifier id= (*iter3)->identify(); 00343 int layer = MdcID::layer(id); 00344 int wire = MdcID::wire(id); 00345 int tdc = (*iter3)->getTimeChannel(); 00346 if(tdc < 0x7FFFFFFF && tdc > 0) { 00347 if(layer<=19) { 00348 typedef pair<int, uint32_t > vpair; 00349 uint32_t mdc_Id = (layer & 0xFFFF ) << 16; 00350 mdc_Id = mdc_Id | (wire & 0xFFFF); 00351 mdc_hitmap.insert(vpair(tdc,mdc_Id)); 00352 } 00353 if(layer>=36&&layer<=39) 00354 { 00355 typedef pair<int, uint32_t > vpair; 00356 uint32_t mdc_Id = (layer & 0xFFFF ) << 16; 00357 mdc_Id = mdc_Id | (wire & 0xFFFF); 00358 mdc_hitmap.insert(vpair(tdc,mdc_Id)); 00359 } 00360 } 00361 } 00362 00363 //------------------------------------------------------------------ 00364 // get tof digits from rawDataProviderSvc ant save them into a map 00365 //------------------------------------------------------------------ 00366 TofDataMap tofDigiMap = m_rawDataProviderSvc->tofDataMapEstime(); 00367 for(TofDataMap::iterator iter3 = tofDigiMap.begin();iter3 != tofDigiMap.end(); iter3++) { 00368 Identifier idd = Identifier(iter3->first); 00369 TofData * p_tofDigi = iter3->second; 00370 int barrel_ec = TofID::barrel_ec(idd); 00371 int layer = TofID::layer(idd); 00372 int im = TofID::phi_module(idd); 00373 if(barrel_ec == 1) { 00374 if(((p_tofDigi->quality()) & 0x5) != 0x5) continue; 00375 double tdc1 = p_tofDigi->tdc1(); 00376 double tdc2 = p_tofDigi->tdc2(); 00377 int tdc; 00378 if(tdc1 > tdc2) tdc = (int) tdc1; 00379 else tdc = (int) tdc2; 00380 typedef pair<int, int > vpair; 00381 tdc = tdc; 00382 tof_hitmap.insert(vpair(tdc,10000*barrel_ec+1000*layer+im*10)); 00383 } 00384 else { 00385 int tdc1 = (int)p_tofDigi->tdc1(); 00386 typedef pair<int, int > vpair; 00387 tdc1 = tdc1; 00388 tof_hitmap.insert(vpair(tdc1,10000*barrel_ec+1000*layer+im*10)); 00389 } 00390 } 00391 00392 //-------------------------- 00393 // get emc digits from TDS 00394 //-------------------------- 00395 SmartDataPtr<EmcDigiCol> emcDigiCol(eventSvc(),"/Event/Digi/EmcDigiCol"); 00396 if (!emcDigiCol) { 00397 log << MSG::FATAL << "Could not find EMC digi" << endreq; 00398 return( StatusCode::FAILURE); 00399 } 00400 00401 //---------------------------------------------------------- 00402 // define initialize waveform object for each energy block 00403 //---------------------------------------------------------- 00404 EmcWaveform blockWave[16]; 00405 00406 //------------------------------------------------------------ 00407 // define a map of trigger cell, contains time and id infor. 00408 //------------------------------------------------------------ 00409 multimap<int,uint32_t,less<int> > emc_TC; 00410 emc_TC.clear(); 00411 00412 //--------------------------------------------------------------------------------- 00413 // get emc analog signal, including trigger cell, energy block and cluster infor. 00414 //--------------------------------------------------------------------------------- 00415 getEmcAnalogSig(emcDigiCol, blockWave, emc_TC); 00416 00417 //----------------------------------- 00418 // find peak time of energy block 00419 //----------------------------------- 00420 double peak_time = 0; 00421 findEmcPeakTime(peak_time, blockWave); 00422 00423 //-------------------------- 00424 // get muc digits from TDS 00425 //-------------------------- 00426 SmartDataPtr<MucDigiCol> mucDigiCol(eventSvc(),"/Event/Digi/MucDigiCol"); 00427 if (!mucDigiCol) { 00428 log << MSG::FATAL << "Could not find MUC digi" << endreq; 00429 return( StatusCode::FAILURE); 00430 } 00431 if(m_mucDigi) m_mucDigi->getMucDigi(mucDigiCol); 00432 00433 //---------------------------------------------- 00434 // output for debugging and count event number 00435 //---------------------------------------------- 00436 if(event%10000 == 0) std::cout << "---> EventNo is " << event << std::endl; 00437 nEvent++; 00438 00439 //******************************************************************** 00440 // start time clock 00441 //******************************************************************** 00442 00443 //-------------------------- 00444 // find start and end time 00445 //-------------------------- 00446 double stime = -1, etime = -1; 00447 findSETime(mdc_hitmap,tof_hitmap,emc_TC,stime,etime); 00448 00449 // calculate total clock number 00450 int nclock = 0; 00451 if(stime >= 0) { 00452 nclock = int ((etime - stime)/24) + 1; 00453 } 00454 else { 00455 nclock = 0; 00456 } 00457 00458 //------------------------------------------------------------ 00459 // define an array to store trigger conditions in each clock 00460 //------------------------------------------------------------ 00461 int** trgcond = new int*[48]; 00462 for(int condId = 0; condId < 48; condId++) { 00463 trgcond[condId] = new int[nclock]; 00464 } 00465 00466 // used for tof status machine 00467 int idle_status = -1; 00468 00469 for(int iclock = 0; iclock < nclock; iclock++) { 00470 //--------------------------- 00471 // start mdc trigger logic 00472 //--------------------------- 00473 runAclock_mdc(iclock, stime, mdc_hitmap); 00474 00475 //--------------------------- 00476 // start tof trigger logic 00477 //--------------------------- 00478 runAclock_tof(iclock, stime, idle_status, tof_hitmap); 00479 00480 //-------------------------- 00481 // start emc trigger logic 00482 //-------------------------- 00483 runAclock_emc(iclock, stime, emc_TC, blockWave); 00484 00485 //---------------------------------- 00486 // start track match trigger logic 00487 //---------------------------------- 00488 //m_pIBGT->startTMTrig(); 00489 00490 //-------------------------- 00491 // set trigger conditions 00492 //-------------------------- 00493 StatusCode status = m_pIBGT->setTrigCondition(); 00494 if(status!=StatusCode::SUCCESS) { 00495 log<<MSG::FATAL<< "Could not set trigger condition index" <<endreq; 00496 return StatusCode::FAILURE; 00497 } 00498 00499 //-------------------------------------------- 00500 // get each trigger condition in each clock 00501 //-------------------------------------------- 00502 for(int condId = 0; condId < 48; condId++) { 00503 trgcond[condId][iclock] = m_pIBGT->getTrigCond(condId); 00504 } 00505 } 00506 00507 //------------------------------ 00508 // stretch trigger conditions 00509 //------------------------------ 00510 stretchTrgCond(nclock, trgcond); 00511 00512 //------------------------- 00513 // SAF delay 00514 //------------------------- 00515 //trgSAFDelay(nclock, trgcond); 00516 00517 //------------------------- 00518 // GTL delay 00519 //------------------------- 00520 //trgGTLDelay(nclock, trgcond); 00521 00522 00523 //******************************************************************** 00524 // end time clock 00525 //******************************************************************** 00526 00527 00528 //------------------------------------------------------------------------------------------------------------------- 00529 // deal with emc trigger conditions, in principle, if NClus>=1 is true between peaktime - 1.6us and peak time, 00530 // other emc conditions can be true, but not used now. 00531 //------------------------------------------------------------------------------------------------------------------- 00532 bool ifClus1 = false; 00533 for(int i = 0; i < nclock; i++) { 00534 if(trgcond[0][i] > 0) ifClus1 = true; 00535 } 00536 00537 if(ifClus1 == false) { 00538 for(int i = 0; i < nclock; i++) { 00539 for(int j = 0; j < 16; j++) { 00540 trgcond[j][i] = 0; 00541 } 00542 } 00543 } 00544 00545 //----------------------------------------------------------- 00546 // do logic 'or' for each trigger condition in all clocks. 00547 //----------------------------------------------------------- 00548 for(int i = 0; i < nclock; i++) { 00549 for(int j = 0; j < 48; j++) { 00550 if(trgcond[j][i]) m_pIBGT->setTrigCond(j,1); 00551 } 00552 } 00553 00554 //---------------------------- 00555 // match with trigger table 00556 //---------------------------- 00557 m_pIBGT->GlobalTrig(); 00558 00559 //-------------------------------------- 00560 // this event can pass trigger or not 00561 //-------------------------------------- 00562 ifpass = m_pIBGT->getIfpass(); 00563 if(ifpass) 00564 { 00565 passNo++; 00566 log<<MSG::INFO<<"pass event number is "<<passNo<<endl; 00567 } 00568 00569 //------------------------------------------- 00570 // write out events which can pass trigger. 00571 //------------------------------------------- 00572 if(writeFile == 2) { 00573 if(ifpass) 00574 { 00575 setFilterPassed(true); 00576 } 00577 else 00578 { 00579 setFilterPassed(false); 00580 } 00581 } 00582 00583 if(mTrigRootFlag) { 00584 //-------------------------------------------- 00585 // fill histograms, trigger conditions of MC 00586 //-------------------------------------------- 00587 for(int i = 0; i < 48; i++) { 00588 bool edge = false; 00589 int NOne = 0; 00590 m_condNOne[i] = -9; 00591 m_condNZero[i] = -9; 00592 for(int j = 0; j < nclock; j++) { 00593 m_mc_cond[i] += trgcond[i][j]; 00594 if(trgcond[i][j] != 0) { 00595 if (NOne == 0) { 00596 m_condNZero[i] = j; 00597 m_trigCondi_MC->Fill(i); 00598 00599 } 00600 edge = true; 00601 NOne++; 00602 } 00603 else { 00604 edge = false; 00605 } 00606 if(edge == false && NOne != 0) break; 00607 } 00608 m_condNOne[i] = NOne; 00609 } 00610 m_cond_id = 48; 00611 00612 //----------------------------------------------- 00613 // fill histograms, trigger conditions of data 00614 //----------------------------------------------- 00615 if(m_runMode == 0) { 00616 SmartDataPtr<TrigData> trigData(eventSvc(), "/Event/Trig/TrigData"); 00617 if (!trigData) { 00618 log << MSG::FATAL << "Could not find Trigger Data for physics analysis" << endreq; 00619 return StatusCode::FAILURE; 00620 } 00621 00622 for(int id = 0; id < 48; id++) { 00623 if(trigData->getTrigCondition(id) != 0) { m_trigCondi_Data->Fill(id); } 00624 m_data_cond[id] = trigData->getTrigCondition(id); 00625 } 00626 m_cond_id = 48; 00627 } 00628 } 00629 00630 //---------------------------- 00631 // release memory 00632 //---------------------------- 00633 for(int condId = 0; condId < 48; condId++) { 00634 delete trgcond[condId]; 00635 } 00636 delete trgcond; 00637 00638 00639 if(mTrigRootFlag) { 00640 m_evtId = event; 00641 m_tuple3->write(); 00642 00643 m_mc_totE_all = m_pIBGT->getEmcTotE(); 00644 m_wetotE = m_pIBGT->getEmcWETotE(); 00645 m_eetotE = m_pIBGT->getEmcEETotE(); 00646 00647 map<int,vector<complex<int> >, greater<int> > mymap; 00648 mymap = m_pIBGT->getEmcClusId(); 00649 log<<MSG::INFO<<"EMC test: "<<endreq; 00650 int emc_btc_id = 0; 00651 for(map<int,vector<complex<int> >, greater<int> >::iterator iter=mymap.begin(); iter!=mymap.end(); iter++) { 00652 if((iter->first)==1) { 00653 for(unsigned int i=0; i<(iter->second).size(); i++) { 00654 log<<MSG::INFO<<"barrel theta is "<<(iter->second[i]).real()<<" phi is "<<(iter->second[i]).imag()<<endreq; 00655 emc_btc_id++; 00656 } 00657 } 00658 if((iter->first)==0) { 00659 for(unsigned int i=0; i<(iter->second).size(); i++) 00660 log<<MSG::INFO<<"east theta is "<<(iter->second[i]).real()<<" phi is "<<(iter->second[i]).imag()<<endreq; 00661 } 00662 if((iter->first)==2) { 00663 for(unsigned int i=0; i<(iter->second).size(); i++) 00664 log<<MSG::INFO<<"west theta is "<<(iter->second[i]).real()<<" phi is "<<(iter->second[i]).imag()<<endreq; 00665 } 00666 } 00667 00668 //retrieve EMC trigger information from EACC 00669 /* SmartDataPtr<TrigGTDCol> trigGTDCol(eventSvc(), "/Event/Trig/TrigGTDCol"); 00670 if (!trigGTDCol) { 00671 log << MSG::FATAL << "Could not find Global Trigger Data" << endreq; 00672 return StatusCode::FAILURE; 00673 } 00674 eacctrig->initialize(); 00675 TrigGTDCol::iterator iter5 = trigGTDCol->begin(); 00676 for (; iter5 != trigGTDCol->end(); iter5++) { 00677 uint32_t size = (*iter5)->getDataSize(); 00678 const uint32_t* ptr = (*iter5)->getDataPtr(); 00679 //set EACC trigger data 00680 if((*iter5)->getId() == 0xD7) { 00681 eacctrig->setEACCTrigData((*iter5)->getId(), (*iter5)->getTimeWindow(), size, ptr); 00682 } 00683 } 00684 00685 double bmean[12] = {8.02,10.1,12.3,7.43,14.8,13.0,12.5,13.2,10.9,12.3,14.7,15.7}; 00686 double bsigma[12] = {0.88,0.52,0.9,0.72,0.7,0.82,0.64,0.78,0.72,0.76,0.54,0.64}; 00687 vector<double> vblockE = m_pIBGT->getEmcBlockE(); 00688 for(int blockId = 0; blockId < vblockE.size(); blockId++) { 00689 //m_mc_blockE[blockId] = vblockE[blockId]; 00690 int block_time; 00691 m_mc_blockE[blockId] = blockWave[blockId+2].max(block_time)*0.333 - 0xa + RandGauss::shoot(bmean[blockId],bsigma[blockId]); 00692 m_data_blockE[blockId] = eacctrig->getBBLKCharge(blockId); 00693 float r_blockE; 00694 if((eacctrig->getBBLKCharge(blockId) - bmean[blockId]) == 0.) r_blockE = 0; 00695 else r_blockE = vblockE[blockId]/(eacctrig->getBBLKCharge(blockId) - bmean[blockId]); 00696 if(!(r_blockE >=0. || r_blockE <= 0.)) r_blockE = 0; 00697 m_R_blockE[blockId] = r_blockE; 00698 } 00699 m_block_id = vblockE.size(); 00700 00701 m_data_totE_all = eacctrig->getEMCTotalCharge(); 00702 //endcap energy 00703 int ee_endcap = 0, we_endcap = 0; 00704 for(int i = 0; i < 2; i++) { 00705 ee_endcap += eacctrig->getEBLKCharge(i); 00706 we_endcap += eacctrig->getWBLKCharge(i); 00707 } 00708 m_data_wetotE = we_endcap; 00709 m_data_eetotE = ee_endcap; 00710 00711 m_data_totE_all = eacctrig->getEMCTotalCharge(); 00712 00713 //fill trigger cell energy 00714 int window = eacctrig->getTimeWindow(); 00715 int index_tc = 0; 00716 for(int i=0;i<TrigConf::TCTHETANO_B;i++) 00717 for(int j=0;j<TrigConf::TCPHINO_B;j++) 00718 { 00719 m_btc_e[index_tc] = m_pIBGT->getBTCEnergy(i,j); 00720 int if_clus = 0; 00721 for(int k = 0; k < window; k++) { 00722 if(eacctrig->getBTC(i,j,k) == 1) { 00723 if_clus = 1; 00724 break; 00725 } 00726 } 00727 m_data_btc[index_tc] = if_clus; 00728 index_tc++; 00729 } 00730 m_index_btc = index_tc; 00731 00732 index_tc = 0; 00733 for(int i =0;i<TrigConf::TCTHETANO_E;i++) 00734 for(int j =0;j<TrigConf::TCPHINO_E;j++) 00735 { 00736 //m_wetc_e[index_tc] = m_pIBGT->getWETCEnergy(i,j); 00737 //m_eetc_e[index_tc] = m_pIBGT->getEETCEnergy(i,j); 00738 index_tc++; 00739 } 00740 //m_index_etc = index_tc; 00741 */ 00742 m_tuple1->write(); 00743 00744 //---------------------------------------------- 00745 // check information of MDC, TOF, EMC output 00746 //---------------------------------------------- 00747 vector<int> vstrkId; 00748 vector<int> vltrkId; 00749 vstrkId = m_pIBGT->getMdcStrkId(); 00750 vltrkId = m_pIBGT->getMdcLtrkId(); 00751 log<<MSG::INFO<<"Mdc test: "<<endreq; 00752 for(unsigned int i=0; i<vstrkId.size(); i++) log<<MSG::INFO<<"short is "<<vstrkId[i]<<endreq; 00753 for(unsigned int j=0; j<vltrkId.size(); j++) { log<<MSG::INFO<<"long is "<<vltrkId[j]<<endreq; } 00754 00755 map<int,vector<int>,greater<int> > tofmap; 00756 tofmap = m_pIBGT->getTofHitPos(); 00757 log<<MSG::INFO<<"TOF test: "<<endreq; 00758 for(map<int,vector<int>,greater<int> >::iterator iter=tofmap.begin(); iter!=tofmap.end(); iter++) { 00759 if(iter->first == 0) { 00760 for(unsigned int i=0; i<iter->second.size(); i++) { 00761 log<<MSG::INFO<<"east tof Id is "<<iter->second[i]<<endreq; 00762 } 00763 } 00764 if(iter->first == 1) { 00765 for(unsigned int i=0; i<iter->second.size(); i++) { log<<MSG::INFO<<" barrel tof Id is "<<iter->second[i]<<endreq; } 00766 } 00767 if(iter->first == 2) { 00768 for(unsigned int i=0; i<iter->second.size(); i++) { log<<MSG::INFO<<"west tof Id is "<<iter->second[i]<<endreq; } 00769 } 00770 } 00771 00772 //Fill ntuple for MUC 00773 std::vector<int> vtmp; 00774 00775 vtmp = m_pIBGT->getMuclayerSeg(); 00776 m_index2 = 0; 00777 for(std::vector<int>::iterator iter = vtmp.begin(); iter != vtmp.end(); iter++) { 00778 m_fireLayer[m_index2] = (long) *iter; 00779 m_index2++; 00780 if(m_index2 > m_index2->range().distance()) { break; cerr<<"*********** too many index ************"<<endl; } 00781 } 00782 //find tracks by count the fired layer number 00783 long trackb3=0, tracke3=0, trackb2=0, tracke2=0, trackb1=0, tracke1=0; 00784 int trackwe = 0, trackee = 0; 00785 for(unsigned int i=0; i<vtmp.size(); i++) { 00786 if(0<=vtmp[i]&&vtmp[i]<100) { 00787 if((vtmp[i]%10)>=3) { tracke3++; trackee++; } 00788 } 00789 if(200<=vtmp[i]) { 00790 if(((vtmp[i]-200)%10)>=3) { tracke3++; trackwe++; } 00791 } 00792 if(100<=vtmp[i]&&vtmp[i]<200) { 00793 if(((vtmp[i]-100)%10)>=3) trackb3++; 00794 } 00795 } 00796 m_ntrack3 = trackb3 + tracke3; 00797 00798 for(unsigned int i=0; i<vtmp.size(); i++) { 00799 if(0<=vtmp[i]&&vtmp[i]<100) { 00800 if((vtmp[i]%10)>=2) tracke2++; 00801 } 00802 if(200<=vtmp[i]) { 00803 if(((vtmp[i]-200)%10)>=2) tracke2++; 00804 } 00805 if(100<=vtmp[i]&&vtmp[i]<200) { 00806 if(((vtmp[i]-100)%10)>=2) trackb2++; 00807 } 00808 } 00809 m_ntrack2 = trackb2 + tracke2; 00810 00811 for(unsigned int i=0; i<vtmp.size(); i++) { 00812 if(0<=vtmp[i]&&vtmp[i]<100) { 00813 if((vtmp[i]%10)>=1) tracke1++; 00814 } 00815 if(200<=vtmp[i]) { 00816 if(((vtmp[i]-200)%10)>=1) tracke1++; 00817 } 00818 if(100<=vtmp[i]&&vtmp[i]<200) { 00819 if(((vtmp[i]-100)%10)>=1) trackb1++; 00820 } 00821 } 00822 m_ntrack1 = trackb1 + tracke1; 00823 //end of finding tracks by count the fired layer number 00824 00825 vtmp = m_pIBGT->getMuchitLayer(); 00826 m_index3 = 0; 00827 for(std::vector<int>::iterator iter = vtmp.begin(); iter != vtmp.end(); iter++) { 00828 m_hitLayer[m_index3] = (long) *iter; 00829 m_index3++; 00830 if(m_index3 > m_index3->range().distance()) { break; cerr<<"*********** too many index ************"<<endl; } 00831 } 00832 00833 vtmp = m_pIBGT->getMuchitSeg(); 00834 m_index4 = 0; 00835 for(std::vector<int>::iterator iter = vtmp.begin(); iter != vtmp.end(); iter++) { 00836 m_hitSeg[m_index4] = *(iter); 00837 m_index4++; 00838 if(m_index4 > m_index4->range().distance()) { break; cerr<<"*********** too many index ************"<<endl; } 00839 } 00840 } // end fill ntuple 00841 00842 //--------------------------------------------------- 00843 // write out event number which not passed trigger. 00844 //--------------------------------------------------- 00845 if(ifoutEvtId==1) 00846 { 00847 ofstream eventnum(outEvtId.c_str(),ios_base::app); 00848 if(!ifpass) 00849 eventnum<<event<<endl; 00850 eventnum.close(); 00851 } 00852 00853 //------------------------------------------------- 00854 // write out event number which passed trigger. 00855 //------------------------------------------------- 00856 if(ifoutEvtId==2) 00857 { 00858 ofstream eventnum(outEvtId.c_str(),ios_base::app); 00859 if(ifpass) 00860 eventnum<<event<<endl; 00861 eventnum.close(); 00862 } 00863 00864 //-------------------------------------------------------- 00865 // write out events (passed trigger) into an ascii file 00866 //-------------------------------------------------------- 00867 if(writeFile==1) 00868 { 00869 EVENT asciiEvt; 00870 readin >> asciiEvt; 00871 if(asciiEvt.header.eventNo == event) 00872 { 00873 if(ifpass==true) 00874 readout<<asciiEvt<<endl; 00875 } 00876 else 00877 cout<<"********* Event No. from AsciiFile do not equal Event No. from TDS " 00878 <<asciiEvt.header.eventNo<<" "<<event<<endl; 00879 } 00880 00881 //-------------------------------------------------------------- 00882 // if it is offline mode, register trigger information into TDS 00883 //-------------------------------------------------------------- 00884 if(m_runMode == 1) { 00885 const int* trigcond = m_pIBGT->getTrigCond(); 00886 const int* trigchan = m_pIBGT->getTrigChan(); 00887 int window = 0; 00888 int timing = 0; 00889 bool preScale = false; 00890 00891 StatusCode sc = StatusCode::SUCCESS ; 00892 TrigEvent* aTrigEvent = new TrigEvent; 00893 sc = eventSvc()->registerObject("/Event/Trig",aTrigEvent); 00894 if(sc!=StatusCode::SUCCESS) { 00895 log<<MSG::DEBUG<< "Could not register TrigEvent, you can ignore." <<endreq; 00896 } 00897 00898 TrigData* aTrigData = new TrigData(window, timing, trigcond, trigchan, preScale); 00899 sc = eventSvc()->registerObject("/Event/Trig/TrigData",aTrigData); 00900 if(sc!=StatusCode::SUCCESS) { 00901 log<<MSG::ERROR<< "Could not register TrigData!!!!!" <<endreq; 00902 } 00903 } 00904 00905 return StatusCode::SUCCESS; 00906 }
StatusCode BesTrigL1::finalize | ( | ) | [virtual] |
Algorithm finalization.
Definition at line 908 of file BesTrigL1.cxx.
References Bes_Common::DEBUG, msgSvc(), passNo, readin, readout, and writeFile.
00908 { 00909 00910 MsgStream msg(msgSvc(), name()); 00911 msg << MSG::DEBUG << "==> Finalize BesTrigL1" << endreq; 00912 00913 if(writeFile==1) 00914 { 00915 readin.close(); 00916 readout.close(); 00917 } 00918 cout<<"There are total "<< passNo<<" event pass trigger"<<endl; 00919 return StatusCode::SUCCESS; 00920 }
void BesTrigL1::findEmcPeakTime | ( | double & | peak_time, | |
EmcWaveform * | blockWave | |||
) |
Definition at line 1260 of file BesTrigL1.cxx.
References genRecEmupikp::i, and EmcWaveform::max().
Referenced by execute().
01260 { 01261 double tot_block_max = 0; 01262 for(int i = 0; i < 16; i++) { 01263 int block_time; 01264 double block_max = blockWave[i].max(block_time); 01265 tot_block_max += block_max; 01266 } 01267 01268 for(int i = 0; i < 16; i++) { 01269 if(tot_block_max == 0) break; 01270 int block_time; 01271 double block_max = blockWave[i].max(block_time); 01272 block_time = block_time*50; 01273 peak_time += block_max/tot_block_max*block_time; 01274 } 01275 }
void BesTrigL1::findSETime | ( | multimap< int, uint32_t, less< int > > | mdc_hitmap, | |
multimap< int, int, less< int > > | tof_hitmap, | |||
multimap< int, uint32_t, less< int > > | emc_TC, | |||
double & | stime, | |||
double & | etime | |||
) |
Definition at line 922 of file BesTrigL1.cxx.
Referenced by execute().
00923 { 00924 std::multimap<int,uint32_t,less<int> >::iterator mdc_iter = mdc_hitmap.begin(); 00925 double smdctime = -1, emdctime = -1; 00926 if(mdc_hitmap.size() != 0) { 00927 smdctime = (mdc_iter->first)*0.09375; 00928 mdc_iter = mdc_hitmap.end(); 00929 mdc_iter--; 00930 emdctime = (mdc_iter->first)*0.09375; 00931 } 00932 00933 std::multimap<int,int,less<int> >::iterator tof_iter = tof_hitmap.begin(); 00934 double stoftime = -1, etoftime = -1; 00935 if(tof_hitmap.size() != 0) { 00936 stoftime = (tof_iter->first); 00937 tof_iter = tof_hitmap.end(); 00938 tof_iter--; 00939 etoftime = (tof_iter->first); 00940 } 00941 00942 std::multimap<int,uint32_t,less<int> >::iterator emc_iter = emc_TC.begin(); 00943 double semctime = -1, eemctime = -1; 00944 if(emc_TC.size() != 0) { 00945 semctime = (emc_iter->first); 00946 emc_iter = emc_TC.end(); 00947 emc_iter--; 00948 eemctime = (emc_iter->first); 00949 } 00950 00951 stime = -1, etime = -1; 00952 if(smdctime >= 0 && stoftime >= 0) { 00953 if(smdctime > stoftime) stime = stoftime; 00954 else stime = smdctime; 00955 00956 if((emdctime+800) > (etoftime + 24)) etime = emdctime+800; 00957 else etime = etoftime + 24; 00958 } 00959 else if(smdctime < 0 && stoftime >= 0) { 00960 stime = stoftime; 00961 etime = etoftime + 24; 00962 } 00963 else if(smdctime >= 0 && stoftime < 0) { 00964 stime = smdctime; 00965 etime = emdctime+800; 00966 } 00967 else { 00968 stime = -1; 00969 etime = -1; 00970 } 00971 //compare with emc time 00972 if(semctime >= 0 && stime >= 0) { 00973 if(semctime > stime) stime = stime; 00974 else stime = semctime; 00975 00976 if((eemctime+16*24) > etime) etime = eemctime+16*24; 00977 else etime = etime; 00978 } 00979 else if(semctime < 0 && stime >= 0) { 00980 stime = stime; 00981 etime = etime; 00982 } 00983 else if(semctime >= 0 && stime < 0) { 00984 stime = semctime; 00985 etime = eemctime+16*24; 00986 } 00987 else { 00988 stime = -1; 00989 etime = -1; 00990 } 00991 }
void BesTrigL1::getEmcAnalogSig | ( | EmcDigiCol * | emcDigiCol, | |
EmcWaveform & | blockWave[16], | |||
multimap< int, uint32_t, less< int > > & | emc_TC | |||
) |
Definition at line 1158 of file BesTrigL1.cxx.
References EmcID::barrel_ec(), emcCalibConstSvc, EmcWaveform::frontEdgeTrg(), EmcTCFinder::getBLKId(), IEmcCalibConstSvc::getIndex(), BesGlobalTrigSvc::getL1TC_GATE(), BesGlobalTrigSvc::getL1TC_THRESH(), EmcTCFinder::getTCPhiId(), EmcTCFinder::getTCThetaId(), RealizationSvc::getTrgGain(), genRecEmupikp::i, ganga-rec::j, m_emcDigi, m_pIBGT, m_RealizationSvc, EmcWaveform::makeWaveformTrg(), EmcID::phi_module(), and EmcID::theta_module().
Referenced by execute().
01158 { 01159 EmcWaveform eewave[32]; 01160 EmcWaveform wewave[32]; 01161 EmcWaveform bwave[11][30]; 01162 01163 for(int i = 0; i < 11; i++) { 01164 for(int j = 0; j < 30; j++) { 01165 bwave[i][j].makeWaveformTrg(0,0); 01166 } 01167 } 01168 for(int i = 0; i < 32; i++) { 01169 if(i < 16) blockWave[i].makeWaveformTrg(0,0); 01170 eewave[i].makeWaveformTrg(0,0); 01171 wewave[i].makeWaveformTrg(0,0); 01172 } 01173 01174 for (EmcDigiCol::iterator iter3=emcDigiCol->begin();iter3!= emcDigiCol->end();iter3++) { 01175 Identifier id=(*iter3)->identify(); 01176 unsigned int module = EmcID::barrel_ec(id); 01177 unsigned int theta = EmcID::theta_module(id); 01178 unsigned int phi = EmcID::phi_module(id); 01179 01180 int index = emcCalibConstSvc->getIndex(module,theta,phi); 01181 double trgGain = m_RealizationSvc->getTrgGain(index); 01182 double adc = (double) (*iter3)->getChargeChannel(); 01183 double mv = RandGauss::shoot(978.,14.); 01184 01185 if((*iter3)->getMeasure()==0) adc = adc*2*mv*2/65535.*(trgGain); 01186 else if((*iter3)->getMeasure()==1) adc = adc*16*mv*2/65535*(trgGain); 01187 else adc = adc*64*mv*2/65535*(trgGain); 01188 01189 unsigned int tdc = (*iter3)->getTimeChannel(); 01190 int theTC = m_emcDigi->getTCThetaId(module,theta,phi); 01191 int phiTC = m_emcDigi->getTCPhiId(module,theta,phi); 01192 EmcWaveform wave1; 01193 if(module == 0) { wave1.makeWaveformTrg(adc,tdc+80); eewave[phiTC] += wave1; } 01194 if(module == 1) { wave1.makeWaveformTrg(adc,tdc+80); bwave[theTC][phiTC] += wave1; } 01195 if(module == 2) { wave1.makeWaveformTrg(adc,tdc+80); wewave[phiTC] += wave1; } 01196 } 01197 01198 //find barrel cluster 01199 for(int i = 0; i < 11; i++) { 01200 for(int j = 0; j < 30; j++) { 01201 int time_low = bwave[i][j].frontEdgeTrg(m_pIBGT->getL1TC_GATE()); 01202 int time_high = bwave[i][j].frontEdgeTrg(m_pIBGT->getL1TC_THRESH()); 01203 int time = -1; 01204 01205 if(time_high >= 0) { 01206 if(time_low*50+1500 > time_high*50) time = time_low*50 + 1500; 01207 else time = time_high*50; 01208 uint32_t TCID = (1 & 0xFF) << 16; 01209 TCID = TCID | ((i & 0xFF) << 8); 01210 TCID = TCID | (j & 0xFF); 01211 typedef pair<int, uint32_t > vpair; 01212 emc_TC.insert(vpair(time,TCID)); 01213 //std::cout <<"i, j: " << i << ", " << j << " time: " << time << std::endl; 01214 } 01215 if(time_low >= 0) { 01216 int blockId = m_emcDigi->getBLKId(i,j); 01217 blockWave[blockId+2] += bwave[i][j]; 01218 } 01219 } 01220 } 01221 //find end cap cluster 01222 for(int i = 0; i < 32; i++) { 01223 //east end cap 01224 int time_low1 = eewave[i].frontEdgeTrg(m_pIBGT->getL1TC_GATE()); 01225 int time_high1 = eewave[i].frontEdgeTrg(m_pIBGT->getL1TC_THRESH()); 01226 int time1 = -1; 01227 if(time_high1 >= 0) { 01228 if(time_low1*50+1500 > time_high1*50) time1 = time_low1*50 + 1500; 01229 else time1 = time_high1*50; 01230 uint32_t TCID1 = (0 & 0xFF) << 16; 01231 TCID1 = TCID1 | ((0 & 0xFF) << 8); 01232 TCID1 = TCID1 | (i & 0xFF); 01233 typedef pair<int, uint32_t > vpair; 01234 emc_TC.insert(vpair(time1,TCID1)); 01235 } 01236 if(time_low1 >= 0) { 01237 if(i<16) blockWave[0] += eewave[i]; 01238 else blockWave[1] += eewave[i]; 01239 } 01240 //west end cap 01241 int time_low2 = wewave[i].frontEdgeTrg(m_pIBGT->getL1TC_GATE()); 01242 int time_high2 = wewave[i].frontEdgeTrg(m_pIBGT->getL1TC_THRESH()); 01243 int time2 = -1; 01244 if(time_high2 >= 0) { 01245 if(time_low2*50+1500 > time_high2*50) time2 = time_low2*50 + 1500; 01246 else time2 = time_high2*50; 01247 uint32_t TCID2 = (2 & 0xFF) << 16; 01248 TCID2 = TCID2 | ((0 & 0xFF) << 8); 01249 TCID2 = TCID2 | (i & 0xFF); 01250 typedef pair<int, uint32_t > vpair; 01251 emc_TC.insert(vpair(time2,TCID2)); 01252 } 01253 if(time_low2 >= 0) { 01254 if(i<16) blockWave[14] += wewave[i]; 01255 else blockWave[15] += wewave[i]; 01256 } 01257 } 01258 }
StatusCode BesTrigL1::initialize | ( | ) | [virtual] |
Destructor Algorithm initialization.
Definition at line 72 of file BesTrigL1.cxx.
References Bes_Common::DEBUG, emcCalibConstSvc, calibUtil::ERROR, EmcTCFinder::get_Emc(), MdcTSF::get_Mdc(), MucTrigHit::get_Muc(), TofHitCount::get_Tof(), Bes_Common::INFO, m_block_id, m_btc_e, m_cond_id, m_condNOne, m_condNZero, m_costheta, m_data_blockE, m_data_btc, m_data_cond, m_data_eetotE, m_data_totE_all, m_data_wetotE, m_delta_tdc, m_eetotE, m_emcDigi, m_EventId, m_evtId, m_fireLayer, m_hitLayer, m_hitphi, m_hitSeg, m_index2, m_index3, m_index4, m_index5, m_index6, m_index_btc, m_mc_blockE, m_mc_cond, m_mc_totE_all, m_MdcTSF, m_mucDigi, m_mumcostheta, m_mumphi, m_ngoodevent, m_ngoodtrack, m_nhitBR, m_nhitEE, m_nhitTotal, m_nhitWE, m_nlayerBR, m_nlayerEE, m_nlayerTotal, m_nlayerWE, m_ntrack1, m_ntrack2, m_ntrack3, m_p, m_pdgcode, m_phi, m_pIBGT, m_R_blockE, m_rawDataProviderSvc, m_RealizationSvc, m_RunId, m_runMode, m_thistsvc, m_tmpSvc, m_TofHitCount, m_trackb, m_tracke, m_trackfind3l, m_trackfindall, m_trigCondi_Data, m_trigCondi_MC, m_tuple, m_tuple1, m_tuple2, m_tuple3, m_wetotE, m_wire_evtId, m_wire_x, m_wire_y, msgSvc(), mTrigRootFlag, ntupleSvc(), BesGlobalTrigSvc::setRunMode(), deljobs::string, totalEvent, and totalTracks.
00072 { 00073 MsgStream log(msgSvc(), name()); 00074 log << MSG::INFO << "in initialize()" << endreq; 00075 00076 //-------------------------------------- 00077 // define a pointer of trigger service 00078 //-------------------------------------- 00079 ISvcLocator* svcLocator = Gaudi::svcLocator(); 00080 StatusCode sc = svcLocator->service("BesGlobalTrigSvc", m_tmpSvc); 00081 m_pIBGT = dynamic_cast<BesGlobalTrigSvc* >(m_tmpSvc); 00082 if(sc!=StatusCode::SUCCESS) { 00083 log<<MSG::DEBUG<< "Unable to open trigger service"<<endreq; 00084 } 00085 00086 // set run mode, 0: online, 1: offline 00087 m_pIBGT->setRunMode(m_runMode); 00088 00089 //-------------------------------------------------------------- 00090 // define a pointer of RawDataProviderSvc, used in tof trigger 00091 //-------------------------------------------------------------- 00092 static const bool CREATEIFNOTTHERE(true); 00093 sc = service ("RawDataProviderSvc", m_rawDataProviderSvc, CREATEIFNOTTHERE); 00094 if ( !sc.isSuccess() ) { 00095 log<<MSG::ERROR << "Could not load RawDataProviderSvc!" << m_rawDataProviderSvc << endreq; 00096 return sc; 00097 } 00098 00099 //-------------------------------------------------------------- 00100 // use realization service to get trigger configure parameters 00101 //-------------------------------------------------------------- 00102 IRealizationSvc *tmpReal; 00103 sc = svcLocator->service("RealizationSvc",tmpReal); 00104 if (!sc.isSuccess()) 00105 { 00106 cout << "FATAL: Could not initialize Realization Service" << endl; 00107 } else { 00108 m_RealizationSvc=dynamic_cast<RealizationSvc*>(tmpReal); 00109 } 00110 00111 //----------------------------------------------------------------------- 00112 // use EmcCalibConstSvc to convert crystal id(theta, phi) to global id. 00113 //----------------------------------------------------------------------- 00114 sc = svcLocator->service("EmcCalibConstSvc", emcCalibConstSvc); 00115 if(sc != StatusCode::SUCCESS) { 00116 cout << "EmcRecDigit2Hit Error: Can't get EmcCalibConstSvc." << endl; 00117 } 00118 00119 if(mTrigRootFlag) { 00120 //----------------------------------------- 00121 // define ntuples for performance check 00122 //----------------------------------------- 00123 NTuplePtr nt(ntupleSvc(),"FILE302/trig1"); 00124 if ( nt ) m_tuple = nt; 00125 else { 00126 m_tuple=ntupleSvc()->book("FILE302/trig1",CLID_ColumnWiseTuple,"TrigL1"); 00127 if(m_tuple) { 00128 sc = m_tuple->addItem ("x",m_wire_x); 00129 sc = m_tuple->addItem ("y",m_wire_y); 00130 sc = m_tuple->addItem ("evtId",m_wire_evtId); 00131 sc = m_tuple->addItem ("delta_t",m_delta_tdc); 00132 } 00133 else { 00134 log << MSG::ERROR <<"Cannot book N-tuple:" << long(m_tuple) << endmsg; 00135 return StatusCode::FAILURE; 00136 } 00137 } 00138 00139 NTuplePtr nt1(ntupleSvc(),"FILE302/trig2"); 00140 if ( nt1 ) m_tuple1 = nt1; 00141 else { 00142 m_tuple1=ntupleSvc()->book("FILE302/trig2",CLID_ColumnWiseTuple,"TrigL1"); 00143 if( m_tuple1 ) { 00144 sc = m_tuple1->addItem ("RunId", m_RunId); 00145 sc = m_tuple1->addItem ("EventId", m_EventId); 00146 sc = m_tuple1->addItem ("mc_totE_all", m_mc_totE_all); 00147 sc = m_tuple1->addItem ("data_totE_all", m_data_totE_all); 00148 sc = m_tuple1->addItem ("mc_wetotE", m_wetotE); 00149 sc = m_tuple1->addItem ("data_wetotE", m_data_wetotE); 00150 sc = m_tuple1->addItem ("mc_eetotE", m_eetotE); 00151 sc = m_tuple1->addItem ("data_eetotE", m_data_eetotE); 00152 sc = m_tuple1->addItem ("index_btc", m_index_btc, 0, 330); 00153 sc = m_tuple1->addIndexedItem ("btc_e", m_index_btc, m_btc_e); 00154 sc = m_tuple1->addIndexedItem ("data_btc", m_index_btc, m_data_btc); 00155 sc = m_tuple1->addItem ("cond_id", m_cond_id, 0, 48); 00156 sc = m_tuple1->addIndexedItem ("mc_cond", m_cond_id, m_mc_cond); 00157 sc = m_tuple1->addIndexedItem ("data_cond", m_cond_id, m_data_cond); 00158 sc = m_tuple1->addItem ("block_id", m_block_id, 0, 12); 00159 sc = m_tuple1->addIndexedItem ("mc_blockE", m_block_id, m_mc_blockE); 00160 sc = m_tuple1->addIndexedItem ("data_blockE", m_block_id, m_data_blockE); 00161 sc = m_tuple1->addIndexedItem ("R_blockE", m_block_id, m_R_blockE); 00162 } 00163 else { // did not manage to book the N tuple.... 00164 log << MSG::ERROR <<"Cannot book N-tuple1:" << long(m_tuple1) << endmsg; 00165 return StatusCode::FAILURE; 00166 } 00167 } 00168 00169 00170 NTuplePtr nt2(ntupleSvc(),"FILE302/muc"); 00171 if ( nt2 ) m_tuple2 = nt2; 00172 else { 00173 m_tuple2=ntupleSvc()->book("FILE302/muc",CLID_ColumnWiseTuple,"TrigL1"); 00174 if( m_tuple2 ) { 00175 sc = m_tuple2->addItem ("indexlayerSeg", m_index2, 0, 5000); 00176 sc = m_tuple2->addIndexedItem ("nlayerSeg", m_index2, m_fireLayer,0,5000); 00177 sc = m_tuple2->addItem ("indexhitLayer", m_index3, 0, 5000); 00178 sc = m_tuple2->addIndexedItem ("nhitLayer", m_index3, m_hitLayer, 0, 5000); 00179 sc = m_tuple2->addItem ("indexhitSeg", m_index4, 0, 5000); 00180 sc = m_tuple2->addIndexedItem ("nhitSeg", m_index4, m_hitSeg, 0, 5000); 00181 sc = m_tuple2->addItem ("indexpara", m_index5, 0, 5000); 00182 sc = m_tuple2->addIndexedItem ("costheta", m_index5, m_costheta, 0, 5000); 00183 sc = m_tuple2->addIndexedItem ("phi", m_index5, m_phi, 0, 5000); 00184 sc = m_tuple2->addIndexedItem ("p", m_index5, m_p, 0, 5000); 00185 sc = m_tuple2->addIndexedItem ("pdgcode", m_index5, m_pdgcode, 0, 5000); 00186 sc = m_tuple2->addItem ("indexhitphi", m_index6, 0, 5000); 00187 sc = m_tuple2->addIndexedItem ("hitphi", m_index6, m_hitphi, 0, 5000); 00188 00189 sc = m_tuple2->addItem ("nlayerEE", m_nlayerEE); 00190 sc = m_tuple2->addItem ("nlayerBR", m_nlayerBR); 00191 sc = m_tuple2->addItem ("nlayerWE", m_nlayerWE); 00192 sc = m_tuple2->addItem ("nlayerTotal", m_nlayerTotal); 00193 sc = m_tuple2->addItem ("nhitEE", m_nhitEE); 00194 sc = m_tuple2->addItem ("nhitBR", m_nhitBR); 00195 sc = m_tuple2->addItem ("nhitWE", m_nhitWE); 00196 sc = m_tuple2->addItem ("nhitTotal", m_nhitTotal); 00197 00198 sc = m_tuple2->addItem ("mumcostheta", m_mumcostheta); 00199 sc = m_tuple2->addItem ("mumphi", m_mumphi); 00200 00201 sc = m_tuple2->addItem ("trackfindall", m_trackfindall); 00202 sc = m_tuple2->addItem ("trackfind3l", m_trackfind3l); 00203 sc = m_tuple2->addItem ("trackb", m_trackb); 00204 sc = m_tuple2->addItem ("tracke", m_tracke); 00205 sc = m_tuple2->addItem ("ntrack1", m_ntrack1); 00206 sc = m_tuple2->addItem ("ntrack2", m_ntrack2); 00207 sc = m_tuple2->addItem ("ntrack3", m_ntrack3); 00208 00209 sc = m_tuple2->addItem ("ngoodevent", m_ngoodevent); 00210 sc = m_tuple2->addItem ("ngoodtrack", m_ngoodtrack); 00211 } 00212 else { // did not manage to book the N tuple.... 00213 log << MSG::ERROR <<"Cannot book N-tuple2:" << long(m_tuple2) << endmsg; 00214 return StatusCode::FAILURE; 00215 } 00216 } 00217 00218 NTuplePtr nt3(ntupleSvc(),"FILE302/trig3"); 00219 if ( nt3 ) m_tuple3 = nt3; 00220 else { 00221 m_tuple3=ntupleSvc()->book("FILE302/trig3",CLID_ColumnWiseTuple,"TrigL1"); 00222 if( m_tuple3 ) { 00223 sc = m_tuple3->addItem ("evtId", m_evtId); 00224 for(int index = 0; index < 48; index++) { 00225 std::ostringstream osname1; 00226 osname1 << "cond"<<index<<"_1"; 00227 std::string name1 = osname1.str(); 00228 00229 std::ostringstream osname2; 00230 osname2 << "cond"<<index<<"_0"; 00231 std::string name2 = osname2.str(); 00232 m_tuple3->addItem(name1.c_str(), m_condNOne[index]); 00233 m_tuple3->addItem(name2.c_str(), m_condNZero[index]); 00234 } 00235 00236 } 00237 else { // did not manage to book the N tuple.... 00238 log << MSG::ERROR <<"Cannot book N-tuple3:" << long(m_tuple3) << endmsg; 00239 return StatusCode::FAILURE; 00240 } 00241 } 00242 } 00243 00244 // pointer of mdc trigger 00245 m_MdcTSF = MdcTSF::get_Mdc(); 00246 00247 // pointer of tof trigger 00248 m_TofHitCount = TofHitCount::get_Tof(); 00249 00250 // pointer of emc trigger 00251 m_emcDigi = EmcTCFinder::get_Emc(); 00252 00253 // pointer of muc trigger 00254 m_mucDigi = MucTrigHit::get_Muc(); 00255 00256 //------------------------------------- 00257 // reset total track and event number 00258 //------------------------------------- 00259 totalEvent = 0; 00260 totalTracks = 0; 00261 00262 if(mTrigRootFlag) { 00263 sc = service("THistSvc", m_thistsvc); 00264 if(sc.isFailure() ){ 00265 log << MSG::INFO << "Unable to retrieve pointer to THistSvc" << endreq; 00266 return sc; 00267 } 00268 m_trigCondi_MC = new TH1F( "trgCond_MC", "trgCond_MC", 48, 0, 48 ); 00269 sc = m_thistsvc->regHist("/TRG/trgCond_MC", m_trigCondi_MC); 00270 m_trigCondi_Data = new TH1F( "trgCond_Data", "trgCond_Data", 48, 0, 48 ); 00271 sc = m_thistsvc->regHist("/TRG/trgCond_Data", m_trigCondi_Data); 00272 } 00273 00274 //------------------------------------------------------------------ 00275 // a pointer used to read emc trigger information from eacc board 00276 //------------------------------------------------------------------ 00277 //eacctrig = new TrigEACC("eacc_trig"); 00278 00279 return StatusCode::SUCCESS; 00280 }
void BesTrigL1::runAclock_emc | ( | int | iclock, | |
double | stime, | |||
std::multimap< int, uint32_t, less< int > > | emc_TC, | |||
EmcWaveform * | blockWave | |||
) |
Definition at line 1129 of file BesTrigL1.cxx.
References m_emcDigi, m_pIBGT, EmcTCFinder::setEmcBE(), EmcTCFinder::setEmcTC(), and BesGlobalTrigSvc::startEmcTrig().
Referenced by execute().
01129 { 01130 std::vector<uint32_t> vemcClus; 01131 std::vector<double> vemcBlkE; 01132 01133 vemcClus.clear(); 01134 vemcBlkE.clear(); 01135 //std::cout << "iclock, emc_TC size: " << iclock << ", " << emc_TC.size() << std::endl; 01136 //cluster finding in emc trigger 01137 for(std::multimap<int,uint32_t,less<int> >::iterator emc_iter = emc_TC.begin(); emc_iter != emc_TC.end(); emc_iter++) 01138 { 01139 double time = (emc_iter->first); 01140 if((time < (stime + (iclock + 1)*24.)) && (time + 16*24) > (stime + iclock*24.)) { 01141 vemcClus.push_back(emc_iter->second); 01142 } 01143 } 01144 01145 //energy adding in emc trigger 01146 for(int blockId = 0; blockId < 16; blockId++) { 01147 double block_ADC = (blockWave[blockId]).getADCTrg((int)stime+iclock*24); 01148 vemcBlkE.push_back(block_ADC); 01149 // std::cout << " block_ADC: " << block_ADC << std::endl; 01150 } 01151 //std::cout << "iclock,stime,vemcClus size: " << iclock << "," << stime << ", " << vemcClus.size() << std::endl; 01152 m_emcDigi->setEmcTC(vemcClus); 01153 m_emcDigi->setEmcBE(vemcBlkE); //set block energy 01154 //start EMC trigger logic 01155 m_pIBGT->startEmcTrig(); 01156 }
void BesTrigL1::runAclock_mdc | ( | int | iclock, | |
double | stime, | |||
multimap< int, uint32_t, less< int > > | mdc_hitmap | |||
) |
Definition at line 993 of file BesTrigL1.cxx.
References m_MdcTSF, m_pIBGT, MdcTSF::setMdcDigi(), and BesGlobalTrigSvc::startMdcTrig().
Referenced by execute().
00993 { 00994 std::vector<int> vmdcHit; 00995 vmdcHit.clear(); 00996 00997 std::multimap<int,uint32_t,less<int> >::iterator mdc_iter = mdc_hitmap.begin(); 00998 //int beginclock = int ((mdc_iter->first)*0.09375/24); 00999 01000 //-------------------------- 01001 // consider mdc noise 01002 //-------------------------- 01003 /* 01004 if((iclock - beginclock) >= 0 && (iclock - beginclock) <= 33) { 01005 for(int i = 0; i < 16; i++) { 01006 for(int hit_id = 0; hit_id < 256; hit_id++) { 01007 int layer, wire; 01008 double ratio = -1; 01009 if(i == 0) layer = 8; 01010 if(i == 1) layer = 9; 01011 if(i == 2) layer = 10; 01012 if(i == 3) layer = 11; 01013 if(i == 4) layer = 12; 01014 if(i == 5) layer = 13; 01015 if(i == 6) layer = 14; 01016 if(i == 7) layer = 15; 01017 if(i == 8) layer = 16; 01018 if(i == 9) layer = 17; 01019 if(i == 10) layer = 18; 01020 if(i == 11) layer = 19; 01021 if(i == 12) layer = 36; 01022 if(i == 13) layer = 37; 01023 if(i == 14) layer = 38; 01024 if(i == 15) layer = 39; 01025 01026 if(hit_id < 76) { 01027 if(i == 0) ratio = hit9[hit_id]; 01028 if(i == 1) ratio = hit10[hit_id]; 01029 } 01030 if(hit_id < 88) { 01031 if(i == 2) ratio = hit11[hit_id]; 01032 if(i == 3) ratio = hit12[hit_id]; 01033 } 01034 if(hit_id < 100) { 01035 if(i == 4) ratio = hit13[hit_id]; 01036 if(i == 5) ratio = hit14[hit_id]; 01037 } 01038 if(hit_id < 112) { 01039 if(i == 6) ratio = hit15[hit_id]; 01040 if(i == 7) ratio = hit16[hit_id]; 01041 } 01042 if(hit_id < 128) { 01043 if(i == 8) ratio = hit17[hit_id]; 01044 if(i == 9) ratio = hit18[hit_id]; 01045 } 01046 if(hit_id < 140) { 01047 if(i == 10) ratio = hit19[hit_id]; 01048 if(i == 11) ratio = hit20[hit_id]; 01049 } 01050 if(i == 12) ratio = hit37[hit_id]; 01051 if(i == 13) ratio = hit38[hit_id]; 01052 if(i == 14) ratio = hit39[hit_id]; 01053 if(i == 15) ratio = hit40[hit_id]; 01054 01055 wire = hit_id; 01056 01057 if(RandFlat::shoot() < ratio*(33 - iclock)*24/2000.) { 01058 vmdcHit.push_back(layer); 01059 vmdcHit.push_back(wire); 01060 } 01061 } 01062 } 01063 } 01064 */ 01065 01066 for(std::multimap<int,uint32_t,less<int> >::iterator mdc_iter = mdc_hitmap.begin(); mdc_iter != mdc_hitmap.end(); mdc_iter++) 01067 { 01068 double time = (mdc_iter->first)*0.09375; 01069 if((time < (stime + (iclock + 1)*24.)) && (time + 800.) > (stime + iclock*24.)) { 01070 uint32_t mdcId = mdc_iter->second; 01071 int layer = (mdcId & 0xFFFF0000 ) >> 16; 01072 int cell = mdcId & 0xFFFF; 01073 bool firstdc = true; 01074 //for(std::multimap<int,int,less<int> >::iterator tmp_mdc = mdc_hitmap.begin(); tmp_mdc != mdc_iter; tmp_mdc++) { 01075 // if(mdcId == (tmp_mdc->second)) firstdc = false; 01076 //} 01077 if(firstdc == true) { 01078 vmdcHit.push_back(layer); 01079 vmdcHit.push_back(cell); 01080 } 01081 } 01082 } 01083 01084 //set mdc vector hit 01085 m_MdcTSF->setMdcDigi(vmdcHit); 01086 m_pIBGT->startMdcTrig(); 01087 }
void BesTrigL1::runAclock_tof | ( | int | iclock, | |
double | stime, | |||
int & | idle_status, | |||
std::multimap< int, int, less< int > > | tof_hitmap | |||
) |
Definition at line 1089 of file BesTrigL1.cxx.
References m_pIBGT, m_TofHitCount, TofHitCount::setTofDigi(), and BesGlobalTrigSvc::startTofTrig().
Referenced by execute().
01089 { 01090 std::vector<int> vtofHit; 01091 vtofHit.clear(); 01092 01093 //tof trigger 01094 if(idle_status != -1 && (iclock - idle_status) == 3) idle_status = -1; 01095 for(std::multimap<int,int,less<int> >::iterator tof_iter = tof_hitmap.begin(); tof_iter != tof_hitmap.end(); tof_iter++) 01096 { 01097 double time = (tof_iter->first); //ns 01098 if(idle_status == -1) { 01099 if(time < (stime + (iclock + 1)*24) && time >= (stime + iclock*24)) { 01100 //if(time < (stime + (iclock + 1)*24) && (time + 24) > (stime + iclock*24)) { //stretch signal 01101 vtofHit.push_back(tof_iter->second); 01102 } 01103 } 01104 else { 01105 if((iclock - idle_status) == 1) { 01106 if((time < (stime + (iclock + 1)*24) && time >= (stime + iclock*24)) || 01107 (time < (stime + iclock*24) && time >= (stime + (iclock - 1)*24)) 01108 ) { 01109 vtofHit.push_back(tof_iter->second); 01110 } 01111 } 01112 if((iclock - idle_status) == 2) { 01113 if((time < (stime + (iclock + 1)*24) && time >= (stime + iclock*24)) || 01114 (time < (stime + iclock*24) && time >= (stime + (iclock - 1)*24)) || 01115 (time < (stime + (iclock - 1)*24) && time >= (stime + (iclock - 2)*24)) 01116 ) { 01117 vtofHit.push_back(tof_iter->second); 01118 } 01119 } 01120 } 01121 } 01122 if(idle_status == -1 && vtofHit.size() != 0) idle_status = iclock; 01123 01124 //set tof vector hit 01125 m_TofHitCount->setTofDigi(vtofHit); 01126 m_pIBGT->startTofTrig(); 01127 }
void BesTrigL1::stretchTrgCond | ( | int | nclock, | |
int **& | trgcond | |||
) |
Definition at line 1277 of file BesTrigL1.cxx.
References mdc.
Referenced by execute().
01277 { 01278 int emc_clus = 34; 01279 int emc_ener = 50; 01280 int mdc = 34; 01281 int mdc_n = 68; 01282 int tof = 4; 01283 for(int icond = 0; icond < 48; icond++) { 01284 int sclock = -1; 01285 bool retrig = false; 01286 for(int iclock = 0; iclock < nclock; iclock++) { 01287 if(icond < 16) { //stretch emc trigger conditions 01288 if(icond < 7 || icond == 12 || icond == 13) { // stretch cluster trigger conditions 01289 if(sclock != -1 && iclock - sclock == emc_clus) sclock = -1; 01290 if(sclock == -1 && trgcond[icond][iclock] > 0) { 01291 if(iclock == 0) sclock = iclock; 01292 else { 01293 if(trgcond[icond][iclock]*trgcond[icond][iclock-1] == 0) sclock = iclock; 01294 } 01295 } 01296 if(sclock != -1 && iclock - sclock < emc_clus) trgcond[icond][iclock] = 1; 01297 } 01298 else { //stretch emc energy trigger conditions, re-triggering is available 01299 if(sclock != -1 && iclock - sclock == emc_ener) sclock = -1; 01300 if(sclock == -1 && trgcond[icond][iclock] > 0) { 01301 if(iclock == 0) sclock = iclock; 01302 else { 01303 if(trgcond[icond][iclock]*trgcond[icond][iclock-1] == 0) sclock = iclock; 01304 } 01305 } 01306 if(sclock != -1 && iclock - sclock < emc_ener && trgcond[icond][iclock] == 0) retrig = true; 01307 if(retrig == true) { 01308 if(trgcond[icond][iclock] > 0) { 01309 sclock = iclock; 01310 retrig = false; 01311 } 01312 } 01313 if(sclock != -1 && iclock - sclock < emc_ener) trgcond[icond][iclock] = 1; 01314 } 01315 } 01316 else if(icond >= 16 && icond < 23) { //stretch tof trigger conditions 01317 if(sclock != -1 && iclock - sclock == tof) sclock = -1; 01318 if(sclock == -1 && trgcond[icond][iclock] > 0) { 01319 if(iclock == 0) sclock = iclock; 01320 else { 01321 if(trgcond[icond][iclock]*trgcond[icond][iclock-1] == 0) sclock = iclock; 01322 } 01323 } 01324 if(sclock != -1 && iclock - sclock < tof) trgcond[icond][iclock] = 1; 01325 } 01326 else if(icond >= 38) { //stretch mdc trigger conditions 01327 if(icond == 39|| icond == 43) { 01328 if(sclock != -1 && iclock - sclock == mdc_n) sclock = -1; 01329 if(sclock == -1 && trgcond[icond][iclock] > 0) { 01330 if(iclock == 0) sclock = iclock; 01331 else { 01332 if(trgcond[icond][iclock]*trgcond[icond][iclock-1] == 0) sclock = iclock; 01333 } 01334 } 01335 if(sclock != -1 && iclock - sclock < mdc_n) trgcond[icond][iclock] = 1; 01336 } 01337 else { 01338 if(sclock != -1 && iclock - sclock == mdc) sclock = -1; 01339 if(sclock == -1 && trgcond[icond][iclock] > 0) { 01340 if(iclock == 0) sclock = iclock; 01341 else { 01342 if(trgcond[icond][iclock]*trgcond[icond][iclock-1] == 0) sclock = iclock; 01343 } 01344 } 01345 if(sclock != -1 && iclock - sclock < mdc) trgcond[icond][iclock] = 1; 01346 } 01347 } 01348 else { //stretch other trigger conditions, including track match and muc 01349 } 01350 } 01351 } 01352 }
void BesTrigL1::trgGTLDelay | ( | int | nclock, | |
int **& | trgcond | |||
) |
Definition at line 1373 of file BesTrigL1.cxx.
01373 { 01374 //GTL delay time 01375 int delay[48] = {1,1,1,1,1,1,1,18,18,18,18,18,1,1,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,14,14,14,14,14,14,10,10,10,10,10,10,10,10,10,10}; 01376 01377 for(int icond = 0; icond < 48; icond++) { 01378 for(int iclock = nclock-1; iclock >= 0; iclock--) { 01379 if(iclock < delay[icond]) trgcond[icond][iclock] = 0; 01380 else trgcond[icond][iclock] = trgcond[icond][iclock-delay[icond]]; 01381 } 01382 } 01383 }
void BesTrigL1::trgSAFDelay | ( | int | nclock, | |
int **& | trgcond | |||
) |
Definition at line 1354 of file BesTrigL1.cxx.
01354 { 01355 //SAF delay time 01356 // int delay[48] = {31,31,31,31,31,31,31,7,7,7,7,7,31,31,7,7, 01357 // 135,135,135,135,135,135,135,83,83,83,6,6,6,83,83,83, 01358 // 97,97,97,97,97,97,86,87,85,87,83,85,83,85,122,122}; 01359 int delay[48] = {24,24,24,24,24,24,24,7,7,7,7,7,24,24,7,7, 01360 0,0,0,0,0,0,0,83,83,83,6,6,6,83,83,83, 01361 97,97,97,97,97,97,0,0,0,0,0,0,0,0,122,122}; 01362 01363 for(int icond = 0; icond < 48; icond++) { 01364 for(int iclock = nclock-1; iclock >= 0; iclock--) { 01365 if(iclock < delay[icond]) trgcond[icond][iclock] = 0; 01366 else { 01367 trgcond[icond][iclock] = trgcond[icond][iclock-delay[icond]]; 01368 } 01369 } 01370 } 01371 }
int BesTrigL1::clock_shift [private] |
IEmcCalibConstSvc* BesTrigL1::emcCalibConstSvc [private] |
double BesTrigL1::hit10[76] [private] |
Definition at line 59 of file BesTrigL1.h.
double BesTrigL1::hit11[88] [private] |
Definition at line 59 of file BesTrigL1.h.
double BesTrigL1::hit12[88] [private] |
Definition at line 59 of file BesTrigL1.h.
double BesTrigL1::hit13[100] [private] |
Definition at line 60 of file BesTrigL1.h.
double BesTrigL1::hit14[100] [private] |
Definition at line 60 of file BesTrigL1.h.
double BesTrigL1::hit15[112] [private] |
Definition at line 60 of file BesTrigL1.h.
double BesTrigL1::hit16[112] [private] |
Definition at line 60 of file BesTrigL1.h.
double BesTrigL1::hit17[128] [private] |
Definition at line 61 of file BesTrigL1.h.
double BesTrigL1::hit18[128] [private] |
Definition at line 61 of file BesTrigL1.h.
double BesTrigL1::hit19[140] [private] |
Definition at line 61 of file BesTrigL1.h.
double BesTrigL1::hit20[140] [private] |
Definition at line 61 of file BesTrigL1.h.
double BesTrigL1::hit37[256] [private] |
Definition at line 62 of file BesTrigL1.h.
double BesTrigL1::hit38[256] [private] |
Definition at line 62 of file BesTrigL1.h.
double BesTrigL1::hit39[256] [private] |
Definition at line 62 of file BesTrigL1.h.
double BesTrigL1::hit40[256] [private] |
Definition at line 62 of file BesTrigL1.h.
double BesTrigL1::hit9[76] [private] |
Definition at line 59 of file BesTrigL1.h.
int BesTrigL1::ifoutEvtId [private] |
bool BesTrigL1::ifpass [private] |
std::string BesTrigL1::indexfile [private] |
Definition at line 85 of file BesTrigL1.h.
std::string BesTrigL1::input [private] |
NTuple::Item<long> BesTrigL1::m_block_id [private] |
NTuple::Array<float> BesTrigL1::m_btc_e [private] |
NTuple::Item<long> BesTrigL1::m_cond_id [private] |
NTuple::Item<long> BesTrigL1::m_condNOne[48] [private] |
NTuple::Item<long> BesTrigL1::m_condNZero[48] [private] |
NTuple::Array<float> BesTrigL1::m_costheta [private] |
NTuple::Array<float> BesTrigL1::m_data_blockE [private] |
NTuple::Array<long> BesTrigL1::m_data_btc [private] |
NTuple::Array<long> BesTrigL1::m_data_cond [private] |
NTuple::Item<long> BesTrigL1::m_data_eetotE [private] |
NTuple::Item<float> BesTrigL1::m_data_totE_all [private] |
NTuple::Item<long> BesTrigL1::m_data_wetotE [private] |
NTuple::Item<long> BesTrigL1::m_delta_tdc [private] |
NTuple::Item<float> BesTrigL1::m_eetotE [private] |
EmcTCFinder* BesTrigL1::m_emcDigi [private] |
Definition at line 76 of file BesTrigL1.h.
Referenced by getEmcAnalogSig(), initialize(), and runAclock_emc().
NTuple::Item<long> BesTrigL1::m_EventId [private] |
NTuple::Item<long> BesTrigL1::m_evtId [private] |
NTuple::Array<long> BesTrigL1::m_fireLayer [private] |
NTuple::Array<long> BesTrigL1::m_hitLayer [private] |
NTuple::Array<float> BesTrigL1::m_hitphi [private] |
NTuple::Array<long> BesTrigL1::m_hitSeg [private] |
NTuple::Item<long> BesTrigL1::m_index2 [private] |
NTuple::Item<long> BesTrigL1::m_index3 [private] |
NTuple::Item<long> BesTrigL1::m_index4 [private] |
NTuple::Item<long> BesTrigL1::m_index5 [private] |
NTuple::Item<long> BesTrigL1::m_index6 [private] |
NTuple::Item<long> BesTrigL1::m_index_btc [private] |
NTuple::Array<float> BesTrigL1::m_mc_blockE [private] |
NTuple::Array<long> BesTrigL1::m_mc_cond [private] |
NTuple::Item<float> BesTrigL1::m_mc_totE_all [private] |
IMdcGeomSvc* BesTrigL1::m_MdcGeomSvc [private] |
Definition at line 68 of file BesTrigL1.h.
MdcTSF* BesTrigL1::m_MdcTSF [private] |
MucTrigHit* BesTrigL1::m_mucDigi [private] |
NTuple::Item<float> BesTrigL1::m_mumcostheta [private] |
NTuple::Item<float> BesTrigL1::m_mumphi [private] |
NTuple::Item<long> BesTrigL1::m_ngoodevent [private] |
NTuple::Item<long> BesTrigL1::m_ngoodtrack [private] |
NTuple::Item<long> BesTrigL1::m_nhitBR [private] |
NTuple::Item<long> BesTrigL1::m_nhitEE [private] |
NTuple::Item<long> BesTrigL1::m_nhitTotal [private] |
NTuple::Item<long> BesTrigL1::m_nhitWE [private] |
NTuple::Item<long> BesTrigL1::m_nlayerBR [private] |
NTuple::Item<long> BesTrigL1::m_nlayerEE [private] |
NTuple::Item<long> BesTrigL1::m_nlayerTotal [private] |
NTuple::Item<long> BesTrigL1::m_nlayerWE [private] |
NTuple::Item<long> BesTrigL1::m_ntrack1 [private] |
NTuple::Item<long> BesTrigL1::m_ntrack2 [private] |
NTuple::Item<long> BesTrigL1::m_ntrack3 [private] |
NTuple::Array<float> BesTrigL1::m_p [private] |
NTuple::Array<float> BesTrigL1::m_pdgcode [private] |
NTuple::Array<float> BesTrigL1::m_phi [private] |
BesGlobalTrigSvc* BesTrigL1::m_pIBGT [private] |
Definition at line 64 of file BesTrigL1.h.
Referenced by execute(), getEmcAnalogSig(), initialize(), runAclock_emc(), runAclock_mdc(), and runAclock_tof().
NTuple::Array<float> BesTrigL1::m_R_blockE [private] |
RealizationSvc* BesTrigL1::m_RealizationSvc [private] |
NTuple::Item<long> BesTrigL1::m_RunId [private] |
int BesTrigL1::m_runMode [private] |
ITHistSvc* BesTrigL1::m_thistsvc [private] |
IBesGlobalTrigSvc* BesTrigL1::m_tmpSvc [private] |
TofHitCount* BesTrigL1::m_TofHitCount [private] |
NTuple::Item<long> BesTrigL1::m_trackb [private] |
NTuple::Item<long> BesTrigL1::m_tracke [private] |
NTuple::Item<long> BesTrigL1::m_trackfind3l [private] |
NTuple::Item<long> BesTrigL1::m_trackfindall [private] |
TH1F* BesTrigL1::m_trigCondi_Data [private] |
TH1F* BesTrigL1::m_trigCondi_MC [private] |
NTuple::Tuple* BesTrigL1::m_tuple [private] |
NTuple::Tuple* BesTrigL1::m_tuple1 [private] |
NTuple::Tuple* BesTrigL1::m_tuple2 [private] |
NTuple::Tuple* BesTrigL1::m_tuple3 [private] |
NTuple::Item<float> BesTrigL1::m_wetotE [private] |
NTuple::Item<long> BesTrigL1::m_wire_evtId [private] |
NTuple::Item<float> BesTrigL1::m_wire_x [private] |
NTuple::Item<float> BesTrigL1::m_wire_y [private] |
ifstream BesTrigL1::mdc_hit [private] |
Definition at line 81 of file BesTrigL1.h.
bool BesTrigL1::mTrigRootFlag [private] |
int BesTrigL1::nEvent [private] |
std::string BesTrigL1::outEvtId [private] |
std::string BesTrigL1::output [private] |
int BesTrigL1::passNo [private] |
ifstream BesTrigL1::readin [private] |
ofstream BesTrigL1::readout [private] |
TrigTOFT* BesTrigL1::toftrig [private] |
Definition at line 178 of file BesTrigL1.h.
int BesTrigL1::totalEvent [private] |
int BesTrigL1::totalTracks [private] |
int BesTrigL1::writeFile [private] |