beamtime/gsi-aug12/hd/go4/MONITOR/TBeamMonitorProc.cxx (r4864/r3218)

Go to the documentation of this file.

#include "TBeamMonitorProc.h"
#include "TGo4Version.h"
#if __GO4BUILDVERSION__ > 40502
   #include "go4iostream.h"
#else
   #include "Riostream.h"
#endif
#include "TTimeStamp.h"
#include "TSystem.h"
#include "TROOT.h"
#include "TGo4Log.h"

#include "TGo4UserException.h"
#include "TGo4MbsEvent.h"
#include "roc/Message.h"
#include "roc/Board.h"
#include "TProfile.h"


TBeamMonitorProc::TBeamMonitorProc(const char* name) :
   TCBMBeamtimeProc(name),
   fCrateInputEvent(0),
   fTriglogInputEvent(0),
#if defined(ROOTCONV_WITHGET4) || defined(ROOTCONV_WITHHODO)
   fRocInputEvent(0),
#endif
   fEpicsInputEvent(0),
   fVftxInputEvent(0),
   fOutputEvent(0)
{
   TGo4Log::Info("TBeamMonitorProc: Create instance %s", name);
   TString obname, obtitle;

   fPar = (TBeamMonitorParam*) MakeParameter("BeamMonitorPar", "TBeamMonitorParam");
   fPar->ConvertChToTdcAndCh( T1290Data::NumChan, FPGA_TDC_NBCHAN );
/*
   TString setupmacro = "set_BeamMonitorPar.C";
   if (!gSystem->AccessPathName(setupmacro.Data())) {
      TGo4Log::Info("Executing beam monitor condition setup script %s", setupmacro.Data());
      gROOT->ProcessLine(Form(".x %s", setupmacro.Data()));

   } else {
      TGo4Log::Info("NO beam monitor  setup script %s. Use previous values!", setupmacro.Data());
   }
*/
   // fCh_Pb = MakeTH2('I', "BeamMonitor/Ch1_Pb", "Cherenkov - Pb", 512, 0., 4096., 512, 0., 4096., "Cherenkov1", "Pb");

   fPmtDiff = MakeTH1('I', "BeamMonitor/PmtDiff", "Time difference between TDC[5][2] and TDC[5][3]", 4096, -2048, +2048, "bin []");

   // following is for slow control display:
   //   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)");
   
   // RPC monitor

      // Offset to use when comparing times from CAEN and from VFTX TDCs
   dCaenVftxOffset = 0;

      // Rate plots
   if( -1 < fPar->iRateIntegrationDuration && -1 < fPar->iRateIntegrationStep )
   {
      uFirstMbsTimeIntegration = 0;
      uLastMbsTimeStep = 0;
      // Vector to hold the counts per strip since last step
      //vStepStripCounts.resize(fPar->iNbStripRpcs);
   } // If rate parameters defined

      // Strip RPCs
   Int_t iDualMultHistoIndex = 0;
   for( Int_t iStripRpcIndex = 0; iStripRpcIndex < fPar->iNbStripRpcs; iStripRpcIndex++)
   {
      fBeamProfileStripRpc[iStripRpcIndex] =  
            MakeTH2('D', Form("BeamMonitor/BeamProfile/Srpc%d", iStripRpcIndex),
            Form("Attempt to get beam profile for %s, Strip map in option file", fPar->sStripRpcName[iStripRpcIndex].Data()) ,
            2*fPar->iBeamProfileSize[iStripRpcIndex], -(fPar->iBeamProfileSize[iStripRpcIndex]/2.0) -0.5, (fPar->iBeamProfileSize[iStripRpcIndex]/2.0) -0.5,
            fPar->uNbStrips[iStripRpcIndex], 
            -((Double_t)fPar->uNbStrips[iStripRpcIndex]*fPar->dStripWidth[iStripRpcIndex]/2.0), 
             ((Double_t)fPar->uNbStrips[iStripRpcIndex]*fPar->dStripWidth[iStripRpcIndex]/2.0),
            "Left right dt [cm]", "Strip index [cm]" ); 
            
      // Maybe put the size of thez Tot histo in time as an option in parameter file
      fTotLeftStripRpc[iStripRpcIndex] = 
            MakeTH2('D', Form("BeamMonitor/TotProfile/TotLeftSrpc%d", iStripRpcIndex),
            Form("Attempt to get Left Tot profile for %s, Strip map in option file", fPar->sStripRpcName[iStripRpcIndex].Data()) ,
            2000, -50, 50,
            fPar->uNbStrips[iStripRpcIndex],
            -((Double_t)fPar->uNbStrips[iStripRpcIndex]/2.0),
             ((Double_t)fPar->uNbStrips[iStripRpcIndex]/2.0),
            "Left Tot [ns]", "Strip index []" ) ; ;

      // Maybe put the size of thez Tot histo in time as an option in parameter file
      fTotRightStripRpc[iStripRpcIndex] =
            MakeTH2('D', Form("BeamMonitor/TotProfile/TotRightSrpc%d", iStripRpcIndex),
            Form("Attempt to get Right Tot profile for %s, Strip map in option file", fPar->sStripRpcName[iStripRpcIndex].Data()) ,
            2000, -50, 50,
            fPar->uNbStrips[iStripRpcIndex], 
            -((Double_t)fPar->uNbStrips[iStripRpcIndex]/2.0), 
             ((Double_t)fPar->uNbStrips[iStripRpcIndex]/2.0),
            "Right Tot [ns]", "Strip index []" ) ;

      // Multiplicity plots
      fMultiplicityStripRpc[iStripRpcIndex] =
            MakeTH1('I', Form("BeamMonitor/Multiplicity/MultipSrpc%d", iStripRpcIndex),
            Form("Attempt to get Multiplicity for %s, Strip map in option file", fPar->sStripRpcName[iStripRpcIndex].Data()) ,
            fPar->uNbStrips[iStripRpcIndex], -0.5, fPar->uNbStrips[iStripRpcIndex] - 0.5,
            "Multiplicity (Number of strip fired simultaneously/event) [strips]" ) ;

      // Rate plots
      if( -1 < fPar->iRateIntegrationDuration && -1 < fPar->iRateIntegrationStep )
      {
         fStripRateStripRpc[iStripRpcIndex] =
               MakeTH2('D', Form("BeamMonitor/Rate/StripRateSrpc%d", iStripRpcIndex),
               Form("Attempt to get rate profile for %s, Strip map in option file", fPar->sStripRpcName[iStripRpcIndex].Data()) ,
               2000, 0, 20000,
               fPar->uNbStrips[iStripRpcIndex],
               -0.5,
               fPar->uNbStrips[iStripRpcIndex]-0.5,
               "Rate [Hz]", "Strip index []" ) ;
         fCounterRateStripRpc[iStripRpcIndex] =
               MakeTH1('D', Form("BeamMonitor/Rate/CounterRateSrpc%d", iStripRpcIndex),
               Form("Attempt to get total rate vs time for %s, Strip map in option file", fPar->sStripRpcName[iStripRpcIndex].Data()) ,
               3600, 0, 7200,
               "Time [s]", "Rate [Hz]" ) ;
         // Vector to hold the counts per strip since last reset
         //(vStepStripCounts[iStripRpcIndex]).resize(fPar->uNbStrips[iStripRpcIndex]);
      } // If rate parameters defined
      if( iStripRpcIndex < fPar->iNbStripRpcs -1)
         for( Int_t iStripRpcIndex2 = iStripRpcIndex+1; iStripRpcIndex2 < fPar->iNbStripRpcs; iStripRpcIndex2++)
         {
            fDualMultiplicityStripRpc[iDualMultHistoIndex] =
               MakeTH2('I', Form("BeamMonitor/Multip2D/MultipSrpc%d_%d", iStripRpcIndex, iStripRpcIndex2),
               Form("Multiplicity for %s vs %s, Strip map in option file", fPar->sStripRpcName[iStripRpcIndex].Data(),
                                                                           fPar->sStripRpcName[iStripRpcIndex2].Data()) ,
               fPar->uNbStrips[iStripRpcIndex], -0.5, fPar->uNbStrips[iStripRpcIndex] - 0.5,
               fPar->uNbStrips[iStripRpcIndex2], -0.5, fPar->uNbStrips[iStripRpcIndex2] - 0.5,
               "Strip Multiplicity Rpc #1 [strips]",
               "Strip Multiplicity Rpc #2 [strips]"  ) ;
            iDualMultHistoIndex++;
         }
   } // for( Int_t iStripRpcIndex = 0; iStripRpcIndex < fPar->iNbStripRpcs; iStripRpcIndex++)

      // Pad RPCs
   for( Int_t iPadRpcIndex = 0; iPadRpcIndex < fPar->iNbPadRpcs; iPadRpcIndex++)
   {
      fBeamProfilePadRpc[iPadRpcIndex] = 
            MakeTH2('D', Form("BeamMonitor/BeamProfile/Prpc%d", iPadRpcIndex),
            Form("Attempt to get beam profile for %s, Pad map in option file", fPar->sPadRpcName[iPadRpcIndex].Data()),
            fPar->uNbPadsX[iPadRpcIndex], 
            -((Double_t)fPar->uNbPadsX[iPadRpcIndex]*fPar->dPadSizeX[iPadRpcIndex]/2.0), 
             ((Double_t)fPar->uNbPadsX[iPadRpcIndex]*fPar->dPadSizeX[iPadRpcIndex]/2.0),
            fPar->uNbPadsY[iPadRpcIndex], 
            -((Double_t)fPar->uNbPadsY[iPadRpcIndex]*fPar->dPadSizeY[iPadRpcIndex]/2.0), 
             ((Double_t)fPar->uNbPadsY[iPadRpcIndex]*fPar->dPadSizeY[iPadRpcIndex]/2.0),
            "X [cm]", "Y [cm]" ) ;
   } // for( Int_t iPadRpcIndex = 0; iPadRpcIndex < fPar->iNbPadRpcs; iPadRpcIndex++)

   // TDCs offset test
   fTdcOffsetTestSameCV = MakeTH1('D', "BeamMonitor/SyncTest/offsetTestSameCV",
         "Test of the offset between CAEN and VFTX, ref in same tdcs" ,
         10000, -10000, 10000,
         "dT [ps]" ) ;
   fTdcOffsetTestDiffCV = MakeTH1('D', "BeamMonitor/SyncTest/offsetTestDiffCV",
         "Test of the offset between CAEN and VFTX, ref in diff tdcs" ,
         10000, -10000, 10000,
         "dT [ps]" ) ;
   fTdcOffsetTestDiffC = MakeTH1('D', "BeamMonitor/SyncTest/offsetTestDiffC",
         "Test of the offset between CAEN and VFTX, ref in diff caen" ,
         10000, -10000, 10000,
         "dT [ps]" ) ;
   fTdcOffsetTestDiffV = MakeTH1('D', "BeamMonitor/SyncTest/offsetTestDiffV",
         "Test of the offset between CAEN and VFTX, ref in diff vftx" ,
         10000, -10000, 10000,
         "dT [ps]" ) ;

   // To be put as preprocessor/enum somewhere (T1290Data.h?)
   Double_t dCaenBinSize = 25.0/1024.0;

   fTdcResolutionTestSameC = MakeTH1('D', "BeamMonitor/SyncTest/resTestSameC",
         "Test of the resolution between CAEN and CAEN, same board" ,
         800, -400*dCaenBinSize*1000, 400*dCaenBinSize*1000,
         "dT [ps]" ) ;
   fTdcResolutionTestDiffC = MakeTH1('D', "BeamMonitor/SyncTest/resTestDiffC",
         "Test of the resolution between CAEN and CAEN, diff board" ,
         800, -400*dCaenBinSize*1000, 400*dCaenBinSize*1000,
         "dT [ps]" ) ;
   fTdcResolutionTestSameV = MakeTH1('D', "BeamMonitor/SyncTest/resTestSameV",
         "Test of the resolution between VFTX and VFTX, same board" ,
         10000, -10000, 10000,
         "dT [ps]" ) ;
   fTdcResolutionTestDiffV = MakeTH1('D', "BeamMonitor/SyncTest/resTestDiffV",
         "Test of the resolution between VFTX and VFTX, diff board" ,
         10000, -10000, 10000,
         "dT [ps]" ) ;

   // ScalOrMu histograms
  // if( 1 == fPar->uQFWHistosEnabled )
   {
      uInitialMbsTime = 0;
      uInitialMilliTime = 0;
      for( Int_t iScalerInd = 0; iScalerInd < SCALORMU_NB_SCAL; iScalerInd++)
      {
         uLastScalerScalOrMu[iScalerInd] = 0;
         uLastMbsMilliTime[iScalerInd] = 0;
         uLastMbsTime[iScalerInd] = 0;
         fScalOrMu[iScalerInd] = MakeTH1('D', Form("ScalOrMu/SOM_Scal%d",iScalerInd),
                                  Form("Evolution of rate on scaler %d in ScalOrMu", iScalerInd),
                                  6000, 0, 1200., "Time [s]", "Rate [Hz]");
      }
      iScaler2BinNb  = 12000;
      dScaler2BinMax = 1200.;
      uInitialScaler1_16 = 0;
      for( Int_t iScalerInd = 0; iScalerInd < N_SCALERS_CH; iScalerInd++)
      {
         uLastScaler2[iScalerInd] = 0;
         uLastScaler1_16[iScalerInd] = 0;
         //uLastMbsMilliTimeScal2[iScalerInd] = 0;
         //uLastMbsTimeScal2[iScalerInd] = 0;
         fScaler2[iScalerInd] = MakeTH1('D', Form("Triglog/trlo_ScalTrigg%d",iScalerInd),
                                  Form("Evolution of rate on scaler2 for trigg %d in Triglog", iScalerInd),
                                  iScaler2BinNb, 0, dScaler2BinMax, "Time [s]", "Rate [Hz]");
      }
      cout<<dScaler2BinMax/(Double_t)iScaler2BinNb<<endl;
   }

   TGo4Log::Info("TBeamMonitorProc Histograms created");
}


TBeamMonitorProc::~TBeamMonitorProc()
{   
   /*
   TGo4Log::Info("Proc  %p", this);
   TGo4Log::Info("Mbs e %p", &fCrateInputEvent);
   TGo4Log::Info("Trl e %p", &fTriglogInputEvent);
   TGo4Log::Info("Epi e %p", &fEpicsInputEvent);
   TGo4Log::Info("Vft e %p", &fVftxInputEvent);
   TGo4Log::Info("Out e %p", &fOutputEvent);
   TGo4Log::Info("Offse %p", &dCaenVftxOffset);
   TGo4Log::Info("Param %p", fPar);
   */
   // Getting mean values for each strip in the Beam profile (offset)
   for( Int_t iStripRpcIndex = 0; iStripRpcIndex < fPar->iNbStripRpcs; iStripRpcIndex++)
   {
//      TGo4Log::Info("Step %p", vStepStripCounts[iStripRpcIndex]);

      if( fBeamProfileStripRpc[iStripRpcIndex]->GetEntries() )
      {
         Double_t offset = 0;
         TString sFormattedOut = "stripsoffs  ";
         TGo4Log::Info("*********** Offset Map %-20s ************", fPar->sStripRpcName[iStripRpcIndex].Data());
         for( UInt_t uBin = 0; uBin < fPar->uNbStrips[iStripRpcIndex]; uBin++)
         {
            offset = ( (TProfile*)fBeamProfileStripRpc[iStripRpcIndex]->ProfileX(
                  Form("%s_pfx%d",fPar->sStripRpcName[iStripRpcIndex].Data(), uBin), uBin+1, uBin+1) )->GetMean();
            TGo4Log::Info("Offset of strip %2u is %3.2f cm, while option is %3.2f", uBin, offset, fPar->dOffsetList[iStripRpcIndex][uBin]);
            sFormattedOut += Form(" %6.2f", offset + fPar->dOffsetList[iStripRpcIndex][uBin] );
         } // for( UInt_t uBin = 0; uBin < fPar->uNbStrips[iStripRpcIndex]; uBin++)
         TGo4Log::Info("%s", sFormattedOut.Data());
         TGo4Log::Info("********************************************************");
      } // if( fBeamProfileStripRpc[iStripRpcIndex]->GetEntries() )
   } // for( Int_t iStripRpcIndex = 0; iStripRpcIndex < fPar->iNbStripRpcs; iStripRpcIndex++)

   /*
   TGo4Log::Info("S %p %p %p %p %p %p",
                  fBeamProfileStripRpc,
                  fTotLeftStripRpc,
                  fTotRightStripRpc,
                  fMultiplicityStripRpc,
                  fStripRateStripRpc,
                  fCounterRateStripRpc
                  );
   TGo4Log::Info("P %p",fBeamProfilePadRpc );

   TGo4Log::Info("Scal %p",fScalOrMu );
   */

   /*
   if( -1 < fPar->iRateIntegrationDuration && -1 < fPar->iRateIntegrationStep )
   {
      //for( Int_t iStripRpcIndex = 0; iStripRpcIndex < fPar->iNbStripRpcs; iStripRpcIndex++)
      //   vStepStripCounts[iStripRpcIndex].clear();
      //vStepStripCounts.clear();
      vStepStripCounts.resize(0);
   }
   */
   
   cout << "**** TBeamMonitorProc: Delete instance " << endl;
}


void TBeamMonitorProc::InitEvent(TGo4EventElement* outevnt)
{
   // first assign input event:
   // since input event object is never discarded within processor lifetime,
   // we just search for subevent by name once to speed up processing
   if(fCrateInputEvent==0)
   {
      TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetInputEvent("Detector"));
      if(btevent)
      {
         fCrateInputEvent=dynamic_cast<TMbsCrateEvent*>(btevent->GetSubEvent("MBSCRATE"));
#if defined(ROOTCONV_WITHGET4) || defined(ROOTCONV_WITHHODO)
         fRocInputEvent=dynamic_cast<TRocEvent*>(btevent->GetSubEvent("ROC"));
#endif
//         fEpicsInputEvent=dynamic_cast<TEpicsEvent*>(btevent->GetSubEvent("EPICS"));
      }
      else
      {
         fCrateInputEvent=dynamic_cast<TMbsCrateEvent*>(GetInputEvent());
      }
      if(fCrateInputEvent==0) {
         GO4_STOP_ANALYSIS_MESSAGE("**** TBeamMonitorProc: Fatal error: no input event TMbsCrateEvent!!! STOP GO4");
      }
#if defined(ROOTCONV_WITHGET4) || defined(ROOTCONV_WITHHODO)
      if(fRocInputEvent==0) {
         GO4_STOP_ANALYSIS_MESSAGE("**** TBeamMonitorProc: Fatal error: no input event TRocEvent!!! STOP GO4");
      }
#endif
//      if(fEpicsInputEvent==0) {
//         Message(2,"**** TBeamMonitorProc: could not find TEpicsEvent!"); // but do not stop...
//      }

   } // if(fCrateInputEvent==0)
   if(fTriglogInputEvent==0)
   {
      TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetInputEvent("Detector"));
      if(btevent)
      {
         fTriglogInputEvent=dynamic_cast<TTriglogEvent*>(btevent->GetSubEvent("TRIGLOG"));
      }

      if(fTriglogInputEvent==0) {
         GO4_STOP_ANALYSIS_MESSAGE("**** TRootConverterProc: Fatal error: input event is/has not a TTriglogEvent!!! STOP GO4");
      }
   } // if(fTriglogInputEvent==0)
   if(fVftxInputEvent==0)
   {
      TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetInputEvent());
      if(btevent)
      {
         fVftxInputEvent=dynamic_cast<TVftxEvent*>(btevent->GetSubEvent("VFTX"));
      }

      if(fVftxInputEvent==0) {
         GO4_STOP_ANALYSIS_MESSAGE("**** TBeamMonitorProc: Fatal error: input event has no TVftxEvent!!! STOP GO4");
      }
   } // if(fVftxInputEvent==0)
   // then assign output event
   // since output event object is never discarded within processor lifetime,
   // we just search for subevent by name once to speed up processing
   if(fOutputEvent==0)
   {
      TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(outevnt);
      if(btevent)
      {
         fOutputEvent=dynamic_cast<TBeamMonitorEvent*>(btevent->GetSubEvent("BEAM"));
      }
      else
      {
         fOutputEvent= dynamic_cast<TBeamMonitorEvent*>(outevnt);
      }
      if(fOutputEvent==0) {
         GO4_STOP_ANALYSIS_MESSAGE("**** TBeamMonitorProc: Fatal error: output event is not a TBeamMonitorEvent!!! STOP GO4");
      }
   } // if(fOutputEvent==0)
}



void TBeamMonitorProc::FinalizeEvent()
{
   // Approximate Factor to convert ns in cm in time difference => To be in option file
//   Double_t dTimeToDistanceFactor = 10.0;
   // To be put as preprocessor/enum somewhere (T1290Data.h?)
   Double_t dCaenBinSize = 25.0/1024.0;
   UInt_t uMultiplicityStripRpc[fPar->iNbStripRpcs];

   if( -1 < fPar->iRateIntegrationDuration && -1 < fPar->iRateIntegrationStep &&
         fTriglogInputEvent && fTriglogInputEvent->IsValid() &&
       0 == uFirstMbsTimeIntegration && 0 == uLastMbsTimeStep )
   {
      uFirstMbsTimeIntegration = fTriglogInputEvent->fMbsTimeSecs;
      uFirstMbsTimeStep        = fTriglogInputEvent->fMbsTimeSecs;
      uLastMbsTimeStep         = fTriglogInputEvent->fMbsTimeSecs;
      for( Int_t iStripRpcIndex = 0; iStripRpcIndex < fPar->iNbStripRpcs; iStripRpcIndex++ )
         for( Int_t iStripRpcIndex = 0; iStripRpcIndex < fPar->iNbStripRpcs; iStripRpcIndex++)
            vStepStripCounts[iStripRpcIndex][iStripRpcIndex] = 0;
   } // if rate parameters set && triglog event OK && rate variables uninitialized
   
   if(fCrateInputEvent && fCrateInputEvent->IsValid())
   {
      fPmtDiff->Fill(fCrateInputEvent->fMtdc[0].lead[20] - fCrateInputEvent->fMtdc[0].lead[22]);

      // fCh_Pb->Fill(fCrateInputEvent->fData1182[1][0], fCrateInputEvent->fData1182[1][5]);

      // fOutputEvent->fIsPion = fPionCond->Test(fCrateInputEvent->fData1182[1][0], fCrateInputEvent->fData1182[1][5]);

      for( Int_t iStripRpcIndex = 0; iStripRpcIndex < fPar->iNbStripRpcs; iStripRpcIndex++)
         if( 0 == fPar->uTdcTypeStrip[iStripRpcIndex] )
         {
            // Tdc range check
            //   if( MAX_1290 <= uTdcStripLeftList[iStripRpcIndex][uStripIndex] )
            //   if( MAX_1290 <= uTdcStripRightList[iStripRpcIndex][uStripIndex] )
            uMultiplicityStripRpc[iStripRpcIndex] = 0;
               
            Double_t dRpcCenterOffset = (Double_t)fPar->uNbStrips[iStripRpcIndex] / 2.0;
            for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips[iStripRpcIndex]; uStripIndex++)
            {
               if( -1 < (fCrateInputEvent->fMtdc[
                                 fPar->uTdcStripLeftList[iStripRpcIndex][uStripIndex]  ]).lead_multi[ 
                                    fPar->uChannelStripLeft[iStripRpcIndex][uStripIndex] ][0] &&
                   -1 < (fCrateInputEvent->fMtdc[ 
                                 fPar->uTdcStripRightList[iStripRpcIndex][uStripIndex] ]).lead_multi[ 
                                    fPar->uChannelStripRight[iStripRpcIndex][uStripIndex]][0] )
               {
                  // Beam profile for strip RPC: X = left right Dt - offset, Y = size index * strip size
                  fBeamProfileStripRpc[iStripRpcIndex]->Fill(
                        fPar->dTimeConv[iStripRpcIndex]*( (fCrateInputEvent->fMtdc[ 
                                                   fPar->uTdcStripRightList[iStripRpcIndex][uStripIndex] ]).lead_multi[ 
                                                      fPar->uChannelStripRight[iStripRpcIndex][uStripIndex]][0]
                                               -(fCrateInputEvent->fMtdc[
                                                   fPar->uTdcStripLeftList[iStripRpcIndex][uStripIndex]  ]).lead_multi[ 
                                                      fPar->uChannelStripLeft[iStripRpcIndex][uStripIndex] ][0]
                                              )*dCaenBinSize
                        - fPar->dOffsetList[iStripRpcIndex][uStripIndex],
                        ((Double_t)uStripIndex - dRpcCenterOffset )*fPar->dStripWidth[iStripRpcIndex] );
                        
                  if( -1 < (fCrateInputEvent->fMtdc[
                                    fPar->uTotTdcStripLeftList[iStripRpcIndex][uStripIndex]  ]).trail_multi[
                                       fPar->uTotChannelStripLeft[iStripRpcIndex][uStripIndex] ][0] )
                  {
                     fTotLeftStripRpc[iStripRpcIndex]->Fill(
                        ( (fCrateInputEvent->fMtdc[ 
                              fPar->uTotTdcStripLeftList[iStripRpcIndex][uStripIndex] ]).trail_multi[
                                 fPar->uTotChannelStripLeft[iStripRpcIndex][uStripIndex]][0]
                          -(fCrateInputEvent->fMtdc[
                              fPar->uTdcStripLeftList[iStripRpcIndex][uStripIndex]  ]).lead_multi[ 
                                 fPar->uChannelStripLeft[iStripRpcIndex][uStripIndex] ][0]
                        )*dCaenBinSize,
                        (Double_t)uStripIndex - dRpcCenterOffset  );

                     if( -1 < (fCrateInputEvent->fMtdc[
                                       fPar->uTotTdcStripRightList[iStripRpcIndex][uStripIndex]  ]).trail_multi[
                                          fPar->uTotChannelStripRight[iStripRpcIndex][uStripIndex] ][0] )
                        uMultiplicityStripRpc[iStripRpcIndex] ++;
                  } // if valid Tot on left side 

                  if( -1 < (fCrateInputEvent->fMtdc[
                                    fPar->uTotTdcStripRightList[iStripRpcIndex][uStripIndex]  ]).trail_multi[
                                       fPar->uTotChannelStripRight[iStripRpcIndex][uStripIndex] ][0] )
                  {
                     fTotRightStripRpc[iStripRpcIndex]->Fill(
                        ( (fCrateInputEvent->fMtdc[
                              fPar->uTotTdcStripRightList[iStripRpcIndex][uStripIndex] ]).trail_multi[
                                 fPar->uTotChannelStripRight[iStripRpcIndex][uStripIndex]][0]
                          -(fCrateInputEvent->fMtdc[
                              fPar->uTdcStripRightList[iStripRpcIndex][uStripIndex]  ]).lead_multi[
                                 fPar->uChannelStripRight[iStripRpcIndex][uStripIndex] ][0]
                        )*dCaenBinSize,
                        (Double_t)uStripIndex - dRpcCenterOffset  );
                  } // if valid Tot on left side
               } // if( valid on both ends!)
            } //  for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips[iStripRpcIndex]; uStripIndex++)
            fMultiplicityStripRpc[iStripRpcIndex]->Fill( uMultiplicityStripRpc[iStripRpcIndex] );
         } // if( 0 == fPar->uTdcTypeStrip[iStripRpcIndex] )
      for( Int_t iPadRpcIndex = 0; iPadRpcIndex < fPar->iNbPadRpcs; iPadRpcIndex++)
         if( 0 == fPar->uTdcTypePad[iPadRpcIndex] )
         {
            Double_t dRpcCenterPadOffsetX = (Double_t)fPar->uNbPadsX[iPadRpcIndex]*fPar->dPadSizeX[iPadRpcIndex]/2.0;
            Double_t dRpcCenterPadOffsetY = (Double_t)fPar->uNbPadsY[iPadRpcIndex]*fPar->dPadSizeY[iPadRpcIndex]/2.0;
            
            for(UInt_t uPadIndexY = 0; uPadIndexY < fPar->uNbPadsY[iPadRpcIndex]; uPadIndexY++)
               for(UInt_t uPadIndexX = 0; uPadIndexX < fPar->uNbPadsX[iPadRpcIndex]; uPadIndexX++)
            {
               if( -1 < (fCrateInputEvent->fMtdc[ 
                                    fPar->uPadsTdc[iPadRpcIndex][uPadIndexY][uPadIndexX] ]).lead[ 
                                          fPar->uPadsChan[iPadRpcIndex][uPadIndexY][uPadIndexX] ] )
               {
                  fBeamProfilePadRpc[iPadRpcIndex]->Fill( (Double_t)uPadIndexX*fPar->dPadSizeX[iPadRpcIndex] - dRpcCenterPadOffsetX, 
                                                          (Double_t)uPadIndexY*fPar->dPadSizeY[iPadRpcIndex] - dRpcCenterPadOffsetY);
               } // if valid hit on this pad
            } // for uPadIndexY uPadIndexX
         } // if( 0 == fPar->uTdcTypeStrip[iStripRpcIndex] )


      if( fTriglogInputEvent && fTriglogInputEvent->IsValid() )
      {
         if( 0 == uInitialMilliTime && 0 == uInitialMilliTime )
         {
            uInitialMilliTime = fTriglogInputEvent->fMbsTimeMillisec;
            uInitialMbsTime      = fTriglogInputEvent->fMbsTimeSecs;
            for( Int_t iScalerInd = 0; iScalerInd < SCALORMU_NB_SCAL; iScalerInd++)
            {
               uLastScalerScalOrMu[iScalerInd] = fCrateInputEvent->fScalOrMu.uScaler[iScalerInd];
               uLastMbsMilliTime[iScalerInd]  = fTriglogInputEvent->fMbsTimeMillisec;
               uLastMbsTime[iScalerInd]       = fTriglogInputEvent->fMbsTimeSecs;
            }
         }
         else
         {
            for( Int_t iScalerInd = 0; iScalerInd < SCALORMU_NB_SCAL; iScalerInd++)
            {
               if( 0 != uLastScalerScalOrMu[iScalerInd] && 0 != fCrateInputEvent->fScalOrMu.uScaler[iScalerInd] &&
                     uLastScalerScalOrMu[iScalerInd] < fCrateInputEvent->fScalOrMu.uScaler[iScalerInd] &&
                     uLastMbsTime[iScalerInd]+ uLastMbsMilliTime[iScalerInd]/1000.0 <
                        fTriglogInputEvent->fMbsTimeSecs + fTriglogInputEvent->fMbsTimeMillisec/1000.0 )
                  fScalOrMu[iScalerInd]->Fill( (Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0
                                              - ( (Double_t)uInitialMbsTime - (Double_t)uInitialMilliTime/1000.0),
                        ( (Double_t)fCrateInputEvent->fScalOrMu.uScaler[iScalerInd] - (Double_t)uLastScalerScalOrMu[iScalerInd] ) /
                        ( ((Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0)
                              - ((Double_t)uLastMbsTime[iScalerInd] + (Double_t)uLastMbsMilliTime[iScalerInd]/1000.0 ) + 0.0)
                        );
                  else  fScalOrMu[iScalerInd]->Fill(
                        (Double_t)fTriglogInputEvent->fMbsTimeSecs + (Double_t)fTriglogInputEvent->fMbsTimeMillisec/1000.0
                        - ( (Double_t)uInitialMbsTime - (Double_t)uInitialMilliTime/1000.0), 0.0);
               uLastScalerScalOrMu[iScalerInd] = fCrateInputEvent->fScalOrMu.uScaler[iScalerInd];
               uLastMbsMilliTime[iScalerInd] = fTriglogInputEvent->fMbsTimeMillisec;
               uLastMbsTime[iScalerInd]      = fTriglogInputEvent->fMbsTimeSecs;
            }
         }
         if( 0 == uInitialScaler1_16 || fTriglogInputEvent->fVulomScaler[0][15] < uInitialScaler1_16)
         {
            uInitialScaler1_16 = fTriglogInputEvent->fVulomScaler[0][15];
            for( Int_t iScalerInd = 0; iScalerInd < N_SCALERS_CH; iScalerInd++)
            {
               uLastScaler2[iScalerInd]            = fTriglogInputEvent->fVulomScaler[1][iScalerInd];
               uLastScaler1_16[iScalerInd]         = fTriglogInputEvent->fVulomScaler[0][15];
            }
         }
         else
         {
            Double_t dDt = 0.0;
            Double_t dDtInit = 0.0;
            Double_t dPulserFreq = 781250.0;
            for( Int_t iScalerInd = 0; iScalerInd < N_SCALERS_CH; iScalerInd++)
            {
               dDt     = ((Double_t)fTriglogInputEvent->fVulomScaler[0][15] - (Double_t)uLastScaler1_16[iScalerInd]) / dPulserFreq;
               dDtInit = ((Double_t)fTriglogInputEvent->fVulomScaler[0][15] - (Double_t)uInitialScaler1_16) / dPulserFreq;
               if( 0 != uLastScaler2[iScalerInd] && 0 != fTriglogInputEvent->fVulomScaler[1][iScalerInd] &&
                     uLastScaler2[iScalerInd] < fTriglogInputEvent->fVulomScaler[1][iScalerInd] &&
                     0. <= dDt  )
               {
                  if( (0.9 * dScaler2BinMax)/(Double_t)iScaler2BinNb <= dDt)
                  fScaler2[iScalerInd]->Fill( dDtInit,
                        ( (Double_t)fTriglogInputEvent->fVulomScaler[1][iScalerInd] - (Double_t)uLastScaler2[iScalerInd] ) / dDt);
               }
                  else
                     fScaler2[iScalerInd]->Fill( dDtInit, 0.0);

               uLastScaler2[iScalerInd]           = fTriglogInputEvent->fVulomScaler[1][iScalerInd];
               uLastScaler1_16[iScalerInd]        = fTriglogInputEvent->fVulomScaler[0][15];
            }
         }
      }
   } // if(fCrateInputEvent && fCrateInputEvent->IsValid())

   if( 0 && fEpicsInputEvent && fEpicsInputEvent->IsValid()) // check if new update has been done
   {
      // TODO: put reasonable display of interesting slow control variables here



      // the following is example from cosy december 2010 beamtime
      // note access to EPICS process variables by full name here
      /*     int motorx = fEpicsInputEvent->GetDouble("CBM:MOTOR:GETPOSX");
     int motory = fEpicsInputEvent->GetDouble("CBM:MOTOR:GETPOSY");
     int rolu_left = fEpicsInputEvent->GetDouble("CBM:rolu:step_to_mm_L");
     int rolu_right = fEpicsInputEvent->GetDouble("CBM:rolu:step_to_mm_R");
     int rolu_up = fEpicsInputEvent->GetDouble("CBM:rolu:step_to_mm_O");
     int rolu_down = fEpicsInputEvent->GetDouble("CBM:rolu:step_to_mm_U");

     fMotorPos->SetTitle(
           Form("Motor position, EPICS Time:%s -",
                 fEpicsInputEvent->GetUpdateTimeString()));
     fMotorPos->Fill(motorx, motory);

     fRoluPos->SetTitle(
           Form("ROLU positions, EPICS Time:%s -",
                 fEpicsInputEvent->GetUpdateTimeString()));
     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);
     }
       */

   } // end EPICS block
   
   if(fVftxInputEvent && fVftxInputEvent->IsValid())
   {
      for( Int_t iStripRpcIndex = 0; iStripRpcIndex < fPar->iNbStripRpcs; iStripRpcIndex++)
         if( 1 == fPar->uTdcTypeStrip[iStripRpcIndex] )
         {
            uMultiplicityStripRpc[iStripRpcIndex] = 0;
            // Tdc range check
            // if( MAX_FPGA_TDC <= uTdcStripLeftList[iStripRpcIndex][uStripIndex] )
            // if( MAX_FPGA_TDC <= uTdcStripRightList[iStripRpcIndex][uStripIndex] )
            
            Double_t dRpcCenterOffset = (Double_t)fPar->uNbStrips[iStripRpcIndex] / 2.0;
            for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips[iStripRpcIndex]; uStripIndex++)
            {
               if( -1 < (fVftxInputEvent->fVftxBoards[
                                          fPar->uTdcStripLeftList[iStripRpcIndex][uStripIndex] ] ).dTimeCorr[
                                             fPar->uChannelStripLeft[iStripRpcIndex][uStripIndex] ][0] &&
                   -1 < (fVftxInputEvent->fVftxBoards[
                                          fPar->uTdcStripRightList[iStripRpcIndex][uStripIndex] ] ).dTimeCorr[
                                             fPar->uChannelStripRight[iStripRpcIndex][uStripIndex] ][0] )
               {
                  // Beam profile for strip RPC: X = left right Dt - offset, Y = size index * strip size
                  fBeamProfileStripRpc[iStripRpcIndex]->Fill(
                        fPar->dTimeConv[iStripRpcIndex]*( (fVftxInputEvent->fVftxBoards[
                                                   fPar->uTdcStripRightList[iStripRpcIndex][uStripIndex] ] ).dTimeCorr[
                                                      fPar->uChannelStripRight[iStripRpcIndex][uStripIndex]][0]
                                               -(fVftxInputEvent->fVftxBoards[
                                                   fPar->uTdcStripLeftList[iStripRpcIndex][uStripIndex] ] ).dTimeCorr[
                                                      fPar->uChannelStripLeft[iStripRpcIndex][uStripIndex] ][0]
                                              )/1000.0
                        - fPar->dOffsetList[iStripRpcIndex][uStripIndex],
                        ((Double_t)uStripIndex - dRpcCenterOffset )*fPar->dStripWidth[iStripRpcIndex] );
                        
                  // Channel nb for trailing edge depends whether the leading edge channel is even or uneven
                  UInt_t uTrailingEdgeChannelLeft;
                  UInt_t uTrailingEdgeChannelRight;
                  if( 1 == fPar->uChannelStripLeft[iStripRpcIndex][uStripIndex]%2 )
                     uTrailingEdgeChannelLeft = fPar->uChannelStripLeft[iStripRpcIndex][uStripIndex] - 1;
                     else uTrailingEdgeChannelLeft = fPar->uChannelStripLeft[iStripRpcIndex][uStripIndex] + 1;
                  if( 1 == fPar->uChannelStripRight[iStripRpcIndex][uStripIndex]%2 )
                     uTrailingEdgeChannelRight = fPar->uChannelStripRight[iStripRpcIndex][uStripIndex] - 1;
                     else uTrailingEdgeChannelRight = fPar->uChannelStripRight[iStripRpcIndex][uStripIndex] + 1;
                     
                  if( -1 < (fVftxInputEvent->fVftxBoards[
                                          fPar->uTdcStripLeftList[iStripRpcIndex][uStripIndex] ] ).dTimeCorr[
                                             uTrailingEdgeChannelLeft ][0] )
                  {
                     fTotLeftStripRpc[iStripRpcIndex]->Fill(
                        ( (fVftxInputEvent->fVftxBoards[
                              fPar->uTdcStripLeftList[iStripRpcIndex][uStripIndex] ] ).dTimeCorr[
                                 uTrailingEdgeChannelLeft ][0]
                          -(fVftxInputEvent->fVftxBoards[
                              fPar->uTdcStripLeftList[iStripRpcIndex][uStripIndex] ] ).dTimeCorr[
                                 fPar->uChannelStripLeft[iStripRpcIndex][uStripIndex] ][0]
                         )/1000.0, 
                        (Double_t)uStripIndex - dRpcCenterOffset );
                     if( -1 < (fVftxInputEvent->fVftxBoards[
                                             fPar->uTdcStripRightList[iStripRpcIndex][uStripIndex] ] ).dTimeCorr[
                                                uTrailingEdgeChannelRight ][0] )
                     {
                        uMultiplicityStripRpc[iStripRpcIndex]++;

                        vStepStripCounts[iStripRpcIndex][uStripIndex]++;
                     }// if valid trailing edge also on right side
                  } // if valid trailing edge on left side

                  if( -1 < (fVftxInputEvent->fVftxBoards[
                                          fPar->uTdcStripRightList[iStripRpcIndex][uStripIndex] ] ).dTimeCorr[
                                             uTrailingEdgeChannelRight ][0] )
                  {
                     fTotRightStripRpc[iStripRpcIndex]->Fill(
                        ( (fVftxInputEvent->fVftxBoards[
                              fPar->uTdcStripRightList[iStripRpcIndex][uStripIndex] ] ).dTimeCorr[
                                 uTrailingEdgeChannelRight ][0]
                          -(fVftxInputEvent->fVftxBoards[
                              fPar->uTdcStripRightList[iStripRpcIndex][uStripIndex] ] ).dTimeCorr[
                                 fPar->uChannelStripRight[iStripRpcIndex][uStripIndex] ][0]
                         )/1000.0,
                        (Double_t)uStripIndex - dRpcCenterOffset );
                  } // if valid trailing edge on right side
               } // if( valid on both ends!)
            } //  for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips[iStripRpcIndex]; uStripIndex++)
            fMultiplicityStripRpc[iStripRpcIndex]->Fill( uMultiplicityStripRpc[iStripRpcIndex] );
         } // if( 1 == fPar->uTdcTypeStrip[iStripRpcIndex] )
      for( Int_t iPadRpcIndex = 0; iPadRpcIndex < fPar->iNbPadRpcs; iPadRpcIndex++)
         if( 1 == fPar->uTdcTypePad[iPadRpcIndex] )
         {
            Double_t dRpcCenterPadOffsetX = (Double_t)fPar->uNbPadsX[iPadRpcIndex]*fPar->dPadSizeX[iPadRpcIndex]/2.0;
            Double_t dRpcCenterPadOffsetY = (Double_t)fPar->uNbPadsY[iPadRpcIndex]*fPar->dPadSizeY[iPadRpcIndex]/2.0;
            
            for(UInt_t uPadIndexY = 0; uPadIndexY < fPar->uNbPadsY[iPadRpcIndex]; uPadIndexY++)
               for(UInt_t uPadIndexX = 0; uPadIndexX < fPar->uNbPadsX[iPadRpcIndex]; uPadIndexX++)
            {
               if( -1 < (fVftxInputEvent->fVftxBoards[ 
                                    fPar->uPadsTdc[iPadRpcIndex][uPadIndexY][uPadIndexX] ]).dTimeCorr[
                                          fPar->uPadsChan[iPadRpcIndex][uPadIndexY][uPadIndexX] ][0] )
               {
                  fBeamProfilePadRpc[iPadRpcIndex]->Fill( (Double_t)uPadIndexX*fPar->dPadSizeX[iPadRpcIndex] - dRpcCenterPadOffsetX, 
                                                          (Double_t)uPadIndexY*fPar->dPadSizeY[iPadRpcIndex] - dRpcCenterPadOffsetY);
               } // if valid hit on this pad
            } // for uPadIndexY uPadIndexX
         } // if( 0 == fPar->uTdcTypeStrip[iStripRpcIndex] )
   } // if(fVftxInputEvent && fVftxInputEvent->IsValid())

   if( -1 < fPar->iRateIntegrationDuration && -1 < fPar->iRateIntegrationStep &&
         fTriglogInputEvent && fTriglogInputEvent->IsValid() )
   {

      if( fPar->iRateIntegrationStep <= (Int_t)fTriglogInputEvent->fMbsTimeSecs - (Int_t)uLastMbsTimeStep)
      {
         for( Int_t iStripRpcIndex = 0; iStripRpcIndex < fPar->iNbStripRpcs; iStripRpcIndex++)
         {
            UInt_t uCounterStepCounts =0;
            for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips[iStripRpcIndex]; uStripIndex++)
            {
               /*
               // Reset the strip rate histogram when the Intergration duration is reached
               if( fPar->iRateIntegrationDuration <= (Int_t)fTriglogInputEvent->fMbsTimeSecs - (Int_t)uFirstMbsTimeIntegration)
               {
                  fStripRateStripRpc[iStripRpcIndex]->Reset();
                  uFirstMbsTimeIntegration = fTriglogInputEvent->fMbsTimeSecs;
               }
               */
               // Fill strip rate histo
               fStripRateStripRpc[iStripRpcIndex]->Fill(
                     vStepStripCounts[iStripRpcIndex][uStripIndex] / ((Int_t)fTriglogInputEvent->fMbsTimeSecs - (Int_t)uLastMbsTimeStep),
                     uStripIndex);
               // Compute counter counts in the step
               uCounterStepCounts += vStepStripCounts[iStripRpcIndex][uStripIndex];
               // Reset Strip counts in the step
               vStepStripCounts[iStripRpcIndex][uStripIndex] = 0;
            } // for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips[iStripRpcIndex]; uStripIndex++)
            // Fill counter rate versus time histo
            fCounterRateStripRpc[iStripRpcIndex]->Fill( fTriglogInputEvent->fMbsTimeSecs - uFirstMbsTimeStep,
                  uCounterStepCounts / (fTriglogInputEvent->fMbsTimeSecs - uLastMbsTimeStep) );
         } // for( Int_t iStripRpcIndex = 0; iStripRpcIndex < fPar->iNbStripRpcs; iStripRpcIndex++)
         uLastMbsTimeStep = fTriglogInputEvent->fMbsTimeSecs;
      } // if time since last update more than step value
   } // if rate parameters set && triglog event OK

   if( fCrateInputEvent && fCrateInputEvent->IsValid() && fVftxInputEvent && fVftxInputEvent->IsValid() )
   {
      if( -1 < fPar->iOffsetFullChannelCaen && -1 < fPar->iOffsetFullChannelVFTX )
      {
         // Offset to use when comparing times from CAEN and from VFTX TDCs
         dCaenVftxOffset = ( (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen  ]).lead_multi[
                                        fPar->iOffsetChannelCaen ][0] )*dCaenBinSize*1000
                           - (fVftxInputEvent->fVftxBoards[ fPar->iOffsetTdcVFTX ]).dTimeCorr[
                                        fPar->iOffsetChannelVFTX][0];

         // Now you can do stuff with times from both TDCs
            // Test of the offset between CAEN and VFTX, ref in same tdcs
         fTdcOffsetTestSameCV->Fill( ( (fCrateInputEvent->fMtdc[ 0 ]).lead_multi[29][0] )*dCaenBinSize*1000
                                     - (fVftxInputEvent->fVftxBoards[ 6 ]).dTimeCorr[1][0]
                                     - dCaenVftxOffset);
            // Test of the offset between CAEN and VFTX, ref in diff tdcs
         fTdcOffsetTestDiffCV->Fill( ( (fCrateInputEvent->fMtdc[ 0 ]).lead_multi[29][0] )*dCaenBinSize*1000
                                     - (fVftxInputEvent->fVftxBoards[ 6 ]).dTimeCorr[1][0]
                                     - dCaenVftxOffset);
            // Test of the offset between CAEN and VFTX, ref in diff caen
         fTdcOffsetTestDiffC->Fill(  ( (fCrateInputEvent->fMtdc[ 0 ]).lead_multi[29][0] )*dCaenBinSize*1000
                                     - (fVftxInputEvent->fVftxBoards[ 6 ]).dTimeCorr[1][0]
                                     - dCaenVftxOffset);
            // Test of the offset between CAEN and VFTX, ref in diff vftx
         fTdcOffsetTestDiffV->Fill(  ( (fCrateInputEvent->fMtdc[ 0 ]).lead_multi[29][0] )*dCaenBinSize*1000
                                     - (fVftxInputEvent->fVftxBoards[ 6 ]).dTimeCorr[1][0]
                                     - dCaenVftxOffset);

            // Test of the resolution between CAEN and CAEN, same board
         fTdcResolutionTestSameC->Fill( ( (fCrateInputEvent->fMtdc[ 0 ]).lead_multi[29][0] )*dCaenBinSize*1000
                                      - ( (fCrateInputEvent->fMtdc[ 0 ]).lead_multi[22][0] )*dCaenBinSize*1000);
            // Test of the resolution between CAEN and CAEN, diff board
         fTdcResolutionTestDiffC->Fill( ( (fCrateInputEvent->fMtdc[ 0 ]).lead_multi[29][0] )*dCaenBinSize*1000
                                      - ( (fCrateInputEvent->fMtdc[ 0 ]).lead_multi[22][0] )*dCaenBinSize*1000);
            // Test of the resolution between CAEN and CAEN, same board
         fTdcResolutionTestSameV->Fill( ( fVftxInputEvent->fVftxBoards[ 6 ]).dTimeCorr[ 1][0]
                                      - ( fVftxInputEvent->fVftxBoards[ 4 ]).dTimeCorr[51][0] );
            // Test of the resolution between CAEN and CAEN, diff board
         fTdcResolutionTestDiffV->Fill(  ( fVftxInputEvent->fVftxBoards[ 6 ]).dTimeCorr[ 1][0]
                                       - ( fVftxInputEvent->fVftxBoards[ 4 ]).dTimeCorr[51][0] );
      } //if( -1 < fPar->iOffsetFullChannelCaen && -1 < fPar->iOffsetFullChannelVFTX )

      Int_t iDualMultHistoIndex = 0;
      for( Int_t iStripRpcIndex = 0; iStripRpcIndex < fPar->iNbStripRpcs - 1; iStripRpcIndex++)
         for( Int_t iStripRpcIndex2 = iStripRpcIndex+1; iStripRpcIndex2 < fPar->iNbStripRpcs; iStripRpcIndex2++)
         {
            /*
            cout<<iStripRpcIndex<<" "<<iStripRpcIndex2<<" "<<" "<<iDualMultHistoIndex<<" "<<
                  (NB_STRIP_RPC_MAX-1)*(NB_STRIP_RPC_MAX-2)/2<<endl;
                  */
            fDualMultiplicityStripRpc[iDualMultHistoIndex]->Fill( uMultiplicityStripRpc[iStripRpcIndex],
                                                                  uMultiplicityStripRpc[iStripRpcIndex2]);
            iDualMultHistoIndex++;
         }
   } // if( fCrateInputEvent && fCrateInputEvent->IsValid() && fVftxInputEvent && fVftxInputEvent->IsValid() )
}