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