beamtime/tof-tdctest/go4/PADRPC/TPadRpcProc.cxx (r4864/r4678)

Go to the documentation of this file.

#include "TPadRpcProc.h"

#include "TProfile.h"
#include "TF1.h"
#include "TMath.h"

TPadRpcProc::TPadRpcProc(const char* name) : TCBMBeamtimeProc(name),
fCrateInputEvent(0),
fTriglogInputEvent(0),
fVftxInputEvent(0),
fOutputEvent(0)
{
   TGo4Log::Info("**** TPadRpcProc: Create instance %s" , name );

   // Making a new parameter object for this RPC
   TString sName = name;
   UInt_t uIndexRpc =((TString)sName( sName.Length()-2, 2 ) ).Atoi();
   fPar = (TPadRpcParam*) MakeParameter( Form("PadRpcPar_%02d", uIndexRpc), "TPadRpcParam");

   if( 1 == fPar->uTdcTypePad || 2 == fPar->uTdcTypePad )
   {
      fVftxPar = (TVftxParam*) GetParameter("VftxPar");
      if( 0 == fVftxPar )
         fVftxPar = (TVftxParam*) MakeParameter("VftxPar", "TVftxParam");
   }

   fParAnalysis = (TGsiAug12Param*) GetParameter("GsiAug12Par");

   //~ cout<<name<<endl;

   // To be put as preprocessor somewhere ? (T1290Data.h?)
   dCaenBinSize     = 25000.0/1024.0;
   dRpcCenterOffsetX   = (Double_t)(fPar->uNbPadsX)                 / 2.0;
   dRpcCenterOffsetY   = (Double_t)(fPar->uNbPadsY)                 / 2.0;
   dRpcCenterOffsetCmX = (Double_t)(fPar->uNbPadsX)*fPar->dPadSizeX / 2.0;
   dRpcCenterOffsetCmY = (Double_t)(fPar->uNbPadsY)*fPar->dPadSizeY / 2.0;
   cout<<dRpcCenterOffsetX<<"/"<<dRpcCenterOffsetY<<" "<<dRpcCenterOffsetCmX<<"/"<<dRpcCenterOffsetCmY<<endl;

   // Create histograms only if at least one pad define!
   if( 0 < fPar->uNbPadsX && 0 < fPar->uNbPadsY )
   {
      fBeamProfilePadRpcCm =
         MakeTH2('D', Form("Rpc/%s/BeamProfileCm%s", fPar->sPadRpcName.Data(), fPar->sPadRpcName.Data()),
            Form("Beam profile for %s, Pad map in option file", fPar->sPadRpcName.Data()) ,
            fPar->uNbPadsX, -dRpcCenterOffsetCmX, dRpcCenterOffsetCmX,
            fPar->uNbPadsY, -dRpcCenterOffsetCmY, dRpcCenterOffsetCmY,
            "Pad X [cm]", "Pad Y [cm]" );

      fBeamProfilePadRpc =
         MakeTH2('D', Form("Rpc/%s/BeamProfile%s", fPar->sPadRpcName.Data(), fPar->sPadRpcName.Data()),
            Form("Beam profile for %s, Pad map in option file", fPar->sPadRpcName.Data()) ,
            fPar->uNbPadsX, 0, fPar->uNbPadsX,
            fPar->uNbPadsY, 0, fPar->uNbPadsY,
            "Pad X []", "Pad Y []" );

      // Multiplicity plots
      fMultiplicityPadRpc =
            MakeTH1('I', Form("Rpc/%s/Multiplicity%s", fPar->sPadRpcName.Data(), fPar->sPadRpcName.Data()),
            Form("Pad Multiplicity for %s, Pad map in option file", fPar->sPadRpcName.Data()) ,
            fPar->uNbPadsX*fPar->uNbPadsY, -0.5, fPar->uNbPadsX*fPar->uNbPadsY - 0.5,
            "Multiplicity (Number of pads fired simultaneously/event) [pads]" ) ;

      // Cluster multiplicity plots
      fClusterMultPadRpc =
            MakeTH1('I', Form("Rpc/%s/ClusterMult%s", fPar->sPadRpcName.Data(), fPar->sPadRpcName.Data()),
            Form("Cluster multiplicity for %s, Pad map in option file", fPar->sPadRpcName.Data()) ,
            (fPar->uNbPadsX*fPar->uNbPadsY)/2 + 1, -0.5, (fPar->uNbPadsX*fPar->uNbPadsY)/2 + 1 - 0.5,
            "Cluster multiplicity [clusters]" ) ;

      // Cluster size plots
      fClusterSizePadRpc =
            MakeTH1('I', Form("Rpc/%s/ClusterSize%s", fPar->sPadRpcName.Data(), fPar->sPadRpcName.Data()),
            Form("Cluster size for %s, Pad map in option file", fPar->sPadRpcName.Data()) ,
            fPar->uNbPadsX*fPar->uNbPadsY -1, 0.5, fPar->uNbPadsX*fPar->uNbPadsY - 0.5,
            "Cluster size [strips]" ) ;

      // Cluster position
      if( 1 == fPar->uOrientation )
         fClusterProfilePadRpc =
               MakeTH2('D', Form("Rpc/%s/BeamProfClusters%s", fPar->sPadRpcName.Data(), fPar->sPadRpcName.Data()),
               Form("Beam profile using clusters center for %s, Pad map in option file", fPar->sPadRpcName.Data()) ,
               fPar->uNbPadsY, -dRpcCenterOffsetCmY, dRpcCenterOffsetCmY,
               fPar->uNbPadsX, -dRpcCenterOffsetCmX, dRpcCenterOffsetCmX,
               "X [cm]", "Y [cm]" );
         else fClusterProfilePadRpc =
               MakeTH2('D', Form("Rpc/%s/BeamProfClusters%s", fPar->sPadRpcName.Data(), fPar->sPadRpcName.Data()),
               Form("Beam profile using clusters center for %s, Pad map in option file", fPar->sPadRpcName.Data()) ,
               fPar->uNbPadsX, -dRpcCenterOffsetCmX, dRpcCenterOffsetCmX,
               fPar->uNbPadsY, -dRpcCenterOffsetCmY, dRpcCenterOffsetCmY,
               "X [cm]", "Y [cm]" );
   } // if( 0 < fPar->uNbPadsX && 0 < fPar->uNbPadsY )

   TGo4Log::Info("**** TPadRpcProc: Instance %s created", name );
}


TPadRpcProc::~TPadRpcProc()
{
   cout << "**** TPadRpcProc: Delete instance " << endl;
}

void TPadRpcProc::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 && ( 0 == fPar->uTdcTypePad || 2 == fPar->uTdcTypePad ))
   {
     TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetOutputEvent("Unpack"));
          if(btevent)
          {
                 fCrateInputEvent=dynamic_cast<TMbsCrateEvent*>(btevent->GetSubEvent("MBSCRATE"));
          }
          else
          {
                 fCrateInputEvent=dynamic_cast<TMbsCrateEvent*>(GetInputEvent());
          }
          if(fCrateInputEvent==0) {
       GO4_STOP_ANALYSIS_MESSAGE("**** TPadRpcProc: Fatal error: Unpack output event has no TMbsCrateEvent!!! STOP GO4");
          }
   } // if(fCrateInputEvent==0 && ( 0 == fPar->uTdcTypePad || 2 == fPar->uTdcTypePad ))
   if(fTriglogInputEvent==0 && kTRUE == fParAnalysis->bWithTriglog)
   {
     TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetOutputEvent("Unpack"));
          if(btevent)
          {
                 fTriglogInputEvent=dynamic_cast<TTriglogEvent*>(btevent->GetSubEvent("TRIGLOG"));
          }

          if(fTriglogInputEvent==0) {
                 GO4_STOP_ANALYSIS_MESSAGE("**** TPadRpcProc: Fatal error: Unpack output event is/has not a TTriglogEvent!!! STOP GO4");
          }
   } // if(fTriglogInputEvent==0)
   if(fVftxInputEvent==0 && ( 1 == fPar->uTdcTypePad || 2 == fPar->uTdcTypePad ))
   {
          TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetInputEvent());
          if(btevent)
          {
                 fVftxInputEvent=dynamic_cast<TVftxEvent*>(btevent->GetSubEvent("VFTX"));
          }

          if(fVftxInputEvent==0) {
                 GO4_STOP_ANALYSIS_MESSAGE("**** TPadRpcProc: Fatal error: input event has no TVftxEvent!!! STOP GO4");
          }
   } // if(fVftxInputEvent==0 && ( 1 == fPar->uTdcTypePad || 2 == fPar->uTdcTypePad ))

   // 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)
      {
         TString sName = GetName();
         if ( sName.Contains("PADRPC_") )
         {
            fOutputEvent=dynamic_cast<TPadRpcEvent*>(btevent->GetSubEvent(
                  (TString)(sName(sName.Index("PADRPC_"), sName.Length() ) ) ) );
         }
            else fOutputEvent=dynamic_cast<TPadRpcEvent*>(btevent->GetSubEvent("PADRPC"));
      }
      else
      {
          fOutputEvent=dynamic_cast<TPadRpcEvent*>(btevent->GetSubEvent("PADRPC"));
      }
      if(fOutputEvent==0) {
         GO4_STOP_ANALYSIS_MESSAGE("**** TPadRpcProc: Fatal error: output event is not a TPadRpcEvent!!! STOP GO4");
      }
      else {
         //     BuildEvent(dynamic_cast<TGo4MbsSubEvent*>(btevent->GetSubEvent("MBSCRATE")));
      }
   }

}

void TPadRpcProc::FinalizeEvent()
{
   hitCurrent.Clear();
   clusterCurrent.Clear();
   uLastFiredPadX = fPar->uNbPadsX; // To be sure it's out of range for dead strips on startup
   uMultiplicityPadRpc = 0;

   if( -1 < fParAnalysis->iTriggerRejection && kTRUE == fParAnalysis->bWithTriglog)
       if( 1 == ((fTriglogInputEvent->fVulomTriggerPattern>>fParAnalysis->iTriggerRejection)&0x1 )  )
      {
          // The trigger Rejection is active and we have rejected trigger
         return;
      }

   if(  fPar->uTdcTypePad < 3 )
   {
      // The trigger selection is active and we have another trigger or no Pad is defined => skip processing
      if( kTRUE == fParAnalysis->bWithTriglog )
         if( !( ( -1 == fPar->iTriggerSelection) ||
             ( 1 == ((fTriglogInputEvent->fVulomTriggerPattern>>fPar->iTriggerSelection)&0x1 )  ) ) ||
               0 == fPar->uNbPadsX || 0 == fPar->uNbPadsY )
         {
            return;
         }

      if( 2 == fPar->uTdcTypePad )
      {
         (fOutputEvent->fEvents).resize(1);
         // Check that both tdc data are valid and calibrated
         if(fCrateInputEvent && fCrateInputEvent->IsValid() &&
               fVftxInputEvent && fVftxInputEvent->IsValid() )
         {
            Double_t dCaenVftxOffset =  0.;
            if( -1 < fVftxPar->iMainReferenceTdc )
            {
               if( -1 < fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] )
               {
                  Bool_t bOffsetOk = kFALSE;
                  if( -1 < fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] )
                  {
                     if( -1 < (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen ]).lead_multi[ fPar->iOffsetChannelCaen ][0] &&
                         -1 < (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
                                     fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] ][0] &&
                        -1 < (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
                                     fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] ][0])
                     {
                        dCaenVftxOffset =  dCaenBinSize*( (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen ]).lead_multi[ fPar->iOffsetChannelCaen ][0] )
                                         - ( (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
                                                    fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] ][0]
                                            +(fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
                                                    fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc ] ][0])/2.;
                        bOffsetOk = kTRUE;
                     } // if all times OK
                  } // if( -1 < fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] )
                  if( kFALSE == bOffsetOk )
                     if( -1 < (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen ]).lead_multi[ fPar->iOffsetChannelCaen ][0] &&
                         -1 < (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
                                     fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] ][0] )
                        dCaenVftxOffset =  dCaenBinSize*( (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen ]).lead_multi[ fPar->iOffsetChannelCaen ][0] )
                                         - (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
                                                    fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] ][0];
               } // if( -1 < fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] )
                  else if( -1 < fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] )
                     if( -1 < (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen ]).lead_multi[ fPar->iOffsetChannelCaen ][0] &&
                         -1 < (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
                                     fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] ][0] )
                        dCaenVftxOffset =  dCaenBinSize*( (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen ]).lead_multi[ fPar->iOffsetChannelCaen ][0] )
                                         - (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
                                                    fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] ][0];
            } // if( -1 < fVftxPar->iMainReferenceTdc )

            for(UInt_t temp_indexY = 0; temp_indexY < fPar->uNbPadsY; temp_indexY++)
               for(UInt_t temp_indexX = 0; temp_indexX < fPar->uNbPadsX; temp_indexX++)
               {
                  hitCurrent.Clear();
                  if( 1 == fPar->uTdcPadType[temp_indexY][temp_indexX])
                     ProcessVftxPad( temp_indexX, temp_indexY );
                     else ProcessCaenPad( temp_indexX, temp_indexY, dCaenVftxOffset );
               } //  for( temp_indexY, temp_indexX)
         } // if(fCrateInputEvent && fCrateInputEvent->IsValid() && fVftxInputEvent && fVftxInputEvent->IsValid() )
      } // if( 2 == fPar->uTdcTypePad )
      else if( 1 == fPar->uTdcTypePad )
      {
         // Check that the VFTX data are valid after calibration
         if(fVftxInputEvent && fVftxInputEvent->IsValid())
         {
            for(UInt_t temp_indexY = 0; temp_indexY < fPar->uNbPadsY; temp_indexY++)
               for(UInt_t temp_indexX = 0; temp_indexX < fPar->uNbPadsX; temp_indexX++)
               {
                  hitCurrent.Clear();

                  ProcessVftxPad( temp_indexX, temp_indexY );
               } //  for( temp_indexY, temp_indexX )
         } // if(fVftxInputEvent && fVftxInputEvent->IsValid())
      } // if( 2 == fPar->uTdcTypePad ) else if( 1 == fPar->uTdcTypePad )
      else
      {
         // Check that the MBS unpack event is valid
         if(fCrateInputEvent && fCrateInputEvent->IsValid())
         {
            for(UInt_t temp_indexY = 0; temp_indexY < fPar->uNbPadsY; temp_indexY++)
               for(UInt_t temp_indexX = 0; temp_indexX < fPar->uNbPadsX; temp_indexX++)
               {
                  hitCurrent.Clear();

                  ProcessCaenPad( temp_indexX, temp_indexY );
               } //  for( temp_indexY, temp_indexX )
         } // if(fCrateInputEvent && fCrateInputEvent->IsValid())
      } // else of if( 2 == fPar->uTdcTypePad )else if( 1 == fPar->uTdcTypePad )

      if( 0 < (clusterCurrent.fHits).size() )
      {
         clusterCurrent.PositionCalculation( dRpcCenterOffsetCmX, dRpcCenterOffsetCmY,
                  fPar->uOrientation,
                  fPar->dPadSizeX, fPar->dPadSizeY );
         (eventCurrent.fClusters).push_back( clusterCurrent );
         clusterCurrent.Clear();
      } // if( 0 < (clusterCurrent.fHits).size() )

      // Multiplicity graph with Pad RPCs
      fMultiplicityPadRpc->Fill( uMultiplicityPadRpc );
      // Cluster multiplicity graph with Pad RPCs
      fClusterMultPadRpc->Fill( (eventCurrent.fClusters).size() );
      // Cluster size graph with Pad RPCs
      for(UInt_t uCluster = 0; uCluster < (eventCurrent.fClusters).size(); uCluster++)
      {
         fClusterSizePadRpc->Fill( ( ( (eventCurrent.fClusters)[uCluster] ).fHits ).size() );
         fClusterProfilePadRpc->Fill( ( (eventCurrent.fClusters)[uCluster] ).dX,
                                        ( (eventCurrent.fClusters)[uCluster] ).dY);
      } // for(UInt_t uCluster = 0; uCluster < (eventCurrent.fClusters).size(); uCluster++)

      // Push event object to the output event
      (fOutputEvent->fEvents).push_back( eventCurrent );
   } // if(  fPar->uTdcTypePad < 3 )

   fOutputEvent->SetValid(kTRUE);
}

/**************************************************************************************************/
void TPadRpcProc::ProcessCaenPad( UInt_t uPadIndexX, UInt_t uPadIndexY, Double_t dCaenOtherOffset )
{
   // Test if both time are there
   if( -1 < (fCrateInputEvent->fMtdc[
               fPar->uTdcPadTime[uPadIndexY][uPadIndexX] ]).lead_multi[
                     fPar->uChannelPadTime[uPadIndexY][uPadIndexX] ][0] )
   {
      fBeamProfilePadRpcCm->Fill( fPar->dPadSizeX*uPadIndexX - dRpcCenterOffsetCmX,
                                  fPar->dPadSizeY*uPadIndexY - dRpcCenterOffsetCmY );
      fBeamProfilePadRpc->Fill( uPadIndexX, uPadIndexY );

      if( -1 < (fCrateInputEvent->fMtdc[
                  fPar->uTdcPadTot[uPadIndexY][uPadIndexX] ]).lead_multi[
                     fPar->uChannelPadTot[uPadIndexY][uPadIndexX] ][0] )
      {
         uMultiplicityPadRpc ++;

         hitCurrent.iPadIndexX     = uPadIndexX ;
         hitCurrent.iPadIndexY     = uPadIndexY ;
         // Store time including offset!
         hitCurrent.dTime  = dCaenBinSize*(
               (fCrateInputEvent->fMtdc[ fPar->uTdcPadTime[uPadIndexY][uPadIndexX] ]).lead_multi[
                                       fPar->uChannelPadTime[uPadIndexY][uPadIndexX] ][0] )
                                 + fPar->dOffsetList[uPadIndexY][uPadIndexX]
                                 - dCaenOtherOffset;
         // Store tot including offset and gain!
         hitCurrent.dTot   =
            ( (fCrateInputEvent->fMtdc[ fPar->uTdcPadTot[uPadIndexY][uPadIndexX] ]).trail_multi[
                                    fPar->uChannelPadTot[uPadIndexY][uPadIndexX]][0]
             -(fCrateInputEvent->fMtdc[ fPar->uTdcPadTime[uPadIndexY][uPadIndexX]  ]).lead_multi[
                                    fPar->uChannelPadTot[uPadIndexY][uPadIndexX] ][0]
            )*fPar->dToTGainList[uPadIndexY][uPadIndexX]*dCaenBinSize
            - fPar->dTotOffsetList[uPadIndexY][uPadIndexX];

         (clusterCurrent.fHits).push_back(hitCurrent);
         clusterCurrent.PositionCalculation( dRpcCenterOffsetCmX, dRpcCenterOffsetCmY,
                  fPar->uOrientation,
                  fPar->dPadSizeX, fPar->dPadSizeY );
         (eventCurrent.fClusters).push_back( clusterCurrent );
         clusterCurrent.Clear();
      }// if valid Tot
   } // if( valid on both ends!)
   return;
}
void TPadRpcProc::ProcessVftxPad( UInt_t uPadIndexX, UInt_t uPadIndexY, Double_t dVftxOtherOffset )
{
   // Test if both time are there
   if( -1 < (fVftxInputEvent->fVftxBoards[
               fPar->uTdcPadTime[uPadIndexY][uPadIndexX] ] ).dTimeCorr[
                  fPar->uChannelPadTime[uPadIndexY][uPadIndexX] ][0] )
   {
      fBeamProfilePadRpcCm->Fill( fPar->dPadSizeX*uPadIndexX - dRpcCenterOffsetCmX,
                                  fPar->dPadSizeY*uPadIndexY - dRpcCenterOffsetCmY );
      fBeamProfilePadRpc->Fill( uPadIndexX, uPadIndexY );

      // Check Right tot is there
      if( -1 < (fVftxInputEvent->fVftxBoards[
                     fPar->uTdcPadTot[uPadIndexY][uPadIndexX] ] ).dTimeCorr[
                        fPar->uChannelPadTot[uPadIndexY][uPadIndexX] ][0] )
      {
         uMultiplicityPadRpc ++;

         hitCurrent.iPadIndexX     = uPadIndexX ;
         hitCurrent.iPadIndexY     = uPadIndexY ;
         // Store time including offset!
         hitCurrent.dTime  = (fVftxInputEvent->fVftxBoards[
                                     fPar->uTdcPadTime[uPadIndexY][uPadIndexX] ] ).dTimeCorr[
                                       fPar->uChannelPadTime[uPadIndexY][uPadIndexX] ][0]
                              + fPar->dOffsetList[uPadIndexY][uPadIndexX]
                              - dVftxOtherOffset
                              - CLOCK_TIME*( 1 == fVftxPar->uTdcOffsetEnable?
                                    fVftxPar->iAutomaticTdcOffset[ fPar->uTdcPadTime[uPadIndexY][uPadIndexX] ] : 0.0);

         // Store tot including offset and gain!
         // Missing the offset for the coarse counter overflow!!!!
         hitCurrent.dTot   =
               (fVftxInputEvent->fVftxBoards[ fPar->uTdcPadTot[uPadIndexY][uPadIndexX] ] ).dTimeCorr[
                  fPar->uChannelPadTot[uPadIndexY][uPadIndexX]  ][0]
             - (fVftxInputEvent->fVftxBoards[ fPar->uTdcPadTime[uPadIndexY][uPadIndexX] ] ).dTimeCorr[
                  fPar->uChannelPadTime[uPadIndexY][uPadIndexX] ][0];
         if( 1000 < (fVftxInputEvent->fVftxBoards[ fPar->uTdcPadTot[uPadIndexY][uPadIndexX] ]).iCoarseTime[
                        fPar->uChannelPadTot[uPadIndexY][uPadIndexX] ][0]
                  - (fVftxInputEvent->fVftxBoards[ fPar->uTdcPadTime[uPadIndexY][uPadIndexX] ]).iCoarseTime[
                        fPar->uChannelPadTime[uPadIndexY][uPadIndexX] ][0] )
            hitCurrent.dTot -= ((TDC_FIFO_COARSE_CT>>TDC_FIFO_COARSE_CT_SHIFT)+1)*(Double_t)CLOCK_TIME;

         if( (fVftxInputEvent->fVftxBoards[ fPar->uTdcPadTot[uPadIndexY][uPadIndexX] ]).iCoarseTime[
                        fPar->uChannelPadTot[uPadIndexY][uPadIndexX] ][0]
            - (fVftxInputEvent->fVftxBoards[ fPar->uTdcPadTime[uPadIndexY][uPadIndexX] ]).iCoarseTime[
                  fPar->uChannelPadTime[uPadIndexY][uPadIndexX] ][0]  < 1000)
            hitCurrent.dTot += ((TDC_FIFO_COARSE_CT>>TDC_FIFO_COARSE_CT_SHIFT)+1)*(Double_t)CLOCK_TIME;

         hitCurrent.dTot *= fPar->dToTGainList[uPadIndexY][uPadIndexX];
         hitCurrent.dTot -= fPar->dTotOffsetList[uPadIndexY][uPadIndexX];

         (clusterCurrent.fHits).push_back(hitCurrent);
         clusterCurrent.PositionCalculation( dRpcCenterOffsetCmX, dRpcCenterOffsetCmY,
                  fPar->uOrientation,
                  fPar->dPadSizeX, fPar->dPadSizeY );
         (eventCurrent.fClusters).push_back( clusterCurrent );
         clusterCurrent.Clear();
      }// if valid tot
   } // if( valid on both ends!)

   return;
}
/**************************************************************************************************/