StRoot: StEmcTriggerMaker/StBemcTrigger.cxx Source File

00001 //
00002 // $Id: StBemcTrigger.cxx,v 1.33 2009/12/03 14:15:59 rfatemi Exp $
00003 //
00004 //
00005 
00006 #include "StBemcTrigger.h"
00007 #include "StEvent/StEvent.h"
00008 #include "StEvent/StEventTypes.h"
00009 #include "StEmcUtil/geometry/StEmcGeom.h"
00010 #include "StarRoot/TUnixTime.h"
00011 #include "StDaqLib/EMC/StEmcDecoder.h"
00012 #include "Stiostream.h"
00013 #include "St_db_Maker/St_db_Maker.h"
00014 #include "tables/St_emcPed_Table.h"
00015 #include "StEmcUtil/database/StBemcTables.h"
00016 #include "StEmcRawMaker/defines.h"
00017 
00018 ClassImp(StBemcTrigger);
00019 
00020 //-------------------------------------------------------------------
00021 StBemcTrigger::StBemcTrigger():TObject()
00022 {
00023     mGeo=StEmcGeom::getEmcGeom("bemc");
00024     mEvent = NULL;
00025     mDecoder = new StEmcDecoder();
00026     resetConf();
00027 }
00028 //----------------------------------------------------
00029 StBemcTrigger::~StBemcTrigger()
00030 {}
00031 
00032 //----------------------------------------------------
00033 void StBemcTrigger::resetConf(){
00034 
00035     PatchMap();
00036 
00037     mTrigger.HTBits = 3;
00038         
00039     //set all towers to status good because only offline status is used
00040     for(int i = 0;i<kNTowers;i++)   mTrigger.TowerStatus[i] = 1;
00041     //set all patches to status good because only offline status is used
00042     for(int i = 0;i<kNPatches;i++)  mTrigger.PatchStatus[i] = 1;
00043    
00044 
00045     mIs2003HT1=-1;
00046     mIs2004HT1=-1;
00047     mIs2004JP1=-1;
00048     mIs2004HT2=-1;
00049     mIs2004JP2=-1;
00050     mIs2005HT1=-1;
00051     mIs2005JP1=-1;
00052     mIs2005HT2=-1;
00053     mIs2005JP2=-1;
00054     mIs2005ADJ=-1;
00055     mIs2005JPSI=-1;
00056     for ( int matrix=0;matrix<6;matrix++){
00057       mIs2006JP0[matrix]=-1;
00058       mIs2006HT2[matrix]=-1;
00059       mIs2006JP1[matrix]=-1;
00060       mIs2006JPSI[matrix]=-1;
00061       mIs2006BHTTP[matrix]=-1;
00062     }
00063     for (int i=0;i<50;i++)
00064     {
00065         mIsTrig[i]=-1;
00066     }
00067 
00068     HT1_ID_2003=-1;
00069     HT1_ID_2004=-1;
00070     HT2_ID_2004=-1;
00071     JP1_ID_2004=-1;
00072     JP2_ID_2004=-1;
00073     HT1_ID_2005=-1;
00074     HT2_ID_2005=-1;
00075     JP1_ID_2005=-1;
00076     JP2_ID_2005=-1;
00077     ADJ_ID_2005=-1;
00078     for (int matrix=0;matrix<6;matrix++){
00079       HT2_ID_2006[matrix]=-1;
00080       JP0_ID_2006[matrix]=-1;
00081       JP1_ID_2006[matrix]=-1;
00082     }
00083     for (int i=0;i<50;i++)
00084       {
00085         mTowJetId[i] = -1;
00086       }
00087     
00088     HT1_DSM_2003=-1;
00089     HT1_DSM_2004=-1;
00090     HT2_DSM_2004=-1;
00091     JP1_DSM_2004=-1;
00092     JP2_DSM_2004=-1;
00093     HT1_DSM_2005=-1;
00094     HT2_DSM_2005=-1;
00095     JP1_DSM_2005=-1;
00096     JP2_DSM_2005=-1;
00097     ADJ_DSM_2005=-1;
00098     for ( int matrix=0;matrix<6;matrix++){
00099       HT2_DSM_2006[matrix]=-1;
00100       JP0_DSM_2006[matrix]=-1;
00101       JP1_DSM_2006[matrix]=-1;
00102     }
00103     BETOT_DSM_2006=-1;
00104     for (int i=0;i<50;i++)
00105     {
00106         mDsmAdc[i] = -1;
00107     }
00108     
00109     for(int i=0;i<kNTowers;i++){
00110       mHT12005array[i]=-1;
00111       mHT22005array[i]=-1;
00112       for (int matrix=0;matrix<6;matrix++) mHT22006array[matrix][i]=-1;
00113     }
00114     for (int i=0;i<kNJet;i++){
00115       mJP12005array[i]=-1;
00116       mJP22005array[i]=-1;
00117       for (int matrix=0;matrix<6;matrix++) mJP02006array[matrix][i]=-1;
00118       for (int matrix=0;matrix<6;matrix++) mJP12006array[matrix][i]=-1;
00119     }
00120 
00121     for (int i=0;i<kNJet/2;i++) BL1_ADC_2006[i]=-1;
00122 
00123     for (int i=0;i<12;i++){
00124       mnumHT[i]=0;
00125       mnumJP[i]=0;
00126       if (i<6) mnumHTTP[i]=0;
00127     }
00128 
00129 }
00130 
00131 //----------------------------------------------------
00132 void StBemcTrigger::zero()
00133 {
00134     for(int i=0;i<kNPatches;i++)
00135     {
00136         mTrigger.HT[i] = 0;
00137         mTrigger.HTID[i]=0;
00138         mTrigger.Patch[i]= 0;
00139     }
00140 
00141     for(int i=0;i<kNJet;i++)
00142     {
00143         mTrigger.Jet[i]= 0;
00144     }
00145 
00146     mTrigger.Et = 0;
00147      
00148 }
00149 
00150 
00151 void StBemcTrigger::PatchMap()
00152 
00153   
00154 
00155 
00156 {
00157 
00158     for (int i=0;i<20;i++)
00159     {
00160         JP_TP[0][i]=i+30;
00161         JP_TP[1][i]=i+50;
00162         JP_TP[2][i]=i+80;
00163         JP_TP[3][i]=i+100;
00164         JP_TP[4][i]=i+130;
00165         JP_TP[5][i]=i;
00166         if (i<10)
00167             JP_TP[6][i]=i+150;
00168         if (i>=10)
00169             JP_TP[6][i]=i+290-10;
00170         JP_TP[7][i]=i+170;
00171         JP_TP[8][i]=i+190;
00172         JP_TP[9][i]=i+220;
00173         JP_TP[10][i]=i+240;
00174         JP_TP[11][i]=i+270;
00175     }
00176 
00177     for (int i=20;i<25;i++)
00178     {
00179         int j=i-20;
00180         int keven=2*j;
00181         int kodd=2*j+1;
00182         JP_TP[0][i]=20+keven;
00183         JP_TP[1][i]=70+kodd;
00184         JP_TP[2][i]=70+keven;
00185         JP_TP[3][i]=120+kodd;
00186         JP_TP[4][i]=120+keven;
00187         JP_TP[5][i]=20+kodd;
00188         JP_TP[6][i]=160+kodd;
00189         JP_TP[7][i]=160+keven;
00190         JP_TP[8][i]=210+kodd;
00191         JP_TP[9][i]=210+keven;
00192         JP_TP[10][i]=260+kodd;
00193         JP_TP[11][i]=260+keven;
00194     }
00195 
00196     for (int i=0;i<12;i++)
00197     {
00198                 TString line("JP");
00199                 line += i;
00200                 line += " is sum of TP = ";
00201         for (int j=0;j<25;j++)
00202         {
00203             if (j!=24){
00204                                 line += JP_TP[i][j];
00205                                 line += "+";
00206                         }
00207             if (j==24)
00208                                 line += JP_TP[i][j];
00209         }
00210                 LOG_INFO << line << endm;
00211     }
00212 
00213 
00214     /****************************************************************************
00215        http://www.nikhef.nl/~ogrebeny/emc/files/Towers%20Layout.xls documents
00216        the tower->TP->JP correpsondence. Using StEmcDecoder,StEmcGeom and 
00217        the above spreadsheet I defined JP#s and assigned correct TP's above.
00218 
00219        JP      TOWERS               Clock Pos. looking from W -> vertex
00220        ---     --------          -----------------------------------------
00221        0        1-100,2101-2400           12
00222        1        101-500                   10
00223        2        501-900                   08
00224        3        901-1300                  06
00225        4        1301-1700                 04
00226        5        1701-2100                 02
00227        6        2401-2500,4501-4800       12
00228        7        2501-2900                 02
00229        8        2901-3300                 04
00230        9        3301-3700                 06
00231        10       3701-4100                 08
00232        11       4101-4500                 10                            
00233     **************************************************************************/
00234 
00235 
00236    /* mapping of renee's JP ids to StEmcDecoder's ids
00237     int renee[12];
00238     renee[0] = 5;
00239     renee[1] = 0;
00240     renee[2] = 1;
00241     renee[3] = 2;
00242     renee[4] = 3;
00243     renee[5] = 4;
00244     renee[6] = 7;
00245     renee[7] = 6;
00246     renee[8] = 11;
00247     renee[9] = 10;
00248     renee[10] = 9;
00249     renee[11] = 8;
00250     */
00251 
00252 }
00253 
00254 
00255 int StBemcTrigger::makeTrigger()
00256 {
00257     get2003Trigger();
00258     get2004Trigger();
00259     get2005Trigger();
00260     get2006Trigger();
00261 
00262     //2003 HT1 == 1101+2201
00263     mIsTrig[0]  =mIs2003HT1;
00264     mTowJetId[0]=HT1_ID_2003;
00265     mDsmAdc[0]  =HT1_DSM_2003;
00266 
00267    //2003 HT2 == 2202
00268     mIsTrig[42]  =mIs2003HT2;
00269     mTowJetId[42]=HT2_ID_2003;
00270     mDsmAdc[42]  =HT2_DSM_2003;
00271 
00272     //2004 HT1 == 45201
00273     mIsTrig[1]  =mIs2004HT1;
00274     mTowJetId[1]=HT1_ID_2004;
00275     mDsmAdc[1]  =HT1_DSM_2004;
00276 
00277     //2004 HT2 == 45202
00278     mIsTrig[2]  =mIs2004HT2;
00279     mTowJetId[2]=HT2_ID_2004;
00280     mDsmAdc[2]  =HT2_DSM_2004;
00281 
00282     //2004 JP1 == 45206
00283     mIsTrig[3]  =mIs2004JP1;
00284     mTowJetId[3]=JP1_ID_2004;
00285     mDsmAdc[3]  =JP1_DSM_2004;
00286 
00287     //2004 JP2 == 45207
00288     mIsTrig[4]  =mIs2004JP2;
00289     mTowJetId[4]=JP2_ID_2004;
00290     mDsmAdc[4]  =JP2_DSM_2004;
00291 
00292     //2005 HT1 == 96201
00293     mIsTrig[5]  =mIs2005HT1;
00294     mTowJetId[5]=HT1_ID_2005;
00295     mDsmAdc[5]  =HT1_DSM_2005;
00296     mnumHT[3] =numHT1_2005;
00297     for (int i=0;i<numHT1_2005;i++){
00298       mHT12005array[i]=HT1_2005_array[i];
00299     }
00300 
00301     //2005 HT2 == 96211
00302     mIsTrig[6]  =mIs2005HT2;
00303     mTowJetId[6]=HT2_ID_2005;
00304     mDsmAdc[6]  =HT2_DSM_2005;
00305     mnumHT[4] =numHT2_2005;
00306     for (int i=0;i<numHT2_2005;i++){
00307       mHT22005array[i]=HT2_2005_array[i];
00308     }
00309 
00310     //2005 JP1 == 96221
00311     mIsTrig[7]  =mIs2005JP1;
00312     mTowJetId[7]=JP1_ID_2005;
00313     mDsmAdc[7]  =JP1_DSM_2005;
00314     mnumJP[2]  =numJP1_2005;
00315     for (int i=0;i<numJP1_2005;i++){
00316       mJP12005array[i]=JP1_2005_array[i];
00317     }
00318 
00319     //2005 JP2 == 96233
00320     mIsTrig[8]  =mIs2005JP2;
00321     mTowJetId[8]=JP2_ID_2005;
00322     mDsmAdc[8]  =JP2_DSM_2005;
00323     mnumJP[3]   =numJP2_2005;
00324     for (int i=0;i<numJP2_2005;i++){
00325       mJP22005array[i]=JP2_2005_array[i];
00326     }
00327 
00328     //2005 AJP == 96241
00329     mIsTrig[9]  =mIs2005ADJ;
00330     mTowJetId[9]=ADJ_ID_2005;
00331     mDsmAdc[9]  =ADJ_DSM_2005;
00332 
00333 
00334     //2005 JPSI
00335     mIsTrig[10] =mIs2005JPSI;
00336     mTowJetId[10]=-1;
00337     mDsmAdc[10]=-1;
00338     for (int i=0;i<kNJet;i++){
00339       mJPSI2005adc[i]=JPSI_2005_ADC[i];
00340       mJPSI2005id[i]=JPSI_2005_ID[i];
00341     }
00342     
00343 
00344 
00345     for (int matrix=0;matrix<6;matrix++){
00346       
00347       //2006 HT2 
00348       mIsTrig[11+(matrix*5)]  =mIs2006HT2[matrix];
00349       mTowJetId[11+(matrix*5)]=HT2_ID_2006[matrix];
00350       mDsmAdc[11+(matrix*5)]  =HT2_DSM_2006[matrix];
00351       mnumHT[5+matrix] =numHT2_2006[matrix];
00352       for (int i=0;i<numHT2_2006[matrix];i++){
00353         mHT22006array[matrix][i]=HT2_2006_array[matrix][i];
00354       }
00355       
00356       //2006 JP1 
00357       mIsTrig[12+(matrix*5)]  =mIs2006JP0[matrix];
00358       mTowJetId[12+(matrix*5)]=JP0_ID_2006[matrix];
00359       mDsmAdc[12+(matrix*5)]  =JP0_DSM_2006[matrix];
00360       mnumJP[5+(matrix*2)]  =numJP0_2006[matrix];
00361       for (int i=0;i<numJP0_2006[matrix];i++){
00362         mJP02006array[matrix][i]=JP0_2006_array[matrix][i];
00363       }
00364       
00365       //2006 JP2 
00366       mIsTrig[13+(matrix*5)]  =mIs2006JP1[matrix];
00367       mTowJetId[13+(matrix*5)]=JP1_ID_2006[matrix];
00368       mDsmAdc[13+(matrix*5)]  =JP1_DSM_2006[matrix];
00369       mnumJP[6+(matrix*2)]   =numJP1_2006[matrix];
00370       for (int i=0;i<numJP1_2006[matrix];i++){
00371         mJP12006array[matrix][i]=JP1_2006_array[matrix][i];
00372       }
00373       
00374       //2006 JPSI
00375       mIsTrig[14+(matrix*5)] =mIs2006JPSI[matrix];
00376       mTowJetId[14+(matrix*5)]=-1;
00377       mDsmAdc[14+(matrix*5)]=-1;
00378       for (int i=0;i<kNJet;i++){
00379         mJPSI2006adc[matrix][i]=JPSI_2006_ADC[matrix][i];
00380         mJPSI2006id[matrix][i]=JPSI_2006_ID[matrix][i];
00381       }
00382       
00383       //2006 BHTTP
00384       mIsTrig[15+(matrix*5)]=mIs2006BHTTP[matrix];
00385       mTowJetId[15+(matrix*5)]=-1;
00386       mDsmAdc[15+(matrix*5)]=-1;
00387       mnumHTTP[matrix]=0;
00388       mnumHTTP[matrix]=numHTTP_2006[matrix];
00389       for (int i=0; i<numHTTP_2006[matrix];i++){
00390         mHTTP2006arrayHT[matrix][i]=BHTTP_2006_HT[matrix][i];
00391         mHTTP2006arrayHTADC[matrix][i]=BHTTP_2006_HT_ADC[matrix][i];
00392         mHTTP2006arrayTP[matrix][i]=BHTTP_2006_TP[matrix][i];
00393         mHTTP2006arrayTPADC[matrix][i]=BHTTP_2006_TP_ADC[matrix][i];
00394       }
00395     }
00396 
00397     //2006 BETOT
00398     mIsTrig[41]=-1;
00399     mTowJetId[41]=-1;
00400     mDsmAdc[41]=BETOT_DSM_2006;
00401     for (int i=0; i<(kNJet/2); i++){mBL12006arrayADC[i]=BL1_ADC_2006[i];}
00402     
00403 
00404 
00405     return kStOK;
00406 }
00407 
00408 
00409 int StBemcTrigger::get2003Trigger()
00410 {
00411     zero();
00412 
00413     const int HT1_TH_2003 = 8;
00414     const int HT2_TH_2003 = 13;
00415 
00416     if(!mEvent)
00417         return kStWarn;
00418     StEmcCollection *emc = mEvent->emcCollection();
00419     if(!emc)
00420         return kStWarn;
00421 
00422     int adc12[kNTowers];
00423     int adc10[kNTowers];
00424     for(int i=0;i<kNTowers;i++)
00425     {
00426         adc12[i] = 0;
00427         adc10[i] = 0;
00428     }
00429 
00430 
00431     StEmcDetector* detector=emc->detector(kBarrelEmcTowerId);
00432     if(detector)
00433     {
00434         for(Int_t m=1;m<=60;m++)
00435         {
00436             StEmcModule* module = detector->module(m);
00437             if(module)
00438             { 
00439                 StSPtrVecEmcRawHit& rawHit=module->hits();
00440                 for(UInt_t k=0;k<rawHit.size();k++)
00441                     if(rawHit[k])
00442                     {
00443                         Int_t did;
00444                         Int_t mod=rawHit[k]->module();
00445                         Int_t e=rawHit[k]->eta();
00446                         Int_t s=abs(rawHit[k]->sub());
00447                         mGeo->getId(mod,e,s,did);
00448                         if(mTrigger.TowerStatus[did-1]==1)
00449                         {
00450                             adc12[did-1]=rawHit[k]->adc();
00451                             adc10[did-1] = adc12[did-1]>>2;
00452                         }
00453                     }
00454             }
00455         }
00456     }
00457 
00458     else
00459     {
00460         return kStWarn;
00461     }
00462 
00463 
00464 
00465     TUnixTime unixTime(mEvent->time());
00466     Int_t dat=0,tim=0;
00467     unixTime.GetGTime(dat,tim);
00468     mDecoder->SetDateTime(dat,tim);
00469     mDecoder->SetFixTowerMapBug(true);
00470 
00471 
00472     int HTmax=0;
00473     int HTmaxID=-1;
00474     for(int i = 0;i<kNPatches;i++)
00475         if(mTrigger.PatchStatus[i]==1)
00476         {
00477             int crate = 0;
00478             int seq  = 0;
00479             int HT = 0;//holder for highest tower in patch
00480             int HTID = -1;//id for highest tower in patch
00481             int id;//BEMC tower id
00482 
00483             mDecoder->GetCrateAndSequenceFromTriggerPatch(i,crate,seq);
00484 
00485             for(int j=seq;j<seq+16;j++)
00486             {
00487                 int stat = mDecoder->GetTowerIdFromCrate(crate,j,id);
00488                 if(stat==1)
00489                 {
00490                     if(adc10[id-1]>=HT)
00491                     {
00492                         HT = adc10[id-1];
00493                         HTID = id;
00494                     }
00495                 }
00496             }
00497 
00498             int SHIFT = mTrigger.HTBits;
00499             HT = HT >> SHIFT;   //shift by 3 bits -> now have 7 bits
00500             int HTL = HT & 0x1F;//strip off 5 LB
00501             int HTH = HT >> 5;//strip off top 2 HB
00502             int B5  = 0;
00503             if(HTH>0) B5 = 1; // IF top bits !=0 B5=1
00504             mTrigger.HT[i] = HTL+(B5<<5); // Or top bits
00505             { LOG_DEBUG <<"Patch number "<<i<<" Tower id = "<<
00506                 HTID<<" adc12 = "<<adc12[HTID-1]<<" adc10 = "<<
00507                 adc10[HTID-1]<<" HT = "<<mTrigger.HT[i]<<endm; }
00508             if (mTrigger.HT[i]>HTmax)
00509               {
00510                 HTmax=mTrigger.HT[i];
00511                 HTmaxID=HTID;
00512             }
00513         }
00514 
00515     if (HTmax>HT1_TH_2003)
00516     {
00517         mIs2003HT1=1;
00518         HT1_ID_2003=HTmaxID;
00519         HT1_DSM_2003=HTmax;
00520     }
00521     else
00522     {
00523         mIs2003HT1=0;
00524         HT1_ID_2003=HTmaxID;
00525         HT1_DSM_2003=HTmax;
00526     }
00527 
00528     if (HTmax>HT2_TH_2003)
00529     {
00530         mIs2003HT2=1;
00531         HT2_ID_2003=HTmaxID;
00532         HT2_DSM_2003=HTmax;
00533     }
00534     else
00535     {
00536         mIs2003HT2=0;
00537         HT2_ID_2003=HTmaxID;
00538         HT2_DSM_2003=HTmax;
00539     }
00540 
00541 
00542     return kStOK;
00543 }
00544 
00545 
00546 //----------------------------------------------------
00547 int StBemcTrigger::get2004Trigger()
00548 {
00549     zero();
00550 
00551     const int HT1_TH_2004 = 10;//bht0=10,bht1=20,bht2=30
00552     const int HT2_TH_2004 = 20;
00553     const int JP1_TH_2004 = 40;//bjp0=15,bjp1=40,bjp2=60
00554     const int JP2_TH_2004 = 60;
00555     const int pedestalTargetValue2004 = 8;
00556 
00557     if(!mEvent)
00558         return kStWarn;
00559     StEmcCollection *emc = mEvent->emcCollection();
00560     if(!emc)
00561         return kStWarn;
00562 
00563 
00564     //This code accesses offline database to get peds. These are NOT == peds
00565     //which were used during running. So NO ONLINE INFO is used in this trigger
00566     //reconstruction because the online database was not filled for 2004!
00567  
00568 
00569     int adc12[kNTowers];
00570     int adc10[kNTowers];
00571     int adc08[kNTowers];
00572     int ped10[kNTowers];
00573     for(int i=0;i<kNTowers;i++)
00574     {
00575         adc12[i] = 0;
00576         adc10[i] = 0;
00577         adc08[i] = 0;
00578         ped10[i] = 0;
00579     }
00580 
00581     int ped12bit, val12bit,operation;// operation bit for pedestal subtraction
00582     // subtract: +1 (default)   add: 0
00583 
00584     StEmcDetector* detector=emc->detector(kBarrelEmcTowerId);
00585     if(detector)
00586     {
00587         for(Int_t m=1;m<=60;m++)
00588         {
00589             StEmcModule* module = detector->module(m);
00590             if(module)
00591             {
00592                 StSPtrVecEmcRawHit& rawHit=module->hits();
00593                 for(UInt_t k=0;k<rawHit.size();k++)
00594                     if(rawHit[k])
00595                     {
00596                         Int_t did;
00597                         Int_t mod=rawHit[k]->module();
00598                         Int_t e=rawHit[k]->eta();
00599                         Int_t s=abs(rawHit[k]->sub());
00600                         mGeo->getId(mod,e,s,did);
00601                         if(mTrigger.TowerStatus[did-1]==1)
00602                         {
00603                             adc12[did-1]=rawHit[k]->adc();
00604                             adc10[did-1] = adc12[did-1]>>2;
00605                             {
00606                                 //ped12bit = pedestalTable->AdcPedestal[did-1]/100;
00608                                 float NEWped=-1;
00609                                 float NEWrms=-1;
00610                                 mTables ->getPedestal(BTOW,did,0,NEWped,NEWrms);
00611                                 ped12bit=(int) NEWped;
00612 
00613 
00614                                 operation = 1;
00615                                 ped10[did-1] = ped12bit >> 2;
00616                                 val12bit = ped12bit - pedestalTargetValue2004;
00617 
00618                                 if(val12bit < 0)
00619                                 {
00620                                     val12bit = -val12bit;
00621                                     operation = 0;
00622                                 }
00623                                 int val10bit = val12bit/4;
00624 
00625                                 //this next line was in the 2004/2005 tcl code
00626                                 //but it seems to be wrong because it results
00627                                 //in ped10==1 at times (ex ADC=71&&ped=39)
00628                                 if (val12bit - val10bit*4 > 2)
00629                                     val10bit+=1;
00630                                 if(val10bit > 15)
00631                                 {
00632                                     // can't subtract/add more than 15 on 10-bit level
00633                                     val10bit = val10bit - 4*((val10bit-11)/4);
00634                                 }
00635 
00636                                 if(operation==1)
00637                                 {
00638                                     adc10[did-1] -= val10bit;
00639                                     ped10[did-1] -= val10bit;
00640                                 }
00641                                 else
00642                                 {
00643                                     adc10[did-1] += val10bit;
00644                                     ped10[did-1] += val10bit;
00645                                 }
00646                             }
00647                             adc08[did-1] = adc10[did-1]>>2;// adc10[],adc08[] are ped-adjusted
00648                         }
00649                     }
00650             }
00651         }
00652     }
00653     else
00654     {
00655         LOG_WARN << "StBemcTrigger::make2004Trigger() -- pointer to StEmcDetector is zero!" << endm;
00656         return kStWarn;
00657     }
00658 
00659     // making trigger patches and high towers
00660     TUnixTime unixTime(mEvent->time());
00661     Int_t dat=0,tim=0;
00662     unixTime.GetGTime(dat,tim);
00663     mDecoder->SetDateTime(dat,tim);
00664     mDecoder->SetFixTowerMapBug(true);
00665 
00666     int HTmax=0;
00667     int HTmaxID=-1;
00668     for(int i = 0;i<kNPatches;i++)
00669         if(mTrigger.PatchStatus[i]==1)
00670         {
00671             int crate = 0;
00672             int seq  = 0;
00673             mDecoder->GetCrateAndSequenceFromTriggerPatch(i,crate,seq);
00674             int HT = 0;
00675             int PA = 0;
00676             int HTID = -1;
00677             int id;
00678             int patchPed = 0;
00679             for(int j=seq;j<seq+16;j++)
00680             {
00681                 int stat = mDecoder->GetTowerIdFromCrate(crate,j,id);
00682                 if(stat==1)
00683                 {
00684                     if(adc10[id-1]>=HT)
00685                     {
00686                         HT = adc10[id-1];
00687                         HTID = id;
00688 
00689                     }
00690                     patchPed+= (ped10[id-1]>>2);
00691                     PA+=adc08[id-1];
00692                 }
00693             }
00694 
00695 
00696             // now HT=10 bits and patch=12 bits
00697             // convert patch sum to 6 bits using LUT
00698             // TPsum= TPsum - 0 for 2004 because all TP peds=0
00699             // for 2005 all TP peds=16 so TPsum=TPsum-15
00700             // The fact that not all peds can be shifted to 2
00701             // on 10bit level require us to add up and then
00702             // subtract patchPed. But patchPed should==0 usually
00703 
00704             if(PA >= patchPed)
00705             {
00706                 mTrigger.Patch[i] = PA - patchPed;
00707                 if(mTrigger.Patch[i] > 62)
00708                     mTrigger.Patch[i] = 62;
00709             }
00710 
00711             // for HT need to OR top 2 bits and drop top bit
00712             // then drop bottom 3 bits
00713             int SHIFT = mTrigger.HTBits;
00714             HT = HT >> SHIFT;
00715             int HTL = HT & 0x1F;
00716             int HTH = HT >> 5;
00717             int B5  = 0;
00718             if(HTH>0)
00719                 B5 = 1;
00720             mTrigger.HT[i] = HTL+(B5<<5);
00721                         { LOG_DEBUG <<"Patch number "<<i<<" Tower id = "<<HTID<<" adc12 = "<<adc12[HTID-1]<<" adc10 = "
00722                                 <<adc10[HTID-1]<<" adc08 = "<<adc08[HTID-1]<<" HT10 = "<<HT<<" PA12 = "<<PA
00723                                 <<" HT = "<<mTrigger.HT[i]<<" PA = "<<mTrigger.Patch[i]<<endm; }
00724             if (mTrigger.HT[i]>HTmax)
00725             {
00726                 HTmax=mTrigger.HT[i];
00727                 HTmaxID=HTID;
00728             }
00729         }
00730 
00731     if (HTmax>HT1_TH_2004)
00732     {
00733         mIs2004HT1=1;
00734         HT1_ID_2004=HTmaxID;
00735         HT1_DSM_2004=HTmax;
00736     }
00737     else
00738     {
00739         mIs2004HT1=0;
00740         HT1_ID_2004=HTmaxID;
00741         HT1_DSM_2004=HTmax;
00742     }
00743     if (HTmax>HT2_TH_2004)
00744     {
00745         mIs2004HT2=1;
00746         HT2_ID_2004=HTmaxID;
00747         HT2_DSM_2004=HTmax;
00748     }
00749     else
00750     {
00751         mIs2004HT2=0;
00752         HT2_ID_2004=HTmaxID;
00753         HT2_DSM_2004=HTmax;
00754     }
00755 
00756     for (int i=0;i<300;i++)
00757     {
00758         trgPatch[i]=0;
00759         trgPatch[i]=mTrigger.Patch[i];
00760     }
00761 
00762     // making Jet trigger and Et
00763     int JPmax=0;
00764     int JPid=0;
00765     mTrigger.Et = 0;
00766     for(int i = 0;i<kNJet; i++)
00767     {
00768         int p0 = 0;
00769         int p1 = p0+25;
00770 
00771         mTrigger.Jet[i]= 0;
00772         for (int j=p0;j<p1;j++)
00773         {
00774             int k=JP_TP[i][j];
00775             mTrigger.Jet[i]+=mTrigger.Patch[k];
00776         }
00777 
00778         mTrigger.Et+=mTrigger.Jet[i];
00779         if (mTrigger.Jet[i]>JPmax)
00780         {
00781             JPmax=mTrigger.Jet[i];
00782             JPid=i;
00783         }
00784     }
00785 
00786     if (JPmax>JP1_TH_2004)
00787     {
00788         mIs2004JP1=1;
00789         JP1_ID_2004=JPid;
00790         JP1_DSM_2004=JPmax;
00791     }
00792     else
00793     {
00794         mIs2004JP1=0;
00795         JP1_ID_2004=JPid;
00796         JP1_DSM_2004=JPmax;
00797     }
00798 
00799     if (JPmax>JP2_TH_2004)
00800     {
00801         mIs2004JP2=1;
00802         JP2_ID_2004=JPid;
00803         JP2_DSM_2004=JPmax;
00804     }
00805     else
00806     {
00807         mIs2004JP2=0;
00808         JP2_ID_2004=JPid;
00809         JP2_DSM_2004=JPmax;
00810     }
00811 
00812 
00813     return kStOK;
00814 }
00815 
00816 
00817 //----------------------------------------------------
00818 int StBemcTrigger::get2005Trigger()
00819 {
00820     //for 2005 still need to test LUT subtraction
00821     //incorporate online peds. trigger masks, DSM masks + LUT tables
00822 
00823     zero();
00824 
00825 
00826     const int JPSI_TH_2005 = 5;//bht0=5,bht1=13,bht2=17
00827     const int HT1_TH_2005 = 13;
00828     const int HT2_TH_2005 = 17;
00829     const int JP1_TH_2005 = 66;//bjp0=46,bjp1=66,bjp2=84
00830     const int JP2_TH_2005 = 84;
00831     const int pedestalTargetValue2005 = 24;
00832 
00833 
00834     if(!mEvent)
00835     {
00836         LOG_WARN << "StBemcTrigger::make2005Trigger() -- no StEvent!" << endm;
00837         return kStWarn;
00838     }
00839     StEmcCollection *emc = mEvent->emcCollection();
00840     if(!emc)
00841     {
00842         LOG_WARN << "StBemcTrigger::make2005Trigger() -- no StEmcCollection!" << endm;
00843         return kStWarn;
00844     }
00845 
00846     int adc12[kNTowers];
00847     int adc10[kNTowers];
00848     int adc08[kNTowers];
00849     int ped10[kNTowers];
00850     for(int i=0;i<kNTowers;i++){
00851         adc12[i] = 0;
00852         adc10[i] = 0;
00853         adc08[i] = 0;
00854         ped10[i] = 0;
00855         HT1_2005_array[i]=-1;
00856         HT2_2005_array[i]=-1;
00857         mHT12005array[i]=-1;
00858         mHT22005array[i]=-1;
00859     }
00860 
00861     mnumHT[3]=0;
00862     mnumHT[4]=0;
00863     mnumJP[2]=0;
00864     mnumJP[3]=0;
00865     mnumJP[4]=0;
00866     
00867     for (int i=0;i<kNJet;i++){
00868       JP1_2005_array[i]=-1;
00869       JP2_2005_array[i]=-1;
00870       mJP12005array[i]=-1;
00871       mJP22005array[i]=-1;
00872       mJPSI2005adc[i]=-1;
00873       mJPSI2005id[i]=-1;
00874      }
00875 
00876     numHT1_2005=0;
00877     numHT2_2005=0;
00878     numJP1_2005=0;
00879     numJP2_2005=0;
00880     numADJ_2005=0;
00881     
00882     
00883 
00884     int ped12bit, val12bit;
00885     int operation; // operation bit for pedestal subtraction
00886     // subtract: +1 (default)
00887     //      add: 0
00888 
00889     StEmcDetector* detector=emc->detector(kBarrelEmcTowerId);
00890     if(detector)
00891     {
00892         for(Int_t m=1;m<=60;m++)
00893         {
00894             StEmcModule* module = detector->module(m);
00895             if(module)
00896             {
00897                 StSPtrVecEmcRawHit& rawHit=module->hits();
00898                 for(UInt_t k=0;k<rawHit.size();k++)
00899                     if(rawHit[k])
00900                     {
00901                         Int_t did;
00902                         Int_t mod=rawHit[k]->module();
00903                         Int_t e=rawHit[k]->eta();
00904                         Int_t s=abs(rawHit[k]->sub());
00905                         mGeo->getId(mod,e,s,did);
00906                         if ((mTrigger.TowerStatus[did-1]==1)&&(mTables->status(BTOW,did,"calib")==1))
00907                         {
00908                             adc12[did-1]=rawHit[k]->adc();
00909                             adc10[did-1] = adc12[did-1]>>2;
00910                             {
00911                                 // Trigger pedestals were subtracted online.
00912                                 // ped12bit = pedestalTable->AdcPedestal[did-1]/100;
00913                                 
00915                                 float NEWped=-1;
00916                                 float NEWrms=-1;
00917                                 mTables ->getPedestal(BTOW,did,0,NEWped,NEWrms);
00918                                 ped12bit=(int) NEWped;
00919 
00920                                 operation = 1;
00921                                 ped10[did-1] = ped12bit >> 2;
00922                                 val12bit = ped12bit - pedestalTargetValue2005;
00923                                 // this is by how much we want to change the ped
00924 
00925                                 if(val12bit < 0)
00926                                 {
00927                                     val12bit = -val12bit;
00928                                     operation = 0;
00929                                 }
00930                                 int val10bit = val12bit/4;
00931                                 if(val12bit - val10bit*4 > 2)
00932                                     val10bit+=1;
00933                                 if(val10bit > 15)
00934                                 {
00935                                     // can't subtract/add more than 15 on 10-bit level
00936                                     val10bit = val10bit - 4*((val10bit-11)/4);
00937                                 }
00938 
00939                                 if(operation==1)
00940                                 {
00941                                     adc10[did-1] -= val10bit;
00942                                     ped10[did-1] -= val10bit;
00943                                 }
00944                                 else
00945                                 {
00946                                     adc10[did-1] += val10bit;
00947                                     ped10[did-1] += val10bit;
00948                                 }
00949                             }
00950                             adc08[did-1] = adc10[did-1]>>2;// adc10[],adc08[] are ped-adj
00951                         }
00952                     }
00953             }
00954         }
00955     }
00956     else
00957     {
00958         LOG_WARN << "StBemcTrigger::make2005Trigger() -- pointer to StEmcDetector is zero!" << endm;
00959         return kStWarn;
00960     }
00961 
00962     // making trigger patches and high towers
00963     TUnixTime unixTime(mEvent->time());
00964     Int_t dat=0,tim=0;
00965     unixTime.GetGTime(dat,tim);
00966     mDecoder->SetDateTime(dat,tim);
00967     mDecoder->SetFixTowerMapBug(false);
00968 
00969     float rped12bit;
00970     int HTmax=0;
00971     int HTmaxID=-1;
00972     for(int i = 0;i<kNPatches;i++)
00973         if(mTrigger.PatchStatus[i]==1)
00974         {
00975             int crate = 0;
00976             int seq  = 0;
00977             mDecoder->GetCrateAndSequenceFromTriggerPatch(i,crate,seq);
00978             mTables->getTriggerPedestal(crate,seq,rped12bit);
00979             //if (rped12bit!=0) cout<<"rped12bit="<<rped12bit<<endl;
00980             int HT = 0;
00981             int PA = 0;
00982             int HTID = -1;
00983             int id;
00984             int patchPed = 0;
00985             for(int j=seq;j<seq+16;j++)
00986             {
00987                 int stat = mDecoder->GetTowerIdFromCrate(crate,j,id);
00988                 if(stat==1)
00989                 {
00990                     if(adc10[id-1]>=HT)
00991                     {
00992                         HT = adc10[id-1];
00993                         HTID = id;
00994                     }
00995                     patchPed+= (ped10[id-1]>>2);
00996                     PA+=adc08[id-1];
00997                 }
00998                 
00999                 //printf("Patch %d Ped=%d PedSum=%d  ADC=%d ADCSum=%d\n",i,ped10[id-1]>>2,patchPed,adc08[id-1],PA);
01000             }
01001 
01002 
01003             // now HT=10 bits and patch=12 bits
01004             // convert patch sum to 6 bits using LUT
01005             // during 2005 LUT's looked like this:
01006             // 0,0,0,...,0,1,2,3,...,63,63,63 -- total 4096 entries
01007             // <-- ped -->
01008             // the number of 0's is equal to patchPed_12bit
01009             if(PA >= patchPed){
01010 
01011                 mTrigger.Patch[i] = PA - (patchPed-1);
01012                 if(mTrigger.Patch[i] > 62)  mTrigger.Patch[i] = 62;
01013             }
01014             if(PA<patchPed) mTrigger.Patch[i]=1;
01015 
01016             // for HT need to OR top 2 bits and take correct bit window
01017             int SHIFT = mTrigger.HTBits;
01018             HT = HT >> SHIFT;
01019             int HTL = HT & 0x1F;
01020             int HTH = HT >> 5;
01021             int B5  = 0;
01022             if(HTH>0) B5 = 1;
01023             mTrigger.HT[i] = HTL+(B5<<5);
01024             mTrigger.HTID[i] = HTID;
01025                 { LOG_DEBUG <<"Patch number "<<i<<" Tower id = "<<mTrigger.HTID[i]<<" adc12 = "<<adc12[HTID-1]
01026                         <<" adc10 = "<<adc10[HTID-1]<<" adc08 = "<<adc08[HTID-1]<<" HT10 = "<<HT<<" PA12 = "<<PA
01027                         <<" HT = "<<mTrigger.HT[i]<<" PA = "<<mTrigger.Patch[i]<<endm; }
01028             
01029             if (mTrigger.HT[i]>HTmax){
01030               HTmax=mTrigger.HT[i];
01031               HTmaxID=HTID;
01032             }
01033             
01034             if (mTrigger.HT[i]>HT1_TH_2005){
01035               HT1_2005_array[numHT1_2005]=HTID;
01036               numHT1_2005++;
01037               LOG_DEBUG<<HTID<<" Passed HT1 threshold="<<numHT1_2005<<"  "<<HT1_2005_array[numHT1_2005-1]<<endm;
01038             }
01039             
01040             if (mTrigger.HT[i]>HT2_TH_2005){
01041               HT2_2005_array[numHT2_2005]=HTID;
01042               numHT2_2005++;
01043               LOG_DEBUG<<HTID<<" Passed HT2 threshold="<<numHT2_2005<<"  "<<HT2_2005_array[numHT2_2005-1]<<endm;
01044             }
01045 
01046         }
01047     
01048     if (HTmax>HT1_TH_2005)
01049     {
01050         mIs2005HT1=1;
01051         HT1_ID_2005=HTmaxID;
01052         HT1_DSM_2005=HTmax;
01053     }
01054     else
01055     {
01056         mIs2005HT1=0;
01057         HT1_ID_2005=HTmaxID;
01058         HT1_DSM_2005=HTmax;
01059     }
01060     if (HTmax>HT2_TH_2005)
01061     {
01062         mIs2005HT2=1;
01063         HT2_ID_2005=HTmaxID;
01064         HT2_DSM_2005=HTmax;
01065     }
01066     else
01067     {
01068         mIs2005HT2=0;
01069         HT2_ID_2005=HTmaxID;
01070         HT2_DSM_2005=HTmax;
01071     }
01072 
01073     // making Jet trigger and Et
01074     int JPmax=0;
01075     int JPid=0;
01076     mTrigger.Et = 0;
01077     for(int i = 0;i<kNJet; i++)
01078     {
01079         int p0 = 0;
01080         int p1 = p0+25;
01081 
01082         mTrigger.Jet[i]= 0;
01083         for (int j=p0;j<p1;j++)
01084         {
01085             int k=JP_TP[i][j];
01086             mTrigger.Jet[i]+=mTrigger.Patch[k];
01087         }
01088 
01089         mTrigger.Et+=mTrigger.Jet[i];
01090         if (mTrigger.Jet[i]>JPmax)
01091         {
01092             JPmax=mTrigger.Jet[i];
01093             JPid=i;
01094         }
01095 
01096 
01097         if (mTrigger.Jet[i]>JP1_TH_2005)
01098         {
01099           JP1_2005_array[numJP1_2005]=i;
01100           numJP1_2005++;
01101         }
01102 
01103        if (mTrigger.Jet[i]>JP2_TH_2005)
01104         {
01105           JP2_2005_array[numJP2_2005]=i;
01106           numJP2_2005++;
01107         }
01108 
01109     }
01110 
01111     if (JPmax>JP1_TH_2005)
01112     {
01113         mIs2005JP1=1;
01114         JP1_ID_2005=JPid;
01115         JP1_DSM_2005=JPmax;
01116     }
01117     else
01118     {
01119         mIs2005JP1=0;
01120         JP1_ID_2005=JPid;
01121         JP1_DSM_2005=JPmax;
01122     }
01123 
01124     if (JPmax>JP2_TH_2005)
01125     {
01126         mIs2005JP2=1;
01127         JP2_ID_2005=JPid;
01128         JP2_DSM_2005=JPmax;
01129     }
01130     else
01131     {
01132         mIs2005JP2=0;
01133         JP2_ID_2005=JPid;
01134         JP2_DSM_2005=JPmax;
01135     }
01136 
01137 
01138     // making Jpsi trigger
01139     int JpsiPatch[kNJet];
01140     for(int i = 0;i<kNJet; i++)
01141     {
01142         int p0 = 0;
01143         int p1 = p0+25;
01144 
01145         JPSI_2005_ADC[i]=0;
01146         JPSI_2005_ID[i]=0;
01147         JpsiPatch[i]=0;
01148         for (int j=p0;j<p1;j++)
01149         {
01150             int k=JP_TP[i][j];
01151             if (mTrigger.HT[k]>JPSI_2005_ADC[i]) {
01152               JPSI_2005_ADC[i]=mTrigger.HT[k];
01153               JPSI_2005_ID[i]=mTrigger.HTID[k];
01154             }
01155             LOG_DEBUG<<"Jet id="<<i<<" Patch id="<<j<<" PatchHT="<<mTrigger.HT[k]<<" PatchHTID="<<mTrigger.HTID[k]<<" JPSI_2005_ADC="<<JPSI_2005_ADC[i]<<endm;
01156         }
01157         if  (JPSI_2005_ADC[i]>JPSI_TH_2005) {
01158           JpsiPatch[i]=1;
01159         }
01160         LOG_DEBUG<<"Final JetPatchHT for JP"<<i<<" is TowID="<<JPSI_2005_ID[i]<<"  with ADC= "<<JPSI_2005_ADC[i]<<" and flag="<<JpsiPatch[i]<<endm;
01161     }
01162 
01163     if ((JpsiPatch[0]&&(JpsiPatch[2]||JpsiPatch[3]||JpsiPatch[4])) ||
01164         (JpsiPatch[1]&&(JpsiPatch[3]||JpsiPatch[4]||JpsiPatch[5])) ||
01165         (JpsiPatch[2]&&(JpsiPatch[4]||JpsiPatch[5])) ||
01166         (JpsiPatch[3]&&JpsiPatch[5]) )
01167       {
01168         
01169         mIs2005JPSI=1;
01170       }
01171     else
01172       {
01173         mIs2005JPSI=0;
01174       }
01175     
01176 
01177     return kStOK;
01178 }
01179 
01180 
01181 
01182 int StBemcTrigger::get2006Trigger()
01183 {
01184 
01185 
01186   zero();
01187 
01188   //trigger matrix for 6 different settings in time
01189   const int HT0WEST_TH_2006[6]= {  5,  5,  5,  5,  5,  5};
01190   const int HT0EAST_TH_2006[6]= { 11, 11,  5,  5,  5,  5};
01191   const int HT1WEST_TH_2006[6]= { 12, 12, 16, 18, 16, 16};
01192   const int HT1EAST_TH_2006[6]= { 12, 12, 16, 18, 16, 16};
01193   const int HT2WEST_TH_2006[6]= { 22, 24, 24, 24, 24, 24};
01194   const int HT2EAST_TH_2006[6]= { 24, 24, 24, 24, 24, 24};
01195   const int HTTP0_TH_2006[6]  = {  1,  1,  1,  1,  1,  1};
01196   const int HTTP1_TH_2006[6]  = { 17, 17, 20, 20, 19, 19};
01197   const int HTTP2_TH_2006[6]  = { 31, 31, 31, 31, 31, 31};
01198   const int JP0_TH_2006[6]    = { 42, 42, 48, 49, 49, 49};
01199   const int JP1_TH_2006[6]    = { 58, 58, 58, 60, 60, 60};
01200   //const int JP2_TH_2006[6]    = {110,110,110,110,110,110};
01201   //const int BEMC_ETOT_2006[6] = {109,109,109,109,109,109};
01202 
01203   const int pedestalTargetValue2006 = 24;
01204 
01205  
01206     
01207     if(!mEvent)
01208     {
01209         LOG_WARN << "StBemcTrigger::make2006Trigger() -- no StEvent!" << endm;
01210         return kStWarn;
01211     }
01212     
01213     StEmcCollection *emc = mEvent->emcCollection();
01214     if(!emc)
01215     {
01216         LOG_WARN << "StBemcTrigger::make2006Trigger() -- no StEmcCollection!" << endm;
01217         return kStWarn;
01218     }
01219 
01220 
01221     int adc12[kNTowers];
01222     int adc10[kNTowers];
01223     int adc08[kNTowers];
01224     int ped10[kNTowers];
01225     for(int i = 0; i < kNTowers; ++i)
01226     {
01227     
01228         adc12[i] = 0;
01229         adc10[i] = 0;
01230         adc08[i] = 0;
01231         ped10[i] = 0;
01232         for ( int matrix=0; matrix<6; matrix++){
01233           HT2_2006_array[matrix][i] = -1;
01234           mHT22006array[matrix][i] = -1;
01235         }
01236     }
01237 
01238     for(int i = 0; i < kNJet; ++i)
01239       {
01240         for (int matrix=0;matrix<6;matrix++)
01241           {
01242             JP0_2006_array[matrix][i] = -1;
01243             JP1_2006_array[matrix][i] = -1;
01244             mJP02006array[matrix][i] = -1;
01245             mJP12006array[matrix][i] = -1;
01246             mJPSI2006adc[matrix][i] = -1;
01247             mJPSI2006id[matrix][i] = -1;
01248           }
01249       }
01250 
01251     
01252     for(int i = 0; i < kNPatches; ++i)
01253       {
01254         for (int matrix=0;matrix<6;matrix++)
01255           {
01256             BHTTP_2006_HT[matrix][i]=-1;
01257             BHTTP_2006_HT_ADC[matrix][i]=-1;
01258             BHTTP_2006_TP[matrix][i]=-1;
01259             BHTTP_2006_TP_ADC[matrix][i]=-1;
01260           }
01261       }
01262 
01263     for (int matrix=0;matrix<6;matrix++){
01264       numHT2_2006[matrix]=0;
01265       numJP0_2006[matrix]=0;
01266       numJP1_2006[matrix]=0;
01267       numHTTP_2006[matrix]=0;
01268     }
01269   
01270     int ped12bit, val12bit, operation; 
01271     // operation bit for pedestal subtraction
01272     // subtract: +1 (default)
01273     //      add: 0
01274 
01275     StEmcDetector* detector=emc->detector(kBarrelEmcTowerId);
01276     if(detector)
01277     {
01278         
01279         for(Int_t m = 1; m <= 120; ++m)
01280         {
01281          
01282             StEmcModule* module = detector->module(m);
01283             if(module)
01284             {
01285             
01286                 StSPtrVecEmcRawHit& rawHit=module->hits();
01287                 for(UInt_t k = 0; k < rawHit.size(); ++k)
01288                 {
01289                 
01290                     if(rawHit[k])
01291                     {
01292                     
01293                         Int_t did;
01294                         Int_t mod=rawHit[k]->module();
01295                         Int_t e=rawHit[k]->eta();
01296                         Int_t s=abs(rawHit[k]->sub());
01297                         mGeo->getId(mod,e,s,did);
01298                         
01299                         if ((mTrigger.TowerStatus[did-1]==1)&&(mTables->status(BTOW,did,"calib")==1))
01300                         {
01301                         
01302                             adc12[did-1]=rawHit[k]->adc();
01303                             adc10[did-1] = adc12[did-1]>>2;
01304                             
01305                             float NEWped=-1;
01306                             float NEWrms=-1;
01307                             mTables ->getPedestal(BTOW,did,0,NEWped,NEWrms);
01308                             ped12bit=(int) NEWped;
01309                             
01310                             operation = 1;
01311                             ped10[did-1] = ped12bit >> 2;
01312                             val12bit = ped12bit - pedestalTargetValue2006;
01313                             
01314                             if(val12bit < 0)
01315                               {
01316                                 val12bit = -val12bit;
01317                                 operation = 0;
01318                               }
01319                             
01320                             int val10bit = val12bit/4;
01321                             if(val12bit - val10bit*4 > 2) val10bit+=1;
01322                             
01323                             if(val10bit > 15)
01324                             {
01325                                 // can't subtract/add more than 15 on 10-bit level
01326                                 val10bit = val10bit - 4*((val10bit-11)/4);
01327                             }
01328                             
01329                             if(operation==1)
01330                             {
01331                                 adc10[did-1] -= val10bit;
01332                                 ped10[did-1] -= val10bit;
01333                             }
01334                             else
01335                             {
01336                                 adc10[did-1] += val10bit;
01337                                 ped10[did-1] += val10bit;
01338                             }
01339                             
01340                             adc08[did-1] = adc10[did-1]>>2;// adc10[],adc08[] are pedestal-adjusted
01341                             
01342                         }
01343                         
01344                     }
01345                     
01346                 }
01347                     
01348             }
01349             
01350         }
01351     
01352     }
01353     else
01354     {
01355         LOG_WARN << "StBemcTrigger::make2006Trigger() -- pointer to StEmcDetector is zero!" << endm;
01356         return kStWarn;
01357     }
01358 
01359     // making trigger patches and high towers
01360     TUnixTime unixTime(mEvent->time());
01361     Int_t dat=0,tim=0;
01362     unixTime.GetGTime(dat,tim);
01363     mDecoder->SetDateTime(dat,tim);
01364     mDecoder->SetFixTowerMapBug(false);
01365 
01366     float rped12bit;
01367     int HTmax=0;
01368     int HTmaxID=-1;
01369     
01370     for(int i = 0; i < kNPatches; ++i) 
01371     {
01372 
01373         if(mTrigger.PatchStatus[i]==1) 
01374         {
01375         
01376             int crate = 0;
01377             int seq  = 0;
01378             int HT = 0;
01379             int PA = 0;
01380             int HTID = -1;
01381             int id;
01382             int patchPed = 0;
01383             
01384             mDecoder->GetCrateAndSequenceFromTriggerPatch(i,crate,seq);
01385             mTables->getTriggerPedestal(crate,seq,rped12bit);
01386             
01387             //loop over each tower(j) in the trigger patch (i)
01388             for(int j = seq; j < seq + 16; ++j)
01389             {
01390             
01391                 int stat = mDecoder->GetTowerIdFromCrate(crate,j,id);
01392                 if(stat == 1)
01393                 {
01394             
01395                     if(adc10[id-1]>=HT)
01396                     {
01397                         HT = adc10[id-1];
01398                         HTID = id;
01399                     }
01400                     
01401                     patchPed += ped10[id-1] >> 2;
01402                     PA += adc08[id-1];
01403                 }
01404             
01405             }
01406         
01407             // now HT=10 bits and patch=12 bits
01408             // convert patch sum to 6 bits using LUT
01409             // during 2006 LUT's looked like this:
01410             // 0,0,0,...,0,1,2,3,...,63,63,63 -- total 4096 entries
01411             // <-- ped -->
01412             // the number of 0's is equal to patchPed_12bit
01413             if(PA >= patchPed)
01414             {
01415             
01416                 mTrigger.Patch[i] = PA - (patchPed - 1);
01417                 if(mTrigger.Patch[i] > 62)  mTrigger.Patch[i] = 62;
01418             }
01419             else
01420             {
01421                 mTrigger.Patch[i] = 1;
01422             }
01423             
01424             // for HT need to:
01425             //1) drop lowest bits (depends on calibration)
01426             //2) take next 6 LSB as HT 6 bit adc
01427             //3) if 6 or higher bit ==1 need to set all bits high (63)
01428             HT = HT >>(mTrigger.HTBits - 1);
01429             int HTL = HT & 0x1F;//5 LSB
01430             int HTH = HT >> 5;  //>= 6 LSB
01431             int B5  = 0;
01432             if(HTH>0) B5 = 1;
01433             mTrigger.HT[i] = HTL+(B5<<5);
01434             mTrigger.HTID[i] = HTID;
01435             
01436             { 
01437             LOG_DEBUG <<"Patch number "<<i<<" Tower id = "<<mTrigger.HTID[i]<<" adc12 = "<<adc12[HTID-1]
01438             <<" adc10 = "<<adc10[HTID-1]<<" adc08 = "<<adc08[HTID-1]<<" HT10 = "<<HT<<" PA12 = "<<PA
01439             <<" HT = "<<mTrigger.HT[i]<<" PA = "<<mTrigger.Patch[i]<<endm; 
01440             }
01441             
01442             if(mTrigger.HT[i]>HTmax)
01443             {
01444                 HTmax=mTrigger.HT[i];
01445                 HTmaxID=HTID;
01446             }
01447     
01448             for (int matrix=0; matrix<6; matrix++){
01449 
01450               if (HTID>2400) {//East
01451                 if(mTrigger.HT[i]>HT2EAST_TH_2006[matrix])
01452                   {
01453                     HT2_2006_array[matrix][numHT2_2006[matrix]]=HTID;
01454                     numHT2_2006[matrix]++;
01455                   }
01456               }
01457               
01458               if (HTID<=2400) {//West
01459                 if(mTrigger.HT[i]>HT2WEST_TH_2006[matrix])
01460                   {
01461                     HT2_2006_array[matrix][numHT2_2006[matrix]]=HTID;
01462                     numHT2_2006[matrix]++;
01463                   }
01464               }
01465             }
01466         }
01467     }
01468             
01469     //making HT trigger
01470     for (int matrix=0; matrix<6; matrix++){
01471 
01472       if (HTmaxID>2400){//East
01473         if (HTmax > HT2EAST_TH_2006[matrix])
01474           {
01475             mIs2006HT2[matrix]=1;
01476             HT2_ID_2006[matrix]=HTmaxID;
01477             HT2_DSM_2006[matrix]=HTmax;
01478           }
01479         else
01480           {
01481             mIs2006HT2[matrix]=0;
01482             HT2_ID_2006[matrix]=HTmaxID;
01483             HT2_DSM_2006[matrix]=HTmax;
01484           }
01485       }
01486 
01487       if (HTmaxID<=2400){//West
01488         if (HTmax > HT2WEST_TH_2006[matrix])
01489           {
01490             mIs2006HT2[matrix]=1;
01491             HT2_ID_2006[matrix]=HTmaxID;
01492             HT2_DSM_2006[matrix]=HTmax;
01493           }
01494         else
01495           {
01496             mIs2006HT2[matrix]=0;
01497             HT2_ID_2006[matrix]=HTmaxID;
01498             HT2_DSM_2006[matrix]=HTmax;
01499           }
01500       }
01501     }
01502     
01503     // making HTTP trigger
01504     int BHTTPcounter[6];
01505     for ( int matrix=0; matrix<6; matrix++){
01506 
01507       mIs2006BHTTP[matrix]=0;
01508       BHTTPcounter[matrix]=0;
01509       
01510       for(int i = 0; i < kNPatches; ++i)
01511         {
01512           
01513           int HTBIT = -1;
01514           int TPBIT = -1;
01515         
01516           if (kNPatches < 150){ //West
01517             if (mTrigger.HT[i] < HT0WEST_TH_2006[matrix]) HTBIT = 0;
01518             if (mTrigger.HT[i] > HT0WEST_TH_2006[matrix]) HTBIT = 1;
01519             if (mTrigger.HT[i] > HT1WEST_TH_2006[matrix]) HTBIT = 2;
01520             if (mTrigger.HT[i] > HT2WEST_TH_2006[matrix]) HTBIT = 3;
01521           }
01522           
01523           if (kNPatches >= 150){//East
01524             if (mTrigger.HT[i] < HT0EAST_TH_2006[matrix]) HTBIT = 0;
01525             if (mTrigger.HT[i] > HT0EAST_TH_2006[matrix]) HTBIT = 1;
01526             if (mTrigger.HT[i] > HT1EAST_TH_2006[matrix]) HTBIT = 2;
01527             if (mTrigger.HT[i] > HT2EAST_TH_2006[matrix]) HTBIT = 3;
01528           }
01529         
01530           if (mTrigger.Patch[i] < HTTP0_TH_2006[matrix]) TPBIT = 0;
01531           if (mTrigger.Patch[i] > HTTP0_TH_2006[matrix]) TPBIT = 1;
01532           if (mTrigger.Patch[i] > HTTP1_TH_2006[matrix]) TPBIT = 2;
01533           if (mTrigger.Patch[i] > HTTP2_TH_2006[matrix]) TPBIT = 3;
01534         
01535           if( TPBIT >= 2 && HTBIT >= 2)
01536             {
01537               mIs2006BHTTP[matrix] = 1;
01538               BHTTP_2006_TP[matrix][BHTTPcounter[matrix]] = i;
01539               BHTTP_2006_TP_ADC[matrix][BHTTPcounter[matrix]] = mTrigger.Patch[i];
01540               BHTTP_2006_HT[matrix][BHTTPcounter[matrix]] = mTrigger.HTID[i];
01541               BHTTP_2006_HT_ADC[matrix][BHTTPcounter[matrix]] = mTrigger.HT[i];
01542               BHTTPcounter[matrix]++;
01543             }
01544         }
01545       numHTTP_2006[matrix]=BHTTPcounter[matrix];
01546     }
01547     
01548 
01549     // Clear jet patch variables
01550     int JPmax = 0;
01551     int JPid = 0;
01552     
01553     for(int i = 0; i < kNJet; ++i)
01554       {
01555         
01556         mTrigger.Jet[i] = 0;
01557         
01558         for(int sequence = 0; sequence < kN_sequences; ++sequence)
01559           {
01560             
01561             int k = 0;
01562             mDecoder->GetTriggerPatchFromJetPatch(i, sequence, k);
01563             mTrigger.Jet[i] += mTrigger.Patch[k];
01564             
01565           }
01566         
01567       }
01568     
01569     // Check jet patch triggers
01570     for(int i = 0; i < kNJet; ++i)
01571       {
01572         
01573         if(mTrigger.Jet[i] > JPmax)
01574           {
01575             JPmax = mTrigger.Jet[i];
01576             JPid = i;
01577           }
01578         
01579         for (int matrix=0;matrix<6;matrix++){
01580         
01581           if(mTrigger.Jet[i] > JP0_TH_2006[matrix])
01582             {
01583               JP0_2006_array[matrix][numJP0_2006[matrix]] = i;
01584               ++numJP0_2006[matrix];
01585             }
01586           
01587           if(mTrigger.Jet[i] > JP1_TH_2006[matrix])
01588             {
01589               JP1_2006_array[matrix][numJP1_2006[matrix]] = i;
01590               ++numJP1_2006[matrix];
01591             }   
01592         }
01593       }
01594         
01595 
01596     for (int matrix=0;matrix<6;matrix++){
01597       
01598       if(JPmax > JP0_TH_2006[matrix])
01599         {
01600           mIs2006JP0[matrix]=1;
01601           JP0_ID_2006[matrix]=JPid;
01602           JP0_DSM_2006[matrix]=JPmax;
01603         }
01604       else
01605         {
01606           mIs2006JP0[matrix]=0;
01607           JP0_ID_2006[matrix]=JPid;
01608           JP0_DSM_2006[matrix]=JPmax;
01609         }
01610     
01611       if(JPmax > JP1_TH_2006[matrix])
01612         {
01613           mIs2006JP1[matrix]=1;
01614           JP1_ID_2006[matrix]=JPid;
01615           JP1_DSM_2006[matrix]=JPmax;
01616         }
01617       else
01618         {
01619           mIs2006JP1[matrix]=0;
01620           JP1_ID_2006[matrix]=JPid;
01621           JP1_DSM_2006[matrix]=JPmax;
01622         }
01623     }
01624     
01625     //making ETOT trigger
01626     //combine 2 JP to form 13 bit adc
01627     //drop 2 LSB 
01628     //check if bit 6 or higher == 1
01629     mTrigger.Et = 0;
01630     int EtotSum[6];
01631     for(int i = 0; i < 6; ++i) 
01632       {
01633         
01634         EtotSum[i] = 0;
01635         BL1_ADC_2006[i] = 0;
01636         Int_t j = 2*i;
01637         Int_t TempSum = 0;
01638         TempSum = mTrigger.Jet[j] + mTrigger.Jet[j+1];
01639         EtotSum[i]=TempSum >> 2;
01640         if (EtotSum[i]>31)  EtotSum[i]=31;
01641         mTrigger.Et += EtotSum[i];
01642         BL1_ADC_2006[i] = EtotSum[i];
01643         
01644       } 
01645     BETOT_DSM_2006=mTrigger.Et;
01646     
01647     //
01648     // Making Jpsi trigger
01649     // See http://www.star.bnl.gov/STAR/html/trg_l/TSL/Software/EMC.pdf
01650     //
01651     int JpsiPatch[6][kNJet];
01652     for (int matrix=0;matrix<6;matrix++)
01653       {
01654         for(int i = 0; i < kNJet; ++i)
01655           {
01656             
01657             JPSI_2006_ADC[matrix][i]=0;
01658             JPSI_2006_ID[matrix][i]=0;
01659             JpsiPatch[matrix][i]=0;
01660           
01661             for(int sequence = 0; sequence < kN_sequences; ++sequence)
01662               {
01663                 
01664                 int k = 0;
01665                 mDecoder->GetTriggerPatchFromJetPatch(i, sequence, k);      
01666                 if(mTrigger.HT[k] > JPSI_2006_ADC[matrix][i]) 
01667 
01668                   {
01669                     JPSI_2006_ADC[matrix][i]=mTrigger.HT[k];
01670                     JPSI_2006_ID[matrix][i]=mTrigger.HTID[k];
01671                   }
01672               }
01673             
01674             if(i < 6) 
01675               {
01676                 // BEMC West
01677                 if(JPSI_2006_ADC[matrix][i] > HT0WEST_TH_2006[matrix]) JpsiPatch[matrix][i] = 1;
01678               }
01679             else 
01680               {
01681                 // BEMC East
01682                 if(JPSI_2006_ADC[matrix][i] > HT0EAST_TH_2006[matrix]) JpsiPatch[matrix][i] = 1;
01683               }
01684             
01685           }
01686         
01687         
01688         
01689         // The J/psi trigger fires if two opposite jet patches have high towers
01690         // above selected thresholds.
01691         // Follow convention in the DSM implementation where vector bits (0-5)
01692         // correspond to positions 2,4,6,8,10,12 o'clock.
01693         
01694         
01695         int ht_jpsi[6]={0,0,0,0,0,0};
01696         
01697         ht_jpsi[4] = JpsiPatch[matrix][0] || JpsiPatch[matrix][6];
01698         ht_jpsi[5] = JpsiPatch[matrix][1] || JpsiPatch[matrix][7];
01699         ht_jpsi[0] = JpsiPatch[matrix][2] || JpsiPatch[matrix][8];
01700         ht_jpsi[1] = JpsiPatch[matrix][3] || JpsiPatch[matrix][9];
01701         ht_jpsi[2] = JpsiPatch[matrix][4] || JpsiPatch[matrix][10];
01702         ht_jpsi[3] = JpsiPatch[matrix][5] || JpsiPatch[matrix][11];
01703 
01704         mIs2006JPSI[matrix] = ((ht_jpsi[0] && (ht_jpsi[2] || ht_jpsi[3] || ht_jpsi[4])) ||
01705                                (ht_jpsi[1] && (ht_jpsi[3] || ht_jpsi[4] || ht_jpsi[5])) ||
01706                                (ht_jpsi[2] && (ht_jpsi[4] || ht_jpsi[5])) || (ht_jpsi[3] &&  ht_jpsi[5]));
01707         
01708       }
01709     
01710     return kStOK;
01711 }