beamtime/cosy-dec10/go4/TCosyDec10Proc.cxx (r4864/r3193)

Go to the documentation of this file.

#include "TCosyDec10Proc.h"


#include "TGo4Version.h"
#if __GO4BUILDVERSION__ > 40502
#include "go4iostream.h"
#else
#include "Riostream.h"
#endif
#include "TH1.h"
#include "TSystem.h"
#include "TH2.h"
#include <stdlib.h>

#include "TCosyDec10Param.h"
#include "TGo4WinCond.h"
#include "TGo4PolyCond.h"
#include "TGo4Picture.h"
#include "TGo4Analysis.h"
#include "TGo4MbsEvent.h"
#include "TRocParam.h"
#include "TGo4Log.h"

#include "TPedestalExtractor.h"

#include "roc/Board.h"
#include "roc/Message.h"
#include "roc/Iterator.h"

extern "C"
{
    INTS4 f_ut_utime(INTS4 l_sec, INTS4 l_msec, CHARS *pc_time);
}

#include "f_ut_utime.h"

#define L1182_DEBUG 0

UChar_t       TCosyDec10Proc::fStsRocIds[]={0,1,2,3};

UChar_t       TCosyDec10Proc::fGEMRocIds[]={7,4,5,6};


// these arrays define GEM geometry mapping:

// left part (for roc 0)

// channel numbers at the end of each y row 
Int_t  TCosyDec10Proc::fGEM_Y_BoundariesLeft[]  ={10,19,31,42,54,65,77,88,100,111,123,134,146,157,169,180,192,203,215,226,237,246,256};

// number of channels for each row
Int_t  TCosyDec10Proc::fGEM_Y_PeriodLeft[]      ={10,9,12,11,12,11,12,11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 11, 9, 10};

// shift of each row with respect to left gem edge
Int_t  TCosyDec10Proc::fGEM_Y_ShiftLeft[]       ={ 2, 2, 0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2 };

// left part (for roc 1)
// channel numbers at the end of each y row 
Int_t  TCosyDec10Proc::fGEM_Y_BoundariesRight[] ={ 9,19,30,42,53,65,76,88,99,111,122,134,145,157,168,180,191,203,214,226,237,247,256};

// number of channels for each row
Int_t  TCosyDec10Proc::fGEM_Y_PeriodRight[]     ={ 9,10,11,12,11,12,11,12,11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 10, 9};

//shift of each row with respect to gem vertical middle line x=11
Int_t  TCosyDec10Proc::fGEM_Y_ShiftRight[]      ={ 1, 0, 1, 0, 1, 0, 1, 0, 1 , 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 ,0,1,0,1 };

            
  

              
          
           
           
            
             
            








       



//***********************************************************
// this one is used in standard factory
TCosyDec10Proc::TCosyDec10Proc(const char* name) : TRocProc(name)
{
   cout << "**** TCosyDec10Proc: Create instance" << name << endl;
   
   
  
   TString obname, obtitle;
   fParam->triggerSignal = 10;
   fLastMbsTimeSecs=0;
  fLastMbsTimeMicros= 0;
  fMbsDeltatime=0.;

   fCosyDec10Par = (TCosyDec10Param*) MakeParameter("CosyDec10Par", "TCosyDec10Param");
   
   if (IsObjMade()) {
      // redefine conditions ranges if we are starting without autosave
      for (unsigned n=0; n<4; n++) 
        ROC[n].fTriggerWind->SetValues(830., 940.);
      for (unsigned n=4; n<8; n++) 
        ROC[n].fTriggerWind->SetValues(850., 1100.);
   }



   fVulomSyncs = MakeTH1('I', "VULOM/Syncs", "Number of sync messages from VULOM", 65536, 0, 65536.);
   
   fSyncQuality = MakeTH1('I', "SyncQuality", "Differences between SYNC1 on different ROCs", 100, -100., 100., "ns");

   for (int n=0;n<NUM_SCALERS;n++)
   {
      fVulomScalers[n] = MakeTH1('I', Form("VULOM/Scaler%d", n), "Distribution of scaler signals", 16, 0, 16.);
       fVulomScalersRate[n] = MakeTH1('I', Form("VULOM/RateScaler%d", n), "Distribution of scaler rates", 16, 0, 16.);
   }
    fVulomScalerOverview=MakeTH2('I', Form("VULOM/ScalersOverview"), "Map of scalers", NUM_SCALERS,0,NUM_SCALERS,16, 0, 16.,"scaler id","channel");
    obname.Form("VulomScalers");
      if (GetPicture(obname.Data()) == 0) {
         obtitle.Form("Scalers overview");
         TGo4Picture* pic = new TGo4Picture(obname.Data(), obtitle.Data());
         pic->SetDivision(1, 1);
         pic->Pic(0, 0)->AddObject(fVulomScalerOverview);
         pic->Pic(0, 0)->SetDrawOption("TEXT BOX");
        AddPicture(pic,"Vulom");
   }
      
   //fScintVertical=MakeTH2('I', Form("Scintillators/ScintVertical"), "Vertical scintillators (Counts/s)", 1,0,1,4, 0, 4,"","y pos");
   //fScintHorizontal=MakeTH2('I', Form("Scintillators/ScintHorizontal"), "Horizotal scintillators (Counts/s)", 4,0,4,1, 0, 1,"x pos","");;
   fScintVerticalQDC = MakeTH2('I', "Scintillators/QDC_ScintVertical", "Vertical scintillators (Counts)", 1, 0.,1., 4, 0., 4.,"","y pos");
   fScintHorizontalQDC = MakeTH2('I', "Scintillators/QDC_ScintHorizontal", "Horizotal scintillators (Counts)", 4, 0.,4., 1, 0., 1.,"x pos","");;
 
   fScintAndQDC=MakeTH2('I', Form("Scintillators/QDC_ScintMap"), "Scintillators xy-AND (Counts/ev)", 4,0,4,4, 0, 4,"x pos","y pos");;
   fScintRolu=MakeTH2('I', Form("Scintillators/ROLU"), "Right upper left lower (Counts/ev)", 3,0,3,3, 0, 3,"x","y");
   fScintExtra=MakeTH2('I', Form("Scintillators/Extra"), "Extra scints (Counts/ev)" , 4,0,4,1, 0, 1);
   if (IsObjMade()) {
            fScintExtra->GetXaxis()->SetBinLabel(1 , "S1");
            fScintExtra->GetXaxis()->SetBinLabel(2 , "S2");
            fScintExtra->GetXaxis()->SetBinLabel(3 , "S3");
            fScintExtra->GetXaxis()->SetBinLabel(4 , "S4");
   }

   obname.Form("BeamCheckScalers");
      if (GetPicture(obname.Data()) == 0) {
         obtitle.Form("Beam scalers");
         TGo4Picture* pic = new TGo4Picture(obname.Data(), obtitle.Data());
         pic->SetDivision(2, 2);
         pic->Pic(0, 0)->AddObject(fScintVerticalQDC);
         pic->Pic(0, 0)->SetDrawOption("Lego2 Z");
          pic->Pic(0, 1)->AddObject(fScintHorizontalQDC);
         pic->Pic(0, 1)->SetDrawOption("Lego2 Z");
          pic->Pic(1, 0)->AddObject(fScintRolu);
         pic->Pic(1, 0)->SetDrawOption("Lego2 Z");
          pic->Pic(1, 1)->AddObject(fScintExtra);
         pic->Pic(1, 1)->SetDrawOption("Lego2 Z");
        AddPicture(pic,"Scintillators");
   }   
   
   

   
      
   for (int n=0;n<NUM_STS_STATIONS;n++) {
      fSTStm[n] = MakeTH1('I', Form("STS/STS%dtm", n), Form("Time correlation on STS%d to SYNC0 signal", n), 500, -1000., 4000.);
      lastSync[n] = 0;
      for (int j=0;j<NX_HISTORY;j++) lastNx[n][j] = 0;

      //fSTStmGate[n]= MakeWinCond(Form("STS/STS%dtm_Gate", n), -20, 2000, fSTStm[n]->GetName());;

      fSTSNeg[n]= MakeTH1('D', Form("STS/STS%d_Neg", n), Form("STS Station %d Negative side", n), NUM_STS_STRIPS, 0, NUM_STS_STRIPS);
      fSTSPos[n]= MakeTH1('D', Form("STS/STS%d_Pos", n), Form("STS Station %d Positive side", n), NUM_STS_STRIPS, 0, NUM_STS_STRIPS);
      fSTSNegTimegated[n]= MakeTH1('D', Form("STS/STS%d_Neg_Gated", n), Form("STS Station %d Negative side under time gate", n), NUM_STS_STRIPS, 0, NUM_STS_STRIPS);
      fSTSPosTimegated[n]= MakeTH1('D', Form("STS/STS%d_Pos_Gated", n), Form("STS Station %d Positive side under time gate", n), NUM_STS_STRIPS, 0, NUM_STS_STRIPS);

   }

   obname.Form("STS_Strips_Overview");
   if (GetPicture(obname.Data()) == 0) {
            obtitle.Form("STS strip overview");
            TGo4Picture* pic = new TGo4Picture(obname.Data(), obtitle.Data());
            pic->SetDivision(NUM_STS_STATIONS, 2);
            for (int n=0;n<NUM_STS_STATIONS;n++) {
            pic->Pic(n, 0)->AddObject(fSTSNeg[n]);
            pic->Pic(n, 0)->SetFillAtt(5, 3001);
            pic->Pic(n, 1)->AddObject(fSTSPos[n]);
            pic->Pic(n, 1)->SetFillAtt(3, 3001);
            }
            AddPicture(pic,"STS");
      }
      
    obname.Form("STS_Strips_Overview_Gated");
   if (GetPicture(obname.Data()) == 0) {
            obtitle.Form("STS strip overview under time condition");
            TGo4Picture* pic = new TGo4Picture(obname.Data(), obtitle.Data());
            pic->SetDivision(NUM_STS_STATIONS, 2);
            for (int n=0;n<NUM_STS_STATIONS;n++) {
            pic->Pic(n, 0)->AddObject(fSTSNegTimegated[n]);
            pic->Pic(n, 0)->SetFillAtt(5, 3001);
            pic->Pic(n, 1)->AddObject(fSTSPosTimegated[n]);
            pic->Pic(n, 1)->SetFillAtt(3, 3001);
            }
            AddPicture(pic,"STS");
      }   

 for (int n=0;n<NUM_GEM_STATIONS;n++) {
      fGEMtm[n] = MakeTH1('I', Form("GEM/GEM%dtm", n), Form("Time correlation on GEM %d to SYNC0 signal", n), 500, -1000., 4000.);

       //fGEMtmGate[n]= MakeWinCond(Form("GEM/GEM%dtm_Gate", n), -20, 2000, fGEMtm[n]->GetName());;

      fGEM_Map[n]=MakeTH2('I', Form("GEM/GEM%d_Map", n), Form("Hits of GEM %d ", n), NUM_GEM_X,0,NUM_GEM_X,NUM_GEM_Y,0,NUM_GEM_Y,"X","Y");
      fGEM_Map_Time[n]=MakeTH2('I', Form("GEM/GEM%d_Map_Timegated", n), Form("Hits of GEM %d under time gate", n), NUM_GEM_X,0,NUM_GEM_X,NUM_GEM_Y,0,NUM_GEM_Y,"X","Y");
  
      fGEM_Map_Adc[n]=MakeTH2('D', Form("GEM/GEM%d_Map_ADC", n), Form("ADC (corrected) of GEM %d ", n), NUM_GEM_X,0,NUM_GEM_X,NUM_GEM_Y,0,NUM_GEM_Y,"X","Y");
      fGEM_Map_Adc_Time[n]=MakeTH2('D', Form("GEM/GEM%d_Map_ADC_Timegated", n), Form("ADC (corrected) of GEM %d under time gate", n), NUM_GEM_X,0,NUM_GEM_X,NUM_GEM_Y,0,NUM_GEM_Y,"X","Y");
   
 }
  

   // 1182 histo
   for (int n=0;n<NUM_1182;n++) {
      obname.Form("1182/1182_channel%d", n);
      obtitle.Form("1182 Channel %d", n);
      f1182h[n] = MakeTH1('I', obname.Data(), obtitle.Data(), 1024, 0, 4096.);
      obname.Form("1182/Gate_1182_channel%d", n);
      obtitle.Form("1182 Channel %d", n);
      f1182Gate[n] = MakeWinCond(obname.Data(), 600, 3000, f1182h[n]->GetName()); // link condition to histogram

   }
   
    obname.Form("QDC_1182_Overview");
      if (GetPicture(obname.Data()) == 0) {
         obtitle.Form("QDC Spectra 1182");
         TGo4Picture* pic = new TGo4Picture(obname.Data(), obtitle.Data());
         pic->SetDivision(2, 4);
         for(int x=0;x<4;++x)
         {
           for(int y=0;y<2;++y)
           {
             pic->Pic(y, x)->AddObject(f1182h[x+4*y]);
             pic->Pic(y, x)->AddCondition(f1182Gate[x+4*y]);
           }
         }
        AddPicture(pic,"Scintillators");
   }   
   
   
   // 1183 histo
   for (int n=0;n<NUM_1183;n++) {
      obname.Form("1183/1183_channel%d", n);
      
      obtitle.Form("1183 Channel %d", n);
      f1183h[n] = MakeTH1('I', obname.Data(), obtitle.Data(), 1024, 0, 8192.);
/*      obname.Form("1183/Gate_1182_channel%d", n);
      obtitle.Form("1183 Channel %d", n);
      f1183Gate[n] = MakeWinCond(obname.Data(), 0, 2000, f1183h[n]->GetName()); // link condition to histogram*/
      
   }
//  obname.Form("QDC_1183_Overview");
//       if (GetPicture(obname.Data()) == 0) {
//          obtitle.Form("QDC Spectra 1183");
//          TGo4Picture* pic = new TGo4Picture(obname.Data(), obtitle.Data());
//          pic->SetDivision(2, 4);
//       for(int x=0;x<4;++x)
//       {
//         for(int y=0;y<2;++y)
//         {
//           pic->Pic(y, x)->AddObject(f1183h[x+4*y]);
//           pic->Pic(y, x)->AddCondition(f1183Gate[x+4*y]);
//         }
//       }
//         AddPicture(pic,"Scintillators");
//    }   

   fMotorPos=MakeTH2('I', Form("Epics/MotorPosition"), Form("GEM Motor"), 60,0,300,60,0,300,"X (mm)","Y (mm)");
   fRoluPos=MakeTH2('I', Form("Epics/ROLUPosition"), Form("Rolu positions"), 35,0,35,35,0,35,"X (mm)","Y (mm)");
   printf("Histograms created \n");
   
    Init_GEM_Map();
}

//***********************************************************
TCosyDec10Proc::~TCosyDec10Proc()
{
}


Bool_t TCosyDec10Proc::IsSTS(roc::Message* msg)
{
 Int_t rocId=msg->getRocNumber();
 for(int ix=0;ix<NUM_STS_ROCS;++ix)
   {
           if(rocId==fStsRocIds[ix])
           {
                   return kTRUE;
           }
   }
 return kFALSE;  
  
}
      
Bool_t TCosyDec10Proc::IsGEM(roc::Message* msg)
{
 Int_t rocId=msg->getRocNumber(); 
 for(int ix=0;ix<NUM_GEM_ROCS;++ix)
   {
           if(rocId==fGEMRocIds[ix])
           {
                   return kTRUE;
           }
   }
 return kFALSE; 
  
}




void TCosyDec10Proc::ProcessRocMsg(roc::Message* msg)
{
   // this is a place for nx-specific code.
   // Here coming hits which are not involved in any kind of calibration procedure


   if (IsSTS(msg)) {
         // add sts mapping by I.Sorokin:

         Int_t rocId = msg->getRocNumber();

         Int_t stsid(0);

         if ((rocId == 0) || (rocId == 1)) stsid = 0; else
         if ((rocId == 2) || (rocId == 3)) stsid = 1;

         uint64_t fulltm = msg->getMsgFullTime(ROC[msg->getRocNumber()].fCurrEpoch);

            if (msg->isSyncMsg()) {

      //         printf("SYNC %10lu  diff %lu\n", fulltm, fulltm - lastNx);
               lastSync[stsid] = fulltm;
               for (int j=0;j<NX_HISTORY;j++) {
                  if (lastNx[stsid][j]>fulltm)
                     fSTStm[stsid]->Fill(roc::Message::CalcDistance(fulltm, lastNx[stsid][j]));
                  else
                     fSTStm[stsid]->Fill(-1.*roc::Message::CalcDistance(lastNx[stsid][j], fulltm));
               }
            } else
            if (msg->isHitMsg()) {
               for (int j=0;j<NX_HISTORY-1;j++)
                  lastNx[stsid][j] = lastNx[stsid][j+1];
               lastNx[stsid][NX_HISTORY-1] = fulltm;
      //         printf("NX %10lu  diff %lu\n", fulltm, fulltm - lastSync);
               uint64_t dist = roc::Message::CalcDistance(lastSync[stsid], fulltm);
               fSTStm[stsid]->Fill(1*dist);

// this part is done in ProcessNxHit now
               // here comes detector mapping:
//                Int_t nxChannel=msg->getNxChNum();
//                Int_t StsStrip=STS_GetStrip(side,odd,nxChannel)+1;// strip numbering begins with 1
//                if(side)
//                                 {
//                                         fCosyDec10Event->fStsNeg[stsid][StsStrip]=msg->getNxAdcValue();
//                                         fSTSNeg[stsid]->Fill(StsStrip,msg->getNxAdcValue());
//                                 }
//                         else
//                 {
//                                         fCosyDec10Event->fStsPos[stsid][StsStrip]=msg->getNxAdcValue();
//                                         fSTSPos[stsid]->Fill(StsStrip,msg->getNxAdcValue());
//                 }

                }
                else 
            if(msg->isSysMsg())
            {
              if(msg->getSysMesType()==roc::SYSMSG_NX_PARITY)
              {
                TString str;
                str.Form("**** TCosyDec10Proc: STS Found roc parity error for roc %d = sts:%d \n",rocId,stsid);
                GO4MESSAGE((2, str.Data()));
              }
            }


   }
   if (IsGEM(msg)) {

      if(msg->isSysMsg() && (msg->getSysMesType()==roc::SYSMSG_NX_PARITY)) {
         TString str;
         str.Form("**** TCosyDec10Proc: GEM Found roc parity error for roc %d  \n",msg->getRocNumber());
         GO4MESSAGE((2, str.Data()));
      }
   }
}



void TCosyDec10Proc::ProcessNxHit(roc::Message* msg, Double_t nxadc_corr)
{
   Int_t rocId=msg->getRocNumber();
   Int_t nxId=msg->getNxNumber();
   Int_t nxChannel=msg->getNxChNum();
   uint64_t fulltm = msg->getMsgFullTime(ROC[rocId].fCurrEpoch);
   int32_t timedist = CalcDistanceToTrigger(rocId, fulltm);
   Bool_t iscorrectedpedestal=kTRUE;
   if( ROC[rocId].fPedestals->GetPedestal(rocId, nxId, nxChannel) < 900 )
           iscorrectedpedestal=kFALSE;
   
   if (IsSTS(msg)) {
         // add sts mapping by I.Sorokin:
         Int_t stsid;
         Int_t side;     // "p"   ->  0    "n"    ->  1
         Int_t odd;      // "Odd" ->  1    "Even" ->  0

         // Actual rocId, nxId must be set.
         if ( rocId == 0 && nxId == 0 ) { stsid = 0; side = 0; odd = 0; }
         if ( rocId == 0 && nxId == 2 ) { stsid = 0; side = 0; odd = 1; }
         if ( rocId == 1 && nxId == 0 ) { stsid = 0; side = 1; odd = 0; }
         if ( rocId == 1 && nxId == 2 ) { stsid = 0; side = 1; odd = 1; }
         if ( rocId == 2 && nxId == 0 ) { stsid = 1; side = 0; odd = 0; }
         if ( rocId == 2 && nxId == 2 ) { stsid = 1; side = 0; odd = 1; }
         if ( rocId == 3 && nxId == 0 ) { stsid = 1; side = 1; odd = 0; }
         if ( rocId == 3 && nxId == 2 ) { stsid = 1; side = 1; odd = 1; }

          // here comes detector mapping:
          Int_t StsStrip=STS_GetStrip(side,odd,nxChannel)+1;// strip numbering begins with 1
          if(iscorrectedpedestal)
        {
          if(side)
                  {
                          //fCosyDec10Event->fStsNeg[stsid][StsStrip]=msg->getNxAdcValue();
                          
                          fCosyDec10Event->fStsNeg[stsid][StsStrip]=nxadc_corr;
                          fSTSNeg[stsid]->Fill(StsStrip,nxadc_corr);
                          if (ROC[rocId].fTriggerWind->Test(timedist))
                            {
                              fSTSNegTimegated[stsid]->Fill(StsStrip,nxadc_corr);
                            }
                          
                          
                  }
          else
                  {
                    
                        fCosyDec10Event->fStsPos[stsid][StsStrip]=  nxadc_corr;
                        fSTSPos[stsid]->Fill(StsStrip,nxadc_corr);
                        if (ROC[rocId].fTriggerWind->Test(timedist))
                          {
                             fSTSPosTimegated[stsid]->Fill(StsStrip,nxadc_corr);
                          }               
                                          
                  }
          }// else ifcorrectedpedestal


    
   } else
   if (IsGEM(msg)) {
      Int_t gemx(0), gemy(0), gemid(0);
      if(!GEM_Map(rocId, nxId, nxChannel, gemid, gemx, gemy)) {
         TString msg;
         msg.Form("**** TCosyDec10Proc: GEM illegal mapping for roc %d nx:%d ch:%d  - ignored\n",rocId,nxId,nxChannel);
         GO4MESSAGE((2, msg.Data()));
         return;
      }

      fGEMtm[gemid]->Fill(timedist);

      if(iscorrectedpedestal){
         if(gemid==0){
            fCosyDec10Event->fGemOne[gemx][gemy]=nxadc_corr;
         }
         else if(gemid==1){
            fCosyDec10Event->fGemTwo[gemx][gemy]=nxadc_corr;
         }
         else
         {
            TString msg;
            msg.Form("**** TCosyDec10Proc: GEM invalid station id %d  - ignored\n",gemid);
            GO4MESSAGE((2, msg.Data()));
            return;

         }
      }
      fGEM_Map[gemid]->Fill(gemx,gemy);
      if(iscorrectedpedestal)
         fGEM_Map_Adc[gemid]->Fill(gemx,gemy,nxadc_corr);



      if (ROC[rocId].fTriggerWind->Test(timedist))
      {
         fGEM_Map_Time[gemid]->Fill(gemx,gemy);
         if(iscorrectedpedestal)
            fGEM_Map_Adc_Time[gemid]->Fill(gemx,gemy,nxadc_corr);
      }
   }
}



void TCosyDec10Proc::ExtractTriggerTimes(TGo4MbsEvent* evt)
{
  fTriggers.clear();
  
  if (evt==0) return;
  TGo4MbsSubEvent* psubevt = 0;
  
  uint32_t fCurrEpoch = 0;
  uint64_t fulltm = 0;

  evt->ResetIterator();
  while((psubevt = evt->NextSubEvent()) != 0) { // loop over subevents
      if (psubevt->GetProcid() != roc::proc_RocEvent) continue;

      // all relevant triggers are on the roc number 1
      if (psubevt->GetSubcrate() != fCosyDec10Par->triggerRoc) continue;

      roc::Iterator iter(psubevt->GetControl());

      iter.setRocNumber(psubevt->GetSubcrate());
      
      int datasize = (psubevt->GetDlen() - 2) * 2;

      if (!iter.assign(psubevt->GetDataField(), datasize)) continue;

      roc::Message* data = & iter.msg();

      while (iter.next()) {

        int rocid = data->getRocNumber();
        if (rocid!=fCosyDec10Par->triggerRoc) {
           printf ("ROCID != %d  \n", fCosyDec10Par->triggerRoc);
           continue;
        }
        
        if (data->isEpochMsg()) fCurrEpoch = data->getEpochNumber();
        
        if (data->isAuxMsg() && (data->getAuxChNum() == fCosyDec10Par->triggerAux) && (data->getAuxFalling() == fCosyDec10Par->triggerFalling)) {
           fulltm = data->getMsgFullTime(fCurrEpoch);
           fTriggers.push_back(fulltm);
        }
      }
  }  
}


int32_t TCosyDec10Proc::CalcDistanceToTrigger(int rocid, uint64_t fulltm)
{
   if (fTriggers.size() == 0) return -100000000;
   
   int32_t diff = -100000000;
   
   int32_t goal = 750;
   
   int32_t curr = 0;
  
   for (unsigned n=0; n < fTriggers.size(); n++) {
      uint64_t trigger = fTriggers[n];
      if (trigger < fulltm) {
         curr = fulltm - trigger;
      } else {
        curr = -1 * (trigger - fulltm);
        if (curr < -1000) curr = - 1000000000;
      }
      if (abs(curr-goal) < abs(diff-goal)) diff = curr;

   }
   
   return diff;
}




//-----------------------------------------------------------
// event function
Bool_t TCosyDec10Proc::BuildEvent(TGo4EventElement* outevnt)
{
   fCosyDec10Event= dynamic_cast<TCosyDec10Event*>(outevnt);
   if(fCosyDec10Event==0) {
      GO4_STOP_ANALYSIS_MESSAGE("**** TCosyDec10Proc: Fatal error: output event is not a TCosyDec10Event!!! STOP GO4");
   }


   for (unsigned n=0; n<fNumRocs; n++)
     ROC[n].fLastSyncTm[1] = 0;
  
   ExtractTriggerTimes(dynamic_cast<TGo4MbsEvent*> (GetInputEvent()));
  
   Bool_t res = TRocProc::BuildEvent(outevnt);
   
   if (ROC[1].fLastSyncTm[1] != 0) {
      if (ROC[2].fLastSyncTm[1]) fSyncQuality->Fill(ROC[2].fLastSyncTm[1] - ROC[1].fLastSyncTm[1]);
      if (ROC[4].fLastSyncTm[1]) fSyncQuality->Fill(ROC[4].fLastSyncTm[1] - ROC[1].fLastSyncTm[1]);
      if (ROC[5].fLastSyncTm[1]) fSyncQuality->Fill(ROC[5].fLastSyncTm[1] - ROC[1].fLastSyncTm[1]);
   }
   
   return res;
}

void TCosyDec10Proc::ProcessSubevent(TGo4MbsSubEvent* subevt)
{
   if (subevt->GetProcid() == roc::proc_Triglog) {
           uint32_t *pudata = (uint32_t*) (subevt->GetDataField());
      //Int_t sync_num = subevt->Data(0);
           UInt_t sync_num = *pudata++;
           fCosyDec10Event->fVulomSyncNumber=sync_num;

      // just to see that sync number is changing
      fVulomSyncs->Fill(sync_num % 65536);

      //int ind = 1;

      pudata++; // skip trigger pattern here!

      // now we have time expression
      UInt_t timeseconds=*pudata++;
      UInt_t timemicros=*pudata++;
      fCosyDec10Event->fMbsTimeSecs=timeseconds;
      fCosyDec10Event->fMbsTimeMicros=timemicros;
      char sbuf[1000]; f_ut_utime(timeseconds, timemicros, sbuf);
      fVulomSyncs->SetTitle(Form("Mbs Time:%s", sbuf));
      //cout <<"found timestring: " << sbuf <<endl;

      // calculate time difference to last mbs event time: 
       UInt_t deltatseconds=0;
       UInt_t deltatmicros=0;
       fMbsDeltatime=0;
       if(fLastMbsTimeSecs)
       {
          deltatseconds=fCosyDec10Event->fMbsTimeSecs-fLastMbsTimeSecs;
          deltatmicros=fCosyDec10Event->fMbsTimeMicros - fLastMbsTimeMicros;
          fMbsDeltatime= 1.0*deltatseconds + 1.0e-3 * deltatmicros; //NOTE: micros are milliseconds
          //cout <<"mbs deltatime: " << fMbsDeltatime <<" s." <<endl;
          
       }
      fLastMbsTimeSecs=fCosyDec10Event->fMbsTimeSecs;
      fLastMbsTimeMicros= fCosyDec10Event->fMbsTimeMicros;


            UInt_t val=0;
            //fScintVertical->Reset("");
            //fScintHorizontal->Reset("");
            fScintRolu->Reset("");
            fScintExtra->Reset("");
            
                             
           for (int nscaler = 0; nscaler < NUM_SCALERS; nscaler++) {

                 fVulomScalers[nscaler]->Reset("");
                 fVulomScalersRate[nscaler]->Reset("");
                 
                        for (int n = 0; n < 16; n++) {

                                val= (UInt_t) ((*pudata++) & 0x7FFFFFFF); // mask upper bits?
                                if(val){
                                        fCosyDec10Event->fVulomScaler[nscaler][n]=val;
                                        fVulomScalers[nscaler]->Fill(n,val); // get histo statistics calculated right
                                        //fVulomScalers[nscaler]->SetBinContent(n+1,val); // maybe faster...?
                                        fVulomScalerOverview->Fill(nscaler,n,val);
                                
                                
                                        Double_t rate=0;
                                        if(fMbsDeltatime)
                                         rate=(val-fVulomOldVals[n]) / fMbsDeltatime;
                                         //rate=(val-fVulomOldVals[n]);
                                        
                                        fVulomScalersRate[nscaler]->Fill(n,rate);    
                                            
                                        if(n>=0 && n<4)
                                        {
                                          fScintExtra->Fill(n, (Double_t) 0,rate);
                                        }
                                        else if(n>=4 && n<8)
                                        
                                        {
                                            if(n==4)
                                              fScintRolu->Fill(2,1,rate);
                                            else if (n==5)
                                              fScintRolu->Fill((Double_t)0,1,rate);
                                            else if (n==6)
                                              fScintRolu->Fill(1,2,rate);
                                            else if (n==7)
                                              fScintRolu->Fill(1,(Double_t)0,rate);
                                        }
                                        else 
                                        {
                                          //NOP
                                        }
                        } // if val 
                             fVulomOldVals[n]=val;   
                        }
                }




      return;
   }

   // SL - for cosy beamtime same procid was used as for previous cern beamtime
   if (subevt->GetProcid() == roc::proc_TRD_MADC) {
      // TRD MADC data + silicon strips + cherenkov
           ProcessMADCSub(subevt);
           return;
   }
   
   
   // SL - at this beamtime epics was produced with procid=8
   if (subevt->GetProcid() == 8) {
      ProcessEpicsSub(subevt);
      return;
   }//
}



void  TCosyDec10Proc::ProcessMADCSub(TGo4MbsSubEvent* subevt)
{
        Int_t *pdata = subevt->GetDataField();
        UInt_t lwords = subevt->GetIntLen();
        
//      printf("TOTALLEN = %u\n", lwords);
        
        const int numtags = 7;
        
        const uint64_t tags[numtags] = { 0x3035357676353530ULL,  // v550
                                        0x3238313131313832ULL,  // 1182
                                        0x3338313131313833ULL,  // 1183
                                        0x3637313131313736ULL,  // 1176
                                        0x3164616d6d616431ULL,  // mad1
                                        0x3264616d6d616432ULL,  // mad2
                                        0x3364616d6d616433ULL   // mad3
                                      };
        Int_t* tagpos[numtags];
        Int_t taglen[numtags];
        
        for (int n=0;n<numtags;n++) {
           tagpos[n] = 0;
           taglen[n] = 0;
        }
        
        int lasttag = -1;
        
//      Int_t* p0 = pdata;
        
        for (UInt_t cur = 0; cur < lwords; ++cur) {
           uint64_t* ptag = (uint64_t*) pdata;
           
//         printf("DATA 0x%x\n", *pdata);
           
           bool find = false;
           
           for (int ntag=0;ntag<numtags;ntag++)
              if (*ptag == tags[ntag]) {
                 if (lasttag>=0) {
                    taglen[lasttag] = pdata - tagpos[lasttag];
                    lasttag = -1;
                 }
                 
                 if (tagpos[ntag]==0) {
//                  printf("TAG %d  pos %u\n", ntag, pdata - p0);
                 
                    pdata+=2; cur+=1;
                    tagpos[ntag] = pdata;
                    lasttag = ntag;
                 } else {
                    printf("FORMAT ERROR found tag %lld twice\n", tags[ntag]);
                    pdata+=2; cur+=1;
                 }

                 find = true;
                 break;

              }
            
            if (!find) pdata++;
        }

        if (lasttag>=0) 
           taglen[lasttag] = pdata - tagpos[lasttag];
/*      
        for (int ntag=0;ntag<numtags;ntag++)
           if (tagpos[ntag])
              printf("TAG %d POS %lu LEN %d\n", ntag, tagpos[ntag] - p0, taglen[ntag]);
        
        exit(1);
*/

        // actually process data in subroutines:
        

        

//      if (tagpos[0] && taglen[0]) ProcessSi(tagpos[0], taglen[0]); // v550
        if (tagpos[1] && taglen[1]) Process1182(tagpos[1], taglen[1]); // 1182
   if (tagpos[2] && taglen[2]) Process1183(tagpos[2], taglen[2]); // 1183
//      if (tagpos[3] && taglen[3]) ProcessTDC(tagpos[3], taglen[3]);  // 1176
//      if (tagpos[4] && taglen[4]) ProcessMADC(0, tagpos[4], taglen[4]);  // mad1
//      if (tagpos[5] && taglen[5]) ProcessMADC(1, tagpos[5], taglen[5]);  // mad2
//      if (tagpos[6] && taglen[6]) ProcessMADC(2, tagpos[6], taglen[6]);  // mad3
}


void TCosyDec10Proc::Process1182(int* pdata, int len) 
{

   if (len < 2 + 8) {
      cout <<"TCosyDec10Proc:Process1182 data length"<< len << "not sufficient!" <<endl;
      return;
   }
   
   // skip event header:
   int header = *pdata++;
   if (L1182_DEBUG)  printf("1182 header:0x%0x \n",header);

   // skip status
   int status = *pdata++;
   if (L1182_DEBUG)
      printf("1182 status:0x%0x :  \n"
            "        conversion complete    (bit0): 0x%x\n"
            "        conversion in progress (bit1): 0x%x\n"
            "        front(1)/rear(0) panel (bit2): 0x%x\n"
            "        Event buffer not full  (bit3): 0x%x\n"
            "        Event count       (bits 4..7): 0x%x\n"
            "        should be 0            (bit8): 0x%x\n"
            "        should be 0            (bit9): 0x%x\n",
            status, status & 1, (status >> 1) & 1 , (status >> 2) & 1, (status >> 3) & 1,
            (status >> 4) & 0xf,  (status >> 8) & 1, (status >> 9) & 1);
  
            
        //fScintVerticalQDC->Reset("");
        // fScintHorizontalQDC->Reset("");
      for(int ch=0;ch<NUM_1182;++ch) {
      int val = *pdata++;
      fCosyDec10Event->fData1182[ch]=val;
      f1182h[ch]->Fill(val);
      Double_t content=0;
      if(f1182Gate[ch]->Test(val))
      {
        Double_t rate=1;
//      if(fMbsDeltatime)
//      {
//        rate=1/fMbsDeltatime;
//      }
        
        if(ch>=0 && ch<4) 
           fScintVerticalQDC->Fill(0., ch + 0., rate);
        if(ch>=4 && ch<8) 
            fScintHorizontalQDC->Fill(ch-4., 0.,rate);

        
      }
      
      f1182OldVals[ch]=content;
      
      
   }

// AND mapping of scints:
  Bool_t x[4]={kFALSE,kFALSE,kFALSE,kFALSE};
   Bool_t y[4]={kFALSE,kFALSE,kFALSE,kFALSE};
  if(f1182Gate[0]->Test(fCosyDec10Event->fData1182[0]))
         y[0]=kTRUE;
  if(f1182Gate[1]->Test(fCosyDec10Event->fData1182[1]))
         y[1]=kTRUE;
   if(f1182Gate[2]->Test(fCosyDec10Event->fData1182[2]))
         y[2]=kTRUE;
  if(f1182Gate[3]->Test(fCosyDec10Event->fData1182[3]))
         y[3]=kTRUE;
  if(f1182Gate[4]->Test(fCosyDec10Event->fData1182[4]))
         x[0]=kTRUE;
  if(f1182Gate[5]->Test(fCosyDec10Event->fData1182[5]))
         x[1]=kTRUE;
   if(f1182Gate[6]->Test(fCosyDec10Event->fData1182[6]))
         x[2]=kTRUE;
  if(f1182Gate[7]->Test(fCosyDec10Event->fData1182[7]))
         x[3]=kTRUE;
  
                      
for(int i=0;i<4;++i)
{
  for(int j=0;j<4;++j)
  {
        if(x[i] && y[j])
              fScintAndQDC->Fill(i,j);  
  }
}
}


void TCosyDec10Proc::Process1183(int* pdata, int len) 
{

   if (len < 2 + 8) {
      cout <<"TCosyDec10Proc::Process1183 data length"<< len << "not sufficient!" <<endl;
      return;
   }

   // skip event header:
   int header = *pdata++;
   if (L1182_DEBUG) printf("1183 header:0x%0x \n",header);

   // skip status:
   int status = *pdata++;
   if (L1182_DEBUG)
      printf("1183 status:0x%0x :  \n"
            "        conversion complete    (bit0): 0x%x\n"
            "        conversion in progress (bit1): 0x%x\n"
            "        front(1)/rear(0) panel (bit2): 0x%x\n"
            "        Event buffer not full  (bit3): 0x%x\n"
            "        Event count       (bits 4..7): 0x%x\n"
            "        should be 0            (bit8): 0x%x\n"
            "        should be 0            (bit9): 0x%x\n",
            status, status & 1, (status >> 1) &1 , (status >> 2) &1, (status >> 3) &1,
            (status >> 4) & 0xf,  (status >> 8) &1, (status >> 9) &1);

   for(int ch=0;ch<8;++ch) {
      int val = *pdata++;
      fCosyDec10Event->fData1183[ch]=val;
      f1183h[ch]->Fill(val);
   }
}



void TCosyDec10Proc::ProcessEpicsSub(TGo4MbsSubEvent* psubevt)
{

   int* pdata= psubevt->GetDataField();
   //first payload: event id number
   pdata++;
   //cout <<"Found event id -"<<evid<< endl;
   // secondly get dabc record time expressiong
   UInt_t timeseconds=*pdata++;
   UInt_t timemicros=0;
   char sbuf[1000]; f_ut_utime(timeseconds, timemicros, sbuf);
   fMotorPos->SetTitle(Form("Motor position, EPICS Time:%s -", sbuf));
   fRoluPos->SetTitle(Form("ROLU positions, EPICS Time:%s -", sbuf));
   //cout <<"Found EPICS timestring: " << sbuf <<endl;


   // first payload: header with number of long records
   int numlong=*pdata++;
   for(int i=0; i<numlong;++i)
   {
      long val=*pdata++;
      if(_VARPRINT_)
      {
         cout <<"Long "<<i<<"="<< val<< endl;
      }
      //                    if(i>=_NUM_LONG_RECS_) continue;
      //                    fLongRecords[i]->Fill(val);
   }
   int numdub=*pdata++;
   int motorx=0;
   int motory=0;
   int rolu_left=0;
   int rolu_right=0;
   int rolu_up=0;
   int rolu_down=0;
   for(int i=0; i<numdub;++i)
   {
      int valint= *pdata++;
      double val=  (double) (valint) / 1000.;
      if(_VARPRINT_)
      {
         printf("Double %d: valint:%d, float:%f\n",i,valint, val);
         //cout <<"Double "<<i<<"="<< val<< endl;
      }
      //                    if(i>=_NUM_DOUBLE_RECS_) continue;
      //                    fDoubleRecords[i]->Fill(val);

      switch(i){

         case CBM_LAUDA0_Read_Bath :
            //cout <<"Read lauda temp:" << val<< endl;
            break;
         case CBM_MOTOR_GETPOSX:
            motorx=val;
            break;
         case CBM_MOTOR_GETPOSY:
            motory=val;
            break;
         case CBM_rolu_step_to_mm_L:
            rolu_left=val;
            break;
         case CBM_rolu_step_to_mm_R:
            rolu_right=val;
            break;
         case CBM_rolu_step_to_mm_O:
            rolu_up=val;
            break;
         case CBM_rolu_step_to_mm_U:
            rolu_down=val;
            break;
         default:
            break;


      };

   }
   fMotorPos->Fill(motorx,motory);

   Int_t roludim=35;
   Int_t middle=roludim/2;
   Int_t displaywidth=6;
   for(int i=0; i<2*displaywidth;++i)
   {
      fRoluPos->Fill(middle-rolu_left,middle-displaywidth+i);
      fRoluPos->Fill(middle+rolu_right,middle-displaywidth+i);
      fRoluPos->Fill(middle-displaywidth+i,middle-rolu_down);
      fRoluPos->Fill(middle-displaywidth+i,rolu_up + middle);

   }
}




Int_t TCosyDec10Proc::STS_GetStrip(Int_t side, Int_t odd, Int_t nxCh)
{
   if( nxCh < 0 || nxCh > 255 ) return 1001;

   // p-E
   if( side == 0 && odd == 0 ) {
      if( nxCh < 64 ) return 2 * ( nxCh + 2 - 2 * ( nxCh % 2 ) );
      return 2 * ( nxCh + 1 );
   }

   // p-O
   if( side == 0 && odd == 1 ) {
      if( nxCh < 64 ) return 256 - 2 * ( nxCh + 2 - 2 * ( nxCh % 2 ) ) + 1;
      return 256 - 2 * nxCh - 1;
   }

   // n-E
   if( side == 1 && odd == 0 ) {
      if( nxCh < 64 ) return 256 - 2 * ( nxCh + 1 - 2 * ( nxCh % 2 ) );
      return 256 - 2 * nxCh;
   }

   // n-O
   if( side == 1 && odd == 1 ) {
      if( nxCh < 64 ) return 2 * ( nxCh + 1 - 2 * ( nxCh % 2 ) ) + 1;
      return 2 * nxCh + 1;
   }

   return 1002;
}


Bool_t TCosyDec10Proc::GEM_Map(Int_t rocid, Int_t nxid, Int_t nxCh, Int_t &gemno, Int_t &xpos, Int_t &ypos)
{
   if( nxCh < 0 || nxCh > 127 ) return kFALSE;
   
   //return kTRUE;
   int rocix=0;
   bool found=false;
   for(rocix=0;rocix<4;++rocix)
   {
           if(rocid==fGEMRocIds[rocix])
           {
                   found=kTRUE; break;
           }
   }
   if(!found) return kFALSE;
   //cout <<"GEM Map found rocix "<<rocix<<" for rocid "<<rocid << endl;
   
   if(rocix<2) 
     gemno=0;
   else
     gemno=1;
   
   int nxix=0;
   if(nxid==0) nxix=0;
   if(nxid==2) nxix=1;
   if(rocix>1) rocix-=2;
   xpos=fGEM_X[rocix][nxix][nxCh]; 
   ypos=fGEM_Y[rocix][nxix][nxCh];
   
   //cout <<"           xpos:"<<xpos<<", ypos:"<<ypos<<" rocid"<<rocid<<",nxid:"<<nxid<<" , ch:"<<nxCh << endl;
   if(gemno==1)
     xpos=22-xpos; // second GEM is flipped around in x
   
   return kTRUE;
   
   
  
  
}

 void TCosyDec10Proc::Init_GEM_Map()
 {

//   int xdimension=22;
   int ydimension=22;
   
   int nx=0;
   
// left part:
int roc=0;
   for(int ch=0; ch<2*NUM_GEM_CH; ch++)
          {
             if(ch>127) 
              nx=1;
            else
              nx=0;
            
            int row=0;
            // find out current row number:
            int channelsum=0;
            for(row=0; row<NUM_GEM_Y; ++row)
              {     
                if(ch< fGEM_Y_BoundariesLeft[row]) break;
                channelsum+=fGEM_Y_PeriodLeft[row];
              }
              
              int y=row; 
              int x= ch - channelsum + fGEM_Y_ShiftLeft[row];
              
                fGEM_Y[roc][nx][ch-nx*128]=ydimension-y; // flip origin of left side down
                fGEM_X[roc][nx][ch-nx*128]=x; 
            
          }// for
// right part:
roc=1;

int xstart=11; // vertical middle line of detector is reference for right side x shift

   for(int ch=0; ch<2*NUM_GEM_CH; ch++)
          {
             if(ch>127) 
              nx=1;
            else
              nx=0;
            
          int row=0;
         // find out current row number:
         int channelsum=0;
         for(row=0; row<NUM_GEM_Y; ++row)
          {         
            if(ch< fGEM_Y_BoundariesRight[row]) break;
            channelsum+=fGEM_Y_PeriodRight[row];
          }
            int y=row; 
            int x= ch - channelsum + fGEM_Y_ShiftRight[row];
           
            fGEM_Y[roc][nx][ch-nx*128]=y; 
            fGEM_X[roc][nx][ch-nx*128]=xstart + x; 
            
          } // for

 printf("GEM Mapping initialized. \n");

 #ifdef _GEM_MAP_DEBUG_ 
// fill histograms for debugging:
for(int roc=0; roc<2;++roc)
{
    for(int nx=0;nx<2;++nx)
    {
      for(int c=0; c<128;++c)
      {
          int mx=fGEM_X[roc][nx][c];
          int my=fGEM_Y[roc][nx][c];
          printf("roc %d nx %d c:%d - \tx=%d \ty=%d \n",roc,nx,c,mx,my);
          fGEM_Map[0]->Fill(mx,my);
    
      }
      }
  
}

#endif
          
  
 }