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