00001 #include "GaudiKernel/AlgFactory.h"
00002 #include "GaudiKernel/MsgStream.h"
00003 #include "GaudiKernel/ISvcLocator.h"
00004 #include "GaudiKernel/SmartDataPtr.h"
00005 #include "GaudiKernel/Bootstrap.h"
00006 #include "GaudiKernel/IDataProviderSvc.h"
00007 #include "GaudiKernel/PropertyMgr.h"
00008 #include "GaudiKernel/IHistogramSvc.h"
00009
00010 #include "CLHEP/Units/PhysicalConstants.h"
00011 #include <CLHEP/Geometry/Point3D.h>
00012
00013 #include "MdcRawEvent/MdcDigi.h"
00014 #include "TofRawEvent/TofDigi.h"
00015 #include "EmcRawEvent/EmcDigi.h"
00016 #include "MucRawEvent/MucDigi.h"
00017 #include "McTruth/MucMcHit.h"
00018 #include "EventModel/EventModel.h"
00019 #include "EventModel/Event.h"
00020 #include "EventModel/EventHeader.h"
00021 #include "TrigEvent/TrigEvent.h"
00022 #include "TrigEvent/TrigData.h"
00023 #include "TrigEvent/TrigGTD.h"
00024 #include "TrigEvent/TrigTOFT.h"
00025 #include "TrigEvent/TrigEACC.h"
00026 #include "RawDataProviderSvc/TofData.h"
00027 #include "Identifier/Identifier.h"
00028 #include "Identifier/MdcID.h"
00029 #include "Identifier/TofID.h"
00030 #include "Identifier/MucID.h"
00031 #include "McTruth/McParticle.h"
00032 #include "EvTimeEvent/RecEsTime.h"
00033 #include "EmcWaveform/EmcWaveform.h"
00034
00035 #include "EmcCalibConstSvc/EmcCalibConstSvc.h"
00036
00037 #include "Trigger/IBesGlobalTrigSvc.h"
00038 #include "Trigger/BesGlobalTrigSvc.h"
00039 #include "Trigger/BesTrigL1.h"
00040 #include "Trigger/AsciiData.h"
00041 #include "Trigger/TrigPara.h"
00042 #include <TGraph.h>
00043 #include <TCanvas.h>
00044 #include "CLHEP/Random/Random.h"
00045 #include "CLHEP/Random/RandFlat.h"
00046 #include "CLHEP/Random/RandGauss.h"
00047 #include <math.h>
00048 #include <map>
00049
00050 using namespace CLHEP;
00051 using namespace std;
00052 using namespace Event;
00053
00054
00055
00056
00057 BesTrigL1::BesTrigL1(const std::string& name, ISvcLocator* pSvcLocator) :
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 }
00070
00071
00072 StatusCode BesTrigL1::initialize(){
00073 MsgStream log(msgSvc(), name());
00074 log << MSG::INFO << "in initialize()" << endreq;
00075
00076
00077
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
00087 m_pIBGT->setRunMode(m_runMode);
00088
00089
00090
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
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
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
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 {
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 {
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 {
00238 log << MSG::ERROR <<"Cannot book N-tuple3:" << long(m_tuple3) << endmsg;
00239 return StatusCode::FAILURE;
00240 }
00241 }
00242 }
00243
00244
00245 m_MdcTSF = MdcTSF::get_Mdc();
00246
00247
00248 m_TofHitCount = TofHitCount::get_Tof();
00249
00250
00251 m_emcDigi = EmcTCFinder::get_Emc();
00252
00253
00254 m_mucDigi = MucTrigHit::get_Muc();
00255
00256
00257
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
00276
00277
00278
00279 return StatusCode::SUCCESS;
00280 }
00281 StatusCode BesTrigL1::execute(){
00282 MsgStream log(msgSvc(),name());
00283
00284 log<<MSG::DEBUG<< "in execute()" <<endreq;
00285
00286 int event, run;
00287 ifpass = false;
00288
00289
00290
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
00302 m_RunId = run;
00303 m_EventId = event;
00304 }
00305
00306
00307
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
00322
00323 multimap<int,uint32_t,less<int> > mdc_hitmap;
00324 mdc_hitmap.clear();
00325
00326
00327
00328
00329 multimap<int,int,less<int> > tof_hitmap;
00330 tof_hitmap.clear();
00331
00332
00333
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
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
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
00403
00404 EmcWaveform blockWave[16];
00405
00406
00407
00408
00409 multimap<int,uint32_t,less<int> > emc_TC;
00410 emc_TC.clear();
00411
00412
00413
00414
00415 getEmcAnalogSig(emcDigiCol, blockWave, emc_TC);
00416
00417
00418
00419
00420 double peak_time = 0;
00421 findEmcPeakTime(peak_time, blockWave);
00422
00423
00424
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
00435
00436 if(event%10000 == 0) std::cout << "---> EventNo is " << event << std::endl;
00437 nEvent++;
00438
00439
00440
00441
00442
00443
00444
00445
00446 double stime = -1, etime = -1;
00447 findSETime(mdc_hitmap,tof_hitmap,emc_TC,stime,etime);
00448
00449
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
00460
00461 int** trgcond = new int*[48];
00462 for(int condId = 0; condId < 48; condId++) {
00463 trgcond[condId] = new int[nclock];
00464 }
00465
00466
00467 int idle_status = -1;
00468
00469 for(int iclock = 0; iclock < nclock; iclock++) {
00470
00471
00472
00473 runAclock_mdc(iclock, stime, mdc_hitmap);
00474
00475
00476
00477
00478 runAclock_tof(iclock, stime, idle_status, tof_hitmap);
00479
00480
00481
00482
00483 runAclock_emc(iclock, stime, emc_TC, blockWave);
00484
00485
00486
00487
00488
00489
00490
00491
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
00501
00502 for(int condId = 0; condId < 48; condId++) {
00503 trgcond[condId][iclock] = m_pIBGT->getTrigCond(condId);
00504 }
00505 }
00506
00507
00508
00509
00510 stretchTrgCond(nclock, trgcond);
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
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
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
00556
00557 m_pIBGT->GlobalTrig();
00558
00559
00560
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
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
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
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
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
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742 m_tuple1->write();
00743
00744
00745
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
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
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
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 }
00841
00842
00843
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
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
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
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 }
00907
00908 StatusCode BesTrigL1::finalize() {
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 }
00921
00922 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,
00923 double& stime, double& etime) {
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
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 }
00992
00993 void BesTrigL1::runAclock_mdc(int iclock, double stime, multimap<int,uint32_t,less<int> > mdc_hitmap) {
00994 std::vector<int> vmdcHit;
00995 vmdcHit.clear();
00996
00997 std::multimap<int,uint32_t,less<int> >::iterator mdc_iter = mdc_hitmap.begin();
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033
01034
01035
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046
01047
01048
01049
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059
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
01075
01076
01077 if(firstdc == true) {
01078 vmdcHit.push_back(layer);
01079 vmdcHit.push_back(cell);
01080 }
01081 }
01082 }
01083
01084
01085 m_MdcTSF->setMdcDigi(vmdcHit);
01086 m_pIBGT->startMdcTrig();
01087 }
01088
01089 void BesTrigL1::runAclock_tof(int iclock, double stime, int& idle_status, std::multimap<int,int,less<int> > tof_hitmap) {
01090 std::vector<int> vtofHit;
01091 vtofHit.clear();
01092
01093
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);
01098 if(idle_status == -1) {
01099 if(time < (stime + (iclock + 1)*24) && time >= (stime + iclock*24)) {
01100
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
01125 m_TofHitCount->setTofDigi(vtofHit);
01126 m_pIBGT->startTofTrig();
01127 }
01128
01129 void BesTrigL1::runAclock_emc(int iclock, double stime, std::multimap<int,uint32_t,less<int> > emc_TC, EmcWaveform* blockWave) {
01130 std::vector<uint32_t> vemcClus;
01131 std::vector<double> vemcBlkE;
01132
01133 vemcClus.clear();
01134 vemcBlkE.clear();
01135
01136
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
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
01150 }
01151
01152 m_emcDigi->setEmcTC(vemcClus);
01153 m_emcDigi->setEmcBE(vemcBlkE);
01154
01155 m_pIBGT->startEmcTrig();
01156 }
01157
01158 void BesTrigL1::getEmcAnalogSig(EmcDigiCol* emcDigiCol, EmcWaveform (&blockWave)[16], multimap<int,uint32_t,less<int> >& emc_TC) {
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
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
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
01222 for(int i = 0; i < 32; i++) {
01223
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
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 }
01259
01260 void BesTrigL1::findEmcPeakTime(double& peak_time, EmcWaveform* blockWave) {
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 }
01276
01277 void BesTrigL1::stretchTrgCond(int nclock, int** & trgcond) {
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) {
01288 if(icond < 7 || icond == 12 || icond == 13) {
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 {
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) {
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) {
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 {
01349 }
01350 }
01351 }
01352 }
01353
01354 void BesTrigL1::trgSAFDelay(int nclock, int** & trgcond) {
01355
01356
01357
01358
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 }
01372
01373 void BesTrigL1::trgGTLDelay(int nclock, int** & trgcond) {
01374
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 }