ROCsoft: beamtime/tof-tdctest/go4/RPC/TRpcProc.cxx (r4864/r4744) Source File

Go to the documentation of this file.
00001 #include "TRpcProc.h"
00002 
00003 #include "TProfile.h"
00004 #include "TF1.h"
00005 #include "TMath.h"
00006 
00007 TRpcProc::TRpcProc(const char* name) : TCBMBeamtimeProc(name),
00008 fCrateInputEvent(0),
00009 fTriglogInputEvent(0),
00010 fGet4v1InputEvent(0),
00011 fVftxInputEvent(0),
00012 fOutputEvent(0)
00013 {
00014    TGo4Log::Info("**** TRpcProc: Create instance %s" , name );
00015 
00016    // Making a new parameter object for this RPC
00017    TString sName = name;
00018    UInt_t uIndexRpc =((TString)sName( sName.Length()-2, 2 ) ).Atoi();
00019    fPar = (TRpcParam*) MakeParameter( Form("RpcPar_%02d", uIndexRpc), "TRpcParam");
00020 
00021    if( 1 == fPar->uTdcTypeStrip || 2 == fPar->uTdcTypeStrip) // Contains VFTX data!
00022    {
00023       fVftxPar = (TVftxParam*) GetParameter("VftxPar");
00024       if( 0 == fVftxPar )
00025          fVftxPar = (TVftxParam*) MakeParameter("VftxPar", "TVftxParam");
00026    } // if( 1 == fPar->uTdcTypeStrip || 2 == fPar->uTdcTypeStrip) // Contains VFTX data!
00027 
00028    // Try to recover the Get4 v1.0 Parameter object
00029    if( 3 == fPar->uTdcTypeStrip ) // Contains GET4 data!
00030    {
00031       fGet4v1Par = (TGet4v1Param*) GetParameter("Get4v1Par");
00032       if( 0 == fGet4v1Par )
00033          fGet4v1Par = (TGet4v1Param*) MakeParameter("Get4v1Par", "TGet4v1Param");
00034    } // if( 3 == fPar->uTdcTypeStrip ) // Contains GET4 data!
00035 
00036    fParAnalysis = (TGsiAug12Param*) GetParameter("GsiAug12Par");
00037 
00038    //~ cout<<name<<endl;
00039 
00040    // To be put as preprocessor somewhere ? (T1290Data.h?)
00041    dCaenBinSize     = 25000.0/1024.0;
00042    dRpcCenterOffset   = (Double_t)(fPar->uNbStrips)                   / 2.0;
00043    dRpcCenterOffsetCm = (Double_t)(fPar->uNbStrips)*fPar->dStripWidth / 2.0;
00044 //   cout<<dRpcCenterOffset<<" "<<dRpcCenterOffsetCm<<endl;
00045 
00046    // Create histograms only if at least one strip define!
00047    if( 0 < fPar->uNbStrips )
00048    {
00049 //      if( (  fPar->ReadoutMode == "Triggered" || fPar->uTdcTypeStrip < 3 ) )
00050       if( ( fPar->uTdcTypeStrip < 3) )
00051       {
00052          if( 1 == fPar->uInitialOffsetCalib)
00053             fBeamProfileStripRpc =
00054                   MakeTH2('D', Form("Rpc/%s/BeamProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00055                   Form("Beam profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00056                   8*fPar->iBeamProfileSize, -(4*fPar->iBeamProfileSize/2.0) -0.5, (4*fPar->iBeamProfileSize/2.0) -0.5,
00057                   fPar->uNbStrips, -dRpcCenterOffsetCm, dRpcCenterOffsetCm,
00058                   "Left right dt [cm]", "Strip index [cm]" );
00059          else if( 2 == fPar->uInitialOffsetCalib)
00060             fBeamProfileStripRpc =
00061                   MakeTH2('D', Form("Rpc/%s/BeamProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00062                   Form("Beam profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00063                   4*fPar->iBeamProfileSize, -(2*fPar->iBeamProfileSize/2.0) -0.5, (2*fPar->iBeamProfileSize/2.0) -0.5,
00064                   fPar->uNbStrips, -dRpcCenterOffsetCm, dRpcCenterOffsetCm,
00065                   "Left right dt [cm]", "Strip index [cm]" );
00066          else fBeamProfileStripRpc =
00067                MakeTH2('D', Form("Rpc/%s/BeamProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00068                Form("Beam profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00069                2*fPar->iBeamProfileSize, -(fPar->iBeamProfileSize/2.0) -0.5, (fPar->iBeamProfileSize/2.0) -0.5,
00070                fPar->uNbStrips, -dRpcCenterOffsetCm, dRpcCenterOffsetCm,
00071                "Left right dt [cm]", "Strip index [cm]" );
00072 
00073          fSingleEvtBeamProfileStripRpc =
00074                MakeTH2('D', Form("Rpc/%s/SingleEvtBeamProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00075                Form("Beam profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00076                2*fPar->iBeamProfileSize, -(fPar->iBeamProfileSize/2.0) -0.5, (fPar->iBeamProfileSize/2.0) -0.5,
00077                fPar->uNbStrips, -dRpcCenterOffsetCm, dRpcCenterOffsetCm,
00078                "Left right dt [cm]", "Strip index [cm]" );
00079 
00080          if( 1 == fPar->uInitialOffsetCalib)
00081             fBeamProfileStripRpcTime =
00082                   MakeTH2('D', Form("Rpc/%s/BeamProfileTime%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00083                   Form("Beam profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00084                   800,-20000,20000, // <= To be put as param later
00085                   fPar->uNbStrips, 0, fPar->uNbStrips,
00086                   "Left right dt [ps]", "Strip index []" );
00087          else if( 2 == fPar->uInitialOffsetCalib)
00088             fBeamProfileStripRpcTime =
00089                   MakeTH2('D', Form("Rpc/%s/BeamProfileTime%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00090                   Form("Beam profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00091                   2400,-60000,60000,  // <= To be put as param later
00092                   fPar->uNbStrips, 0, fPar->uNbStrips,
00093                   "Left right dt [ps]", "Strip index [cm]" );
00094          else fBeamProfileStripRpcTime =
00095                MakeTH2('D', Form("Rpc/%s/BeamProfileTime%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00096                Form("Beam profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00097                800,-10000,10000,  // <= To be put as param later
00098                fPar->uNbStrips, 0, fPar->uNbStrips,
00099                "Left right dt [ps]", "Strip index []" );
00100 
00101          if( 0 == fPar->uTdcTypeStrip ) // Contains CAEN data!
00102          {
00103             // CAEN TDC
00104             if( 1 == fPar->uInitialOffsetCalib)
00105                fReference1ProfileRpc =
00106                      MakeTH2('D', Form("Rpc/%s/ReferenceProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data() ),
00107                      Form("Reference profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00108                      9600,-240000,240000,  // <= To be put as param later
00109                     fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00110                      "Distance Mean Time to Reference [ps]", "Strip index []" ) ;
00111             else fReference1ProfileRpc =
00112                      MakeTH2('D', Form("Rpc/%s/ReferenceProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data() ),
00113                      Form("Reference profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00114                      2400,-60000, 60000,  // <= To be put as param later
00115                      fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00116                      "Distance Mean Time to Reference [ps]", "Strip index []" ) ;
00117             fReference2ProfileRpc =
00118                      MakeTH2('D', Form("Rpc/%s/DiamondProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data() ),
00119                      Form("Diamond profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00120                      2400,-120000, 120000,  // <= To be put as param later
00121                      fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00122                      "Distance Mean Time to Diamond [ps]", "Strip index []" ) ;
00123          }
00124             else
00125             {
00126                if( -1 < fVftxPar->iMainReferenceTdc ) // Contains VFTX data!
00127                {
00128                   if( -1 < fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] )
00129                   {
00130                      if( 1 == fPar->uInitialOffsetCalib)
00131                         fReference1ProfileRpc =
00132                               MakeTH2('D', Form("Rpc/%s/Reference1Profile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data() ),
00133                               Form("1st Reference profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00134                               9600,-240000,240000,  // <= To be put as param later
00135                               fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00136                               "Distance Mean Time to 1st Reference [ps]", "Strip index []" ) ;
00137                      else fReference1ProfileRpc =
00138                               MakeTH2('D', Form("Rpc/%s/Reference1Profile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data() ),
00139                               Form("1st Reference profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00140                               2400,-120000, 120000,  // <= To be put as param later
00141                               fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00142                               "Distance Mean Time to 1st Reference [ps]", "Strip index []" ) ;
00143 
00144                      if( -1 < fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] )
00145                         fMeanRefProfileRpc =
00146                               MakeTH2('D', Form("Rpc/%s/MeanRefProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data() ),
00147                               Form("Profile against mean of 1st and 2nd reference signal for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00148                               2400,-120000, 120000,  // <= To be put as param later
00149                               fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00150                               "Distance Mean Time to Mean Reference [ps]", "Strip index []" ) ;
00151                   } // if( -1 < fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] )
00152 
00153                   if( -1 < fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] )
00154                      fReference2ProfileRpc =
00155                               MakeTH2('D', Form("Rpc/%s/Reference2Profile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data() ),
00156                               Form("2nd Reference (Diamond) profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00157                               2400,-120000, 120000,  // <= To be put as param later
00158                               fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00159                               "Distance Mean Time to 2nd Reference (Diamond) [ps]", "Strip index []" ) ;
00160                } // else if( -1 < fVftxPar->iMainReferenceTdc ) of if( 0 == fPar->uTdcTypeStrip )
00161             }
00162 
00163          // Maybe put the size of thez Tot histo in time as an option in parameter file
00164          fTotLeftStripRpc =
00165                MakeTH2('D', Form("Rpc/%s/TotLeftProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00166                Form("Left Tot profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00167                2000, -50, 50,
00168                fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00169                "Left Tot [ns]", "Strip index []" ) ; ;
00170 
00171          // Maybe put the size of thez Tot histo in time as an option in parameter file
00172          fTotRightStripRpc =
00173                MakeTH2('D', Form("Rpc/%s/TotRightProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00174                Form("Right Tot profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00175                2000, -50, 50,
00176                fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00177                "Right Tot [ns]", "Strip index []" ) ;
00178       } // if( 3 < fPar->uTdcTypeStrip )
00179          else if( ( fPar->uTdcTypeStrip == 3) )
00180          {
00181             fBeamProfileStripRpc =
00182                   MakeTH2('D', Form("Rpc/%s/BeamProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00183                   Form("Beam profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00184                   4*fPar->iBeamProfileSize, -(2*fPar->iBeamProfileSize/2.0) -0.5, (2*fPar->iBeamProfileSize/2.0) -0.5,
00185                   fPar->uNbStrips, -dRpcCenterOffsetCm, dRpcCenterOffsetCm,
00186                   "Left right dt [cm]", "Strip index [cm]" );
00187 
00188             fBeamProfileStripRpcTime =
00189                   MakeTH2('D', Form("Rpc/%s/BeamProfileTime%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00190                   Form("Beam profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00191                   2400,-60000,60000,  // <= To be put as param later
00192                   fPar->uNbStrips, 0, fPar->uNbStrips,
00193                   "Left right dt [ps]", "Strip index []" );
00194 
00195             // Maybe put the size of thez Tot histo in time as an option in parameter file
00196             fTotLeftStripRpc =
00197                   MakeTH2('D', Form("Rpc/%s/TotLeftProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00198                   Form("Left Tot profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00199                   500, -0.05, 50-0.05,
00200                   fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00201                   "Left Tot [ns]", "Strip index []" ) ; ;
00202 
00203             // Maybe put the size of thez Tot histo in time as an option in parameter file
00204             fTotRightStripRpc =
00205                   MakeTH2('D', Form("Rpc/%s/TotRightProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00206                   Form("Right Tot profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00207                   500, -0.05, 50-0.05,
00208                   fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00209                   "Right Tot [ns]", "Strip index []" ) ;
00210 
00211             if( -1 < fGet4v1Par->iMainReferenceTdc)
00212             {
00213                if( -1 < fGet4v1Par->iReference1Channel )
00214                {
00215                   // 1st reference channel is defined
00216                   fReference1ProfileRpc =
00217                         MakeTH2('D', Form("Rpc/%s/Reference1Profile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data() ),
00218                         Form("1st Reference profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00219                         2400,-120000, 120000,  // <= To be put as param later
00220                         fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00221                         "Distance Mean Time to 1st Reference [ps]", "Strip index []" ) ;
00222                   if( -1 < fGet4v1Par->iReference2Channel )
00223                   {
00224                      // 2nd reference channel is also defined
00225                      fReference2ProfileRpc =
00226                            MakeTH2('D', Form("Rpc/%s/Reference2Profile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data() ),
00227                            Form("2nd Reference (Diamond) profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00228                            2400,-120000, 120000,  // <= To be put as param later
00229                            fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00230                            "Distance Mean Time to 2nd Reference (Diamond) [ps]", "Strip index []" ) ;
00231                      fMeanRefProfileRpc =
00232                            MakeTH2('D', Form("Rpc/%s/MeanRefProfile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data() ),
00233                            Form("Profile against mean of 1st and 2nd reference signal for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00234                            2400,-120000, 120000,  // <= To be put as param later
00235                            fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00236                            "Distance Mean Time to Mean Reference [ps]", "Strip index []" ) ;
00237                   } // if( -1 < fGet4v1Par->iReference2Channel )
00238                } // if( -1 < fGet4v1Par->iReference1Channel )
00239                   else if( -1 < fGet4v1Par->iReference2Channel )
00240                      // Only 2nd reference channel is defined
00241                      fReference2ProfileRpc =
00242                            MakeTH2('D', Form("Rpc/%s/Reference2Profile%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data() ),
00243                            Form("2nd Reference (Diamond) profile for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00244                            2400,-120000, 120000,  // <= To be put as param later
00245                            fPar->uNbStrips, 0. , (Double_t)fPar->uNbStrips,
00246                            "Distance Mean Time to 2nd Reference (Diamond) [ps]", "Strip index []" ) ;
00247             } // if( -1 < fGet4v1Par->iMainReferenceTdc)
00248          } // else if( ( fPar->uTdcTypeStrip == 3) ) of if( 3 < fPar->uTdcTypeStrip )
00249 
00250       // Multiplicity plots
00251       fMultiplicityStripRpc =
00252             MakeTH1('I', Form("Rpc/%s/Multiplicity%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00253             Form("Strip Multiplicity for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00254             fPar->uNbStrips, -0.5, fPar->uNbStrips - 0.5,
00255             "Multiplicity (Number of strip fired simultaneously/event) [strips]" ) ;
00256 
00257       // Cluster multiplicity plots
00258       fClusterMultStripRpc =
00259             MakeTH1('I', Form("Rpc/%s/ClusterMult%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00260             Form("Cluster multiplicity for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00261             fPar->uNbStrips/2 + 1, -0.5, fPar->uNbStrips/2 + 1 - 0.5,
00262             "Cluster multiplicity [clusters]" ) ;
00263 
00264       // Multiple TDc hits rejection
00265       if( 1 == fPar->uRejectMultipleHits )
00266          fTdcMultiRejectStripRpc =
00267                MakeTH1('I', Form("Rpc/%s/fTdcMultiReject%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00268                Form("Multiple TDc hits rejection per strip for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00269                fPar->uNbStrips, -0.5, fPar->uNbStrips - 0.5,
00270                "Strip []", "Nb of rejected events []" ) ;
00271 
00272       // Cluster size plots
00273       fClusterSizeStripRpc =
00274             MakeTH1('I', Form("Rpc/%s/ClusterSize%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00275             Form("Cluster size for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00276             fPar->uNbStrips -1, 0.5, fPar->uNbStrips - 0.5,
00277             "Cluster size [strips]" ) ;
00278 
00279       // Cluster position
00280       if( 1 == fPar->uOrientation )
00281          fClusterProfileStripRpc =
00282                MakeTH2('D', Form("Rpc/%s/BeamProfClusters%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00283                Form("Beam profile using clusters center for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00284                fPar->uNbStrips, -dRpcCenterOffsetCm, dRpcCenterOffsetCm,
00285                2*fPar->iBeamProfileSize, -(fPar->iBeamProfileSize/2.0) -0.5, (fPar->iBeamProfileSize/2.0) -0.5,
00286                "X [cm]", "Y [cm]" );
00287          else fClusterProfileStripRpc =
00288                MakeTH2('D', Form("Rpc/%s/BeamProfClusters%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00289                Form("Beam profile using clusters center for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00290                2*fPar->iBeamProfileSize, -(fPar->iBeamProfileSize/2.0) -0.5, (fPar->iBeamProfileSize/2.0) -0.5,
00291                fPar->uNbStrips, -dRpcCenterOffsetCm, dRpcCenterOffsetCm,
00292                "X [cm]", "Y [cm]" );
00293 
00294       fMultiHitsEvents = MakeTH1('I', Form("Rpc/%s/MultiHitsEvents%s", fPar->sStripRpcName.Data(), fPar->sStripRpcName.Data()),
00295                            Form("Multiple hits flag for Events with at least 1 cluster for %s, Strip map in option file", fPar->sStripRpcName.Data()) ,
00296                            2, -0.5, 2 - 0.5,
00297                            "Multiple hits Flag []" ) ;
00298    } // if( 0 < fPar->uNbStrips )
00299 
00300 
00301    TGo4Log::Info("**** TRpcProc: Instance %s created", name );
00302 }
00303 
00304 
00305 TRpcProc::~TRpcProc()
00306 {
00307    cout << "**** TRpcProc: Delete instance " << endl;
00308 }
00309 
00310 void TRpcProc::InitEvent(TGo4EventElement* outevnt)
00311 {
00312    // first assign input event:
00313    // since input event object is never discarded within processor lifetime,
00314    // we just search for subevent by name once to speed up processing
00315 
00316    if(fCrateInputEvent==0 && ( 0 == fPar->uTdcTypeStrip || 2 == fPar->uTdcTypeStrip ))
00317    {
00318           TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetOutputEvent("Unpack"));
00319           if(btevent)
00320           {
00321                  fCrateInputEvent=dynamic_cast<TMbsCrateEvent*>(btevent->GetSubEvent("MBSCRATE"));
00322           }
00323           else
00324           {
00325                  fCrateInputEvent=dynamic_cast<TMbsCrateEvent*>(GetInputEvent());
00326           }
00327           if(fCrateInputEvent==0) {
00328                  GO4_STOP_ANALYSIS_MESSAGE("**** TRpcProc: Fatal error: Unpack output event has no TMbsCrateEvent!!! STOP GO4");
00329           }
00330    } // if(fCrateInputEvent==0 && ( 0 == fPar->uTdcTypeStrip || 2 == fPar->uTdcTypeStrip ))
00331    if(fTriglogInputEvent==0 && kTRUE == fParAnalysis->bWithTriglog )
00332    {
00333           TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetOutputEvent("Unpack"));
00334           if(btevent)
00335           {
00336                  fTriglogInputEvent=dynamic_cast<TTriglogEvent*>(btevent->GetSubEvent("TRIGLOG"));
00337           }
00338 
00339           if(fTriglogInputEvent==0) {
00340                  GO4_STOP_ANALYSIS_MESSAGE("**** TRpcProc: Fatal error: Unpack output event is/has not a TTriglogEvent!!! STOP GO4");
00341           }
00342    } // if(fTriglogInputEvent==0)
00343    if(fVftxInputEvent==0 && ( 1 == fPar->uTdcTypeStrip || 2 == fPar->uTdcTypeStrip ) )
00344    {
00345           TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetInputEvent());
00346           if(btevent)
00347           {
00348                  fVftxInputEvent=dynamic_cast<TVftxEvent*>(btevent->GetSubEvent("VFTX"));
00349           }
00350 
00351           if(fVftxInputEvent==0) {
00352                  GO4_STOP_ANALYSIS_MESSAGE("**** TRpcProc: Fatal error: input event has no TVftxEvent!!! STOP GO4");
00353           }
00354    } // if(fVftxInputEvent==0 && ( 1 == fPar->uTdcTypeStrip || 2 == fPar->uTdcTypeStrip ) )
00355    if(fGet4v1InputEvent==0  && 3 == fPar->uTdcTypeStrip )
00356    {
00357      TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetOutputEvent("Unpack"));
00358      if(btevent)
00359      {
00360         fGet4v1InputEvent=dynamic_cast<TGet4v1Event*>(btevent->GetSubEvent("ROCGET4V10"));
00361      }
00362 
00363      if(fGet4v1InputEvent==0) {
00364        GO4_STOP_ANALYSIS_MESSAGE("**** TRpcProc: Fatal error: Unpack output event has no TGet4v1Event!!! STOP GO4");
00365      }
00366    } // if(fGet4v1InputEvent==0  && 3 == fPar->uTdcTypeStrip )
00367 
00368    // then assign output event
00369    // since output event object is never discarded within processor lifetime,
00370    // we just search for subevent by name once to speed up processing
00371    if(fOutputEvent==0)
00372    {
00373       TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(outevnt);
00374       if(btevent)
00375       {
00376          TString sName = GetName();
00377          if ( sName.Contains("RPC_") )
00378          {
00379             fOutputEvent=dynamic_cast<TRpcEvent*>(btevent->GetSubEvent(
00380                   (TString)(sName(sName.Index("RPC_"), sName.Length() ) ) ) );
00381          }
00382          else
00383             fOutputEvent=dynamic_cast<TRpcEvent*>(btevent->GetSubEvent("Rpc"));
00384       }
00385       else
00386       {
00387           fOutputEvent=dynamic_cast<TRpcEvent*>(btevent->GetSubEvent("Rpc"));
00388       }
00389       if(fOutputEvent==0) {
00390          GO4_STOP_ANALYSIS_MESSAGE("**** TRpcProc: Fatal error: output event is not a TRpcEvent!!! STOP GO4");
00391       }
00392       else {
00393          //     BuildEvent(dynamic_cast<TGo4MbsSubEvent*>(btevent->GetSubEvent("MBSCRATE")));
00394       }
00395    }
00396 
00397 }
00398 
00399 void TRpcProc::FinalizeEvent()
00400 {
00401 //   if( fPar->ReadoutMode == "Triggered" && fPar->uTdcTypeStrip < 3 )
00402    // Make a single event using the full MBS/LMD/GO4 event
00403    hitCurrent.Clear();
00404    clusterCurrent.Clear();
00405    eventCurrent.Clear();
00406    uLastFiredStrip = fPar->uNbStrips; // To be sure it's out of range for dead strips on startup
00407    uMultiplicityStripRpc = 0;
00408 
00409    if( -1 < fParAnalysis->iTriggerRejection && kTRUE == fParAnalysis->bWithTriglog)
00410       if( 1 == ((fTriglogInputEvent->fVulomTriggerPattern>>fParAnalysis->iTriggerRejection)&0x1 )  )
00411       {
00412           // The trigger Rejection is active and we have rejected trigger
00413          return;
00414       }
00415 
00416    if(  fPar->uTdcTypeStrip < 3 )
00417    {
00418       if( 0 < fPar->uNbStrips )
00419          fSingleEvtBeamProfileStripRpc->Reset();
00420 
00421       // The trigger selection is active and we have another trigger or no strip is defined => skip processing
00422       if( kTRUE == fParAnalysis->bWithTriglog )
00423          if( !( ( -1 == fPar->iTriggerSelection) ||
00424              ( 1 == ((fTriglogInputEvent->fVulomTriggerPattern>>fPar->iTriggerSelection)&0x1 )  ) ) ||
00425              0 == fPar->uNbStrips )
00426          {
00427             return;
00428          }
00429 
00430       if( 2 == fPar->uTdcTypeStrip )
00431       {
00432          // Check that both tdc data are valid and calibrated
00433          if(fCrateInputEvent && fCrateInputEvent->IsValid() &&
00434                fVftxInputEvent && fVftxInputEvent->IsValid() )
00435          {
00436 
00437             Double_t dCaenVftxOffset =  0.;
00438             if( -1 < fVftxPar->iMainReferenceTdc )
00439             {
00440                if( -1 < fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] )
00441                {
00442                   Bool_t bOffsetOk = kFALSE;
00443                   if( -1 < fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] )
00444                   {
00445                      if( -1 < (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen ]).lead_multi[ fPar->iOffsetChannelCaen ][0] &&
00446                          -1 < (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
00447                                      fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] ][0] &&
00448                         -1 < (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
00449                                      fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] ][0])
00450                      {
00451                         dCaenVftxOffset =  dCaenBinSize*( (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen ]).lead_multi[ fPar->iOffsetChannelCaen ][0] )
00452                                          - ( (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
00453                                                     fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] ][0]
00454                                             +(fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
00455                                                     fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc ] ][0])/2.;
00456                         bOffsetOk = kTRUE;
00457                      } // if all times OK
00458                   } // if( -1 < fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] )
00459                   if( kFALSE == bOffsetOk )
00460                      if( -1 < (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen ]).lead_multi[ fPar->iOffsetChannelCaen ][0] &&
00461                          -1 < (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
00462                                      fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] ][0] )
00463                         dCaenVftxOffset =  dCaenBinSize*( (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen ]).lead_multi[ fPar->iOffsetChannelCaen ][0] )
00464                                          - (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
00465                                                     fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] ][0];
00466                } // if( -1 < fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] )
00467                   else if( -1 < fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] )
00468                      if( -1 < (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen ]).lead_multi[ fPar->iOffsetChannelCaen ][0] &&
00469                          -1 < (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
00470                                      fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] ][0] )
00471                         dCaenVftxOffset =  dCaenBinSize*( (fCrateInputEvent->fMtdc[ fPar->iOffsetTdcCaen ]).lead_multi[ fPar->iOffsetChannelCaen ][0] )
00472                                          - (fVftxInputEvent->fVftxBoards[ fVftxPar->iMainReferenceTdc ] ).dTimeCorr[
00473                                                     fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] ][0];
00474             } // if( -1 < fVftxPar->iMainReferenceTdc )
00475             for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips; uStripIndex++)
00476             {
00477                hitCurrent.Clear();
00478                if( 1 == fPar->uTdcStripType[uStripIndex])
00479                   ProcessVftxStrip( uStripIndex );
00480                   else ProcessCaenStrip( uStripIndex, dCaenVftxOffset );
00481             } //  for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips; uStripIndex++)
00482          } // if(fCrateInputEvent && fCrateInputEvent->IsValid() && fVftxInputEvent && fVftxInputEvent->IsValid() )
00483       } // if( 2 == fPar->uTdcTypeStrip )
00484       else if( 1 == fPar->uTdcTypeStrip )
00485       {
00486          // Check that the VFTX data are valid after calibration
00487          if(fVftxInputEvent && fVftxInputEvent->IsValid())
00488          {
00489             for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips; uStripIndex++)
00490             {
00491                hitCurrent.Clear();
00492 
00493                ProcessVftxStrip( uStripIndex );
00494             } //  for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips; uStripIndex++)
00495          } // if(fVftxInputEvent && fVftxInputEvent->IsValid())
00496       } // if( 2 == fPar->uTdcTypeStrip ) else if( 1 == fPar->uTdcTypeStrip )
00497       else
00498       {
00499          // Check that the MBS unpack event is valid
00500          if(fCrateInputEvent && fCrateInputEvent->IsValid())
00501          {
00502             for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips; uStripIndex++)
00503             {
00504                hitCurrent.Clear();
00505 
00506                ProcessCaenStrip( uStripIndex );
00507             } //  for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips; uStripIndex++)
00508          } // if(fCrateInputEvent && fCrateInputEvent->IsValid())
00509 
00510       } // else of if( 2 == fPar->uTdcTypeStrip )else if( 1 == fPar->uTdcTypeStrip )
00511 
00512       if( 0 < (clusterCurrent.fHits).size() )
00513       {
00514          clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
00515                   fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
00516          (eventCurrent.fClusters).push_back( clusterCurrent );
00517          clusterCurrent.Clear();
00518       } // if( 0 < (clusterCurrent.fHits).size() )
00519 
00520       // Multiplicity graph with Strip RPCs
00521       fMultiplicityStripRpc->Fill( uMultiplicityStripRpc );
00522       // Cluster multiplicity graph with Strip RPCs
00523       fClusterMultStripRpc->Fill( (eventCurrent.fClusters).size() );
00524       // Cluster size graph with Strip RPCs
00525       for(UInt_t uCluster = 0; uCluster < (eventCurrent.fClusters).size(); uCluster++)
00526       {
00527          fClusterSizeStripRpc->Fill( ( ( (eventCurrent.fClusters)[uCluster] ).fHits ).size() );
00528          fClusterProfileStripRpc->Fill( ( (eventCurrent.fClusters)[uCluster] ).dX,
00529                                         ( (eventCurrent.fClusters)[uCluster] ).dY);
00530       }
00531       if( 0 < (eventCurrent.fClusters).size() )
00532          fMultiHitsEvents->Fill( eventCurrent.IsMultiEdge() );
00533       (fOutputEvent->fEvents).push_back( eventCurrent );
00534    } // if GlobalParam->ReadoutMode is "Triggered" and not a Get4 v1.0 RPC
00535    else if( 3== fPar->uTdcTypeStrip )
00536    {
00537 
00538       for( UInt_t uGet4EventIndex = 0; uGet4EventIndex < fGet4v1InputEvent->fEvents.size(); uGet4EventIndex++)
00539       {
00540          eventCurrent.Clear();
00541 
00542          for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips; uStripIndex++)
00543          {
00544             ProcessGet4v10Strip( uGet4EventIndex, uStripIndex );
00545          } //  for( UInt_t uStripIndex = 0; uStripIndex < fPar->uNbStrips; uStripIndex++)
00546 
00547          if( 0 < (clusterCurrent.fHits).size() )
00548          {
00549             clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
00550                      fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
00551             (eventCurrent.fClusters).push_back( clusterCurrent );
00552             clusterCurrent.Clear();
00553          } // if( 0 < (clusterCurrent.fHits).size() )
00554 
00555          {
00556             // Multiplicity graph with Strip RPCs
00557             fMultiplicityStripRpc->Fill( uMultiplicityStripRpc );
00558             // Cluster multiplicity graph with Strip RPCs
00559             fClusterMultStripRpc->Fill( (eventCurrent.fClusters).size() );
00560             // Cluster size graph with Strip RPCs
00561             for(UInt_t uCluster = 0; uCluster < (eventCurrent.fClusters).size(); uCluster++)
00562             {
00563                fClusterSizeStripRpc->Fill( ( ( (eventCurrent.fClusters)[uCluster] ).fHits ).size() );
00564                fClusterProfileStripRpc->Fill( ( (eventCurrent.fClusters)[uCluster] ).dX,
00565                                               ( (eventCurrent.fClusters)[uCluster] ).dY);
00566             }
00567          }
00568 
00569          (fOutputEvent->fEvents).push_back( eventCurrent );
00570       } // for( UInt_t uGet4EventIndex = 0; uGet4EventIndex < fGet4v1InputEvent->fEvents.size(); uGet4EventIndex++)
00571       if( 0 == fGet4v1InputEvent->fEvents.size() )
00572       {
00573          // Multiplicity graph with Strip RPCs
00574          fMultiplicityStripRpc->Fill( 0 );
00575          // Cluster multiplicity graph with Strip RPCs
00576          fClusterMultStripRpc->Fill( 0 );
00577          if( kFALSE == fGet4v1Par->bFreeStreaming || kTRUE == fGet4v1Par->bRawDataMode )
00578          {
00579             eventCurrent.Clear();
00580             (fOutputEvent->fEvents).push_back( eventCurrent );
00581          } // if( kFALSE == fGet4v1Par->bFreeStreaming || kTRUE == fGet4v1Par->bRawDataMode )
00582       } // if( 0 == fGet4v1InputEvent->fEvents.size() )
00583 
00584    } // else if( 3== fPar->uTdcTypeStrip ) of if GlobalParam->ReadoutMode is "Triggered" and not a Get4 v1.0 RPC
00585 
00586    fOutputEvent->SetValid(kTRUE);
00587 }
00588 
00589 /**************************************************************************************************/
00590 void TRpcProc::ProcessCaenStrip( UInt_t uStripIndex, Double_t dCaenOtherOffset )
00591 {
00592    // If multiple hits rejection is enable and there are more than 1 TDC hit on
00593    // at least one side of the strip => reject => no hits, return
00594    if( 1 == fPar->uRejectMultipleHits &&
00595        ( 1 < (fCrateInputEvent->fMtdc[
00596                fPar->uTdcStripLeftTime[uStripIndex]  ]).hit_lead[
00597                   fPar->uChannelStripLeftTime[uStripIndex] ] ||
00598          1 < (fCrateInputEvent->fMtdc[
00599                fPar->uTdcStripLeftTime[uStripIndex] ]).hit_trail[
00600                   fPar->uChannelStripLeftTime[uStripIndex] ]  ||
00601          1 < (fCrateInputEvent->fMtdc[
00602                fPar->uTdcStripRightTime[uStripIndex] ]).hit_lead[
00603                   fPar->uChannelStripRightTime[uStripIndex] ]  ||
00604          1 < (fCrateInputEvent->fMtdc[
00605                fPar->uTdcStripRightTime[uStripIndex] ]).hit_trail[
00606                   fPar->uChannelStripRightTime[uStripIndex] ] )
00607          )
00608    {
00609       fTdcMultiRejectStripRpc->Fill(uStripIndex);
00610       return;
00611    } // if( reject Multi &  multi tdc data for at least 1 edge on at least 1 side )
00612 
00613    // Test if both time are there
00614    if( -1 < (fCrateInputEvent->fMtdc[
00615                fPar->uTdcStripLeftTime[uStripIndex]  ]).lead_multi[
00616                         fPar->uChannelStripLeftTime[uStripIndex] ][0] &&
00617        -1 < (fCrateInputEvent->fMtdc[
00618                      fPar->uTdcStripRightTime[uStripIndex] ]).lead_multi[
00619                         fPar->uChannelStripRightTime[uStripIndex]][0] )
00620    {
00621       // Beam profile for strip RPC: X = left right Dt - offset, Y = size index * strip size
00622       fBeamProfileStripRpc->Fill(
00623             fPar->dTimeConv*( ( (fCrateInputEvent->fMtdc[
00624                                     fPar->uTdcStripRightTime[uStripIndex] ]).lead_multi[
00625                                        fPar->uChannelStripRightTime[uStripIndex]][0]
00626                                -(fCrateInputEvent->fMtdc[
00627                                     fPar->uTdcStripLeftTime[uStripIndex]  ]).lead_multi[
00628                                        fPar->uChannelStripLeftTime[uStripIndex] ][0]
00629                              )*dCaenBinSize
00630                              + fPar->dOffsetListRight[uStripIndex]
00631                              - fPar->dOffsetListLeft[uStripIndex]
00632                                   )/1000.0,
00633             ((Double_t)uStripIndex)*fPar->dStripWidth - dRpcCenterOffsetCm +0.00001 );
00634       fSingleEvtBeamProfileStripRpc->Fill(
00635             fPar->dTimeConv*( ( (fCrateInputEvent->fMtdc[
00636                                     fPar->uTdcStripRightTime[uStripIndex] ]).lead_multi[
00637                                        fPar->uChannelStripRightTime[uStripIndex]][0]
00638                                -(fCrateInputEvent->fMtdc[
00639                                     fPar->uTdcStripLeftTime[uStripIndex]  ]).lead_multi[
00640                                        fPar->uChannelStripLeftTime[uStripIndex] ][0]
00641                              )*dCaenBinSize
00642                              + fPar->dOffsetListRight[uStripIndex]
00643                              - fPar->dOffsetListLeft[uStripIndex]
00644                                   )/1000.0,
00645             ((Double_t)uStripIndex)*fPar->dStripWidth - dRpcCenterOffsetCm +0.00001 );
00646       fBeamProfileStripRpcTime->Fill(
00647                             ( ( (fCrateInputEvent->fMtdc[
00648                                     fPar->uTdcStripRightTime[uStripIndex] ]).lead_multi[
00649                                        fPar->uChannelStripRightTime[uStripIndex]][0]
00650                                -(fCrateInputEvent->fMtdc[
00651                                     fPar->uTdcStripLeftTime[uStripIndex]  ]).lead_multi[
00652                                        fPar->uChannelStripLeftTime[uStripIndex] ][0]
00653                              )*dCaenBinSize
00654                              + fPar->dOffsetListRight[uStripIndex]
00655                              - fPar->dOffsetListLeft[uStripIndex]
00656                                   ),
00657             ((Double_t)uStripIndex) +0.00001 );
00658 
00659       if( -1 < (fCrateInputEvent->fMtdc[
00660                         fPar->uTdcStripRightTot[uStripIndex]  ]).trail_multi[
00661                            fPar->uChannelStripRightTot[uStripIndex] ][0] )
00662       {
00663          fTotRightStripRpc->Fill(
00664             ( (fCrateInputEvent->fMtdc[
00665                   fPar->uTdcStripRightTot[uStripIndex] ]).trail_multi[
00666                      fPar->uChannelStripRightTot[uStripIndex]][0]
00667               -(fCrateInputEvent->fMtdc[
00668                   fPar->uTdcStripRightTime[uStripIndex]  ]).lead_multi[
00669                      fPar->uChannelStripRightTime[uStripIndex] ][0]
00670             )*fPar->dToTGainListLeft[uStripIndex]*dCaenBinSize/1000.0
00671             - fPar->dOffsetListRight[uStripIndex]/1000.0
00672             - fPar->dTotOffsetListRight[uStripIndex],
00673             (Double_t)uStripIndex  );
00674       } // if valid Tot on right side
00675 
00676       if( -1 < (fCrateInputEvent->fMtdc[
00677                         fPar->uTdcStripLeftTot[uStripIndex]  ]).trail_multi[
00678                            fPar->uChannelStripLeftTot[uStripIndex] ][0] )
00679       {
00680          fTotLeftStripRpc->Fill(
00681             ( (fCrateInputEvent->fMtdc[
00682                   fPar->uTdcStripLeftTot[uStripIndex] ]).trail_multi[
00683                      fPar->uChannelStripLeftTot[uStripIndex]][0]
00684               -(fCrateInputEvent->fMtdc[
00685                   fPar->uTdcStripLeftTime[uStripIndex]  ]).lead_multi[
00686                      fPar->uChannelStripLeftTime[uStripIndex] ][0]
00687             )*fPar->dToTGainListLeft[uStripIndex]*dCaenBinSize/1000.0
00688             - fPar->dOffsetListLeft[uStripIndex]/1000.0
00689             - fPar->dTotOffsetListLeft[uStripIndex],
00690             (Double_t)uStripIndex  );
00691 
00692          if( -1 < (fCrateInputEvent->fMtdc[
00693                            fPar->uTdcStripRightTot[uStripIndex]  ]).trail_multi[
00694                               fPar->uChannelStripRightTot[uStripIndex] ][0] )
00695          {
00696             uMultiplicityStripRpc ++;
00697 
00698             if( -1 < (fCrateInputEvent->fMtdc[fPar->iOffsetTdcCaen] ).lead_multi[fPar->iOffsetChannelCaen][0])
00699             {
00700                // Reference profile
00701                fReference1ProfileRpc->Fill(
00702                     ( ( (fCrateInputEvent->fMtdc[fPar->iOffsetTdcCaen] ).lead_multi[fPar->iOffsetChannelCaen][0] -
00703                        ( (fCrateInputEvent->fMtdc[
00704                              fPar->uTdcStripRightTime[uStripIndex] ] ).lead_multi[
00705                                fPar->uChannelStripRightTime[uStripIndex]][0]
00706                         +(fCrateInputEvent->fMtdc[
00707                             fPar->uTdcStripLeftTime[uStripIndex] ] ).lead_multi[
00708                                 fPar->uChannelStripLeftTime[uStripIndex] ][0])/2.
00709                            )*dCaenBinSize
00710                         - fPar->dReference1SignalOffset
00711                         -(  fPar->dOffsetListRight[uStripIndex]
00712                           + fPar->dOffsetListLeft[uStripIndex] )/2 ),
00713                                                                            /*
00714                                fPar->uChannelStripLeftTime[uStripIndex] ][0] )/2.
00715                       )*dCaenBinSize/1000.0 - fPar->dRefOffsetList[uStripIndex]),
00716                       */
00717                   (Double_t)uStripIndex );
00718             } // if( -1 < (fCrateInputEvent->fMtdc[fPar->iOffsetTdcCaen] ).lead_multi[fPar->iOffsetChannelCaen][0])
00719 
00720             if( -1 < (fCrateInputEvent->fMtdc[fPar->iDiamondTdcCaen] ).lead_multi[fPar->iDiamondChannelCaen][0])
00721             {
00722                // Diamond profile
00723                fReference2ProfileRpc->Fill(
00724                     ( ( (fCrateInputEvent->fMtdc[fPar->iDiamondTdcCaen] ).lead_multi[fPar->iDiamondChannelCaen][0] -
00725                        ( (fCrateInputEvent->fMtdc[
00726                              fPar->uTdcStripRightTime[uStripIndex] ] ).lead_multi[
00727                                fPar->uChannelStripRightTime[uStripIndex]][0]
00728                         +(fCrateInputEvent->fMtdc[
00729                             fPar->uTdcStripLeftTime[uStripIndex] ] ).lead_multi[
00730                                 fPar->uChannelStripLeftTime[uStripIndex] ][0])/2.
00731                            )*dCaenBinSize
00732                         - fPar->dReference2SignalOffset
00733                         -(  fPar->dOffsetListRight[uStripIndex]
00734                           + fPar->dOffsetListLeft[uStripIndex] )/2
00735                           ),
00736                   (Double_t)uStripIndex );
00737             } // if( -1 < (fCrateInputEvent->fMtdc[fPar->iDiamondTdcCaen] ).lead_multi[fPar->iDiamondChannelCaen][0])
00738 
00739             // Check multiples and set flag only in fired strips case!
00740             if( 1 < (fCrateInputEvent->fMtdc[
00741                         fPar->uTdcStripLeftTime[uStripIndex]  ]).hit_lead[
00742                            fPar->uChannelStripLeftTime[uStripIndex] ] ||
00743                  1 < (fCrateInputEvent->fMtdc[
00744                         fPar->uTdcStripLeftTime[uStripIndex] ]).hit_trail[
00745                            fPar->uChannelStripLeftTime[uStripIndex] ]  ||
00746                  1 < (fCrateInputEvent->fMtdc[
00747                         fPar->uTdcStripRightTime[uStripIndex] ]).hit_lead[
00748                            fPar->uChannelStripRightTime[uStripIndex] ]  ||
00749                  1 < (fCrateInputEvent->fMtdc[
00750                         fPar->uTdcStripRightTime[uStripIndex] ]).hit_trail[
00751                            fPar->uChannelStripRightTime[uStripIndex] ]
00752                   )
00753             {
00754                eventCurrent.fbMultiEdgesPresent = kTRUE;
00755                hitCurrent.fbMultiEdge = kTRUE;
00756             } // if( multi tdc data for at least 1 edge on at least 1 side )
00757 
00758             hitCurrent.iStrip     = uStripIndex ;
00759             // Store time including offset!
00760             hitCurrent.dTimeLeft  = dCaenBinSize*( (fCrateInputEvent->fMtdc[ fPar->uTdcStripLeftTime[uStripIndex]  ]).lead_multi[
00761                                                                 fPar->uChannelStripLeftTime[uStripIndex] ][0] )
00762                                     + fPar->dOffsetListLeft[uStripIndex]
00763                                     - dCaenOtherOffset;
00764             // Store tot including offset and gain!
00765             // Missing the offset for the coarse counter overflow!!!!
00766             hitCurrent.dTotLeft   =
00767                ( (fCrateInputEvent->fMtdc[ fPar->uTdcStripLeftTot[uStripIndex] ]).trail_multi[
00768                                        fPar->uChannelStripLeftTot[uStripIndex]][0]
00769                 -(fCrateInputEvent->fMtdc[ fPar->uTdcStripLeftTime[uStripIndex]  ]).lead_multi[
00770                                        fPar->uChannelStripLeftTime[uStripIndex] ][0]
00771                )*fPar->dToTGainListLeft[uStripIndex]*dCaenBinSize
00772                - fPar->dOffsetListLeft[uStripIndex]
00773                - fPar->dTotOffsetListLeft[uStripIndex]*1000.0;
00774             // Store time including offset!
00775             hitCurrent.dTimeRight = dCaenBinSize*( (fCrateInputEvent->fMtdc[fPar->uTdcStripRightTime[uStripIndex] ]).lead_multi[
00776                                                                 fPar->uChannelStripRightTime[uStripIndex]][0] )
00777                                     + fPar->dOffsetListRight[uStripIndex]
00778                                     - dCaenOtherOffset;
00779             // Store tot including offset and gain!
00780             // Missing the offset for the coarse counter overflow!!!!
00781             hitCurrent.dTotRight  =
00782                ( (fCrateInputEvent->fMtdc[ fPar->uTdcStripRightTot[uStripIndex] ]).trail_multi[
00783                                        fPar->uChannelStripRightTot[uStripIndex]][0]
00784                 -(fCrateInputEvent->fMtdc[ fPar->uTdcStripRightTime[uStripIndex]  ]).lead_multi[
00785                                        fPar->uChannelStripRightTime[uStripIndex] ][0]
00786                )*fPar->dToTGainListLeft[uStripIndex]*dCaenBinSize
00787                - fPar->dOffsetListRight[uStripIndex]
00788                - fPar->dTotOffsetListRight[uStripIndex]*1000.0;
00789 
00790             // Check if the new hit is more or less aligned with previous hit
00791             // in case of an already existing cluster
00792             Bool_t bDistanceToLastHitInClustOk = kTRUE;
00793             if( 0 < fPar->dStripHitMaxDistance && 0 < (clusterCurrent.fHits).size() )
00794             {
00795                Double_t dLastHitClustPos =
00796                      ( (clusterCurrent.fHits)[ (clusterCurrent.fHits).size() - 1 ]).PositionCalculation(
00797                            fPar->dTimeConv );
00798                Double_t dCurrentHitPos = hitCurrent.PositionCalculation( fPar->dTimeConv );
00799                if( fPar->dStripHitMaxDistance < TMath::Abs(dCurrentHitPos - dLastHitClustPos) )
00800                   bDistanceToLastHitInClustOk = kFALSE;
00801             }
00802 
00803             if(  ( (uStripIndex - 1) == uLastFiredStrip  &&
00804                   kTRUE == bDistanceToLastHitInClustOk ) ||
00805                   ( 0 == (clusterCurrent.fHits).size() && 0 == fPar->uTdcStripNoisy[uStripIndex] )
00806                   )
00807             {
00808                (clusterCurrent.fHits).push_back( hitCurrent );
00809                uLastFiredStrip = uStripIndex;
00810             } // if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip || 0 == (clusterCurrent.fHits).size())
00811             else if( 1 < uStripIndex && 0 == fPar->uTdcStripNoisy[uStripIndex])
00812             {
00813                // Test if we are not with a cluster cut in two by a dead strip
00814                if( ( (uStripIndex - 2) == uLastFiredStrip && 1 == fPar->uTdcStripDead[uStripIndex - 1] ) &&
00815                      kTRUE == bDistanceToLastHitInClustOk )
00816                {
00817                   (clusterCurrent.fHits).push_back( hitCurrent );
00818                   uLastFiredStrip = uStripIndex;
00819                }
00820                else if(0 == fPar->uTdcStripNoisy[uStripIndex])
00821                {
00822                   if( 0 < (clusterCurrent.fHits).size() )
00823                   {
00824                      clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
00825                            fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
00826                      (eventCurrent.fClusters).push_back( clusterCurrent );
00827                   }
00828                   clusterCurrent.Clear();
00829                   (clusterCurrent.fHits).push_back( hitCurrent );
00830                   uLastFiredStrip = uStripIndex;
00831                } // if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip) else if( not noisy )
00832                else if( 0 < (clusterCurrent.fHits).size() )
00833                {
00834                   clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
00835                         fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
00836                   (eventCurrent.fClusters).push_back( clusterCurrent );
00837                   clusterCurrent.Clear();
00838                } // else of ( if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip) else if( 0 < (clusterCurrent.fHits).size() ))
00839 
00840             }
00841             else if(0 == fPar->uTdcStripNoisy[uStripIndex])
00842             {
00843                if( 0 < (clusterCurrent.fHits).size() )
00844                {
00845                   clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
00846                         fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
00847                   (eventCurrent.fClusters).push_back( clusterCurrent );
00848                }
00849                clusterCurrent.Clear();
00850                (clusterCurrent.fHits).push_back( hitCurrent );
00851                uLastFiredStrip = uStripIndex;
00852             } // if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip) else if( not noisy )
00853             else if( 0 < (clusterCurrent.fHits).size() )
00854             {
00855                clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
00856                      fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
00857                (eventCurrent.fClusters).push_back( clusterCurrent );
00858                clusterCurrent.Clear();
00859             } // else of ( if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip) else if( 0 < (clusterCurrent.fHits).size() ))
00860 
00861             //hitCurrent.Clear();
00862          }// if valid trailing edge also on right side => valid hit!
00863       } // if valid Tot on left side
00864    } // if( valid on both ends!)
00865    return;
00866 }
00867 void TRpcProc::ProcessVftxStrip( UInt_t uStripIndex, Double_t dVftxOtherOffset )
00868 {
00869    // If multiple hits rejection is enable and there are more than 1 TDC hit on
00870    // at least one side of the strip => reject => no hits, return
00871    if( 1 == fPar->uRejectMultipleHits &&
00872        ( 1 < (fVftxInputEvent->fVftxBoards[
00873                 fPar->uTdcStripLeftTime[uStripIndex] ] ).iMultiplicity[
00874                    fPar->uChannelStripLeftTime[uStripIndex] ] ||
00875          1 < (fVftxInputEvent->fVftxBoards[
00876                 fPar->uTdcStripLeftTot[uStripIndex] ] ).iMultiplicity[
00877                    fPar->uChannelStripLeftTot[uStripIndex] ]  ||
00878          1 < (fVftxInputEvent->fVftxBoards[
00879                 fPar->uTdcStripRightTime[uStripIndex] ] ).iMultiplicity[
00880                    fPar->uChannelStripRightTime[uStripIndex] ]  ||
00881          1 < (fVftxInputEvent->fVftxBoards[
00882                 fPar->uTdcStripRightTot[uStripIndex] ] ).iMultiplicity[
00883                    fPar->uChannelStripRightTot[uStripIndex] ] )
00884          )
00885    {
00886       fTdcMultiRejectStripRpc->Fill(uStripIndex);
00887       return;
00888    } // if( reject Multi & multi tdc data for at least 1 edge on at least 1 side )
00889 
00890    UInt_t uTotTdcHitToUseLeft  = 0;
00891    UInt_t uTotTdcHitToUseRight = 0;
00892 
00893    // Test if both time are there
00894    if( kTRUE == fVftxInputEvent->IsHitThere(
00895                   fPar->uTdcStripLeftTime[uStripIndex],
00896                   fPar->uChannelStripLeftTime[uStripIndex],
00897                   0 ) &&
00898        kTRUE == fVftxInputEvent->IsHitThere(
00899                   fPar->uTdcStripRightTime[uStripIndex],
00900                   fPar->uChannelStripRightTime[uStripIndex],
00901                   0 ) )
00902    {
00903       Double_t dAutoOffset = CLOCK_TIME*(
00904             fVftxPar->iAutomaticTdcOffset[ fPar->uTdcStripRightTime[uStripIndex] ]
00905            -fVftxPar->iAutomaticTdcOffset[ fPar->uTdcStripLeftTime[ uStripIndex] ] );
00906       Double_t dAutoOffsetSum = CLOCK_TIME*(
00907             fVftxPar->iAutomaticTdcOffset[ fPar->uTdcStripRightTime[uStripIndex] ]
00908            +fVftxPar->iAutomaticTdcOffset[ fPar->uTdcStripLeftTime[ uStripIndex] ] );
00909       // Beam profile for strip RPC: X = left right Dt - offset, Y = size index * strip size
00910       fBeamProfileStripRpc->Fill(
00911             fPar->dTimeConv*( fVftxInputEvent->GetCalibratedTime(
00912                                    fPar->uTdcStripRightTime[uStripIndex],
00913                                    fPar->uChannelStripRightTime[uStripIndex],
00914                                    0, fVftxPar->uUseCoarseCorrectedTime )
00915                              - fVftxInputEvent->GetCalibratedTime(
00916                                    fPar->uTdcStripLeftTime[uStripIndex],
00917                                    fPar->uChannelStripLeftTime[uStripIndex],
00918                                    0, fVftxPar->uUseCoarseCorrectedTime )
00919                              + fPar->dOffsetListRight[uStripIndex]
00920                              - fPar->dOffsetListLeft[uStripIndex]
00921                              - ( 1 == fVftxPar->uTdcOffsetEnable? dAutoOffset : 0.0)
00922                                   )/1000.0,
00923             ((Double_t)uStripIndex)*fPar->dStripWidth - dRpcCenterOffsetCm +0.00001 );
00924       fBeamProfileStripRpcTime->Fill(
00925                             ( fVftxInputEvent->GetCalibratedTime(
00926                                   fPar->uTdcStripRightTime[uStripIndex],
00927                                   fPar->uChannelStripRightTime[uStripIndex],
00928                                   0, fVftxPar->uUseCoarseCorrectedTime )
00929                              - fVftxInputEvent->GetCalibratedTime(
00930                                    fPar->uTdcStripLeftTime[uStripIndex],
00931                                    fPar->uChannelStripLeftTime[uStripIndex],
00932                                    0, fVftxPar->uUseCoarseCorrectedTime )
00933                              + fPar->dOffsetListRight[uStripIndex]
00934                              - fPar->dOffsetListLeft[uStripIndex]
00935                              - ( 1 == fVftxPar->uTdcOffsetEnable? dAutoOffset : 0.0)
00936                                   ),
00937             ((Double_t)uStripIndex) +0.00001 );
00938 
00939       if( 0 < fPar->dMinimalTimeBetweenHits &&
00940           1 < (fVftxInputEvent->fVftxBoards[
00941                 fPar->uTdcStripRightTime[uStripIndex] ] ).iMultiplicity[
00942                    fPar->uChannelStripRightTime[uStripIndex] ]  &&
00943           1 < (fVftxInputEvent->fVftxBoards[
00944                 fPar->uTdcStripRightTot[uStripIndex] ] ).iMultiplicity[
00945                    fPar->uChannelStripRightTot[uStripIndex] ] &&
00946           kTRUE == fVftxInputEvent->IsHitThere(
00947                             fPar->uTdcStripRightTot[uStripIndex],
00948                             fPar->uChannelStripRightTot[uStripIndex],
00949                             0 ) &&
00950           kTRUE == fVftxInputEvent->IsHitThere(
00951                             fPar->uTdcStripRightTot[uStripIndex],
00952                             fPar->uChannelStripRightTot[uStripIndex],
00953                             1 ) &&
00954           kTRUE == fVftxInputEvent->IsHitThere(
00955                      fPar->uTdcStripRightTime[uStripIndex],
00956                      fPar->uChannelStripRightTime[uStripIndex],
00957                      1 ) )
00958       {
00959          Double_t dDistanceBtwnFirstSecond =
00960                fVftxInputEvent->GetCalibratedTime(
00961                   fPar->uTdcStripRightTime[uStripIndex],
00962                   fPar->uChannelStripRightTime[uStripIndex],
00963                   1, fVftxPar->uUseCoarseCorrectedTime )
00964              - fVftxInputEvent->GetCalibratedTime(
00965                     fPar->uTdcStripRightTot[uStripIndex],
00966                     fPar->uChannelStripRightTot[uStripIndex],
00967                     0, fVftxPar->uUseCoarseCorrectedTime );
00968          // For now take merge all hits under limit, even those
00969          // where second hit starts befor first hit finish
00970          if( 0 < dDistanceBtwnFirstSecond &&
00971              dDistanceBtwnFirstSecond < fPar->dMinimalTimeBetweenHits )
00972             uTotTdcHitToUseRight = 1;
00973       } // if min hit dist defined and at least 2 full hits
00974       if( 0 < fPar->dMinimalTimeBetweenHits &&
00975           1 < (fVftxInputEvent->fVftxBoards[
00976                 fPar->uTdcStripLeftTime[uStripIndex] ] ).iMultiplicity[
00977                    fPar->uChannelStripLeftTime[uStripIndex] ]  &&
00978           1 < (fVftxInputEvent->fVftxBoards[
00979                 fPar->uTdcStripLeftTot[uStripIndex] ] ).iMultiplicity[
00980                    fPar->uChannelStripLeftTot[uStripIndex] ] &&
00981           kTRUE == fVftxInputEvent->IsHitThere(
00982                             fPar->uTdcStripLeftTot[uStripIndex],
00983                             fPar->uChannelStripLeftTot[uStripIndex],
00984                             0 ) &&
00985           kTRUE == fVftxInputEvent->IsHitThere(
00986                             fPar->uTdcStripLeftTot[uStripIndex],
00987                             fPar->uChannelStripLeftTot[uStripIndex],
00988                             1 ) &&
00989           kTRUE == fVftxInputEvent->IsHitThere(
00990                      fPar->uTdcStripLeftTime[uStripIndex],
00991                      fPar->uChannelStripLeftTime[uStripIndex],
00992                      1 ) )
00993       {
00994          Double_t dDistanceBtwnFirstSecond =
00995                fVftxInputEvent->GetCalibratedTime(
00996                   fPar->uTdcStripLeftTime[uStripIndex],
00997                   fPar->uChannelStripLeftTime[uStripIndex],
00998                   1, fVftxPar->uUseCoarseCorrectedTime )
00999              - fVftxInputEvent->GetCalibratedTime(
01000                     fPar->uTdcStripLeftTot[uStripIndex],
01001                     fPar->uChannelStripLeftTot[uStripIndex],
01002                     0, fVftxPar->uUseCoarseCorrectedTime );
01003          // For now take merge all hits under limit, even those
01004          // where second hit starts befor first hit finish
01005          if( 0 < dDistanceBtwnFirstSecond &&
01006              dDistanceBtwnFirstSecond < fPar->dMinimalTimeBetweenHits )
01007             uTotTdcHitToUseLeft = 1;
01008       } // if min hit dist defined and at least 2 full hits
01009 
01010       // Check Right tot is there
01011       if( kTRUE == fVftxInputEvent->IsHitThere(
01012                   fPar->uTdcStripRightTot[uStripIndex],
01013                   fPar->uChannelStripRightTot[uStripIndex],
01014                   uTotTdcHitToUseRight ) )
01015       {
01016          fTotRightStripRpc->Fill(
01017             ( fVftxInputEvent->GetCalibratedTime(
01018                     fPar->uTdcStripRightTot[uStripIndex],
01019                     fPar->uChannelStripRightTot[uStripIndex],
01020                     uTotTdcHitToUseRight,
01021                     fVftxPar->uUseCoarseCorrectedTime )
01022               - fVftxInputEvent->GetCalibratedTime(
01023                     fPar->uTdcStripRightTime[uStripIndex],
01024                     fPar->uChannelStripRightTime[uStripIndex],
01025                     0, fVftxPar->uUseCoarseCorrectedTime )
01026              )*fPar->dToTGainListRight[uStripIndex]/1000.0
01027 //             - fPar->dOffsetListRight[uStripIndex]/1000.0
01028              - fPar->dTotOffsetListRight[uStripIndex],
01029             (Double_t)uStripIndex );
01030       } // if valid trailing edge on right side
01031 
01032       // Check Left tot is there
01033       if( kTRUE == fVftxInputEvent->IsHitThere(
01034                   fPar->uTdcStripLeftTot[uStripIndex],
01035                   fPar->uChannelStripLeftTot[uStripIndex],
01036                   uTotTdcHitToUseLeft ) )
01037       {
01038          fTotLeftStripRpc->Fill(
01039             ( fVftxInputEvent->GetCalibratedTime(
01040                     fPar->uTdcStripLeftTot[uStripIndex],
01041                     fPar->uChannelStripLeftTot[uStripIndex],
01042                     uTotTdcHitToUseLeft,
01043                     fVftxPar->uUseCoarseCorrectedTime )
01044               - fVftxInputEvent->GetCalibratedTime(
01045                     fPar->uTdcStripLeftTime[uStripIndex],
01046                     fPar->uChannelStripLeftTime[uStripIndex],
01047                     0, fVftxPar->uUseCoarseCorrectedTime )
01048              )*fPar->dToTGainListLeft[uStripIndex]/1000.0
01049 //             - fPar->dOffsetListLeft[uStripIndex]/1000.0
01050              - fPar->dTotOffsetListLeft[uStripIndex],
01051             (Double_t)uStripIndex );
01052 
01053          // Check last time info there => valid hit!
01054          if( kTRUE == fVftxInputEvent->IsHitThere(
01055                      fPar->uTdcStripRightTot[uStripIndex],
01056                      fPar->uChannelStripRightTot[uStripIndex],
01057                      0) )
01058          {
01059             uMultiplicityStripRpc ++;
01060 
01061             fSingleEvtBeamProfileStripRpc->Fill(
01062                   fPar->dTimeConv*( fVftxInputEvent->GetCalibratedTime(
01063                                          fPar->uTdcStripRightTime[uStripIndex],
01064                                          fPar->uChannelStripRightTime[uStripIndex],
01065                                          0, fVftxPar->uUseCoarseCorrectedTime )
01066                                    - fVftxInputEvent->GetCalibratedTime(
01067                                          fPar->uTdcStripLeftTime[uStripIndex],
01068                                          fPar->uChannelStripLeftTime[uStripIndex],
01069                                          0, fVftxPar->uUseCoarseCorrectedTime )
01070                                    + fPar->dOffsetListRight[uStripIndex]
01071                                    - fPar->dOffsetListLeft[uStripIndex]
01072                                         )/1000.0,
01073                   ((Double_t)uStripIndex)*fPar->dStripWidth - dRpcCenterOffsetCm +0.00001,
01074                   ( fVftxInputEvent->GetCalibratedTime(
01075                         fPar->uTdcStripLeftTot[uStripIndex],
01076                         fPar->uChannelStripLeftTot[uStripIndex],
01077                         uTotTdcHitToUseLeft,
01078                         fVftxPar->uUseCoarseCorrectedTime )
01079                    - fVftxInputEvent->GetCalibratedTime(
01080                         fPar->uTdcStripLeftTime[uStripIndex],
01081                         fPar->uChannelStripLeftTime[uStripIndex],
01082                         0, fVftxPar->uUseCoarseCorrectedTime )
01083                    )*fPar->dToTGainListLeft[uStripIndex]/1000.0
01084                    - fPar->dTotOffsetListLeft[uStripIndex]
01085                 +( fVftxInputEvent->GetCalibratedTime(
01086                         fPar->uTdcStripRightTot[uStripIndex],
01087                         fPar->uChannelStripRightTot[uStripIndex],
01088                         uTotTdcHitToUseRight,
01089                         fVftxPar->uUseCoarseCorrectedTime )
01090                   - fVftxInputEvent->GetCalibratedTime(
01091                         fPar->uTdcStripRightTime[uStripIndex],
01092                         fPar->uChannelStripRightTime[uStripIndex],
01093                         0, fVftxPar->uUseCoarseCorrectedTime )
01094                  )*fPar->dToTGainListRight[uStripIndex]/1000.0
01095                  - fPar->dTotOffsetListRight[uStripIndex]
01096                   );
01097 
01098             // Mean strip time for profile against reference
01099             Double_t dTimeMeanSum = fVftxInputEvent->GetCalibratedTime(
01100                                        fPar->uTdcStripRightTime[uStripIndex],
01101                                        fPar->uChannelStripRightTime[uStripIndex],
01102                                        0, fVftxPar->uUseCoarseCorrectedTime )
01103                                    + fVftxInputEvent->GetCalibratedTime(
01104                                        fPar->uTdcStripLeftTime[uStripIndex],
01105                                        fPar->uChannelStripLeftTime[uStripIndex],
01106                                        0, fVftxPar->uUseCoarseCorrectedTime );
01107 
01108             // Check first if the main reference TDC is defined in VFTX parameter
01109             if( -1 < fVftxPar->iMainReferenceTdc )
01110             {
01111                // Then Check if the 1st reference channel is defined for this TDC
01112                if( -1 < fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc] )
01113                   if( kTRUE == fVftxInputEvent->IsHitThere(
01114                               fVftxPar->iMainReferenceTdc,
01115                               fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc],
01116                               0 ))
01117                   {
01118                      fReference1ProfileRpc->Fill(
01119                        ( ( fVftxInputEvent->GetCalibratedTime(
01120                               fVftxPar->iMainReferenceTdc,
01121                               fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc],
01122                               0, fVftxPar->uUseCoarseCorrectedTime )
01123                          - fPar->dReference1SignalOffset
01124                          - ( dTimeMeanSum
01125                              + fPar->dOffsetListRight[uStripIndex]
01126                              + fPar->dOffsetListLeft[uStripIndex]
01127                              - ( 1 == fVftxPar->uTdcOffsetEnable? dAutoOffsetSum : 0.0)
01128                              )/2.
01129                                ) ),
01130                         (Double_t)uStripIndex );
01131 
01132                      // Then Check if the 2nd reference channel is defined for this TDC
01133                      if( -1 < fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] )
01134                         if( kTRUE == fVftxInputEvent->IsHitThere(
01135                                     fVftxPar->iMainReferenceTdc,
01136                                     fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc],
01137                                     0 ))
01138                         {
01139                            Double_t dRefMeanSum = 0.;
01140                            dRefMeanSum += fVftxInputEvent->GetCalibratedTime(
01141                                              fVftxPar->iMainReferenceTdc,
01142                                              fVftxPar->iVftxReference1Channel[fVftxPar->iMainReferenceTdc],
01143                                              0, fVftxPar->uUseCoarseCorrectedTime )
01144                                           - fPar->dReference1SignalOffset;
01145                            dRefMeanSum += fVftxInputEvent->GetCalibratedTime(
01146                                              fVftxPar->iMainReferenceTdc,
01147                                              fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc],
01148                                              0, fVftxPar->uUseCoarseCorrectedTime )
01149                                           - fPar->dReference2SignalOffset;
01150                            fMeanRefProfileRpc->Fill(
01151                              ( dRefMeanSum/2. -
01152                                  ( dTimeMeanSum
01153                                    + fPar->dOffsetListRight[uStripIndex]
01154                                    + fPar->dOffsetListLeft[uStripIndex]
01155                                    - ( 1 == fVftxPar->uTdcOffsetEnable? dAutoOffsetSum : 0.0)
01156                                  )/2. ),
01157                               (Double_t)uStripIndex );
01158                         } // if Ref 2 hit 0 ok
01159                   } // if Ref 1 hit 0 ok
01160 
01161                // Then Check if the 2nd reference channel is defined for this TDC
01162                if( -1 < fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc] )
01163                   if( kTRUE == fVftxInputEvent->IsHitThere(
01164                               fVftxPar->iMainReferenceTdc,
01165                               fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc],
01166                               0 ))
01167                   {
01168                      fReference2ProfileRpc->Fill(
01169                        ( ( fVftxInputEvent->GetCalibratedTime(
01170                               fVftxPar->iMainReferenceTdc,
01171                               fVftxPar->iVftxReference2Channel[fVftxPar->iMainReferenceTdc],
01172                               0, fVftxPar->uUseCoarseCorrectedTime )
01173                          - fPar->dReference2SignalOffset
01174                          - ( dTimeMeanSum
01175                              + fPar->dOffsetListRight[uStripIndex]
01176                              + fPar->dOffsetListLeft[uStripIndex]
01177                              - ( 1 == fVftxPar->uTdcOffsetEnable? dAutoOffsetSum : 0.0)
01178                            )/2.
01179                                ) ),
01180                         (Double_t)uStripIndex );
01181                   } // if Ref 2 hit 0 ok
01182             } // if( -1 < fVftxPar->iMainReferenceTdc )
01183 
01184             // Check multiples and set flag only in fired strips case!
01185             if( 1 < (fVftxInputEvent->fVftxBoards[
01186                          fPar->uTdcStripLeftTime[uStripIndex] ] ).iMultiplicity[
01187                             fPar->uChannelStripLeftTime[uStripIndex] ] ||
01188                  1 < (fVftxInputEvent->fVftxBoards[
01189                          fPar->uTdcStripLeftTot[uStripIndex] ] ).iMultiplicity[
01190                             fPar->uChannelStripLeftTot[uStripIndex] ]  ||
01191                  1 < (fVftxInputEvent->fVftxBoards[
01192                          fPar->uTdcStripRightTime[uStripIndex] ] ).iMultiplicity[
01193                             fPar->uChannelStripRightTime[uStripIndex] ]  ||
01194                  1 < (fVftxInputEvent->fVftxBoards[
01195                          fPar->uTdcStripRightTot[uStripIndex] ] ).iMultiplicity[
01196                             fPar->uChannelStripRightTot[uStripIndex] ]
01197                   )
01198             {
01199                eventCurrent.fbMultiEdgesPresent = kTRUE;
01200                hitCurrent.fbMultiEdge = kTRUE;
01201             } // if( multi tdc data for at least 1 edge on at least 1 side )
01202 
01203             hitCurrent.iStrip     = uStripIndex ;
01204             // Store time including offset!
01205             hitCurrent.dTimeLeft  = fVftxInputEvent->GetCalibratedTime(
01206                                           fPar->uTdcStripLeftTime[uStripIndex],
01207                                           fPar->uChannelStripLeftTime[uStripIndex],
01208                                           0, fVftxPar->uUseCoarseCorrectedTime )
01209                                     + fPar->dOffsetListLeft[uStripIndex]
01210                                     - dVftxOtherOffset
01211                                     - CLOCK_TIME*( 1 == fVftxPar->uTdcOffsetEnable?
01212                                           fVftxPar->iAutomaticTdcOffset[ fPar->uTdcStripLeftTime[ uStripIndex] ] : 0.0);
01213 
01214             // Store tot including offset and gain!
01215             // Missing the offset for the coarse counter overflow!!!!
01216             hitCurrent.dTotLeft   =
01217                ( fVftxInputEvent->GetCalibratedTime(
01218                       fPar->uTdcStripLeftTot[uStripIndex],
01219                       fPar->uChannelStripLeftTot[uStripIndex],
01220                       uTotTdcHitToUseLeft,
01221                       fVftxPar->uUseCoarseCorrectedTime )
01222                 - fVftxInputEvent->GetCalibratedTime(
01223                       fPar->uTdcStripLeftTime[uStripIndex],
01224                       fPar->uChannelStripLeftTime[uStripIndex],
01225                       0, fVftxPar->uUseCoarseCorrectedTime )
01226                )*fPar->dToTGainListLeft[uStripIndex]
01227 //               - fPar->dOffsetListLeft[uStripIndex]
01228                - fPar->dTotOffsetListLeft[uStripIndex]*1000.0;
01229             //Store time including offset!
01230             hitCurrent.dTimeRight = fVftxInputEvent->GetCalibratedTime(
01231                                           fPar->uTdcStripRightTime[uStripIndex],
01232                                           fPar->uChannelStripRightTime[uStripIndex],
01233                                           0, fVftxPar->uUseCoarseCorrectedTime )
01234                                     + fPar->dOffsetListRight[uStripIndex]
01235                                     - dVftxOtherOffset
01236                                     - CLOCK_TIME*( 1 == fVftxPar->uTdcOffsetEnable?
01237                                           fVftxPar->iAutomaticTdcOffset[ fPar->uTdcStripRightTime[uStripIndex] ] : 0.0);
01238             // Store tot including offset and gain!
01239             // Missing the offset for the coarse counter overflow!!!!
01240             hitCurrent.dTotRight  =
01241                ( fVftxInputEvent->GetCalibratedTime(
01242                      fPar->uTdcStripRightTot[uStripIndex],
01243                      fPar->uChannelStripRightTot[uStripIndex],
01244                      uTotTdcHitToUseRight,
01245                      fVftxPar->uUseCoarseCorrectedTime )
01246                 - fVftxInputEvent->GetCalibratedTime(
01247                       fPar->uTdcStripRightTime[uStripIndex],
01248                       fPar->uChannelStripRightTime[uStripIndex],
01249                       0, fVftxPar->uUseCoarseCorrectedTime )
01250                )*fPar->dToTGainListRight[uStripIndex]
01251 //               - fPar->dOffsetListRight[uStripIndex]
01252                - fPar->dTotOffsetListRight[uStripIndex]*1000.0;
01253 
01254             // Check if the new hit is more or less aligned with previous hit
01255             // in case of an already existing cluster
01256             Bool_t bDistanceToLastHitInClustOk = kTRUE;
01257             if( 0 < fPar->dStripHitMaxDistance && 0 < (clusterCurrent.fHits).size() )
01258             {
01259                Double_t dLastHitClustPos =
01260                      ( (clusterCurrent.fHits)[ (clusterCurrent.fHits).size() - 1 ]).PositionCalculation(
01261                            fPar->dTimeConv );
01262                Double_t dCurrentHitPos = hitCurrent.PositionCalculation( fPar->dTimeConv );
01263                if( fPar->dStripHitMaxDistance < TMath::Abs(dCurrentHitPos - dLastHitClustPos) )
01264                   bDistanceToLastHitInClustOk = kFALSE;
01265             }
01266 
01267             if(  ( (uStripIndex - 1) == uLastFiredStrip &&
01268                   kTRUE == bDistanceToLastHitInClustOk )||
01269                   ( 0 == (clusterCurrent.fHits).size() && 0 == fPar->uTdcStripNoisy[uStripIndex] )
01270                   )
01271             {
01272                (clusterCurrent.fHits).push_back( hitCurrent );
01273                uLastFiredStrip = uStripIndex;
01274             } // if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip || 0 == (clusterCurrent.fHits).size())
01275             else if( 1 < uStripIndex && 0 == fPar->uTdcStripNoisy[uStripIndex])
01276             {
01277                // Test if we are not with a cluster cut in two by a dead strip
01278                if( ( (uStripIndex - 2) == uLastFiredStrip && 1 == fPar->uTdcStripDead[uStripIndex - 1] ) &&
01279                      kTRUE == bDistanceToLastHitInClustOk )
01280                {
01281                   (clusterCurrent.fHits).push_back( hitCurrent );
01282                   uLastFiredStrip = uStripIndex;
01283                }
01284                else if(0 == fPar->uTdcStripNoisy[uStripIndex])
01285                {
01286                   if( 0 < (clusterCurrent.fHits).size() )
01287                   {
01288                      clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
01289                            fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
01290                      (eventCurrent.fClusters).push_back( clusterCurrent );
01291                   }
01292                   clusterCurrent.Clear();
01293                   (clusterCurrent.fHits).push_back( hitCurrent );
01294                   uLastFiredStrip = uStripIndex;
01295                } // if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip) else if( not noisy )
01296                else if( 0 < (clusterCurrent.fHits).size() )
01297                {
01298                   clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
01299                         fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
01300                   (eventCurrent.fClusters).push_back( clusterCurrent );
01301                   clusterCurrent.Clear();
01302                } // else of ( if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip) else if( 0 < (clusterCurrent.fHits).size() ))
01303 
01304             }
01305             else if(0 == fPar->uTdcStripNoisy[uStripIndex])
01306             {
01307                if( 0 < (clusterCurrent.fHits).size() )
01308                {
01309                   clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
01310                         fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
01311                   (eventCurrent.fClusters).push_back( clusterCurrent );
01312                }
01313                clusterCurrent.Clear();
01314                (clusterCurrent.fHits).push_back( hitCurrent );
01315                uLastFiredStrip = uStripIndex;
01316             } // if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip) else if( not noisy )
01317             else if( 0 < (clusterCurrent.fHits).size() )
01318             {
01319                clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
01320                      fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
01321                (eventCurrent.fClusters).push_back( clusterCurrent );
01322                clusterCurrent.Clear();
01323             } // else of ( if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip) else if( 0 < (clusterCurrent.fHits).size() ))
01324 
01325             //hitCurrent.Clear();
01326          }// if valid trailing edge also on right side => valid hit!
01327       } // if valid trailing edge on left side
01328    } // if( valid on both ends!)
01329 
01330    return;
01331 }
01332 
01333 /**************************************************************************************************/
01334 void TRpcProc::ProcessGet4v10Strip( UInt_t uEventIndex , UInt_t uStripIndex, Double_t dGet4v10OtherOffset )
01335 {
01336    // If multiple hits rejection is enable and there are more than 1 TDC hit on
01337    // at least one side of the strip => reject => no hits, return
01338    if( 1 == fPar->uRejectMultipleHits &&
01339        ( 1 < fGet4v1InputEvent->GetHitsNumber( uEventIndex, fPar->uTdcStripLeftTime[uStripIndex],
01340                                                fPar->uChannelStripLeftTime[uStripIndex]  )  ||
01341          1 < fGet4v1InputEvent->GetHitsNumber( uEventIndex, fPar->uTdcStripRightTime[uStripIndex] ,
01342                                                fPar->uChannelStripRightTime[uStripIndex] ) )
01343          )
01344    {
01345       fTdcMultiRejectStripRpc->Fill(uStripIndex);
01346       return;
01347    }
01348 
01349    // Test if both ends are there
01350    if( 0 < fGet4v1InputEvent->GetHitsNumber( uEventIndex, fPar->uTdcStripLeftTime[uStripIndex],
01351                                             fPar->uChannelStripLeftTime[uStripIndex]  ) &&
01352        0 < fGet4v1InputEvent->GetHitsNumber( uEventIndex, fPar->uTdcStripRightTime[uStripIndex] ,
01353                                             fPar->uChannelStripRightTime[uStripIndex] )  )
01354    {
01355       // Beam profile for strip RPC: X = left right Dt - offset, Y = size index * strip size
01356       fBeamProfileStripRpc->Fill(
01357             fPar->dTimeConv*( fGet4v1InputEvent->GetHitTime(
01358                                     uEventIndex, fPar->uTdcStripRightTime[uStripIndex],
01359                                     fPar->uChannelStripRightTime[uStripIndex], 0)
01360                              - fGet4v1InputEvent->GetHitTime(
01361                                     uEventIndex, fPar->uTdcStripLeftTime[uStripIndex],
01362                                     fPar->uChannelStripLeftTime[uStripIndex], 0)
01363                              + fPar->dOffsetListRight[uStripIndex]
01364                              - fPar->dOffsetListLeft[uStripIndex]
01365                                   )/1000.0,
01366             ((Double_t)uStripIndex)*fPar->dStripWidth - dRpcCenterOffsetCm +0.00001 );
01367       fBeamProfileStripRpcTime->Fill(
01368             fGet4v1InputEvent->GetHitTime(
01369                   uEventIndex, fPar->uTdcStripRightTime[uStripIndex],
01370                   fPar->uChannelStripRightTime[uStripIndex], 0)
01371            - fGet4v1InputEvent->GetHitTime(
01372                   uEventIndex, fPar->uTdcStripLeftTime[uStripIndex],
01373                   fPar->uChannelStripLeftTime[uStripIndex], 0)
01374            + fPar->dOffsetListRight[uStripIndex]
01375            - fPar->dOffsetListLeft[uStripIndex] ,
01376             ((Double_t)uStripIndex) +0.00001 );
01377 
01378       fTotLeftStripRpc->Fill(
01379          ( fGet4v1InputEvent->GetHitTot(
01380                uEventIndex, fPar->uTdcStripLeftTime[uStripIndex],
01381                fPar->uChannelStripLeftTime[uStripIndex], 0)
01382           )*fPar->dToTGainListLeft[uStripIndex]/1000.0
01383           - fPar->dTotOffsetListLeft[uStripIndex],
01384          (Double_t)uStripIndex );
01385 
01386       fTotRightStripRpc->Fill(
01387          ( fGet4v1InputEvent->GetHitTot(
01388                uEventIndex,fPar->uTdcStripRightTime[uStripIndex],
01389                fPar->uChannelStripRightTime[uStripIndex], 0 )
01390           )*fPar->dToTGainListRight[uStripIndex]/1000.0
01391           - fPar->dTotOffsetListRight[uStripIndex],
01392          (Double_t)uStripIndex );
01393 
01394       // Mean strip time for profile against reference
01395       Double_t dTimeMeanSum = ( fGet4v1InputEvent->GetHitTime(
01396                                     uEventIndex, fPar->uTdcStripRightTime[uStripIndex],
01397                                     fPar->uChannelStripRightTime[uStripIndex], 0)
01398                                + fGet4v1InputEvent->GetHitTime(
01399                                     uEventIndex, fPar->uTdcStripLeftTime[uStripIndex],
01400                                     fPar->uChannelStripLeftTime[uStripIndex], 0)
01401                                + fPar->dOffsetListRight[uStripIndex]
01402                                + fPar->dOffsetListLeft[uStripIndex]
01403                               )/2.;
01404 
01405       // Check first if the main reference TDC is defined in VFTX parameter
01406       if( -1 < fGet4v1Par->iMainReferenceTdc )
01407       {
01408          // Then Check if the 1st reference channel is defined for this TDC
01409          if( -1 < fGet4v1Par->iReference1Channel )
01410             if( -1 < fGet4v1InputEvent->GetHitTime(
01411                   uEventIndex, fGet4v1Par->iMainReferenceTdc,
01412                   fGet4v1Par->iReference1Channel, 0 ) )
01413             {
01414                fReference1ProfileRpc->Fill(
01415                      fGet4v1InputEvent->GetHitTime(
01416                        uEventIndex, fGet4v1Par->iMainReferenceTdc,
01417                        fGet4v1Par->iReference1Channel, 0 )
01418                    - fPar->dReference1SignalOffset
01419                    - dTimeMeanSum,
01420                   (Double_t)uStripIndex );
01421 
01422                // Then Check if the 2nd reference channel is defined for this TDC
01423                if( -1 < fGet4v1Par->iReference2Channel )
01424                   if( -1 < fGet4v1InputEvent->GetHitTime(
01425                               uEventIndex, fGet4v1Par->iMainReferenceTdc,
01426                               fGet4v1Par->iReference2Channel, 0 ) )
01427                   {
01428                      Double_t dRefMeanSum = 0.;
01429                      dRefMeanSum += fGet4v1InputEvent->GetHitTime(
01430                                        uEventIndex, fGet4v1Par->iMainReferenceTdc,
01431                                        fGet4v1Par->iReference1Channel, 0 )
01432                                     - fPar->dReference1SignalOffset;
01433                      dRefMeanSum += fGet4v1InputEvent->GetHitTime(
01434                                        uEventIndex, fGet4v1Par->iMainReferenceTdc,
01435                                        fGet4v1Par->iReference2Channel, 0 )
01436                                     - fPar->dReference2SignalOffset;
01437                      fMeanRefProfileRpc->Fill(
01438                         dRefMeanSum/2. - dTimeMeanSum,
01439                         (Double_t)uStripIndex );
01440                   } // if Ref 2 hit 0 ok
01441             } // if Ref 1 hit 0 ok
01442          // Then Check if the 2nd reference channel is defined for this TDC
01443          if( -1 < fGet4v1Par->iReference2Channel )
01444             if( -1 < fGet4v1InputEvent->GetHitTime(
01445                         uEventIndex, fGet4v1Par->iMainReferenceTdc,
01446                         fGet4v1Par->iReference2Channel, 0 ) )
01447             {
01448                fReference2ProfileRpc->Fill(
01449                      fGet4v1InputEvent->GetHitTime(
01450                         uEventIndex, fGet4v1Par->iMainReferenceTdc,
01451                         fGet4v1Par->iReference2Channel, 0 )
01452                      - fPar->dReference2SignalOffset
01453                      - dTimeMeanSum,
01454                   (Double_t)uStripIndex );
01455             } // if Ref 2 hit 0 ok
01456       } // if( -1 < fVftxPar->iMainReferenceTdc )
01457 
01458       uMultiplicityStripRpc ++;
01459 
01460       hitCurrent.iStrip     = uStripIndex ;
01461       // Store time including offset!
01462       hitCurrent.dTimeLeft  = fGet4v1InputEvent->GetHitTime(
01463                                     uEventIndex, fPar->uTdcStripLeftTime[uStripIndex],
01464                                     fPar->uChannelStripLeftTime[uStripIndex], 0)
01465                               + fPar->dOffsetListLeft[uStripIndex]
01466                               - dGet4v10OtherOffset;
01467 
01468       // Store tot including offset and gain!
01469       // Missing the offset for the coarse counter overflow!!!!
01470       hitCurrent.dTotLeft   =
01471          ( fGet4v1InputEvent->GetHitTot(
01472                uEventIndex,fPar->uTdcStripRightTime[uStripIndex],
01473                fPar->uChannelStripRightTime[uStripIndex], 0 )
01474          )*fPar->dToTGainListLeft[uStripIndex]
01475          - fPar->dTotOffsetListLeft[uStripIndex]*1000.0;
01476       //Store time including offset!
01477       hitCurrent.dTimeRight = fGet4v1InputEvent->GetHitTime(
01478                                     uEventIndex, fPar->uTdcStripRightTime[uStripIndex],
01479                                     fPar->uChannelStripRightTime[uStripIndex], 0)
01480                               + fPar->dOffsetListRight[uStripIndex]
01481                               - dGet4v10OtherOffset;
01482       // Store tot including offset and gain!
01483       // Missing the offset for the coarse counter overflow!!!!
01484       hitCurrent.dTotRight  =
01485          ( ( ( (fGet4v1InputEvent->fEvents[uEventIndex]).
01486                   fGet4Boards[ fPar->uTdcStripRightTime[uStripIndex] ] ).
01487                    fHits[ fPar->uChannelStripRightTime[uStripIndex] ] )[0].GetTot()
01488          )*fPar->dToTGainListRight[uStripIndex]
01489          - fPar->dTotOffsetListRight[uStripIndex]*1000.0;
01490 
01491       // Check if the new hit is more or less aligned with previous hit
01492       // in case of an already existing cluster
01493       Bool_t bDistanceToLastHitInClustOk = kTRUE;
01494       if( 0 < fPar->dStripHitMaxDistance && 0 < (clusterCurrent.fHits).size() )
01495       {
01496          Double_t dLastHitClustPos =
01497                ( (clusterCurrent.fHits)[ (clusterCurrent.fHits).size() - 1 ]).PositionCalculation(
01498                      fPar->dTimeConv );
01499          Double_t dCurrentHitPos = hitCurrent.PositionCalculation( fPar->dTimeConv );
01500          if( fPar->dStripHitMaxDistance < TMath::Abs(dCurrentHitPos - dLastHitClustPos) )
01501             bDistanceToLastHitInClustOk = kFALSE;
01502       }
01503 
01504       if(  ( (uStripIndex - 1) == uLastFiredStrip &&
01505             kTRUE == bDistanceToLastHitInClustOk )||
01506             ( 0 == (clusterCurrent.fHits).size() && 0 == fPar->uTdcStripNoisy[uStripIndex] )
01507             )
01508       {
01509          (clusterCurrent.fHits).push_back( hitCurrent );
01510          uLastFiredStrip = uStripIndex;
01511       } // if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip || 0 == (clusterCurrent.fHits).size())
01512       else if( 1 < uStripIndex && 0 == fPar->uTdcStripNoisy[uStripIndex])
01513       {
01514          // Test if we are not with a cluster cut in two by a dead strip
01515          if( ( (uStripIndex - 2) == uLastFiredStrip && 1 == fPar->uTdcStripDead[uStripIndex - 1] ) &&
01516                kTRUE == bDistanceToLastHitInClustOk )
01517          {
01518             (clusterCurrent.fHits).push_back( hitCurrent );
01519             uLastFiredStrip = uStripIndex;
01520          }
01521          else if(0 == fPar->uTdcStripNoisy[uStripIndex])
01522          {
01523             if( 0 < (clusterCurrent.fHits).size() )
01524             {
01525                clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
01526                      fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
01527                (eventCurrent.fClusters).push_back( clusterCurrent );
01528             }
01529             clusterCurrent.Clear();
01530             (clusterCurrent.fHits).push_back( hitCurrent );
01531             uLastFiredStrip = uStripIndex;
01532          } // if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip) else if( not noisy )
01533          else if( 0 < (clusterCurrent.fHits).size() )
01534          {
01535             clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
01536                   fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
01537             (eventCurrent.fClusters).push_back( clusterCurrent );
01538             clusterCurrent.Clear();
01539          } // else of ( if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip) else if( 0 < (clusterCurrent.fHits).size() ))
01540 
01541       }
01542       else if(0 == fPar->uTdcStripNoisy[uStripIndex])
01543       {
01544          if( 0 < (clusterCurrent.fHits).size() )
01545          {
01546             clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
01547                   fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
01548             (eventCurrent.fClusters).push_back( clusterCurrent );
01549          }
01550          clusterCurrent.Clear();
01551          (clusterCurrent.fHits).push_back( hitCurrent );
01552          uLastFiredStrip = uStripIndex;
01553       } // if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip) else if( not noisy )
01554       else if( 0 < (clusterCurrent.fHits).size() )
01555       {
01556          clusterCurrent.PositionCalculation( dRpcCenterOffsetCm, fPar->uOrientation,
01557                fPar->dStripWidth, fPar->dTimeConv, fPar->uUseChargeGravityCenter );
01558          (eventCurrent.fClusters).push_back( clusterCurrent );
01559          clusterCurrent.Clear();
01560       } // else of ( if( 0 == uStripIndex || (uStripIndex - 1) == uLastFiredStrip) else if( 0 < (clusterCurrent.fHits).size() ))
01561 
01562       //hitCurrent.Clear();
01563    } // if( valid on both ends!)
01564    return;
01565 }
01566 
01567 /**************************************************************************************************/
01568 Double_t box(Double_t* x, Double_t* p)
01569 {
01570     /* x[0]= x
01571        p[0]= A
01572        p[1]= x_0
01573        p[2]= B
01574        p[3]= C
01575      */
01576     return p[0]/(1.+TMath::Exp((pow(x[0]-p[1],2)-p[2])/p[3]));
01577 }