BOSS6.5.5: BesTrigL1 Class Reference

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 }

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     SmartDataPtr<TrigData> trigData(eventSvc(), "/Event/Trig/TrigData");
00616     if (!trigData) {
00617       log << MSG::FATAL << "Could not find Trigger Data for physics analysis" << endreq;
00618       return StatusCode::FAILURE;
00619     }
00620 
00621     for(int id = 0; id < 48; id++) {
00622       if(trigData->getTrigCondition(id) != 0) { m_trigCondi_Data->Fill(id); }
00623       m_data_cond[id] = trigData->getTrigCondition(id);
00624     }
00625     m_cond_id = 48;
00626 
00627   }
00628 
00629   //----------------------------
00630   // release memory
00631   //----------------------------
00632   for(int condId = 0; condId < 48; condId++) {
00633     delete trgcond[condId];
00634   }
00635   delete trgcond;
00636 
00637 
00638   if(mTrigRootFlag) { 
00639     m_evtId = event;
00640     m_tuple3->write();
00641 
00642     m_mc_totE_all = m_pIBGT->getEmcTotE();
00643     m_wetotE = m_pIBGT->getEmcWETotE();
00644     m_eetotE = m_pIBGT->getEmcEETotE();
00645  
00646     map<int,vector<complex<int> >, greater<int> > mymap;
00647     mymap = m_pIBGT->getEmcClusId();
00648     log<<MSG::INFO<<"EMC test: "<<endreq;
00649     int emc_btc_id = 0;
00650     for(map<int,vector<complex<int> >, greater<int> >::iterator iter=mymap.begin(); iter!=mymap.end(); iter++) {
00651       if((iter->first)==1) {
00652         for(unsigned int i=0; i<(iter->second).size(); i++) {
00653           log<<MSG::INFO<<"barrel theta is "<<(iter->second[i]).real()<<" phi is "<<(iter->second[i]).imag()<<endreq;
00654           emc_btc_id++;
00655         } 
00656       }
00657       if((iter->first)==0) {
00658         for(unsigned int i=0; i<(iter->second).size(); i++)
00659           log<<MSG::INFO<<"east theta is "<<(iter->second[i]).real()<<" phi is "<<(iter->second[i]).imag()<<endreq;
00660       }
00661       if((iter->first)==2) {
00662         for(unsigned int i=0; i<(iter->second).size(); i++)
00663           log<<MSG::INFO<<"west theta is "<<(iter->second[i]).real()<<" phi is "<<(iter->second[i]).imag()<<endreq;
00664       }
00665     }
00666 
00667     //retrieve EMC trigger information from EACC
00668   /*  SmartDataPtr<TrigGTDCol> trigGTDCol(eventSvc(), "/Event/Trig/TrigGTDCol");
00669     if (!trigGTDCol) {
00670       log << MSG::FATAL << "Could not find Global Trigger Data" << endreq;
00671       return StatusCode::FAILURE;
00672     }
00673     eacctrig->initialize();
00674     TrigGTDCol::iterator iter5 = trigGTDCol->begin();
00675     for (; iter5 != trigGTDCol->end(); iter5++) {
00676       uint32_t size = (*iter5)->getDataSize();
00677       const uint32_t* ptr = (*iter5)->getDataPtr();
00678       //set EACC trigger data
00679       if((*iter5)->getId() == 0xD7) {
00680         eacctrig->setEACCTrigData((*iter5)->getId(), (*iter5)->getTimeWindow(), size, ptr);
00681       }
00682     }
00683 
00684     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};
00685     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};
00686     vector<double> vblockE = m_pIBGT->getEmcBlockE();
00687     for(int blockId = 0; blockId < vblockE.size(); blockId++) {
00688       //m_mc_blockE[blockId] = vblockE[blockId]; 
00689       int block_time;
00690       m_mc_blockE[blockId] = blockWave[blockId+2].max(block_time)*0.333 - 0xa + RandGauss::shoot(bmean[blockId],bsigma[blockId]); 
00691       m_data_blockE[blockId] = eacctrig->getBBLKCharge(blockId);
00692       float r_blockE;
00693       if((eacctrig->getBBLKCharge(blockId) - bmean[blockId]) == 0.) r_blockE = 0; 
00694       else r_blockE = vblockE[blockId]/(eacctrig->getBBLKCharge(blockId) - bmean[blockId]);
00695       if(!(r_blockE >=0. || r_blockE <= 0.)) r_blockE = 0;
00696       m_R_blockE[blockId] = r_blockE;
00697     }   
00698     m_block_id = vblockE.size();
00699 
00700     m_data_totE_all = eacctrig->getEMCTotalCharge();
00701     //endcap energy
00702     int ee_endcap = 0, we_endcap = 0;
00703     for(int i = 0; i < 2; i++) {
00704       ee_endcap += eacctrig->getEBLKCharge(i);
00705       we_endcap += eacctrig->getWBLKCharge(i);
00706     }
00707     m_data_wetotE = we_endcap;
00708     m_data_eetotE = ee_endcap;
00709 
00710     m_data_totE_all = eacctrig->getEMCTotalCharge();
00711   
00712     //fill trigger cell energy
00713     int window = eacctrig->getTimeWindow();
00714     int index_tc = 0;
00715     for(int i=0;i<TrigConf::TCTHETANO_B;i++)
00716       for(int j=0;j<TrigConf::TCPHINO_B;j++)
00717       {
00718         m_btc_e[index_tc] = m_pIBGT->getBTCEnergy(i,j);
00719         int if_clus = 0;
00720         for(int k = 0; k < window; k++) {
00721           if(eacctrig->getBTC(i,j,k) == 1) {
00722             if_clus = 1;
00723             break;
00724           }
00725         }
00726         m_data_btc[index_tc] = if_clus;
00727         index_tc++;
00728       }
00729     m_index_btc = index_tc;
00730     
00731     index_tc = 0;
00732     for(int i =0;i<TrigConf::TCTHETANO_E;i++)
00733       for(int j =0;j<TrigConf::TCPHINO_E;j++)
00734       { 
00735         //m_wetc_e[index_tc] = m_pIBGT->getWETCEnergy(i,j);
00736         //m_eetc_e[index_tc] = m_pIBGT->getEETCEnergy(i,j);
00737         index_tc++;
00738       }
00739     //m_index_etc = index_tc;
00740 */
00741     m_tuple1->write();
00742 
00743     //----------------------------------------------
00744     // check information of MDC, TOF, EMC output
00745     //----------------------------------------------
00746     vector<int> vstrkId;
00747     vector<int> vltrkId;
00748     vstrkId = m_pIBGT->getMdcStrkId();
00749     vltrkId = m_pIBGT->getMdcLtrkId();
00750     log<<MSG::INFO<<"Mdc test: "<<endreq;
00751     for(unsigned int i=0; i<vstrkId.size(); i++) log<<MSG::INFO<<"short is "<<vstrkId[i]<<endreq;
00752     for(unsigned int j=0; j<vltrkId.size(); j++) { log<<MSG::INFO<<"long is "<<vltrkId[j]<<endreq; }
00753 
00754     map<int,vector<int>,greater<int> > tofmap;
00755     tofmap = m_pIBGT->getTofHitPos();
00756     log<<MSG::INFO<<"TOF test: "<<endreq;
00757     for(map<int,vector<int>,greater<int> >::iterator iter=tofmap.begin(); iter!=tofmap.end(); iter++) {
00758       if(iter->first == 0) {
00759         for(unsigned int i=0; i<iter->second.size(); i++) { 
00760           log<<MSG::INFO<<"east tof Id is "<<iter->second[i]<<endreq; 
00761         }
00762       }
00763       if(iter->first == 1) {
00764         for(unsigned int i=0; i<iter->second.size(); i++) { log<<MSG::INFO<<" barrel tof Id is "<<iter->second[i]<<endreq; }
00765       }
00766       if(iter->first == 2) {
00767         for(unsigned int i=0; i<iter->second.size(); i++) { log<<MSG::INFO<<"west tof Id is "<<iter->second[i]<<endreq; }
00768       }
00769     }
00770 
00771     //Fill ntuple for MUC
00772     std::vector<int> vtmp;
00773 
00774     vtmp = m_pIBGT->getMuclayerSeg();
00775     m_index2 = 0;
00776     for(std::vector<int>::iterator iter = vtmp.begin(); iter != vtmp.end(); iter++) {
00777       m_fireLayer[m_index2] = (long) *iter;
00778       m_index2++;
00779       if(m_index2 > m_index2->range().distance()) { break; cerr<<"*********** too many index ************"<<endl; }
00780     }
00781     //find tracks by count the fired layer number
00782     long trackb3=0, tracke3=0, trackb2=0, tracke2=0, trackb1=0, tracke1=0;
00783     int trackwe = 0, trackee = 0;
00784     for(unsigned int i=0; i<vtmp.size(); i++) {
00785       if(0<=vtmp[i]&&vtmp[i]<100) {
00786         if((vtmp[i]%10)>=3) { tracke3++; trackee++; }
00787       }
00788       if(200<=vtmp[i]) {
00789         if(((vtmp[i]-200)%10)>=3) { tracke3++; trackwe++; }
00790       }
00791       if(100<=vtmp[i]&&vtmp[i]<200) {
00792         if(((vtmp[i]-100)%10)>=3) trackb3++;
00793       }
00794     }
00795     m_ntrack3 = trackb3 + tracke3;
00796 
00797     for(unsigned int i=0; i<vtmp.size(); i++) {
00798       if(0<=vtmp[i]&&vtmp[i]<100) {
00799         if((vtmp[i]%10)>=2) tracke2++;
00800       }
00801       if(200<=vtmp[i]) {
00802         if(((vtmp[i]-200)%10)>=2) tracke2++;
00803       }
00804       if(100<=vtmp[i]&&vtmp[i]<200) {
00805         if(((vtmp[i]-100)%10)>=2) trackb2++;
00806       }
00807     }
00808     m_ntrack2 = trackb2 + tracke2;
00809 
00810     for(unsigned int i=0; i<vtmp.size(); i++) {
00811       if(0<=vtmp[i]&&vtmp[i]<100) {
00812         if((vtmp[i]%10)>=1) tracke1++;
00813         }
00814         if(200<=vtmp[i]) {
00815         if(((vtmp[i]-200)%10)>=1) tracke1++;
00816       }
00817       if(100<=vtmp[i]&&vtmp[i]<200) {
00818         if(((vtmp[i]-100)%10)>=1) trackb1++;
00819       }
00820     }
00821     m_ntrack1 = trackb1 + tracke1;
00822     //end of finding tracks by count the fired layer number
00823 
00824     vtmp = m_pIBGT->getMuchitLayer();
00825     m_index3 = 0;
00826     for(std::vector<int>::iterator iter = vtmp.begin(); iter != vtmp.end(); iter++) {
00827       m_hitLayer[m_index3] = (long) *iter;
00828       m_index3++;
00829       if(m_index3 > m_index3->range().distance()) { break; cerr<<"*********** too many index ************"<<endl; }
00830     }
00831  
00832     vtmp = m_pIBGT->getMuchitSeg();
00833     m_index4 = 0;
00834     for(std::vector<int>::iterator iter = vtmp.begin(); iter != vtmp.end(); iter++) {
00835       m_hitSeg[m_index4] =  *(iter);
00836       m_index4++;
00837       if(m_index4 > m_index4->range().distance()) { break; cerr<<"*********** too many index ************"<<endl; }
00838     }
00839   } // end fill ntuple
00840 
00841   //---------------------------------------------------
00842   // write out event number which not passed trigger.
00843   //---------------------------------------------------
00844   if(ifoutEvtId==1)
00845   {
00846     ofstream eventnum(outEvtId.c_str(),ios_base::app);
00847     if(!ifpass)
00848       eventnum<<event<<endl;
00849     eventnum.close();
00850   }
00851   
00852   //-------------------------------------------------
00853   // write out event number which passed trigger.
00854   //-------------------------------------------------
00855   if(ifoutEvtId==2)
00856   {
00857     ofstream eventnum(outEvtId.c_str(),ios_base::app);
00858     if(ifpass)
00859       eventnum<<event<<endl;
00860     eventnum.close();
00861   }
00862 
00863   //--------------------------------------------------------
00864   // write out events (passed trigger) into an ascii file
00865   //--------------------------------------------------------
00866   if(writeFile==1) 
00867   {
00868     EVENT asciiEvt;
00869     readin >> asciiEvt;
00870     if(asciiEvt.header.eventNo == event)
00871     {
00872       if(ifpass==true)
00873       readout<<asciiEvt<<endl;
00874     }
00875     else 
00876     cout<<"********* Event No. from AsciiFile do not equal Event No. from TDS "
00877          <<asciiEvt.header.eventNo<<" "<<event<<endl;
00878   }
00879 
00880   //--------------------------------------------------------------
00881   // if it is offline mode, register trigger information into TDS
00882   //--------------------------------------------------------------
00883   if(m_runMode == 1) {
00884     const int* trigcond = m_pIBGT->getTrigCond();
00885     const int* trigchan = m_pIBGT->getTrigChan();
00886     int window = 0;
00887     int timing = 0;
00888     bool preScale = false;
00889 
00890     StatusCode sc = StatusCode::SUCCESS ;
00891     TrigEvent* aTrigEvent = new TrigEvent;
00892     sc = eventSvc()->registerObject("/Event/Trig",aTrigEvent);
00893     if(sc!=StatusCode::SUCCESS) {
00894       log<<MSG::DEBUG<< "Could not register TrigEvent, you can ignore." <<endreq;
00895     }
00896 
00897     TrigData* aTrigData = new TrigData(window, timing, trigcond, trigchan, preScale);
00898     sc = eventSvc()->registerObject("/Event/Trig/TrigData",aTrigData);
00899     if(sc!=StatusCode::SUCCESS) {
00900       log<<MSG::ERROR<< "Could not register TrigData!!!!!" <<endreq;
00901     }
00902   }
00903 
00904   return StatusCode::SUCCESS;  
00905 }

00907                                {
00908 
00909   MsgStream msg(msgSvc(), name());
00910   msg << MSG::DEBUG << "==> Finalize BesTrigL1" << endreq;
00911 
00912   if(writeFile==1)
00913   {
00914     readin.close();
00915     readout.close();
00916   }
00917   cout<<"There are total "<< passNo<<" event pass trigger"<<endl;
00918   return StatusCode::SUCCESS;
00919 }

01259                                                                          {
01260   double tot_block_max = 0;
01261   for(int i = 0; i < 16; i++) {
01262     int block_time;
01263     double block_max = blockWave[i].max(block_time);
01264     tot_block_max += block_max;
01265   }
01266 
01267   for(int i = 0; i < 16; i++) {
01268     if(tot_block_max == 0) break;
01269     int block_time;
01270     double block_max = blockWave[i].max(block_time);
01271     block_time = block_time*50;
01272     peak_time += block_max/tot_block_max*block_time;
01273   }
01274 }

00922                                                          {
00923   std::multimap<int,uint32_t,less<int> >::iterator mdc_iter = mdc_hitmap.begin();
00924   double smdctime = -1, emdctime = -1;
00925   if(mdc_hitmap.size() != 0) {
00926     smdctime = (mdc_iter->first)*0.09375;
00927     mdc_iter = mdc_hitmap.end();
00928     mdc_iter--;
00929     emdctime = (mdc_iter->first)*0.09375;
00930   }
00931 
00932   std::multimap<int,int,less<int> >::iterator tof_iter = tof_hitmap.begin();
00933   double stoftime = -1, etoftime = -1;
00934   if(tof_hitmap.size() != 0) {
00935     stoftime = (tof_iter->first);
00936     tof_iter = tof_hitmap.end();
00937     tof_iter--;
00938     etoftime = (tof_iter->first);
00939   }
00940 
00941   std::multimap<int,uint32_t,less<int> >::iterator emc_iter = emc_TC.begin();
00942   double semctime = -1, eemctime = -1;
00943   if(emc_TC.size() != 0) {
00944     semctime = (emc_iter->first);
00945     emc_iter = emc_TC.end();
00946     emc_iter--;
00947     eemctime = (emc_iter->first);
00948   }
00949 
00950   stime = -1, etime = -1;
00951   if(smdctime >= 0 && stoftime >= 0) {
00952     if(smdctime > stoftime) stime = stoftime;
00953     else stime = smdctime;
00954 
00955     if((emdctime+800) > (etoftime + 24)) etime = emdctime+800;
00956     else etime = etoftime + 24;
00957   }
00958   else if(smdctime < 0 && stoftime >= 0) {
00959     stime = stoftime;
00960     etime = etoftime + 24;
00961   }
00962   else if(smdctime >= 0 && stoftime < 0) {
00963     stime = smdctime;
00964     etime = emdctime+800;
00965   }
00966   else {
00967     stime = -1;
00968     etime = -1;
00969   }
00970   //compare with emc time
00971   if(semctime >= 0 && stime >= 0) {
00972     if(semctime > stime) stime = stime;
00973     else stime = semctime;
00974 
00975     if((eemctime+16*24) > etime) etime = eemctime+16*24;
00976     else etime = etime;
00977   }
00978   else if(semctime < 0 && stime >= 0) {
00979     stime = stime;
00980     etime = etime;
00981   }
00982   else if(semctime >= 0 && stime < 0) {
00983     stime = semctime;
00984     etime = eemctime+16*24;
00985   }
00986   else {
00987     stime = -1;
00988     etime = -1;
00989   }
00990 }

01157                                                                                                                                {
01158   EmcWaveform eewave[32];
01159   EmcWaveform wewave[32];
01160   EmcWaveform bwave[11][30];
01161 
01162   for(int i = 0; i < 11; i++) {
01163     for(int j = 0; j < 30; j++) {
01164       bwave[i][j].makeWaveformTrg(0,0);
01165     } 
01166   } 
01167   for(int i = 0; i < 32; i++) {
01168     if(i < 16) blockWave[i].makeWaveformTrg(0,0);
01169     eewave[i].makeWaveformTrg(0,0);
01170     wewave[i].makeWaveformTrg(0,0);
01171   }
01172 
01173   for (EmcDigiCol::iterator iter3=emcDigiCol->begin();iter3!= emcDigiCol->end();iter3++) {
01174     Identifier id=(*iter3)->identify();
01175     unsigned int module = EmcID::barrel_ec(id);
01176     unsigned int theta = EmcID::theta_module(id);
01177     unsigned int phi = EmcID::phi_module(id);
01178 
01179     int index = emcCalibConstSvc->getIndex(module,theta,phi);
01180     double trgGain = m_RealizationSvc->getTrgGain(index);
01181     double adc = (double) (*iter3)->getChargeChannel();
01182     double mv = RandGauss::shoot(978.,14.);
01183     
01184     if((*iter3)->getMeasure()==0) adc = adc*2*mv*2/65535.*(trgGain);
01185     else if((*iter3)->getMeasure()==1) adc = adc*16*mv*2/65535*(trgGain);
01186     else adc = adc*64*mv*2/65535*(trgGain);
01187 
01188     unsigned int tdc = (*iter3)->getTimeChannel();
01189     int theTC = m_emcDigi->getTCThetaId(module,theta,phi);
01190     int phiTC = m_emcDigi->getTCPhiId(module,theta,phi);
01191     EmcWaveform wave1;
01192     if(module == 0) { wave1.makeWaveformTrg(adc,tdc+80); eewave[phiTC] += wave1; }
01193     if(module == 1) { wave1.makeWaveformTrg(adc,tdc+80); bwave[theTC][phiTC] += wave1; }
01194     if(module == 2) { wave1.makeWaveformTrg(adc,tdc+80); wewave[phiTC] += wave1; }
01195   }
01196 
01197   //find barrel cluster
01198   for(int i = 0; i < 11; i++) {
01199     for(int j = 0; j < 30; j++) {
01200       int time_low = bwave[i][j].frontEdgeTrg(m_pIBGT->getL1TC_GATE());
01201       int time_high = bwave[i][j].frontEdgeTrg(m_pIBGT->getL1TC_THRESH());
01202       int time = -1;
01203 
01204       if(time_high >= 0) {
01205         if(time_low*50+1500 > time_high*50) time = time_low*50 + 1500;
01206         else time = time_high*50;
01207         uint32_t TCID = (1 & 0xFF) << 16;
01208         TCID = TCID | ((i & 0xFF) << 8);
01209         TCID = TCID | (j & 0xFF);
01210         typedef pair<int, uint32_t > vpair;
01211         emc_TC.insert(vpair(time,TCID));
01212         //std::cout <<"i, j: " << i << ", " << j << "  time: " << time << std::endl;
01213       }
01214       if(time_low >= 0) {
01215         int blockId = m_emcDigi->getBLKId(i,j);
01216         blockWave[blockId+2] += bwave[i][j];
01217       }
01218     }
01219   }
01220   //find end cap cluster
01221   for(int i = 0; i < 32; i++) {
01222     //east end cap
01223     int time_low1 = eewave[i].frontEdgeTrg(m_pIBGT->getL1TC_GATE());
01224     int time_high1 = eewave[i].frontEdgeTrg(m_pIBGT->getL1TC_THRESH());
01225     int time1 = -1;
01226     if(time_high1 >= 0) {
01227       if(time_low1*50+1500 > time_high1*50) time1 = time_low1*50 + 1500;
01228       else time1 = time_high1*50;
01229       uint32_t TCID1 = (0 & 0xFF) << 16;
01230       TCID1 = TCID1 | ((0 & 0xFF) << 8);
01231       TCID1 = TCID1 | (i & 0xFF);
01232       typedef pair<int, uint32_t > vpair;
01233       emc_TC.insert(vpair(time1,TCID1));
01234     }
01235     if(time_low1 >= 0) {
01236       if(i<16) blockWave[0] += eewave[i];
01237       else blockWave[1] += eewave[i];
01238     }
01239     //west end cap
01240     int time_low2 = wewave[i].frontEdgeTrg(m_pIBGT->getL1TC_GATE());
01241     int time_high2 = wewave[i].frontEdgeTrg(m_pIBGT->getL1TC_THRESH());
01242     int time2 = -1;
01243     if(time_high2 >= 0) {
01244       if(time_low2*50+1500 > time_high2*50) time2 = time_low2*50 + 1500;
01245       else time2 = time_high2*50;
01246       uint32_t TCID2 = (2 & 0xFF) << 16;
01247       TCID2 = TCID2 | ((0 & 0xFF) << 8);
01248       TCID2 = TCID2 | (i & 0xFF);
01249       typedef pair<int, uint32_t > vpair;
01250       emc_TC.insert(vpair(time2,TCID2));
01251     }
01252     if(time_low2 >= 0) {
01253       if(i<16) blockWave[14] += wewave[i];
01254       else blockWave[15] += wewave[i];
01255     }
01256   }
01257 }

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 }

01128                                                                                                                            {
01129   std::vector<uint32_t> vemcClus;
01130   std::vector<double> vemcBlkE;
01131 
01132   vemcClus.clear();
01133   vemcBlkE.clear();
01134   //std::cout << "iclock, emc_TC size: " << iclock << ", " << emc_TC.size() << std::endl;
01135   //cluster finding in emc trigger
01136   for(std::multimap<int,uint32_t,less<int> >::iterator emc_iter = emc_TC.begin(); emc_iter != emc_TC.end(); emc_iter++)
01137   {
01138     double time = (emc_iter->first);
01139     if((time < (stime + (iclock + 1)*24.)) && (time + 16*24) > (stime + iclock*24.)) {
01140       vemcClus.push_back(emc_iter->second);
01141     } 
01142   }
01143   
01144   //energy adding in emc trigger
01145   for(int blockId = 0; blockId < 16; blockId++) {
01146     double block_ADC = (blockWave[blockId]).getADCTrg((int)stime+iclock*24);
01147     vemcBlkE.push_back(block_ADC);
01148    // std::cout << " block_ADC: " << block_ADC << std::endl;
01149   } 
01150   //std::cout << "iclock,stime,vemcClus size: " << iclock << "," << stime << ", " << vemcClus.size() << std::endl;  
01151   m_emcDigi->setEmcTC(vemcClus);
01152   m_emcDigi->setEmcBE(vemcBlkE); //set block energy
01153   //start EMC trigger logic
01154   m_pIBGT->startEmcTrig(); 
01155 }

00992                                                                                                     {
00993   std::vector<int> vmdcHit;
00994   vmdcHit.clear();
00995  
00996   std::multimap<int,uint32_t,less<int> >::iterator mdc_iter = mdc_hitmap.begin();
00997   //int beginclock = int ((mdc_iter->first)*0.09375/24);
00998 
00999   //--------------------------
01000   // consider mdc noise
01001   //--------------------------
01002   /*
01003   if((iclock - beginclock) >= 0 && (iclock - beginclock) <= 33) {
01004     for(int i = 0; i < 16; i++) {
01005       for(int hit_id = 0; hit_id < 256; hit_id++) {
01006         int layer, wire;
01007         double ratio = -1;
01008         if(i == 0) layer = 8;
01009         if(i == 1) layer = 9;
01010         if(i == 2) layer = 10;
01011         if(i == 3) layer = 11;
01012         if(i == 4) layer = 12;
01013         if(i == 5) layer = 13;
01014         if(i == 6) layer = 14;
01015         if(i == 7) layer = 15;
01016         if(i == 8) layer = 16;
01017         if(i == 9) layer = 17;
01018         if(i == 10) layer = 18;
01019         if(i == 11) layer = 19;
01020         if(i == 12) layer = 36;
01021         if(i == 13) layer = 37;
01022         if(i == 14) layer = 38;
01023         if(i == 15) layer = 39;
01024         
01025         if(hit_id < 76) {
01026           if(i == 0) ratio = hit9[hit_id];
01027           if(i == 1) ratio = hit10[hit_id];
01028         }
01029         if(hit_id < 88) {
01030           if(i == 2) ratio = hit11[hit_id];
01031           if(i == 3) ratio = hit12[hit_id];
01032         }
01033         if(hit_id < 100) { 
01034           if(i == 4) ratio = hit13[hit_id];
01035           if(i == 5) ratio = hit14[hit_id];
01036         }
01037         if(hit_id < 112) { 
01038           if(i == 6) ratio = hit15[hit_id];
01039           if(i == 7) ratio = hit16[hit_id];
01040         }
01041         if(hit_id < 128) { 
01042           if(i == 8) ratio = hit17[hit_id];
01043           if(i == 9) ratio = hit18[hit_id];
01044         }
01045         if(hit_id < 140) {
01046           if(i == 10) ratio = hit19[hit_id];
01047           if(i == 11) ratio = hit20[hit_id];
01048         }
01049         if(i == 12) ratio = hit37[hit_id];
01050         if(i == 13) ratio = hit38[hit_id];
01051         if(i == 14) ratio = hit39[hit_id];
01052         if(i == 15) ratio = hit40[hit_id];
01053        
01054         wire = hit_id;
01055           
01056         if(RandFlat::shoot() < ratio*(33 - iclock)*24/2000.) {
01057           vmdcHit.push_back(layer);
01058           vmdcHit.push_back(wire);
01059         }
01060       }
01061     }
01062   }
01063   */
01064 
01065   for(std::multimap<int,uint32_t,less<int> >::iterator mdc_iter = mdc_hitmap.begin(); mdc_iter != mdc_hitmap.end(); mdc_iter++)
01066   {
01067     double time = (mdc_iter->first)*0.09375;
01068     if((time < (stime + (iclock + 1)*24.)) && (time + 800.) > (stime + iclock*24.)) {
01069       uint32_t mdcId = mdc_iter->second;
01070       int layer =  (mdcId & 0xFFFF0000 ) >> 16;
01071       int cell = mdcId & 0xFFFF;
01072       bool firstdc = true;
01073       //for(std::multimap<int,int,less<int> >::iterator tmp_mdc = mdc_hitmap.begin(); tmp_mdc != mdc_iter; tmp_mdc++) {
01074       //  if(mdcId == (tmp_mdc->second)) firstdc = false;
01075       //} 
01076       if(firstdc == true) {
01077         vmdcHit.push_back(layer);
01078         vmdcHit.push_back(cell);
01079       }
01080     }
01081   }
01082 
01083   //set mdc vector hit
01084   m_MdcTSF->setMdcDigi(vmdcHit);
01085   m_pIBGT->startMdcTrig();
01086 }

01088                                                                                                                     {
01089   std::vector<int> vtofHit;
01090   vtofHit.clear();
01091 
01092   //tof trigger
01093   if(idle_status != -1 && (iclock - idle_status) == 3) idle_status = -1;
01094   for(std::multimap<int,int,less<int> >::iterator tof_iter = tof_hitmap.begin(); tof_iter != tof_hitmap.end(); tof_iter++)
01095   {
01096     double time = (tof_iter->first); //ns
01097     if(idle_status == -1) {
01098       if(time < (stime + (iclock + 1)*24) && time >= (stime + iclock*24)) {
01099       //if(time < (stime + (iclock + 1)*24) && (time + 24) > (stime + iclock*24)) { //stretch signal
01100         vtofHit.push_back(tof_iter->second);
01101       }
01102     }
01103     else {
01104       if((iclock - idle_status) == 1) {
01105         if((time < (stime + (iclock + 1)*24) && time >= (stime + iclock*24)) ||
01106            (time < (stime + iclock*24) && time >= (stime + (iclock - 1)*24))
01107           ) {
01108           vtofHit.push_back(tof_iter->second);
01109         }
01110       }
01111       if((iclock - idle_status) == 2) {
01112         if((time < (stime + (iclock + 1)*24) && time >= (stime + iclock*24)) ||
01113            (time < (stime + iclock*24) && time >= (stime + (iclock - 1)*24)) ||
01114            (time < (stime + (iclock - 1)*24) && time >= (stime + (iclock - 2)*24))
01115           ) {
01116           vtofHit.push_back(tof_iter->second);
01117         }
01118       }
01119     }
01120   }
01121   if(idle_status == -1 && vtofHit.size() != 0) idle_status = iclock;
01122 
01123   //set tof vector hit
01124   m_TofHitCount->setTofDigi(vtofHit);
01125   m_pIBGT->startTofTrig();
01126 }

01276                                                           {
01277   int emc_clus = 34;
01278   int emc_ener = 50;
01279   int mdc = 34;
01280   int mdc_n = 68;
01281   int tof = 4;
01282   for(int icond = 0; icond < 48; icond++) {
01283     int sclock = -1;
01284     bool retrig = false;
01285     for(int iclock = 0; iclock < nclock; iclock++) {
01286       if(icond < 16) { //stretch emc trigger conditions
01287         if(icond < 7 || icond == 12 || icond == 13) { // stretch cluster trigger conditions
01288           if(sclock != -1 && iclock - sclock == emc_clus) sclock = -1;
01289           if(sclock == -1 && trgcond[icond][iclock] > 0) {
01290             if(iclock == 0) sclock = iclock;
01291             else {
01292               if(trgcond[icond][iclock]*trgcond[icond][iclock-1] == 0) sclock = iclock;
01293             }
01294           } 
01295           if(sclock != -1 && iclock - sclock < emc_clus) trgcond[icond][iclock] = 1;  
01296         }
01297         else { //stretch emc energy trigger conditions, re-triggering is available
01298           if(sclock != -1 && iclock - sclock == emc_ener) sclock = -1;
01299           if(sclock == -1 && trgcond[icond][iclock] > 0) {
01300             if(iclock == 0) sclock = iclock;
01301             else {
01302               if(trgcond[icond][iclock]*trgcond[icond][iclock-1] == 0) sclock = iclock;
01303             }
01304           }
01305           if(sclock != -1 && iclock - sclock < emc_ener && trgcond[icond][iclock] == 0) retrig = true;
01306           if(retrig == true) {
01307             if(trgcond[icond][iclock] > 0) {
01308               sclock = iclock;
01309               retrig = false;
01310             }
01311           }
01312           if(sclock != -1 && iclock - sclock < emc_ener) trgcond[icond][iclock] = 1;
01313         } 
01314       }
01315       else if(icond >= 16 && icond < 23) { //stretch tof trigger conditions
01316         if(sclock != -1 && iclock - sclock == tof) sclock = -1;
01317           if(sclock == -1 && trgcond[icond][iclock] > 0) {
01318             if(iclock == 0) sclock = iclock;
01319             else {
01320               if(trgcond[icond][iclock]*trgcond[icond][iclock-1] == 0) sclock = iclock;
01321             }
01322           }
01323           if(sclock != -1 && iclock - sclock < tof) trgcond[icond][iclock] = 1;
01324       }
01325       else if(icond >= 38) { //stretch mdc trigger conditions
01326         if(icond == 39|| icond == 43) {
01327           if(sclock != -1 && iclock - sclock == mdc_n) sclock = -1;
01328           if(sclock == -1 && trgcond[icond][iclock] > 0) {
01329             if(iclock == 0) sclock = iclock;
01330             else {
01331               if(trgcond[icond][iclock]*trgcond[icond][iclock-1] == 0) sclock = iclock;
01332             }
01333           }
01334           if(sclock != -1 && iclock - sclock < mdc_n) trgcond[icond][iclock] = 1;
01335         }
01336         else {
01337           if(sclock != -1 && iclock - sclock == mdc) sclock = -1;
01338           if(sclock == -1 && trgcond[icond][iclock] > 0) {
01339             if(iclock == 0) sclock = iclock;
01340             else {
01341               if(trgcond[icond][iclock]*trgcond[icond][iclock-1] == 0) sclock = iclock;
01342             }
01343           }
01344           if(sclock != -1 && iclock - sclock < mdc) trgcond[icond][iclock] = 1;
01345         }
01346       }
01347       else { //stretch other trigger conditions, including track match and muc
01348       }
01349     }
01350   }
01351 }

01372                                                        {
01373   //GTL delay time
01374   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};
01375 
01376   for(int icond = 0; icond < 48; icond++) {
01377     for(int iclock = nclock-1; iclock >= 0; iclock--) {
01378       if(iclock < delay[icond]) trgcond[icond][iclock] = 0;
01379       else trgcond[icond][iclock] = trgcond[icond][iclock-delay[icond]];
01380     }
01381   }
01382 }

01353                                                        {
01354   //SAF delay time
01355 //  int delay[48] = {31,31,31,31,31,31,31,7,7,7,7,7,31,31,7,7,
01356 //                   135,135,135,135,135,135,135,83,83,83,6,6,6,83,83,83,
01357 //                   97,97,97,97,97,97,86,87,85,87,83,85,83,85,122,122};
01358   int delay[48] = {24,24,24,24,24,24,24,7,7,7,7,7,24,24,7,7,
01359                    0,0,0,0,0,0,0,83,83,83,6,6,6,83,83,83,
01360                    97,97,97,97,97,97,0,0,0,0,0,0,0,0,122,122};
01361 
01362   for(int icond = 0; icond < 48; icond++) {
01363     for(int iclock = nclock-1; iclock >= 0; iclock--) {
01364       if(iclock < delay[icond]) trgcond[icond][iclock] = 0;
01365       else {
01366         trgcond[icond][iclock] = trgcond[icond][iclock-delay[icond]];
01367       }
01368     }
01369   }
01370 }

BesTrigL1 Class Reference

Public Member Functions

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
	BesTrigL1 (const std::string &name, ISvcLocator *pSvcLocator)
	Standard constructor.
	BesTrigL1 (const std::string &name, ISvcLocator *pSvcLocator)
	Standard constructor.
virtual StatusCode	execute ()
	Algorithm execution.
virtual StatusCode	execute ()
	Algorithm execution.
virtual StatusCode	finalize ()
	Algorithm finalization.
virtual StatusCode	finalize ()
	Algorithm finalization.
void	findEmcPeakTime (double &peak_time, EmcWaveform *blockWave)
void	findEmcPeakTime (double &peak_time, EmcWaveform *blockWave)
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	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	getEmcAnalogSig (EmcDigiCol *emcDigiCol, EmcWaveform(&blockWave)[16], multimap< int, uint32_t, less< int > > &emc_TC)
void	getEmcAnalogSig (EmcDigiCol *emcDigiCol, EmcWaveform(&blockWave)[16], multimap< int, uint32_t, less< int > > &emc_TC)
virtual StatusCode	initialize ()
	Algorithm initialization.
virtual StatusCode	initialize ()
	Algorithm initialization.
void	runAclock_emc (int iclock, double stime, std::multimap< int, uint32_t, less< int > > emc_TC, EmcWaveform *blockWave)
void	runAclock_emc (int iclock, double stime, std::multimap< int, uint32_t, less< int > > emc_TC, EmcWaveform *blockWave)
void	runAclock_mdc (int iclock, double stime, multimap< int, uint32_t, less< int > > mdc_hitmap)
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_tof (int iclock, double stime, int &idle_status, std::multimap< int, int, less< int > > tof_hitmap)
void	stretchTrgCond (int nclock, int **&trgcond)
void	stretchTrgCond (int nclock, int **&trgcond)
void	trgGTLDelay (int nclock, int **&trgcond)
void	trgGTLDelay (int nclock, int **&trgcond)
void	trgSAFDelay (int nclock, int **&trgcond)
void	trgSAFDelay (int nclock, int **&trgcond)
virtual	~BesTrigL1 ()
virtual	~BesTrigL1 ()
Private Attributes
int	clock_shift
IEmcCalibConstSvc *	emcCalibConstSvc
IEmcCalibConstSvc *	emcCalibConstSvc
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]
double	hit9 [76]
int	ifoutEvtId
bool	ifpass
std::string	indexfile
std::string	input
NTuple::Item< long >	m_block_id
NTuple::Item< long >	m_block_id
NTuple::Array< float >	m_btc_e
NTuple::Array< float >	m_btc_e
NTuple::Item< long >	m_cond_id
NTuple::Item< long >	m_cond_id
NTuple::Item< long >	m_condNOne [48]
NTuple::Item< long >	m_condNOne [48]
NTuple::Item< long >	m_condNZero [48]
NTuple::Item< long >	m_condNZero [48]
NTuple::Array< float >	m_costheta
NTuple::Array< float >	m_costheta
NTuple::Array< float >	m_data_blockE
NTuple::Array< float >	m_data_blockE
NTuple::Array< long >	m_data_btc
NTuple::Array< long >	m_data_btc
NTuple::Array< long >	m_data_cond
NTuple::Array< long >	m_data_cond
NTuple::Item< long >	m_data_eetotE
NTuple::Item< long >	m_data_eetotE
NTuple::Item< float >	m_data_totE_all
NTuple::Item< float >	m_data_totE_all
NTuple::Item< long >	m_data_wetotE
NTuple::Item< long >	m_data_wetotE
NTuple::Item< long >	m_delta_tdc
NTuple::Item< long >	m_delta_tdc
NTuple::Item< float >	m_eetotE
NTuple::Item< float >	m_eetotE
EmcTCFinder *	m_emcDigi
EmcTCFinder *	m_emcDigi
NTuple::Item< long >	m_EventId
NTuple::Item< long >	m_EventId
NTuple::Item< long >	m_evtId
NTuple::Item< long >	m_evtId
NTuple::Array< long >	m_fireLayer
NTuple::Array< long >	m_fireLayer
NTuple::Array< long >	m_hitLayer
NTuple::Array< long >	m_hitLayer
NTuple::Array< float >	m_hitphi
NTuple::Array< float >	m_hitphi
NTuple::Array< long >	m_hitSeg
NTuple::Array< long >	m_hitSeg
NTuple::Item< long >	m_index2
NTuple::Item< long >	m_index2
NTuple::Item< long >	m_index3
NTuple::Item< long >	m_index3
NTuple::Item< long >	m_index4
NTuple::Item< long >	m_index4
NTuple::Item< long >	m_index5
NTuple::Item< long >	m_index5
NTuple::Item< long >	m_index6
NTuple::Item< long >	m_index6
NTuple::Item< long >	m_index_btc
NTuple::Item< long >	m_index_btc
NTuple::Array< float >	m_mc_blockE
NTuple::Array< float >	m_mc_blockE
NTuple::Array< long >	m_mc_cond
NTuple::Array< long >	m_mc_cond
NTuple::Item< float >	m_mc_totE_all
NTuple::Item< float >	m_mc_totE_all
IMdcGeomSvc *	m_MdcGeomSvc
IMdcGeomSvc *	m_MdcGeomSvc
MdcTSF *	m_MdcTSF
MdcTSF *	m_MdcTSF
MucTrigHit *	m_mucDigi
MucTrigHit *	m_mucDigi
NTuple::Item< float >	m_mumcostheta
NTuple::Item< float >	m_mumcostheta
NTuple::Item< float >	m_mumphi
NTuple::Item< float >	m_mumphi
NTuple::Item< long >	m_ngoodevent
NTuple::Item< long >	m_ngoodevent
NTuple::Item< long >	m_ngoodtrack
NTuple::Item< long >	m_ngoodtrack
NTuple::Item< long >	m_nhitBR
NTuple::Item< long >	m_nhitBR
NTuple::Item< long >	m_nhitEE
NTuple::Item< long >	m_nhitEE
NTuple::Item< long >	m_nhitTotal
NTuple::Item< long >	m_nhitTotal
NTuple::Item< long >	m_nhitWE
NTuple::Item< long >	m_nhitWE
NTuple::Item< long >	m_nlayerBR
NTuple::Item< long >	m_nlayerBR
NTuple::Item< long >	m_nlayerEE
NTuple::Item< long >	m_nlayerEE
NTuple::Item< long >	m_nlayerTotal
NTuple::Item< long >	m_nlayerTotal
NTuple::Item< long >	m_nlayerWE
NTuple::Item< long >	m_nlayerWE
NTuple::Item< long >	m_ntrack1
NTuple::Item< long >	m_ntrack1
NTuple::Item< long >	m_ntrack2
NTuple::Item< long >	m_ntrack2
NTuple::Item< long >	m_ntrack3
NTuple::Item< long >	m_ntrack3
NTuple::Array< float >	m_p
NTuple::Array< float >	m_p
NTuple::Array< float >	m_pdgcode
NTuple::Array< float >	m_pdgcode
NTuple::Array< float >	m_phi
NTuple::Array< float >	m_phi
BesGlobalTrigSvc *	m_pIBGT
BesGlobalTrigSvc *	m_pIBGT
NTuple::Array< float >	m_R_blockE
NTuple::Array< float >	m_R_blockE
IRawDataProviderSvc *	m_rawDataProviderSvc
IRawDataProviderSvc *	m_rawDataProviderSvc
RealizationSvc *	m_RealizationSvc
RealizationSvc *	m_RealizationSvc
NTuple::Item< long >	m_RunId
NTuple::Item< long >	m_RunId
int	m_runMode
ITHistSvc *	m_thistsvc
ITHistSvc *	m_thistsvc
IBesGlobalTrigSvc *	m_tmpSvc
IBesGlobalTrigSvc *	m_tmpSvc
TofHitCount *	m_TofHitCount
TofHitCount *	m_TofHitCount
NTuple::Item< long >	m_trackb
NTuple::Item< long >	m_trackb
NTuple::Item< long >	m_tracke
NTuple::Item< long >	m_tracke
NTuple::Item< long >	m_trackfind3l
NTuple::Item< long >	m_trackfind3l
NTuple::Item< long >	m_trackfindall
NTuple::Item< long >	m_trackfindall
TH1F *	m_trigCondi_Data
TH1F *	m_trigCondi_Data
TH1F *	m_trigCondi_MC
TH1F *	m_trigCondi_MC
NTuple::Tuple *	m_tuple
NTuple::Tuple *	m_tuple
NTuple::Tuple *	m_tuple1
NTuple::Tuple *	m_tuple1
NTuple::Tuple *	m_tuple2
NTuple::Tuple *	m_tuple2
NTuple::Tuple *	m_tuple3
NTuple::Tuple *	m_tuple3
NTuple::Item< float >	m_wetotE
NTuple::Item< float >	m_wetotE
NTuple::Item< long >	m_wire_evtId
NTuple::Item< long >	m_wire_evtId
NTuple::Item< float >	m_wire_x
NTuple::Item< float >	m_wire_x
NTuple::Item< float >	m_wire_y
NTuple::Item< float >	m_wire_y
ifstream	mdc_hit
bool	mTrigRootFlag
int	nEvent
std::string	outEvtId
std::string	output
int	passNo
ifstream	readin
ofstream	readout
TrigTOFT *	toftrig
TrigTOFT *	toftrig
int	totalEvent
int	totalTracks
int	writeFile